@astrale-os/kernel-core 0.4.1

package/dist/domain/compile/internals.d.ts

@@ -0,0 +1,93 @@
+/**
+ * DomainInternals — everything the compiler knows about a schema,
+ * scoped under a single sigil so schema members can spread flat without
+ * colliding with engine metadata.
+ *
+ * Access pattern:
+ *
+ *   K.$.origin                // DomainOrigin
+ *   K.$.refs                  // structured refs (interfaces, classes, core)
+ *   K.$.methods               // resolved methods (incl. inherited)
+ *   K.$.properties            // property key index
+ *   K.$.c('Author')           // class lookup — bypasses flat-spread shadowing
+ *   K.$.i('Named')            // interface lookup — bypasses flat-spread shadowing
+ *   K.$.group('Author', flat) // shape a flat record into {attrs, props}
+ *
+ * The only reserved name at the top level of K is `$`. Everything else is
+ * a schema member (flat class/interface access).
+ */
+import type { Core, DefRef, Schema, SchemaIR } from '@astrale-os/kernel-dsl';
+import type { Attributes, BoundAccessorMethods, Properties } from '#domain/accessors/types';
+import type { DomainKeysMap } from '#domain/addressing/keys/types';
+import type { Layout, LayoutMap } from '#domain/addressing/layout/types';
+import type { DomainRefs } from '#domain/addressing/refs/types';
+import type { DomainOrigin } from '#domain/origin';
+import type { CompiledCore } from './core/compile';
+import type { DomainImportsMap } from './imports/types';
+import type { DomainMethodsMap } from './method/types';
+import type { DomainPropertyIndex } from './property/types';
+import type { ClassPathMap } from './types';
+import type { ValidationWarning } from './validation/validate';
+/**
+ * Inputs needed to assemble DomainInternals — everything the compiler has
+ * already computed, bundled so `buildInternals` stays a pure shape transform.
+ */
+export interface InternalsInput<S extends Schema> {
+    readonly origin: DomainOrigin;
+    readonly schema: S;
+    readonly layout: Layout;
+    readonly refs: DomainRefs<S>;
+    readonly keys: DomainKeysMap<S>;
+    readonly paths: {
+        readonly absolute: LayoutMap;
+        readonly class: ClassPathMap;
+    };
+    readonly imports: DomainImportsMap<S>;
+    readonly core: CompiledCore | undefined;
+    readonly properties: DomainPropertyIndex;
+    readonly methods: DomainMethodsMap;
+    readonly warnings: readonly ValidationWarning[];
+}
+/**
+ * The `$` sigil — engine-facing metadata and tools for a compiled domain.
+ *
+ * All fields that used to sit at the top level of CompiledDomain live here.
+ * Schema members (classes, interfaces) are spread flat on the compiled
+ * object alongside this single `$` entry.
+ */
+export interface DomainInternals<S extends Schema = Schema> extends BoundAccessorMethods<S> {
+    readonly origin: DomainOrigin;
+    readonly schema: S;
+    readonly layout: Layout;
+    readonly refs: DomainRefs<S>;
+    readonly paths: {
+        readonly absolute: LayoutMap;
+        readonly class: ClassPathMap;
+    };
+    readonly keys: DomainKeysMap<S>;
+    readonly interfaces: S['interfaces'];
+    readonly classes: S['classes'];
+    readonly imports: DomainImportsMap<S>;
+    readonly core: CompiledCore | undefined;
+    readonly properties: DomainPropertyIndex;
+    readonly methods: DomainMethodsMap;
+    readonly warnings: readonly ValidationWarning[];
+    readonly inheritanceChain: Readonly<Record<DefRef, readonly string[]>>;
+    readonly ir: SchemaIR;
+    group(className: string, flat: Readonly<Record<string, unknown>>): {
+        attrs: Attributes;
+        props: Properties;
+    };
+    c<Name extends keyof S['classes'] & string>(name: Name): DomainRefs<S>['classes'][Name];
+    i<Name extends keyof S['interfaces'] & string>(name: Name): DomainRefs<S>['interfaces'][Name];
+}
+/**
+ * Assemble the `$` bundle from compiled parts.
+ *
+ * Pure shape transform — no schema walking, no validation. Lazy getters for
+ * `inheritanceChain` and `ir` preserve the compiler's existing behavior.
+ */
+export declare function buildInternals<S extends Schema>(input: InternalsInput<S>): DomainInternals<S>;
+/** Core<S> re-export for callers that need to type the optional core argument. */
+export type { Core };
+//# sourceMappingURL=internals.d.ts.map

