@astrale-os/kernel-core 0.4.1

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

@@ -0,0 +1,93 @@
+/**
+ * Method resolution — builder-schema → domain method maps.
+ *
+ * Two resolvers live here:
+ *   - `resolveAllMethodsForSchema` — walks every def, resolves methods with
+ *     origin/override tracking via the identity map.
+ *   - `resolveAllMethodsForDomain` — translates the builder's 3-valued
+ *     inheritance axis to the domain's richer 5-valued axis
+ *     (sealed / abstract / own / override / inherited-default).
+ *
+ * Pure: no handler code, no runtime execution.
+ */
+import type { AnyDef, MethodInheritance, Schema } from '@astrale-os/kernel-dsl';
+import { type DefDescriptor } from '@astrale-os/kernel-dsl';
+import type { ResolvedMethod } from './types';
+import type { MethodWithOrigin } from './types';
+/** Domain-level inheritance classification (5-valued). */
+export type DomainInheritance = 'sealed' | 'abstract' | 'own' | 'override' | 'inherited-default';
+/**
+ * Translate a builder-level method + context into the domain's richer
+ * inheritance classification.
+ *
+ * `isOwn` is the identity-correct signal for "declared on this def" — it does
+ * NOT compare names (a class and an interface can share a name, e.g.
+ * `Function`, so a name comparison would mislabel an inherited method as own).
+ *
+ * Rules:
+ *   builder 'sealed'   → domain 'sealed'
+ *   builder 'abstract' → domain 'abstract' (concrete class must implement)
+ *   isOwn && !isOverride → 'own'
+ *   isOwn && isOverride  → 'override'
+ *   !isOwn               → 'inherited-default'
+ */
+export declare function toDomainInheritance(builderInheritance: MethodInheritance, isOwn: boolean, isOverride: boolean): DomainInheritance;
+/**
+ * The graph-storage axis: the only values `Function.inheritance` legitimately
+ * contains in the graph. Three values, all round-trippable via `translateInheritance`.
+ *
+ * Distinct from `functionInheritanceSchema` which is the DTO/builder axis (what the
+ * schema author writes). See the note on `functionInheritanceSchema` in
+ * `compile/method/serialized.ts`.
+ */
+export type GraphInheritanceMarker = 'sealed' | 'override' | 'default';
+/**
+ * Map a resolved method to the graph-storage marker written on its materialized
+ * Function node (`Function.inheritance`).
+ *
+ * SINGLE source of the marker rule, shared by the boot pipeline and the serializer
+ * so the two producers cannot drift. Three values only — no `memberKind` branch.
+ *
+ * The marker is the axis `translateInheritance` (`deserialize/deserialize.ts`) reads:
+ * `'override'` is the only marker that recovers `isOverride: true` on round-trip;
+ * `'sealed'` stays `'sealed'`; everything else (`'own'`, `'inherited-default'`,
+ * `'abstract'`) maps to `'default'`, which `translateInheritance` resolves back to
+ * `'own'` or `'inherited-default'` depending on the declaring/owner relationship.
+ *
+ * The node-vs-edge / materialization decision is the caller's responsibility —
+ * see `isMaterializedAsNode`.
+ */
+export declare function toGraphInheritance(rm: ResolvedMethod): GraphInheritanceMarker;
+/**
+ * `true` if this resolved method is materialized as a Function node in the graph.
+ *
+ * - class  : own/override → node; sealed/inherited-default → reuses origin's node
+ *            via `method_of` edge; abstract → not materialized at all.
+ * - interface: own non-abstract → node; inherited methods reuse the parent's node.
+ *
+ * The `isOwn` discipline on the interface branch is ESSENTIAL — without it, an
+ * interface that inherits sealed methods from a parent (e.g. `Function` extends
+ * `Container` + `Identity` in the kernel) would emit duplicate nodes.
+ */
+export declare function isMaterializedAsNode(rm: ResolvedMethod): boolean;
+/**
+ * Resolve all methods for a definition with origin/override tracking.
+ *
+ * Walks the inheritance chain using the identity map.
+ * Own methods shadow inherited ones and are marked as overrides when applicable.
+ */
+export declare function resolveMethodsWithOrigin(def: AnyDef, defName: string, descriptorMap: Map<AnyDef, DefDescriptor>): Record<string, MethodWithOrigin>;
+/**
+ * Resolve all methods for a schema with full inheritance/origin tracking.
+ * Returns a map of defRef (`class.X` / `interface.X`) → methodName →
+ * MethodWithOrigin. Keyed by the kind-qualified ref (NOT bare name) so a
+ * class and an interface sharing a name each get their own entry.
+ */
+export declare function resolveAllMethodsForSchema<S extends Schema>(schema: S): Map<string, Record<string, MethodWithOrigin>>;
+/**
+ * Resolve all methods for every concrete def in a schema.
+ * Wraps `resolveAllMethodsForSchema` and translates the builder's
+ * MethodInheritance → domain inheritance axis.
+ */
+export declare function resolveAllMethodsForDomain(schema: Schema, origin: string): Record<string, Record<string, ResolvedMethod>>;
+//# sourceMappingURL=resolve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../../../domain/compile/method/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACV,MAAM,EAIN,iBAAiB,EACjB,MAAM,EACP,MAAM,wBAAwB,CAAA;AAE/B,OAAO,EAAsC,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAM/F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAE/C,0DAA0D;AAC1D,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,UAAU,GAAG,KAAK,GAAG,UAAU,GAAG,mBAAmB,CAAA;AAEhG;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CACjC,kBAAkB,EAAE,iBAAiB,EACrC,KAAK,EAAE,OAAO,EACd,UAAU,EAAE,OAAO,GAClB,iBAAiB,CAKnB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,sBAAsB,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAA;AAEtE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,cAAc,GAAG,sBAAsB,CAI7E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,cAAc,GAAG,OAAO,CAKhE;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GACxC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CA8DlC;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,MAAM,EACzD,MAAM,EAAE,CAAC,GACR,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAY/C;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAgChD"}

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

