Static getter on a class extending a call expression: this.of(x) throws "of is not a function" (this = holder, call path differs from read path) — OpenCode v1.18.30 bootstrap wall #10210

export const Service = <Self>() => <const Id extends string, const Fields extends ConfigMap>(id: Id, fields: Fields) => {
  class ConfigTag extends Context.Service<Self, Shape<Fields>>()(id) {
    static get layer() {
      const tag = this
      return Layer.effect(tag, Effect.gen(function* () {
        const config = yield* Config.all(fields)
        return tag.of(config as Shape<Fields>)        // <-- "of is not a function"
      }))
    }
  }
  return ConfigTag
}
// src/effect/runtime-flags.ts
export class Service extends ConfigService.Service<Service>()("@opencode/RuntimeFlags", { ... }) {}
export const node = LayerNode.make({ service: Service, layer: Service.layer.pipe(Layer.orDie), deps: [] })

// static-getter-this.ts
const Proto: any = { of(self: any) { return self } }
const Key = function () {
  function K() {}
  Object.setPrototypeOf(K, Proto)
  return function (key: string) { (K as any).key = key; return K }
}
const t = (name: string, f: () => any) => { try { console.log(name, JSON.stringify(f())) } catch (e: any) { console.log(name, "THROW", e.message) } }

// N1 nested class + subclass, static getter calls this.of(x)
const mk1 = (id: string) => { class T extends (Key as any)()(id) { static get g() { return (this as any).of({ n: 1 }) } }; return T as any }
class S1 extends mk1("S1") {}
t("N1 nested+sub getter this.of(x)", () => S1.g)
// N2 same receiver, read first then call
const mk2 = (id: string) => { class T extends (Key as any)()(id) { static get g() { const f = (this as any).of; return [typeof f, f.call(this, { n: 2 })] } }; return T as any }
class S2 extends mk2("S2") {}
t("N2 nested+sub getter f=this.of; f.call", () => S2.g)
// N5 nested, no subclass
t("N5 nested no-sub getter this.of(x)", () => mk1("T5").g)
// N6 top-level + subclass
class T6 extends (Key as any)()("T6") { static get g() { return (this as any).of({ n: 6 }) } }
class S6 extends T6 {}
t("N6 top-level+sub getter this.of(x)", () => S6.g)
// N7 top-level, no subclass (works)
t("N7 top-level no-sub getter this.of(x)", () => T6.g)
// N8 who is `this` inside the getter?
const mk8 = (id: string) => { class T extends (Key as any)()(id) { static get g() { return { th: this as any, T } } }; return T as any }
class S8 extends mk8("S8") {}
t("N8 identity", () => { const { th, T } = S8.g; return { thisIsSub: th === S8, thisIsT: th === T, thisIsSubProto: th === Object.getPrototypeOf(S8), subProtoIsT: Object.getPrototypeOf(S8) === T, typeofThisOf: typeof th.of } })
// N10 static METHOD with the same body (works)
const mk10 = (id: string) => { class T extends (Key as any)()(id) { static m() { return (this as any).of({ n: 10 }) } }; return T as any }
class S10 extends mk10("S10") {}
t("N10 nested+sub method this.of(x)", () => S10.m())
// M1 calling the function a static getter returns, on a class that extends a call expression
const mk11 = (id: string) => { class T extends (Key as any)()(id) { static get g() { return () => 11 } }; return T as any }
t("M1 nestedClass.getter()", () => mk11("T11").g())