package/dist/domain/compile/internals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internals.d.ts","sourceRoot":"","sources":["../../../domain/compile/internals.ts"],"names":[],"mappings":"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"}

package/dist/domain/compile/internals.js

@@ -0,0 +1,78 @@
+/**
+ * DomainInternals — everything the compiler knows about a schema,
+ * scoped under a single sigil so schema members can spread flat without
+ * colliding with engine metadata.
+ *
+ * Access pattern:
+ *
+ *   K.$.origin                // DomainOrigin
+ *   K.$.refs                  // structured refs (interfaces, classes, core)
+ *   K.$.methods               // resolved methods (incl. inherited)
+ *   K.$.properties            // property key index
+ *   K.$.c('Author')           // class lookup — bypasses flat-spread shadowing
+ *   K.$.i('Named')            // interface lookup — bypasses flat-spread shadowing
+ *   K.$.group('Author', flat) // shape a flat record into {attrs, props}
+ *
+ * The only reserved name at the top level of K is `$`. Everything else is
+ * a schema member (flat class/interface access).
+ */
+import { serialize } from '@astrale-os/kernel-dsl';
+import { bindAccessorMethods } from '#domain/accessors/bind';
+import { groupProperties } from '#domain/accessors/group';
+import { buildInheritanceChains } from './inheritance';
+/**
+ * Assemble the `$` bundle from compiled parts.
+ *
+ * Pure shape transform — no schema walking, no validation. Lazy getters for
+ * `inheritanceChain` and `ir` preserve the compiler's existing behavior.
+ */
+export function buildInternals(input) {
+    const { origin, schema, layout, refs, keys, paths, imports, core, properties, methods, warnings, } = input;
+    let _inheritanceChain;
+    let _ir;
+    // Bind accessor methods eagerly — the factory itself just creates closures
+    // that capture origin/properties/methods. Per-class caches inside `bind.ts`
+    // are still lazy, so there's no meaningful startup cost.
+    const accessors = bindAccessorMethods(origin, properties, methods);
+    const internals = {
+        origin,
+        schema,
+        layout,
+        refs,
+        keys,
+        paths,
+        interfaces: schema.interfaces,
+        classes: schema.classes,
+        imports,
+        core,
+        properties,
+        methods,
+        warnings,
+        // Accessor methods spread flat — `wrap` / `validate` / `qualify` / `draft`
+        // / `draftEdge` sit at `$` level alongside the other internals.
+        ...accessors,
+        group(className, flat) {
+            const byClass = properties.byClass[className];
+            if (!byClass) {
+                throw new Error(`compileDomain.group: unknown class "${className}" in domain "${origin}"`);
+            }
+            return groupProperties(byClass, className, origin, flat);
+        },
+        c: ((name) => refs.classes[name]),
+        i: ((name) => refs.interfaces[name]),
+        get inheritanceChain() {
+            if (!_inheritanceChain) {
+                _inheritanceChain = Object.freeze(buildInheritanceChains(schema));
+            }
+            return _inheritanceChain;
+        },
+        get ir() {
+            if (!_ir) {
+                _ir = serialize(schema);
+            }
+            return _ir;
+        },
+    };
+    return Object.freeze(internals);
+}
+//# sourceMappingURL=internals.js.map