@@ -0,0 +1,194 @@
+/**
+ * Method resolution — builder-schema → domain method maps.
+ *
+ * Two resolvers live here:
+ *   - `resolveAllMethodsForSchema` — walks every def, resolves methods with
+ *     origin/override tracking via the identity map.
+ *   - `resolveAllMethodsForDomain` — translates the builder's 3-valued
+ *     inheritance axis to the domain's richer 5-valued axis
+ *     (sealed / abstract / own / override / inherited-default).
+ *
+ * Pure: no handler code, no runtime execution.
+ */
+import { buildDefDescriptorMap, parseDefRef } from '@astrale-os/kernel-dsl';
+import { MethodPath } from '#domain/addressing/paths/method';
+import { Ref } from '#domain/addressing/refs/ref';
+import { allDefs } from '#domain/compile/catalog/defs';
+/**
+ * Translate a builder-level method + context into the domain's richer
+ * inheritance classification.
+ *
+ * `isOwn` is the identity-correct signal for "declared on this def" — it does
+ * NOT compare names (a class and an interface can share a name, e.g.
+ * `Function`, so a name comparison would mislabel an inherited method as own).
+ *
+ * Rules:
+ *   builder 'sealed'   → domain 'sealed'
+ *   builder 'abstract' → domain 'abstract' (concrete class must implement)
+ *   isOwn && !isOverride → 'own'
+ *   isOwn && isOverride  → 'override'
+ *   !isOwn               → 'inherited-default'
+ */
+export function toDomainInheritance(builderInheritance, isOwn, isOverride) {
+    if (builderInheritance === 'sealed')
+        return 'sealed';
+    if (builderInheritance === 'abstract')
+        return 'abstract';
+    if (isOwn)
+        return isOverride ? 'override' : 'own';
+    return 'inherited-default';
+}
+/**
+ * Map a resolved method to the graph-storage marker written on its materialized
+ * Function node (`Function.inheritance`).
+ *
+ * SINGLE source of the marker rule, shared by the boot pipeline and the serializer
+ * so the two producers cannot drift. Three values only — no `memberKind` branch.
+ *
+ * The marker is the axis `translateInheritance` (`deserialize/deserialize.ts`) reads:
+ * `'override'` is the only marker that recovers `isOverride: true` on round-trip;
+ * `'sealed'` stays `'sealed'`; everything else (`'own'`, `'inherited-default'`,
+ * `'abstract'`) maps to `'default'`, which `translateInheritance` resolves back to
+ * `'own'` or `'inherited-default'` depending on the declaring/owner relationship.
+ *
+ * The node-vs-edge / materialization decision is the caller's responsibility —
+ * see `isMaterializedAsNode`.
+ */
+export function toGraphInheritance(rm) {
+    if (rm.inheritance === 'sealed')
+        return 'sealed';
+    if (rm.inheritance === 'override')
+        return 'override';
+    return 'default'; // 'own' (class + interface), 'inherited-default', 'abstract' → 'default'
+}
+/**
+ * `true` if this resolved method is materialized as a Function node in the graph.
+ *
+ * - class  : own/override → node; sealed/inherited-default → reuses origin's node
+ *            via `method_of` edge; abstract → not materialized at all.
+ * - interface: own non-abstract → node; inherited methods reuse the parent's node.
+ *
+ * The `isOwn` discipline on the interface branch is ESSENTIAL — without it, an
+ * interface that inherits sealed methods from a parent (e.g. `Function` extends
+ * `Container` + `Identity` in the kernel) would emit duplicate nodes.
+ */
+export function isMaterializedAsNode(rm) {
+    if (rm.memberKind === 'class') {
+        return rm.inheritance === 'own' || rm.inheritance === 'override';
+    }
+    return rm.isOwn && rm.inheritance !== 'abstract';
+}
+/**
+ * Resolve all methods for a definition with origin/override tracking.
+ *
+ * Walks the inheritance chain using the identity map.
+ * Own methods shadow inherited ones and are marked as overrides when applicable.
+ */
+export function resolveMethodsWithOrigin(def, defName, descriptorMap) {
+    // Kind of THIS def — stamped as `originKind` on its own methods so consumers
+    // can address the declaring def without re-resolving by (ambiguous) name.
+    const descriptor = descriptorMap.get(def);
+    if (!descriptor) {
+        throw new Error(`descriptor missing for def "${defName}" — def must be in schema.interfaces, schema.classes, or a direct import`);
+    }
+    const selfKind = descriptor.group;
+    // Collect inherited methods first
+    const inherited = {};
+    const inherits = def.config.inherits ?? [];
+    for (const parent of inherits) {
+        const parentDescriptor = descriptorMap.get(parent);
+        if (!parentDescriptor)
+            continue;
+        const parentMethods = resolveMethodsWithOrigin(parent, parentDescriptor.name, descriptorMap);
+        for (const [name, method] of Object.entries(parentMethods)) {
+            inherited[name] = {
+                fnDef: method.fnDef,
+                origin: method.origin,
+                originKind: method.originKind,
+                inheritance: method.inheritance,
+            };
+        }
+    }
+    const result = {};
+    // Start with inherited methods
+    for (const [name, { fnDef, origin, originKind, inheritance }] of Object.entries(inherited)) {
+        result[name] = {
+            fnDef,
+            inheritance,
+            origin,
+            originKind,
+            isOwn: false,
+            isOverride: false,
+            shadowsSealed: false,
+        };
+    }
+    // Own methods shadow inherited
+    const ownMethods = def.config.methods ?? {};
+    for (const [name, fnDef] of Object.entries(ownMethods)) {
+        const parent = inherited[name];
+        result[name] = {
+            fnDef,
+            inheritance: fnDef.config.inheritance ?? 'default',
+            origin: defName,
+            originKind: selfKind,
+            isOwn: true,
+            isOverride: parent !== undefined,
+            shadowsSealed: parent?.inheritance === 'sealed',
+        };
+    }
+    return result;
+}
+/**
+ * Resolve all methods for a schema with full inheritance/origin tracking.
+ * Returns a map of defRef (`class.X` / `interface.X`) → methodName →
+ * MethodWithOrigin. Keyed by the kind-qualified ref (NOT bare name) so a
+ * class and an interface sharing a name each get their own entry.
+ */
+export function resolveAllMethodsForSchema(schema) {
+    const descriptorMap = buildDefDescriptorMap(schema);
+    const result = new Map();
+    for (const [name, def] of allDefs(schema)) {
+        const resolved = resolveMethodsWithOrigin(def, name, descriptorMap);
+        if (Object.keys(resolved).length > 0) {
+            result.set(descriptorMap.get(def).ref, resolved);
+        }
+    }
+    return result;
+}
+/**
+ * Resolve all methods for every concrete def in a schema.
+ * Wraps `resolveAllMethodsForSchema` and translates the builder's
+ * MethodInheritance → domain inheritance axis.
+ */
+export function resolveAllMethodsForDomain(schema, origin) {
+    const resolved = resolveAllMethodsForSchema(schema);
+    const result = {};
+    for (const [defRefKey, methods] of resolved) {
+        // `defRefKey` is `class.X` / `interface.X`; memberKind + bare name come
+        // straight from it (no `interfaceNames.has(name)` — that collapses homonyms).
+        const { kind: memberKind, name: memberName } = parseDefRef(defRefKey);
+        const methodRecord = {};
+        for (const [methodName, method] of Object.entries(methods)) {
+            methodRecord[methodName] = Object.freeze({
+                fnDef: method.fnDef,
+                inheritance: toDomainInheritance(method.inheritance, method.isOwn, method.isOverride),
+                origin: method.origin,
+                originKind: method.originKind,
+                isOwn: method.isOwn,
+                isOverride: method.isOverride,
+                shadowsSealed: method.shadowsSealed,
+                memberKind,
+                ref: Ref.method(memberKind, memberName, methodName).toString(),
+                path: MethodPath.from({
+                    domain: origin,
+                    member: memberName,
+                    memberKind,
+                    method: methodName,
+                }),
+            });
+        }
+        result[defRefKey] = Object.freeze(methodRecord);
+    }
+    return result;
+}
+//# sourceMappingURL=resolve.js.map

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

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

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

