@k8ts/instruments 0.11.4 → 0.12.0

package/src/core/graph/origin/kind-map/index.ts

@@ -1,89 +1,88 @@
 import { doddlify, seq, type Seq } from "doddle"
-import type { AnyCtor } from "what-are-you"
-import { InstrumentsError } from "../../../../error"
 
-import { Ident, Ident_Kind } from "../../resource/api-kind"
-import { RefKey } from "../../resource/ref-key"
-import { Rsc_Ctor_Of } from "../../resource/reference"
+import { K8tsGraphError } from "../../error"
+import { Gvk, Gvk_Base } from "../../resource/gvk"
+import { ResourceIdent } from "../../resource/ident"
+import { ResourceRef_Constructor } from "../../resource/ref"
 const separator = "/"
-interface NodeEntry {
+interface GvkClassDictEntry {
     kindName: string
-    class: AnyCtor<any>
-    ident: Ident_Kind
+    class: ResourceRef_Constructor
+    kind: Gvk
 }
-export type KindMapInput<Ks extends Rsc_Ctor_Of> = Ks[]
-type LookupKey = string | RefKey | AnyCtor<any> | Ident_Kind
-export class KindMap<Kinds extends Rsc_Ctor_Of = Rsc_Ctor_Of> {
+export type GvkClassDict_Input<Ks extends ResourceRef_Constructor> = Ks[]
+type LookupKey = string | ResourceIdent | ResourceRef_Constructor | Gvk
+export class GvkClassDict<Kinds extends ResourceRef_Constructor = ResourceRef_Constructor> {
     __KINDS__!: Kinds["prototype"]["kind"]
-    constructor(private _ownKinds: KindMapInput<Kinds>) {}
+    constructor(private _ownKinds: GvkClassDict_Input<Kinds>) {}
 
     [Symbol.iterator]() {
         return this._ownKinds[Symbol.iterator]()
     }
-    child<Ks extends Rsc_Ctor_Of = Rsc_Ctor_Of>(
-        kinds: KindMapInput<Ks> | KindMap<Ks>
-    ): KindMap<Kinds | Ks> {
-        const ownKinds = kinds instanceof KindMap ? kinds._ownKinds : kinds
-        return new KindMap<Kinds | Ks>([...this._ownKinds, ...ownKinds])
+    child<Ks extends ResourceRef_Constructor = ResourceRef_Constructor>(
+        kinds: GvkClassDict_Input<Ks> | GvkClassDict<Ks>
+    ): GvkClassDict<Kinds | Ks> {
+        const ownKinds = kinds instanceof GvkClassDict ? kinds._ownKinds : kinds
+        return new GvkClassDict<Kinds | Ks>([...this._ownKinds, ...ownKinds])
     }
 
     @doddlify
-    private get _entriesSeq(): Seq<NodeEntry> {
+    private get _entriesSeq(): Seq<GvkClassDictEntry> {
         return seq(this._ownKinds).map(klass => {
             const kind = klass.prototype.kind
-            const entry: NodeEntry = {
-                kindName: kind.name,
+            const entry: GvkClassDictEntry = {
+                kindName: kind.value,
                 class: klass,
-                ident: kind
+                kind: kind
             }
             return entry
         })
     }
     @doddlify
-    private get _entriesMap(): Map<LookupKey, NodeEntry> {
+    private get _entriesMap(): Map<LookupKey, GvkClassDictEntry> {
         return seq(this._entriesSeq)
             .flatMap(entry => {
                 return [
                     [entry.kindName, entry],
                     [entry.class, entry],
-                    [entry.ident.text, entry]
+                    [entry.kind.url, entry]
                 ] as const
             })
             .toMap(x => x)
             .pull()
     }
 
-    parse(ref: string | RefKey<this["__KINDS__"]>): RefKey<this["__KINDS__"]> {
+    parse(ref: string | ResourceIdent<this["__KINDS__"]>): ResourceIdent<this["__KINDS__"]> {
         const result = this.tryParse(ref)
         if (!result) {
-            throw new InstrumentsError(`Could not parse reference key: ${ref}`)
+            throw new K8tsGraphError(`Could not parse reference key: ${ref}`)
         }
         return result as any
     }
 
-    tryParse(ref: unknown): RefKey<this["__KINDS__"]> | undefined {
+    tryParse(ref: unknown): ResourceIdent<this["__KINDS__"]> | undefined {
         if (typeof ref !== "string" && typeof ref !== "object") {
             return undefined
         }
         if (ref == null) {
             return undefined
         }
-        if (ref instanceof RefKey) {
+        if (ref instanceof ResourceIdent) {
             return ref
         }
         if (typeof ref === "object") {
             return undefined
         }
-        const [kind, name] = ref.split(separator).map(s => s.trim())
-        if (!kind || !name) {
+        const [sKind, name] = ref.split(separator).map(s => s.trim())
+        if (!sKind || !name) {
             return undefined
         }
-        const ident = this.tryGetKind(kind)
-        if (!ident) {
+        const kind = this.tryGetKind(sKind)
+        if (!kind) {
             return undefined
         }
 
-        return (ident as Ident_Kind).refKey({
+        return (kind as Gvk).refKey({
             name
         })
     }
@@ -96,35 +95,36 @@ export class KindMap<Kinds extends Rsc_Ctor_Of = Rsc_Ctor_Of> {
     }
 
     private _unknownNameError(kind: string) {
-        return new InstrumentsError(`The shorthand name ${kind} is not registered`)
+        return new K8tsGraphError(`The shorthand name ${kind} is not registered`)
     }
-    private _unknownIdentError(ident: Ident) {
-        return new InstrumentsError(`The kind identifier ${ident} is not registered`)
+    private _unknownIdentError(kind: Gvk_Base) {
+        return new K8tsGraphError(`The kind identifier ${kind} is not registered`)
     }
     private _unknownClassError(klass: Function) {
-        return new InstrumentsError(`The class ${klass.name} is not registered`)
+        return new K8tsGraphError(`The class ${klass.name} is not registered`)
     }
-    private _convert(something: LookupKey | RefKey | Function | Ident_Kind) {
+    private _convert(something: LookupKey | ResourceIdent | Function | Gvk) {
         if (typeof something === "string") {
             if (something.includes("/")) {
-                return this.parse(something).kind
+                const r = this.parse(something)
+                return r.kind.url
             }
             return something
         } else if (typeof something === "function") {
-            return something as AnyCtor<any>
-        } else if (something instanceof Ident) {
-            return something.text
-        } else if (something instanceof RefKey) {
-            return something.kind.text
+            return something as ResourceRef_Constructor
+        } else if (something instanceof Gvk_Base) {
+            return something.url
+        } else if (something instanceof ResourceIdent) {
+            return something.kind.url
         }
-        throw new InstrumentsError(`Invalid argument ${something}`)
+        throw new K8tsGraphError(`Invalid argument ${something}`)
     }
     private _getEntry(key: LookupKey) {
         const entry = this._tryGetEntry(key)
         if (!entry) {
             if (typeof key === "string") {
                 throw this._unknownNameError(key)
-            } else if (key instanceof Ident) {
+            } else if (key instanceof Gvk_Base) {
                 throw this._unknownIdentError(key)
             } else if (typeof key === "function") {
                 throw this._unknownClassError(key)
@@ -132,31 +132,31 @@ export class KindMap<Kinds extends Rsc_Ctor_Of = Rsc_Ctor_Of> {
         }
         return entry!
     }
-    private _tryGetEntry(key: LookupKey): NodeEntry | undefined {
+    private _tryGetEntry(key: LookupKey): GvkClassDictEntry | undefined {
         const converted = this._convert(key)
         return this._entriesMap.get(converted)
     }
 
     tryGetKind(kindOrIdent: LookupKey): this["__KINDS__"] | undefined {
-        return this._tryGetEntry(kindOrIdent)?.ident as this["__KINDS__"] | undefined
+        return this._tryGetEntry(kindOrIdent)?.kind as this["__KINDS__"] | undefined
     }
 
     getKind(kindOrClass: LookupKey): this["__KINDS__"] {
-        return this._getEntry(kindOrClass).ident
+        return this._getEntry(kindOrClass).kind
     }
 
-    tryGetClass(kindOrIdent: LookupKey): AnyCtor<any> | undefined {
-        return this._tryGetEntry(kindOrIdent)?.class
+    tryGetClass(kind: LookupKey): ResourceRef_Constructor | undefined {
+        return this._tryGetEntry(kind)?.class
     }
 
-    getClass(refKey: RefKey): AnyCtor<any>
-    getClass<F extends AnyCtor<any>>(klass: F): F
-    getClass(kind: string): AnyCtor<any>
-    getClass(ident: Ident_Kind): AnyCtor<any>
-    getClass<T extends AnyCtor<any> | string>(
+    getClass(refKey: ResourceIdent): ResourceRef_Constructor
+    getClass<F extends ResourceRef_Constructor>(klass: F): F
+    getClass(kind: string): ResourceRef_Constructor
+    getClass(kind: Gvk): ResourceRef_Constructor
+    getClass<T extends ResourceRef_Constructor | string>(
         kindOrClass: T
-    ): T extends AnyCtor<any> ? string : AnyCtor<any>
-    getClass(kindOrClass: LookupKey): AnyCtor<any> | string {
+    ): T extends ResourceRef_Constructor ? string : ResourceRef_Constructor
+    getClass(kindOrClass: LookupKey): ResourceRef_Constructor | string {
         return this._getEntry(kindOrClass).class
     }
 

package/src/core/graph/origin/origin.ts

@@ -0,0 +1,144 @@
+import { Metadata } from "@k8ts/metadata"
+import chalk from "chalk"
+import { doddlify, seq } from "doddle"
+import EventEmitter from "eventemitter3"
+import { mapValues } from "lodash"
+import { display } from "../../../utils/mixin/display"
+import { EntityBase } from "../entity"
+import type { ResourceRef } from "../resource/ref"
+import { ResourceEntity } from "../resource/resource"
+import { type OriginEventMap } from "./events"
+import { GvkClassDict } from "./kind-map"
+import { type Origin_Props } from "./props"
+import type { OriginTracker_Binder } from "./tracker"
+import { OriginContextTracker } from "./tracker"
+import { OriginVertex } from "./vertex"
+
+@display({
+    simple: x => `[${x.__vertex__.shortFqn}]`,
+    pretty(origin) {
+        const kindPart = chalk.greenBright.bold(origin.kind)
+        const originName = chalk.cyan(origin.name)
+        return `${kindPart}/${originName}`
+    }
+})
+export abstract class OriginEntity<Props extends Origin_Props = Origin_Props> extends EntityBase<
+    OriginVertex,
+    OriginEntity
+> {
+    abstract get kind(): string
+    private _emitter = new EventEmitter<OriginEventMap>()
+    private readonly _ownResources: ResourceEntity[] = []
+    readonly metadata: Metadata
+    abstract namespace: string | undefined
+    private readonly _ownKids: OriginEntity[] = []
+    protected __kids__() {
+        return this._ownKids
+    }
+    get noEmit() {
+        return !!this._props.noEmit
+    }
+    set noEmit(value: boolean) {
+        this._props.noEmit = value
+    }
+    protected __attach_kid__(kid: OriginEntity): void {
+        this._ownKids.push(kid)
+        this.__emit__("origin/attached", {
+            origin: this,
+            child: kid
+        })
+    }
+    equals(other: any): boolean {
+        const ForwardExports = require("../resource/forward/exports").ForwardExports
+        if (!other) {
+            return false
+        }
+        if (ForwardExports.is(other)) {
+            return other.equals(this)
+        }
+        if (other instanceof OriginEntity) {
+            return Object.is(this, other)
+        }
+
+        return false
+    }
+    constructor(
+        readonly name: string,
+        protected readonly _props: Props
+    ) {
+        super()
+
+        this.metadata = new Metadata(_props.metadata ?? {})
+    }
+
+    get __vertex__(): OriginVertex {
+        return new OriginVertex(this)
+    }
+    on<EventKey extends keyof OriginEventMap>(
+        event: EventKey,
+        listener: (data: OriginEventMap[EventKey]) => void
+    ) {
+        this._emitter.on(event, listener as any)
+    }
+
+    onMany<EventKeys extends keyof OriginEventMap>(handlers: {
+        [K in EventKeys]: (data: OriginEventMap[K]) => void
+    }) {
+        for (const key of Object.keys(handlers) as EventKeys[]) {
+            this._emitter.on(key, handlers[key] as any)
+        }
+    }
+    protected __emit__<EventKey extends keyof OriginEventMap>(
+        event: EventKey,
+        data: OriginEventMap[EventKey]
+    ) {
+        const values = mapValues(data, v => `${v}`)
+
+        for (const target of [this.__vertex__, ...this.__vertex__.ancestors]) {
+            target.entity.cast(OriginEntity)._emitter.emit(event, data)
+        }
+    }
+    @doddlify
+    protected get __resource_kinds__(): GvkClassDict {
+        const parent = this.__parent__?.cast(OriginEntity)
+        const parentKindsIfAny = parent?.__resource_kinds__ ?? []
+        return new GvkClassDict([...(this._props.kinds ?? []), ...parentKindsIfAny])
+    }
+
+    protected __attach_resource__(resources: ResourceEntity | Iterable<ResourceEntity>) {
+        resources = Symbol.iterator in resources ? resources : [resources]
+        for (const resource of resources) {
+            this._ownResources.push(resource)
+            if ("metadata" in resource && resource.metadata instanceof Metadata) {
+                resource.metadata.add(this.__vertex__.inheritedMeta)
+            }
+            this.__emit__("resource/attached", {
+                origin: this,
+                resource
+            })
+        }
+    }
+    protected __bind__<F extends (...args: any[]) => any>(fn: F): F {
+        const bound = this.__binder__.bind(fn)
+        return bound as F
+    }
+
+    protected get __binder__(): OriginTracker_Binder {
+        const origin = this
+        return OriginContextTracker.binder(origin)
+    }
+
+    // We don't cache this because resources can be added dynamically
+    get resources(): Iterable<ResourceRef> {
+        const self = this
+        return seq(function* () {
+            for (const resource of self._ownResources) {
+                yield resource
+            }
+            for (const kid of self.__kids__()) {
+                const asOrigin = kid as OriginEntity
+                yield* asOrigin.resources
+            }
+        })
+    }
+}

package/src/core/graph/origin/props.ts

@@ -0,0 +1,11 @@
+import type { Metadata_Input } from "@k8ts/metadata"
+import type { ResourceRef_Constructor } from "../resource"
+import type { GvkClassDict_Input } from "./kind-map"
+
+export interface Origin_Props<
+    KindedCtors extends ResourceRef_Constructor = ResourceRef_Constructor
+> {
+    noEmit?: boolean
+    metadata?: Metadata_Input
+    kinds?: GvkClassDict_Input<KindedCtors>
+}

package/src/core/graph/origin/template.ts

@@ -0,0 +1,36 @@
+import { ResourceEntity, ResourceRef } from "../resource"
+import { OriginEntity } from "./origin"
+import type { Origin_Props } from "./props"
+export interface TemplateOrigin_Props extends Origin_Props {
+    owner: ResourceEntity
+}
+export class TemplateOrigin extends OriginEntity<TemplateOrigin_Props> {
+    #_ = (() => {
+        this.on("resource/manifested", e => {
+            // Templated resources should never have a namespace when manifested
+            // But they still need to keep track of it internally for validation
+            if (e.manifest?.metadata?.namespace) {
+                delete e.manifest.metadata.namespace
+            }
+        })
+        this.noEmit = true
+    })()
+
+    get __parent__() {
+        return this.owner.cast(ResourceEntity)["__origin__"]
+    }
+    get namespace() {
+        return this.owner.ident.namespace
+    }
+    get kind() {
+        return "Template"
+    }
+    get owner() {
+        return this._props.owner
+    }
+
+    attach<T extends ResourceRef>(scope: () => T): T {
+        const bound = this.__bind__(scope)
+        return bound()
+    }
+}

package/src/core/graph/origin/tracker.ts

@@ -1,35 +1,24 @@
 import { AsyncLocalStorage } from "async_hooks"
 import { doddle, pull, type Doddle, type MaybeDoddle } from "doddle"
-import { isIterable, type AnyCtor } from "what-are-you"
-import { Origin_Entity } from "./entity"
+import { isIterable } from "what-are-you"
+import { OriginEntity } from "./origin"
 
-export interface OriginStackBinder {
+export interface OriginTracker_Binder {
     run<T>(callback: () => T): T
     bind<F extends (...args: any[]) => any>(fn: F): F
 }
 
-export class _OriginContextTracker {
-    private readonly _store: AsyncLocalStorage<Origin_Entity | undefined>
+export class OriginTracker {
+    private readonly _store: AsyncLocalStorage<OriginEntity | undefined>
     constructor() {
-        this._store = new AsyncLocalStorage<Origin_Entity | undefined>()
+        this._store = new AsyncLocalStorage<OriginEntity | undefined>()
     }
 
-    get current(): Origin_Entity | undefined {
+    get current(): OriginEntity | undefined {
         return this._store.getStore()
     }
 
-    firstOfType<X extends Origin_Entity>(t: AnyCtor<X>): X {
-        let current = this._store.getStore()
-        while (current) {
-            if (current instanceof t) {
-                return current
-            }
-            current = current["__parent__"]()?.assert(Origin_Entity)
-        }
-        throw new Error(`No origin of type ${t.name} found in the current origin stack`)
-    }
-
-    disposableOriginModifier(origin: Origin_Entity): Disposable {
+    disposableOriginModifier(origin: OriginEntity): Disposable {
         const curOrigin = this._store.getStore()
         this._store.enterWith(origin)
         return {
@@ -39,7 +28,7 @@ export class _OriginContextTracker {
         }
     }
 
-    binder(origin: MaybeDoddle<Origin_Entity>): OriginStackBinder {
+    binder(origin: MaybeDoddle<OriginEntity>): OriginTracker_Binder {
         const runner = this
         return {
             run<T>(callback: () => T): T {
@@ -48,17 +37,17 @@ export class _OriginContextTracker {
             },
             bind<F extends (...args: any[]) => any>(fn: F): F {
                 const boundOrigin = origin
-                return runner._bind(boundOrigin as Doddle<Origin_Entity>, fn)
+                return runner._bind(boundOrigin as Doddle<OriginEntity>, fn)
             }
         }
     }
 
-    private _run<T>(origin: Origin_Entity, callback: () => T): T {
+    private _run<T>(origin: OriginEntity, callback: () => T): T {
         return this._store.run(origin, callback)
     }
 
     private _bindIterator(
-        boundOrigin: Doddle<Origin_Entity> | Origin_Entity,
+        boundOrigin: Doddle<OriginEntity> | OriginEntity,
         iterator: Iterator<any>
     ): Iterator<any> {
         const runner = this
@@ -86,7 +75,7 @@ export class _OriginContextTracker {
     }
 
     private _bindIterable<It extends Iterable<any>>(
-        boundOrigin: Doddle<Origin_Entity> | Origin_Entity,
+        boundOrigin: Doddle<OriginEntity> | OriginEntity,
         iterable: It
     ) {
         const iterator = iterable[Symbol.iterator]()
@@ -99,7 +88,7 @@ export class _OriginContextTracker {
         return boundIterator
     }
 
-    private _bind<F extends (...args: any[]) => any>(origin: Doddle<Origin_Entity>, fn: F): F {
+    private _bind<F extends (...args: any[]) => any>(origin: Doddle<OriginEntity>, fn: F): F {
         const self = this
         return function boundRunFunction(this: any, ...args: any[]) {
             const result = self._run(pull(origin), () => fn.apply(this, args))
@@ -111,4 +100,4 @@ export class _OriginContextTracker {
     }
 }
 
-export const OriginContextTracker = new _OriginContextTracker()
+export const OriginContextTracker = new OriginTracker()

package/src/core/graph/origin/{node.ts → vertex.ts}

@@ -1,13 +1,12 @@
-import { Meta } from "@k8ts/metadata"
+import { Metadata } from "@k8ts/metadata"
 import chalk from "chalk"
 import { seq, Seq } from "doddle"
-import { displayers } from "../../../utils/displayers"
-import { Node } from "../node"
-import type { Rsc_Ctor_Of, Rsc_Ref } from "../resource"
-import { Origin_Entity } from "./entity"
-import { type KindMapInput } from "./kind-map"
+import { display } from "../../../utils/mixin/display"
+import type { ResourceRef } from "../resource"
+import { Vertex } from "../vertex"
+import { OriginEntity } from "./origin"
 
-@displayers({
+@display({
     simple: s => `[${s.shortFqn}]`,
     prefix: s => {
         return ""
@@ -20,12 +19,21 @@ import { type KindMapInput } from "./kind-map"
         return chalk.underline(`${pref}${kindName}:${resourceName}`)
     }
 })
-export class OriginNode extends Node<OriginNode, Origin_Entity> {
+export class OriginVertex extends Vertex<OriginVertex, OriginEntity> {
     get kids() {
-        return seq(this.entity["__kids__"]()).map(x => x.assert(Origin_Entity).node)
+        return seq(this.entity["__kids__"]()).map(x => x.cast(OriginEntity).__vertex__)
     }
-    get meta() {
-        return this.entity.meta
+    get noEmit() {
+        return this.entity.noEmit
+    }
+    get hasInheritedNoEmit() {
+        return this.noEmit || this.ancestors.some(x => x.noEmit).pull()
+    }
+    get name() {
+        return this.entity.name
+    }
+    get metadata() {
+        return this.entity.metadata
     }
     get kind() {
         return this.entity.kind
@@ -33,18 +41,18 @@ export class OriginNode extends Node<OriginNode, Origin_Entity> {
     get shortFqn() {
         return `${this.kind}/${this.name}`
     }
-    get inheritedMeta(): Meta {
+    get inheritedMeta(): Metadata {
         const self = this
         return [this, ...this.ancestors]
-            .map(x => x.meta.clone())
-            .reduce((acc, meta) => acc.add(meta), Meta.make())
+            .map(x => x.metadata.clone())
+            .reduce((acc, meta) => acc.add(meta), new Metadata())
     }
-    constructor(entity: Origin_Entity) {
+    constructor(entity: OriginEntity) {
         super(entity)
     }
 
     get resourceKinds() {
-        return this.entity["__resource_kinds__"]()
+        return this.entity["__resource_kinds__"]
     }
 
     get relations() {
@@ -54,7 +62,7 @@ export class OriginNode extends Node<OriginNode, Origin_Entity> {
     get resources() {
         return this.entity.resources
     }
-    readonly attachedTree: Seq<Rsc_Ref> = seq(() => {
+    readonly attachedTree: Seq<ResourceRef> = seq(() => {
         const self = this
         const desc = self.descendants
             .concatTo([this])
@@ -68,8 +76,3 @@ export class OriginNode extends Node<OriginNode, Origin_Entity> {
         return desc
     }).cache()
 }
-
-export interface Origin_Props<KindedCtors extends Rsc_Ctor_Of = Rsc_Ctor_Of> {
-    meta?: Meta.Input
-    kinds?: KindMapInput<KindedCtors>
-}

package/src/core/graph/relation.ts

@@ -1,19 +1,17 @@
-import { pretty } from "../../utils/_string"
-import { displayers } from "../../utils/displayers"
-import type { Node } from "./node"
+import { display } from "../../utils/mixin/display"
+import { phrases } from "../../utils/phrase-renderer"
+import type { Vertex } from "./vertex"
 
-@displayers({
+@display({
     simple: s => [s.why, "-->", s.needed],
     pretty: (dep, format) => {
-        const neededFmt = pretty`${["lowkey", dep.needed]}`
+        const neededFmt = phrases`${["lowkey", dep.needed]}`
         return [dep.why, neededFmt].join("➜ ")
     }
 })
-export class Relation<_Node extends Node<_Node>> {
+export class Relation<_Node extends Vertex<_Node>> {
     constructor(
         readonly why: string,
-        readonly needed: Node
-    ) {
-        const a = 1
-    }
+        readonly needed: Vertex
+    ) {}
 }

package/src/core/graph/resource/creation-options.ts

@@ -0,0 +1,27 @@
+import type { Metadata_Input } from "@k8ts/metadata"
+import type { OriginEntity } from "../origin"
+
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends { kind: any }
+        ? T[P]
+        : T[P] extends object
+          ? DeepPartial<T[P]>
+          : T[P]
+}
+
+export interface ResourceTop_CreationOptions_Origins {
+    /** The Resource's Origin. */
+    own: OriginEntity
+    /** The Origin to be used by top resources created within a subscope of this Resource. */
+    subscope: OriginEntity
+}
+export interface ResourceTop_CreationOptions {
+    /** Specifies explicit Origins to use for this Resource. */
+    origins: ResourceTop_CreationOptions_Origins
+}
+
+export interface ResourceTop_CreationOptions_Input
+    extends DeepPartial<ResourceTop_CreationOptions> {
+    /** Extra metadata to apply to the Resource. */
+    metadata?: Metadata_Input
+}

package/src/core/graph/resource/dummy/base.ts

@@ -0,0 +1,13 @@
+import { NullOrigin } from "../../origin/dummy"
+import type { Gvk_Base } from "../gvk"
+import { ResourceEntity } from "../resource"
+export abstract class DummyResource<K extends Gvk_Base> extends ResourceEntity<string, any> {
+    get noEmit() {
+        return true
+    }
+    protected get __origin__() {
+        return NullOrigin.instance
+    }
+
+    abstract get kind(): K
+}

package/src/core/graph/resource/forward/error.ts

@@ -0,0 +1,7 @@
+export class K8tsProxyError extends Error {
+    name = "K8tsProxyError" as const
+    constructor(message: string, details: Record<string, any> = {}) {
+        super(message)
+        Object.assign(this, details)
+    }
+}