package/dist/domain/compile/internals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internals.js","sourceRoot":"","sources":["../../../domain/compile/internals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAQlD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AASzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAA;AAyEtD;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAmB,KAAwB;IACvE,MAAM,EACJ,MAAM,EACN,MAAM,EACN,MAAM,EACN,IAAI,EACJ,IAAI,EACJ,KAAK,EACL,OAAO,EACP,IAAI,EACJ,UAAU,EACV,OAAO,EACP,QAAQ,GACT,GAAG,KAAK,CAAA;IAET,IAAI,iBAA0E,CAAA;IAC9E,IAAI,GAAyB,CAAA;IAE7B,2EAA2E;IAC3E,4EAA4E;IAC5E,yDAAyD;IACzD,MAAM,SAAS,GAAG,mBAAmB,CAAI,MAAM,EAAE,UAAU,EAAE,OAAO,CAAC,CAAA;IAErE,MAAM,SAAS,GAAuB;QACpC,MAAM;QACN,MAAM;QACN,MAAM;QACN,IAAI;QACJ,IAAI;QACJ,KAAK;QACL,UAAU,EAAE,MAAM,CAAC,UAAU;QAC7B,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,OAAO;QACP,IAAI;QACJ,UAAU;QACV,OAAO;QACP,QAAQ;QAER,2EAA2E;QAC3E,gEAAgE;QAChE,GAAG,SAAS;QAEZ,KAAK,CAAC,SAAS,EAAE,IAAI;YACnB,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;YAC7C,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CAAC,uCAAuC,SAAS,gBAAgB,MAAM,GAAG,CAAC,CAAA;YAC5F,CAAC;YACD,OAAO,eAAe,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,CAAA;QAC1D,CAAC;QAED,CAAC,EAAE,CAAC,CAAC,IAAY,EAAE,EAAE,CAClB,IAAI,CAAC,OAAmC,CAAC,IAAI,CAAC,CAA4B;QAC7E,CAAC,EAAE,CAAC,CAAC,IAAY,EAAE,EAAE,CAClB,IAAI,CAAC,UAAsC,CAAC,IAAI,CAAC,CAA4B;QAEhF,IAAI,gBAAgB;YAClB,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACvB,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC,CAAA;YACnE,CAAC;YACD,OAAO,iBAAiB,CAAA;QAC1B,CAAC;QAED,IAAI,EAAE;YACJ,IAAI,CAAC,GAAG,EAAE,CAAC;gBACT,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,CAAA;YACzB,CAAC;YACD,OAAO,GAAG,CAAA;QACZ,CAAC;KACF,CAAA;IAED,OAAO,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;AACjC,CAAC"}

package/dist/domain/compile/method/bind.d.ts

@@ -0,0 +1,33 @@
+/**
+ * bindMethods — attach handler slots to a CompiledDomain's resolved methods.
+ *
+ * Produces a `BoundMethod[]` with one entry per class/interface method that
+ * requires an implementation. The handler is carried through as an opaque
+ * `THandler` slot — core performs STRUCTURAL validation only:
+ *   - sealed methods on classes cannot be re-implemented by the class
+ *   - abstract methods must have a handler
+ *   - interface non-abstract methods must have a handler
+ *
+ * Core does NOT inspect the shape of a handler (e.g. whether it has an
+ * `execute` function). Runtime-specific shape validation lives with the
+ * runtime that owns the handler contract — see
+ * `kernel/runtime/functions/definition/validate-handler.ts`.
+ */
+import type { Schema } from '@astrale-os/kernel-dsl';
+import type { BoundMethod } from './bound-method';
+import type { DomainMethodsMap } from './types';
+/**
+ * Attach handlers to a compiled domain's methods.
+ *
+ * @param schema - The domain schema (interfaces + classes)
+ * @param methods - Resolved method map (className → methodName → ResolvedMethod)
+ * @param handlers - Namespace-keyed map: `handlers[namespace][ownerName][methodName] = handler`,
+ *   where `namespace` is `'class'` or `'interface'`. Splitting by namespace lets a class and an
+ *   interface share the same name without collapsing their handler slots.
+ * @returns Array of BoundMethod entries
+ */
+export declare function bindMethods<THandler = unknown>(schema: Schema, methods: DomainMethodsMap, handlers: {
+    class?: Record<string, Record<string, THandler>>;
+    interface?: Record<string, Record<string, THandler>>;
+}): BoundMethod<THandler>[];
+//# sourceMappingURL=bind.d.ts.map

package/dist/domain/compile/method/bind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind.d.ts","sourceRoot":"","sources":["../../../../domain/compile/method/bind.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAS,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAQ3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,SAAS,CAAA;AAmB/D;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,QAAQ,GAAG,OAAO,EAC5C,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,gBAAgB,EACzB,QAAQ,EAAE;IACR,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAA;IAChD,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAA;CACrD,GACA,WAAW,CAAC,QAAQ,CAAC,EAAE,CAoDzB"}

package/dist/domain/compile/method/bind.js