@@ -0,0 +1,130 @@
+/**
+ * Canonical serialized form for methods (Functions).
+ *
+ * Single source of truth for the shape of method metadata as it travels on
+ * the wire, in graph storage (as stringified properties), through runtime
+ * serializers, and through SDK serializers.
+ *
+ * The kernel `Function` node interface (schema/interfaces/Function.interface.ts)
+ * imports `functionSchema` from here to derive its prop shape — one-way
+ * schema→domain edge.
+ */
+import type { JSONSchema7 } from 'json-schema';
+import { z } from 'zod';
+export type { JSONSchema7 as JSONSchema };
+/**
+ * Sandbox-eval code strings. All fields optional at the wire level:
+ *  - Kernel domain methods (sandbox-eval'd) carry `authorize` + `execute`.
+ *  - Remote-bound methods (SDK-authored domains) carry none — dispatch goes
+ *    through `binding.remoteUrl` and never reaches the sandbox.
+ * The kernel-side authoring API (`FunctionHooks` in kernel-runtime) still
+ * requires `authorize`/`execute` at compile time — strictness lives there.
+ */
+export declare const functionCodeSchema: z.ZodObject<{
+    authenticate: z.ZodOptional<z.ZodString>;
+    authorize: z.ZodOptional<z.ZodString>;
+    resolve: z.ZodOptional<z.ZodString>;
+    invariants: z.ZodOptional<z.ZodString>;
+    execute: z.ZodOptional<z.ZodString>;
+    rollback: z.ZodOptional<z.ZodString>;
+    effects: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const functionBindingSchema: z.ZodOptional<z.ZodObject<{
+    remoteUrl: z.ZodOptional<z.ZodString>;
+    route: z.ZodOptional<z.ZodObject<{
+        method: z.ZodEnum<{
+            "*": "*";
+            DELETE: "DELETE";
+            GET: "GET";
+            PATCH: "PATCH";
+            POST: "POST";
+            PUT: "PUT";
+        }>;
+        path: z.ZodString;
+        self: z.ZodOptional<z.ZodString>;
+        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        body: z.ZodOptional<z.ZodUnknown>;
+        credential: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+    auth: z.ZodOptional<z.ZodEnum<{
+        optional: "optional";
+        public: "public";
+        required: "required";
+    }>>;
+}, z.core.$strip>>;
+export declare const functionOutputSchema: z.ZodEnum<{
+    binary: "binary";
+    stream: "stream";
+    value: "value";
+}>;
+/**
+ * DTO/builder axis — what the schema author writes (`fn({ inheritance: 'sealed' })`).
+ * NOT the graph storage axis: the graph also legitimately contains `'override'` for
+ * methods that override a parent's default. See `GraphInheritanceMarker` in
+ * `compile/method/resolve.ts` for the storage axis.
+ */
+export declare const functionInheritanceSchema: z.ZodEnum<{
+    abstract: "abstract";
+    default: "default";
+    sealed: "sealed";
+}>;
+/**
+ * JSON-transportable shape of a method.
+ *
+ * Graph storage (stringified props), runtime serializers, SDK serializers,
+ * and materialize all derive from this.
+ */
+export declare const functionSchema: z.ZodObject<{
+    ref: z.ZodString;
+    inputSchema: z.ZodCustom<JSONSchema7, JSONSchema7>;
+    outputSchema: z.ZodCustom<JSONSchema7, JSONSchema7>;
+    code: z.ZodOptional<z.ZodObject<{
+        authenticate: z.ZodOptional<z.ZodString>;
+        authorize: z.ZodOptional<z.ZodString>;
+        resolve: z.ZodOptional<z.ZodString>;
+        invariants: z.ZodOptional<z.ZodString>;
+        execute: z.ZodOptional<z.ZodString>;
+        rollback: z.ZodOptional<z.ZodString>;
+        effects: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    isStatic: z.ZodOptional<z.ZodBoolean>;
+    output: z.ZodOptional<z.ZodEnum<{
+        binary: "binary";
+        stream: "stream";
+        value: "value";
+    }>>;
+    inheritance: z.ZodOptional<z.ZodEnum<{
+        abstract: "abstract";
+        default: "default";
+        sealed: "sealed";
+    }>>;
+    binding: z.ZodOptional<z.ZodObject<{
+        remoteUrl: z.ZodOptional<z.ZodString>;
+        route: z.ZodOptional<z.ZodObject<{
+            method: z.ZodEnum<{
+                "*": "*";
+                DELETE: "DELETE";
+                GET: "GET";
+                PATCH: "PATCH";
+                POST: "POST";
+                PUT: "PUT";
+            }>;
+            path: z.ZodString;
+            self: z.ZodOptional<z.ZodString>;
+            query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            body: z.ZodOptional<z.ZodUnknown>;
+            credential: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>;
+        auth: z.ZodOptional<z.ZodEnum<{
+            optional: "optional";
+            public: "public";
+            required: "required";
+        }>>;
+    }, z.core.$strip>>;
+    environment: z.ZodOptional<z.ZodString>;
+    domain: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FunctionSchema = z.infer<typeof functionSchema>;
+//# sourceMappingURL=serialized.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serialized.d.ts","sourceRoot":"","sources":["../../../../domain/compile/method/serialized.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAE9C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,YAAY,EAAE,WAAW,IAAI,UAAU,EAAE,CAAA;AAIzC;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;iBAQ7B,CAAA;AAcF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;kBAMrB,CAAA;AAEb,eAAO,MAAM,oBAAoB;;;;EAAwC,CAAA;AAEzE;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;;;;EAA4C,CAAA;AAIlF;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWzB,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}

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

@@ -0,0 +1,75 @@
+/**
+ * Canonical serialized form for methods (Functions).
+ *
+ * Single source of truth for the shape of method metadata as it travels on
+ * the wire, in graph storage (as stringified properties), through runtime
+ * serializers, and through SDK serializers.
+ *
+ * The kernel `Function` node interface (schema/interfaces/Function.interface.ts)
+ * imports `functionSchema` from here to derive its prop shape — one-way
+ * schema→domain edge.
+ */
+import { z } from 'zod';
+// ── Canonical sub-schemas ──────────────────────────────────────────────
+/**
+ * Sandbox-eval code strings. All fields optional at the wire level:
+ *  - Kernel domain methods (sandbox-eval'd) carry `authorize` + `execute`.
+ *  - Remote-bound methods (SDK-authored domains) carry none — dispatch goes
+ *    through `binding.remoteUrl` and never reaches the sandbox.
+ * The kernel-side authoring API (`FunctionHooks` in kernel-runtime) still
+ * requires `authorize`/`execute` at compile time — strictness lives there.
+ */
+export const functionCodeSchema = z.object({
+    authenticate: z.string().optional(),
+    authorize: z.string().optional(),
+    resolve: z.string().optional(),
+    invariants: z.string().optional(),
+    execute: z.string().optional(),
+    rollback: z.string().optional(),
+    effects: z.string().optional(),
+});
+const httpMethodSchema = z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', '*']);
+const routeBindingSchema = z.object({
+    method: httpMethodSchema,
+    path: z.string(),
+    self: z.string().optional(),
+    query: z.record(z.string(), z.string()).optional(),
+    headers: z.record(z.string(), z.unknown()).optional(),
+    body: z.unknown().optional(),
+    credential: z.unknown().optional(),
+});
+export const functionBindingSchema = z
+    .object({
+    remoteUrl: z.string().optional(),
+    route: routeBindingSchema.optional(),
+    auth: z.enum(['required', 'optional', 'public']).optional(),
+})
+    .optional();
+export const functionOutputSchema = z.enum(['value', 'stream', 'binary']);
+/**
+ * DTO/builder axis — what the schema author writes (`fn({ inheritance: 'sealed' })`).
+ * NOT the graph storage axis: the graph also legitimately contains `'override'` for
+ * methods that override a parent's default. See `GraphInheritanceMarker` in
+ * `compile/method/resolve.ts` for the storage axis.
+ */
+export const functionInheritanceSchema = z.enum(['sealed', 'abstract', 'default']);
+// ── functionSchema — THE canonical serialized form ────────────────────
+/**
+ * JSON-transportable shape of a method.
+ *
+ * Graph storage (stringified props), runtime serializers, SDK serializers,
+ * and materialize all derive from this.
+ */
+export const functionSchema = z.object({
+    ref: z.string(),
+    inputSchema: z.custom(),
+    outputSchema: z.custom(),
+    code: functionCodeSchema.optional(),
+    isStatic: z.boolean().optional(),
+    output: functionOutputSchema.optional(),
+    inheritance: functionInheritanceSchema.optional(),
+    binding: functionBindingSchema,
+    environment: z.string().optional(),
+    domain: z.string().optional(),
+});
+//# sourceMappingURL=serialized.js.map

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

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

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

@@ -0,0 +1,78 @@
+/**
+ * Method signature resolution — type-level helpers that map a schema FnDef
+ * into concrete param / return / self types.
+ *
+ * Purely type-level. No runtime behavior.
+ */
+import type { AllMethods, InferProperties, RefSchema, Schema, SelfDef } from '@astrale-os/kernel-dsl';
+import type { z } from 'zod';
+import type { AllDefNames, DefForClass, DefForInterface } from '#domain/compile/catalog/def-types';
+import type { Node, Edge } from '#graph';
+import type { NodeId } from '#ids';
+import type { MethodSelf } from './bound-method';
+export type InterfaceMethodDefs<S extends Schema, K extends string> = AllMethods<DefForInterface<S, K>>;
+/**
+ * Map `{ id: string }` → `{ id: NodeId }` for ref params.
+ *
+ * `self` is resolved separately — at dispatch time `bindSelf` wraps the
+ * concrete node into an `AccessorNode` with structural identity attached
+ * (see `bound-method.ts#MethodSelf`). Ref params (`params.parent = ref(Node)`)
+ * are NOT hydrated; handlers resolve them on demand via
+ * `kernel.graph.getNode(IdPath.from(params.X.id))` when they need a path.
+ */
+export type WithNodeId<T> = T extends {
+    readonly id: string;
+} ? Omit<T, 'id'> & {
+    readonly id: NodeId;
+} : T;
+/** Resolve FnConfig params to inferred TypeScript type. */
+export type ResolveParams<MC> = MC extends {
+    readonly params: infer P;
+} ? P extends () => infer R ? {
+    [K in keyof InferProperties<R>]: WithNodeId<InferProperties<R>[K]>;
+} : {
+    [K in keyof InferProperties<P>]: WithNodeId<InferProperties<P>[K]>;
+} : Record<string, never>;
+/** Resolve scalar return type from FnConfig. */
+type ResolveScalarReturn<MC> = MC extends {
+    readonly returns: infer R;
+} ? R extends RefSchema<SelfDef> ? Node | Edge : R extends z.ZodType ? z.infer<R> : unknown : unknown;
+/** Resolve return type — wraps in AsyncGenerator when stream: true. */
+export type ResolveReturn<MC> = MC extends {
+    readonly output: 'stream';
+} ? AsyncGenerator<ResolveScalarReturn<MC>> : ResolveScalarReturn<MC>;
+/** Whether a method is static (no self context). */
+export type IsStatic<MC> = MC extends {
+    readonly static: true;
+} ? true : false;
+/**
+ * Core's resolved method config — params / result / self / static / output.
+ * Environments use this to build their own MethodImpl by wrapping in their
+ * handler shape.
+ *
+ * `self` is the universal `MethodSelf` (an `AccessorNode`). Typed grouped
+ * property narrowing per def is a follow-up refinement on the builder side —
+ * until then handlers cast through `self.attrs` / `self.Interface`.
+ *
+ * Class-context: resolves the method via `DefForClass`, so a class/interface
+ * homonym (`Function`) resolves the CLASS's methods (e.g. `init`), not the
+ * interface's. The interface side builds its handler shape separately
+ * (`InterfaceMethodImpl`).
+ */
+export type ClassMethodConfig<S extends Schema, K extends AllDefNames<S>, M extends string> = M extends keyof AllMethods<DefForClass<S, K>> ? AllMethods<DefForClass<S, K>>[M] extends {
+    readonly config: infer MC;
+} ? {
+    params: ResolveParams<MC>;
+    result: ResolveReturn<MC>;
+    self: MethodSelf;
+    isStatic: MC extends {
+        readonly static: true;
+    } ? true : false;
+    output: MC extends {
+        readonly output: 'stream';
+    } ? 'stream' : MC extends {
+        readonly output: 'binary';
+    } ? 'binary' : 'value';
+} : never : never;
+export {};
+//# sourceMappingURL=signature.d.ts.map

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * Method signature resolution — type-level helpers that map a schema FnDef
+ * into concrete param / return / self types.
+ *
+ * Purely type-level. No runtime behavior.
+ */
+export {};
+//# sourceMappingURL=signature.js.map

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

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