@@ -0,0 +1,182 @@
+/**
+ * bindMethods — attach handler slots to a CompiledDomain's resolved methods.
+ *
+ * Produces a `BoundMethod[]` with one entry per class/interface method that
+ * requires an implementation. The handler is carried through as an opaque
+ * `THandler` slot — core performs STRUCTURAL validation only:
+ *   - sealed methods on classes cannot be re-implemented by the class
+ *   - abstract methods must have a handler
+ *   - interface non-abstract methods must have a handler
+ *
+ * Core does NOT inspect the shape of a handler (e.g. whether it has an
+ * `execute` function). Runtime-specific shape validation lives with the
+ * runtime that owns the handler contract — see
+ * `kernel/runtime/functions/definition/validate-handler.ts`.
+ */
+import { z } from 'zod';
+import { Ref } from '#domain/addressing/refs/ref';
+import { MethodBindingError } from './errors';
+import { classMethods } from './types';
+/** Build a Zod object schema from a FnDef's params config. Inputs are strict — unknown fields throw. */
+function buildInputSchema(fnDef) {
+    // params may still be a thunk at runtime if this FnDef was constructed outside
+    // defineSchema (which resolves thunks during Phase 1). FnDef's type drops the
+    // thunk union; recover it here via a runtime check.
+    const raw = fnDef.config.params;
+    const params = typeof raw === 'function' ? raw() : raw;
+    // Strict: unknown keys reject loudly. The dispatch-time silent-strip on
+    // typo'd field names was a foot-gun (see Node.createNode { props vs properties }
+    // historical asymmetry). Strict propagates through ser/de — z.toJSONSchema
+    // emits `additionalProperties: false`, which `to-zod.ts` rebuilds back as strict.
+    return z.strictObject(params ?? {});
+}
+/**
+ * Attach handlers to a compiled domain's methods.
+ *
+ * @param schema - The domain schema (interfaces + classes)
+ * @param methods - Resolved method map (className → methodName → ResolvedMethod)
+ * @param handlers - Namespace-keyed map: `handlers[namespace][ownerName][methodName] = handler`,
+ *   where `namespace` is `'class'` or `'interface'`. Splitting by namespace lets a class and an
+ *   interface share the same name without collapsing their handler slots.
+ * @returns Array of BoundMethod entries
+ */
+export function bindMethods(schema, methods, handlers) {
+    const entries = [];
+    // Pass 1: Interface methods (sealed + default)
+    for (const [name, def] of Object.entries(schema.interfaces)) {
+        const ownMethods = def.config.methods;
+        if (!ownMethods)
+            continue;
+        const interfaceHandlers = handlers.interface?.[name];
+        validateInterfaceHandlerExistence(name, ownMethods, interfaceHandlers);
+        for (const [methodName, fnDef] of Object.entries(ownMethods)) {
+            const inheritance = fnDef.config.inheritance;
+            if (inheritance === 'abstract')
+                continue;
+            // Handler must exist — validated structurally above.
+            const handler = interfaceHandlers[methodName];
+            entries.push(buildBoundMethod('interface', name, methodName, fnDef, handler));
+        }
+    }
+    // Pass 2: Class methods (own + abstract inherited + overrides)
+    for (const [className, def] of Object.entries(schema.classes)) {
+        const resolvedMethods = classMethods(methods, className);
+        if (!resolvedMethods || Object.keys(resolvedMethods).length === 0)
+            continue;
+        const classHandlers = handlers.class?.[className];
+        const ownKeys = new Set(Object.keys(def.config.methods ?? {}));
+        validateClassHandlerExistence(className, resolvedMethods, classHandlers, ownKeys);
+        for (const [methodName, rm] of Object.entries(resolvedMethods)) {
+            // Sealed → handled in pass 1 (interface provides impl)
+            if (rm.inheritance === 'sealed' && !ownKeys.has(methodName))
+                continue;
+            // Inherited default without a class-level handler → the interface's
+            // implementation applies at dispatch time. Skip this class.
+            //
+            // If the class DOES provide its own handler for an inherited default,
+            // treat it as an override and bind a class-specific contract.
+            if (rm.inheritance === 'inherited-default' && !classHandlers?.[methodName])
+                continue;
+            // Every remaining case (own / override / abstract / inherited-default-with-handler)
+            // requires a handler — the existence check happens in validateClassHandlerExistence.
+            const handler = classHandlers[methodName];
+            entries.push(buildBoundMethod('class', className, methodName, rm.fnDef, handler));
+        }
+    }
+    return entries;
+}
+function buildBoundMethod(namespace, owner, method, fnDef, handler) {
+    return {
+        ref: Ref.method(namespace, owner, method).toString(),
+        owner,
+        method,
+        fnDef,
+        inputSchema: buildInputSchema(fnDef),
+        outputSchema: fnDef.config.returns ?? z.unknown(),
+        isStatic: fnDef.config.static === true,
+        output: fnDef.config.output ?? 'value',
+        handler,
+    };
+}
+// ── Structural validation helpers ──
+// These check handler presence and sealed-method conflicts. They DO NOT inspect
+// the internal shape of a handler (e.g. the existence of an `execute` function)
+// — that's a runtime-shape concern owned by the runtime that consumes the
+// bound methods.
+/**
+ * An interface must provide handlers for its non-abstract methods.
+ * Abstract methods on interfaces are implemented downstream by classes.
+ */
+function validateInterfaceHandlerExistence(interfaceName, 
+// oxlint-disable-next-line no-explicit-any
+ownMethods, impls) {
+    const required = [];
+    for (const [name, opDef] of Object.entries(ownMethods)) {
+        // oxlint-disable-next-line no-explicit-any
+        const inheritance = opDef.config?.inheritance;
+        if (inheritance === 'abstract')
+            continue;
+        required.push(name);
+    }
+    if (required.length === 0)
+        return;
+    if (!impls) {
+        throw new MethodBindingError('MISSING_HANDLER', `Interface '${interfaceName}' has non-abstract methods that require implementations: ${required.join(', ')}`, interfaceName);
+    }
+    const missing = required.filter((n) => !impls[n]);
+    if (missing.length > 0) {
+        throw new MethodBindingError('MISSING_HANDLER', `Interface '${interfaceName}' is missing handlers for: ${missing.join(', ')}`, interfaceName);
+    }
+}
+/**
+ * A concrete class must:
+ *   - Not re-implement sealed methods owned by its interfaces.
+ *   - Provide handlers for every abstract method it inherits.
+ *   - Provide handlers for its own (non-sealed, non-inherited-default-without-handler) methods.
+ */
+function validateClassHandlerExistence(className, resolvedMethods, impls, ownMethodKeys) {
+    const missingAbstract = [];
+    const missingOwn = [];
+    const forbidden = [];
+    for (const [name, rm] of Object.entries(resolvedMethods)) {
+        // Shadowing a parent's sealed method is always a violation, regardless
+        // of whether the shadowing declaration is itself sealed or has a handler.
+        if (rm.shadowsSealed) {
+            forbidden.push(`${name} (shadows sealed from '${rm.origin}')`);
+            continue;
+        }
+        if (rm.inheritance === 'sealed') {
+            if (ownMethodKeys.has(name)) {
+                // Class-own sealed method — requires a class-side handler.
+                if (!impls?.[name])
+                    missingOwn.push(`${name} (own sealed)`);
+            }
+            else if (impls?.[name]) {
+                // Inherited sealed from an interface — must not be re-implemented.
+                forbidden.push(`${name} (sealed in '${rm.origin}')`);
+            }
+            continue;
+        }
+        if (rm.inheritance === 'inherited-default')
+            continue; // interface provides default impl
+        if (impls?.[name])
+            continue;
+        if (rm.inheritance === 'abstract') {
+            missingAbstract.push(`${name} (abstract from '${rm.origin}')`);
+        }
+        else {
+            missingOwn.push(`${name} (${rm.inheritance})`);
+        }
+    }
+    if (forbidden.length > 0) {
+        throw new MethodBindingError('SEALED_VIOLATION', `'${className}' must not provide implementations for sealed methods: ${forbidden.join(', ')}`, className);
+    }
+    if (missingAbstract.length > 0 && missingOwn.length === 0) {
+        throw new MethodBindingError('MISSING_ABSTRACT_IMPL', `'${className}' must implement abstract methods: ${missingAbstract.join(', ')}`, className);
+    }
+    if (missingAbstract.length + missingOwn.length > 0) {
+        const all = [...missingAbstract, ...missingOwn].join(', ');
+        throw new MethodBindingError('MISSING_HANDLER', `'${className}' is missing handlers for methods: ${all}`, className);
+    }
+}
+//# sourceMappingURL=bind.js.map

package/dist/domain/compile/method/bind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind.js","sourceRoot":"","sources":["../../../../domain/compile/method/bind.ts"],"names":[],"mappings":"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"}

package/dist/domain/compile/method/bound-method.d.ts

@@ -0,0 +1,56 @@
+import type { FnDef } from '@astrale-os/kernel-dsl';
+import type { z } from 'zod';
+import type { AccessorNode } from '#domain/accessors/types';
+/**
+ * A method definition paired with a handler slot.
+ *
+ * This type is STRUCTURAL — core never asserts anything about the shape of
+ * `THandler`. Each environment (kernel runtime, SDK) specializes THandler to
+ * its own handler type (e.g. the kernel runtime uses hooks with authenticate /
+ * authorize / execute / rollback, while a remote SDK handler may have a
+ * different shape entirely).
+ *
+ * Validating the runtime-specific shape of a handler is a runtime concern —
+ * see `kernel/runtime/functions/definition/validate-handler.ts`.
+ */
+export type BoundMethod<THandler = unknown> = {
+    /** Method ref: 'namespace.Owner.method.methodName' (e.g. 'class.Author.method.deactivate') */
+    ref: string;
+    /** Owning def name (class or interface) */
+    owner: string;
+    /** Method name */
+    method: string;
+    /** The resolved FnDef from the schema (present after bindMethods, absent in sandbox hydration). */
+    fnDef?: FnDef;
+    /** Zod schema for input validation */
+    inputSchema: z.ZodType;
+    /** Zod schema for output validation */
+    outputSchema: z.ZodType;
+    /** true if no self context */
+    isStatic: boolean;
+    /** Output mode */
+    output: 'value' | 'stream' | 'binary';
+    /** Environment-specific handler */
+    handler: THandler;
+    /** Optional description */
+    description?: string;
+    /** Optional binding metadata */
+    binding?: {
+        remoteUrl?: string;
+        route?: {
+            method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | '*';
+            path: string;
+        };
+    };
+};
+/**
+ * Bound node/edge instance passed to method handlers.
+ *
+ * Handlers receive the same `AccessorNode` shape the SDK/CLI use elsewhere —
+ * one accessor type across the system, nothing handler-specific. Identity
+ * (`id`, `path`, `class`) is part of that shape; data lives behind explicit
+ * groups (`attrs` / interface names / `$d()`). See `AccessorNode` for the
+ * full contract.
+ */
+export type MethodSelf = AccessorNode;
+//# sourceMappingURL=bound-method.d.ts.map

package/dist/domain/compile/method/bound-method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bound-method.d.ts","sourceRoot":"","sources":["../../../../domain/compile/method/bound-method.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AACnD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAI3D;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,CAAC,QAAQ,GAAG,OAAO,IAAI;IAC5C,8FAA8F;IAC9F,GAAG,EAAE,MAAM,CAAA;IACX,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb,kBAAkB;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,mGAAmG;IACnG,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,sCAAsC;IACtC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAA;IACtB,uCAAuC;IACvC,YAAY,EAAE,CAAC,CAAC,OAAO,CAAA;IACvB,8BAA8B;IAC9B,QAAQ,EAAE,OAAO,CAAA;IACjB,kBAAkB;IAClB,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAA;IACrC,mCAAmC;IACnC,OAAO,EAAE,QAAQ,CAAA;IACjB,2BAA2B;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,gCAAgC;IAChC,OAAO,CAAC,EAAE;QACR,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,KAAK,CAAC,EAAE;YAAE,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,GAAG,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;KACpF,CAAA;CACF,CAAA;AAID;;;;;;;;GAQG;AACH,MAAM,MAAM,UAAU,GAAG,YAAY,CAAA"}

package/dist/domain/compile/method/bound-method.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bound-method.js.map

package/dist/domain/compile/method/bound-method.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bound-method.js","sourceRoot":"","sources":["../../../../domain/compile/method/bound-method.ts"],"names":[],"mappings":""}

package/dist/domain/compile/method/errors.d.ts

@@ -0,0 +1,8 @@
+import { DomainError } from '#domain/errors';
+/** Structural validation failures during method handler binding. */
+export declare class MethodBindingError extends DomainError {
+    readonly code: 'MISSING_HANDLER' | 'SEALED_VIOLATION' | 'MISSING_ABSTRACT_IMPL';
+    readonly owner: string;
+    constructor(code: 'MISSING_HANDLER' | 'SEALED_VIOLATION' | 'MISSING_ABSTRACT_IMPL', message: string, owner: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/domain/compile/method/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../domain/compile/method/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAE5C,oEAAoE;AACpE,qBAAa,kBAAmB,SAAQ,WAAW;IAE/C,QAAQ,CAAC,IAAI,EAAE,iBAAiB,GAAG,kBAAkB,GAAG,uBAAuB;IAE/E,QAAQ,CAAC,KAAK,EAAE,MAAM;IAHxB,YACW,IAAI,EAAE,iBAAiB,GAAG,kBAAkB,GAAG,uBAAuB,EAC/E,OAAO,EAAE,MAAM,EACN,KAAK,EAAE,MAAM,EAGvB;CACF"}

package/dist/domain/compile/method/errors.js

@@ -0,0 +1,12 @@
+import { DomainError } from '#domain/errors';
+/** Structural validation failures during method handler binding. */
+export class MethodBindingError extends DomainError {
+    code;
+    owner;
+    constructor(code, message, owner) {
+        super('MethodBindingError', `MethodBindingError [${code}]: ${message}`);
+        this.code = code;
+        this.owner = owner;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/domain/compile/method/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../../domain/compile/method/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAE5C,oEAAoE;AACpE,MAAM,OAAO,kBAAmB,SAAQ,WAAW;IAEtC,IAAI;IAEJ,KAAK;IAHhB,YACW,IAAsE,EAC/E,OAAe,EACN,KAAa;QAEtB,KAAK,CAAC,oBAAoB,EAAE,uBAAuB,IAAI,MAAM,OAAO,EAAE,CAAC,CAAA;oBAJ9D,IAAI;qBAEJ,KAAK;IAGhB,CAAC;CACF"}

package/dist/domain/compile/method/index.d.ts

@@ -0,0 +1,12 @@
+export { MethodBindingError } from './errors';
+export type { ResolvedMethod, DomainMethodsMap, MethodWithOrigin, MethodClassKeys, InterfaceMethodKeys, } from './types';
+export type { DefDescriptor } from './types';
+export { classMethods, interfaceMethods, methodsOf } from './types';
+export type { DomainInheritance, GraphInheritanceMarker } from './resolve';
+export { resolveMethodsWithOrigin, resolveAllMethodsForSchema, resolveAllMethodsForDomain, toDomainInheritance, toGraphInheritance, isMaterializedAsNode, } from './resolve';
+export type { BoundMethod, MethodSelf } from './bound-method';
+export { bindMethods } from './bind';
+export { methodWirePath, parseMethodFromWirePath } from './wire';
+export type { InterfaceMethodDefs, IsStatic, ClassMethodConfig, ResolveParams, ResolveReturn, WithNodeId, } from './signature';
+export type { DefaultOverrideKeys, InheritedDefaultKeys, NonSealedMethodKeys, OwnMethodKeys, SealedKeys, } from './inheritance-keys';
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/compile/method/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../domain/compile/method/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAG7C,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,mBAAmB,GACpB,MAAM,SAAS,CAAA;AAChB,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAG5C,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAGnE,YAAY,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA;AAC1E,OAAO,EACL,wBAAwB,EACxB,0BAA0B,EAC1B,0BAA0B,EAC1B,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,WAAW,CAAA;AAGlB,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAG7D,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AAGpC,OAAO,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,QAAQ,CAAA;AAGhE,YAAY,EACV,mBAAmB,EACnB,QAAQ,EACR,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,UAAU,GACX,MAAM,aAAa,CAAA;AAGpB,YAAY,EACV,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACnB,aAAa,EACb,UAAU,GACX,MAAM,oBAAoB,CAAA"}

package/dist/domain/compile/method/index.js

@@ -0,0 +1,10 @@
+// Errors
+export { MethodBindingError } from './errors';
+// Accessors for the defRef-keyed DomainMethodsMap (look up by bare name + kind)
+export { classMethods, interfaceMethods, methodsOf } from './types';
+export { resolveMethodsWithOrigin, resolveAllMethodsForSchema, resolveAllMethodsForDomain, toDomainInheritance, toGraphInheritance, isMaterializedAsNode, } from './resolve';
+// Binding (structural only — shape validation is a runtime concern)
+export { bindMethods } from './bind';
+// Wire path construction
+export { methodWirePath, parseMethodFromWirePath } from './wire';
+//# sourceMappingURL=index.js.map

package/dist/domain/compile/method/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../domain/compile/method/index.ts"],"names":[],"mappings":"AAAA,SAAS;AACT,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAY7C,gFAAgF;AAChF,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAInE,OAAO,EACL,wBAAwB,EACxB,0BAA0B,EAC1B,0BAA0B,EAC1B,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,WAAW,CAAA;AAKlB,oEAAoE;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AAEpC,yBAAyB;AACzB,OAAO,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,QAAQ,CAAA"}

package/dist/domain/compile/method/inheritance-keys.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Inheritance-classified method key sets.
+ *
+ * TypeScript lacks higher-kinded types, so core cannot parameterize a
+ * per-class `MethodsImpl` by handler shape. Instead, these key-set utilities
+ * partition a class's methods by their inheritance relationship to its
+ * parents, and each environment composes its own implementation map using
+ * these keys + its handler shape.
+ *
+ * Purely type-level. No runtime behavior.
+ */
+import type { AllMethods, AllSealedKeys, ExtractMethods, InheritedDefaultKeys as BuilderInheritedDefaultKeys, Schema } from '@astrale-os/kernel-dsl';
+import type { DefForClass } from '#domain/compile/catalog/def-types';
+/** Methods declared directly on the class (not inherited). */
+export type OwnMethodKeys<S extends Schema, K extends string> = keyof ExtractMethods<DefForClass<S, K>> & string;
+/** Own methods that happen to override a parent's default implementation. */
+export type DefaultOverrideKeys<S extends Schema, K extends string> = OwnMethodKeys<S, K> & BuilderInheritedDefaultKeys<DefForClass<S, K>>;
+/** Methods sealed by an interface — classes must NOT re-implement them. */
+export type SealedKeys<S extends Schema, K extends string> = Exclude<AllSealedKeys<DefForClass<S, K>> & string, OwnMethodKeys<S, K>>;
+/** Default methods inherited from an interface; the class may override them. */
+export type InheritedDefaultKeys<S extends Schema, K extends string> = Exclude<BuilderInheritedDefaultKeys<DefForClass<S, K>> & string, OwnMethodKeys<S, K>>;
+/** Methods that are neither sealed, inherited-default, nor own — e.g. abstract. */
+export type NonSealedMethodKeys<S extends Schema, K extends string> = Exclude<keyof AllMethods<DefForClass<S, K>> & string, SealedKeys<S, K> | InheritedDefaultKeys<S, K> | OwnMethodKeys<S, K>>;
+//# sourceMappingURL=inheritance-keys.d.ts.map

package/dist/domain/compile/method/inheritance-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inheritance-keys.d.ts","sourceRoot":"","sources":["../../../../domain/compile/method/inheritance-keys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,aAAa,EACb,cAAc,EACd,oBAAoB,IAAI,2BAA2B,EACnD,MAAM,EACP,MAAM,wBAAwB,CAAA;AAE/B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AAOpE,8DAA8D;AAC9D,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,IAAI,MAAM,cAAc,CAClF,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAClB,GACC,MAAM,CAAA;AAER,6EAA6E;AAC7E,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,IAAI,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,GACvF,2BAA2B,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AAEhD,2EAA2E;AAC3E,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,IAAI,OAAO,CAClE,aAAa,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,MAAM,EACzC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CACpB,CAAA;AAED,gFAAgF;AAChF,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,IAAI,OAAO,CAC5E,2BAA2B,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,MAAM,EACvD,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CACpB,CAAA;AAED,mFAAmF;AACnF,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,IAAI,OAAO,CAC3E,MAAM,UAAU,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,MAAM,EAC5C,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CACpE,CAAA"}

package/dist/domain/compile/method/inheritance-keys.js

@@ -0,0 +1,13 @@
+/**
+ * Inheritance-classified method key sets.
+ *
+ * TypeScript lacks higher-kinded types, so core cannot parameterize a
+ * per-class `MethodsImpl` by handler shape. Instead, these key-set utilities
+ * partition a class's methods by their inheritance relationship to its
+ * parents, and each environment composes its own implementation map using
+ * these keys + its handler shape.
+ *
+ * Purely type-level. No runtime behavior.
+ */
+export {};
+//# sourceMappingURL=inheritance-keys.js.map

package/dist/domain/compile/method/inheritance-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inheritance-keys.js","sourceRoot":"","sources":["../../../../domain/compile/method/inheritance-keys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}