@astrale-os/sdk 0.1.0 → 0.1.2

package/dist/dispatch/identity.js

@@ -0,0 +1,106 @@
+/**
+ * Per-callable identity — dispatcher runtime + install-time wiring.
+ *
+ * Two flavors of callable get an identity per the install-time identity
+ * binding: Methods on classes/interfaces (sub = MethodPath) and auto-
+ * materialized core function nodes — RemoteFunctions and Views (sub =
+ * AbsolutePath of the node under `core/{functions,views}/<slug>`).
+ *
+ * At server startup the method dispatcher and the View / RemoteFunction
+ * route mounter pre-compute, for every materialized callable, the
+ * `RemoteIdentityConfig` they sign outbound kernel calls with. The kernel
+ * then matches an existing function identity instead of provisioning a
+ * generic one.
+ *
+ * **Single source of truth:** every helper here is a thin lens over the
+ * canonical `resolveCallables` from `@astrale-os/kernel-core/domain`. The
+ * kernel validates install subs against the SAME function — drift = 0
+ * by construction. This closes the previous SDK-side gap where
+ * `collectMethodPaths` filtered to `own|override` and silently dropped
+ * `sealed`/`default` interface methods (which DO materialize as nodes).
+ */
+import { resolveCallables } from '@astrale-os/kernel-core/domain';
+/**
+ * For each materialized method node, emit its `MethodPath` (semantic,
+ * layout-independent) keyed by the method's namespaced ref. Used to
+ * build the install `subs` claim and to look up runtime per-method
+ * subjects in `buildIdentityMap`.
+ *
+ * Includes every method node the kernel materializes — class own/override
+ * AND interface own (sealed/default/override). Inherited (non-overriding)
+ * class methods reuse the interface's node via a `method_of` edge and
+ * are correctly absent here.
+ */
+export function collectMethodPaths(compiled) {
+    const out = {};
+    for (const c of resolveCallables(compiled)) {
+        if (c.kind === 'method')
+            out[c.ref] = c.sub;
+    }
+    return out;
+}
+export function collectAuxIdentityPaths(compiled) {
+    const views = {};
+    const remoteFunctions = {};
+    for (const c of resolveCallables(compiled)) {
+        if (c.kind !== 'core' || !c.slug)
+            continue;
+        if (c.className === 'View') {
+            views[c.slug] = c.sub;
+        }
+        else if (c.className === 'Function') {
+            // Standalone callables (the former `RemoteFunction`) materialize as the
+            // canonical kernel `Function` class.
+            remoteFunctions[c.slug] = c.sub;
+        }
+        else {
+            throw new Error(`collectAuxIdentityPaths: unrecognised aux callable className "${c.className}" ` +
+                `at ${c.ref}. If you've added a new auto-materialized Function class to extendCore, ` +
+                `extend this collector + the kernel walker (resolveCallables) to handle it.`);
+        }
+    }
+    return { views, remoteFunctions };
+}
+export function buildAuxIdentityMap(compiled, privateKey, issuer) {
+    const paths = collectAuxIdentityPaths(compiled);
+    const views = {};
+    for (const [slug, subject] of Object.entries(paths.views)) {
+        views[slug] = { issuer, subject, privateKey };
+    }
+    const remoteFunctions = {};
+    for (const [slug, subject] of Object.entries(paths.remoteFunctions)) {
+        remoteFunctions[slug] = { issuer, subject, privateKey };
+    }
+    return { views, remoteFunctions };
+}
+/**
+ * Pre-resolve per-method identity configs. Lookup is by BoundMethod instance,
+ * so the dispatcher pays O(1) per call instead of re-constructing the config.
+ *
+ * `iss` = the worker's own **serving URL** (`issuer` arg, e.g.
+ * `https://crm.test.com`) — its cryptographic identity, DECOUPLED from the
+ * domain's addressing `origin` (a graph slug). The kernel stamps the same
+ * value on each function node at install (it pins `iss` to the URL it fetched
+ * the domain at) and verifies inbound credentials against that issuer's JWKS
+ * (OIDC discovery). The function `sub` stays the origin-addressed MethodPath —
+ * `sub` = which function, `iss` = who signs.
+ */
+export function buildIdentityMap(compiled, methods, privateKey, issuer) {
+    const paths = collectMethodPaths(compiled);
+    const out = new Map();
+    for (const bound of methods) {
+        const subject = paths[bound.ref];
+        if (!subject) {
+            // Under the "drift = 0" invariant every dispatched method's ref is a key
+            // in `paths`. A miss means an install/index drift — fail loudly at boot
+            // rather than signing with `bound.ref` (a namespaced ref, NOT a
+            // MethodPath sub), which would silently fail kernel identity matching at
+            // call time. Mirrors `identityFor` / `requireAuxIdentity`.
+            throw new Error(`buildIdentityMap: method "${bound.ref}" is in the dispatch index but absent ` +
+                `from resolveCallables(compiled) — no identity subject to sign with.`);
+        }
+        out.set(bound, { issuer, subject, privateKey });
+    }
+    return out;
+}
+//# sourceMappingURL=identity.js.map

package/dist/dispatch/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.js","sourceRoot":"","sources":["../../src/dispatch/identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAKjE;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAAC,QAAwB;IACzD,MAAM,GAAG,GAA2B,EAAE,CAAA;IACtC,KAAK,MAAM,CAAC,IAAI,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC3C,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ;YAAE,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAA;IAC7C,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC;AAkBD,MAAM,UAAU,uBAAuB,CAAC,QAAwB;IAC9D,MAAM,KAAK,GAA2B,EAAE,CAAA;IACxC,MAAM,eAAe,GAA2B,EAAE,CAAA;IAClD,KAAK,MAAM,CAAC,IAAI,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC3C,IAAI,CAAC,CAAC,IAAI,KAAK,MAAM,IAAI,CAAC,CAAC,CAAC,IAAI;YAAE,SAAQ;QAC1C,IAAI,CAAC,CAAC,SAAS,KAAK,MAAM,EAAE,CAAC;YAC3B,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAA;QACvB,CAAC;aAAM,IAAI,CAAC,CAAC,SAAS,KAAK,UAAU,EAAE,CAAC;YACtC,wEAAwE;YACxE,qCAAqC;YACrC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAA;QACjC,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,KAAK,CACb,iEAAiE,CAAC,CAAC,SAAS,IAAI;gBAC9E,MAAM,CAAC,CAAC,GAAG,0EAA0E;gBACrF,4EAA4E,CAC/E,CAAA;QACH,CAAC;IACH,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE,CAAA;AACnC,CAAC;AAUD,MAAM,UAAU,mBAAmB,CACjC,QAAwB,EACxB,UAAsB,EACtB,MAAc;IAEd,MAAM,KAAK,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAA;IAC/C,MAAM,KAAK,GAAyC,EAAE,CAAA;IACtD,KAAK,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1D,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,CAAA;IAC/C,CAAC;IACD,MAAM,eAAe,GAAyC,EAAE,CAAA;IAChE,KAAK,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,EAAE,CAAC;QACpE,eAAe,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,CAAA;IACzD,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE,CAAA;AACnC,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAC9B,QAAwB,EACxB,OAAwC,EACxC,UAAsB,EACtB,MAAc;IAEd,MAAM,KAAK,GAAG,kBAAkB,CAAC,QAAQ,CAAC,CAAA;IAC1C,MAAM,GAAG,GAAG,IAAI,GAAG,EAAuD,CAAA;IAC1E,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QAChC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,yEAAyE;YACzE,wEAAwE;YACxE,gEAAgE;YAChE,yEAAyE;YACzE,2DAA2D;YAC3D,MAAM,IAAI,KAAK,CACb,6BAA6B,KAAK,CAAC,GAAG,wCAAwC;gBAC5E,qEAAqE,CACxE,CAAA;QACH,CAAC;QACD,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAA;IACjD,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC"}

package/dist/dispatch/index.d.ts

@@ -0,0 +1,8 @@
+export { SdkDispatcher, type SdkDispatcherConfig } from './dispatcher';
+export { resolveMethod, buildMethodIndex, type MethodIndex } from './resolve';
+export { validateParams, validateResult, type ValidationResult, type ResultValidationResult, } from './validate';
+export { resolveSelf, type SelfResult } from './self';
+export { executeHandler, type ExecuteParams } from './execute';
+export { makeCallRemote, type CallRemoteFn } from './call-remote';
+export { AuthorizationDeniedError, MethodNotFoundError, SdkValidationError, SdkResultValidationError, } from './errors';
+//# sourceMappingURL=index.d.ts.map

package/dist/dispatch/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dispatch/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAA;AACtE,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAA;AAC7E,OAAO,EACL,cAAc,EACd,cAAc,EACd,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,GAC5B,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,QAAQ,CAAA;AACrD,OAAO,EAAE,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,WAAW,CAAA;AAC9D,OAAO,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAA;AACjE,OAAO,EACL,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,UAAU,CAAA"}

package/dist/dispatch/index.js

@@ -0,0 +1,8 @@
+export { SdkDispatcher } from './dispatcher';
+export { resolveMethod, buildMethodIndex } from './resolve';
+export { validateParams, validateResult, } from './validate';
+export { resolveSelf } from './self';
+export { executeHandler } from './execute';
+export { makeCallRemote } from './call-remote';
+export { AuthorizationDeniedError, MethodNotFoundError, SdkValidationError, SdkResultValidationError, } from './errors';
+//# sourceMappingURL=index.js.map

package/dist/dispatch/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/dispatch/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAA4B,MAAM,cAAc,CAAA;AACtE,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAoB,MAAM,WAAW,CAAA;AAC7E,OAAO,EACL,cAAc,EACd,cAAc,GAGf,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,WAAW,EAAmB,MAAM,QAAQ,CAAA;AACrD,OAAO,EAAE,cAAc,EAAsB,MAAM,WAAW,CAAA;AAC9D,OAAO,EAAE,cAAc,EAAqB,MAAM,eAAe,CAAA;AACjE,OAAO,EACL,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,UAAU,CAAA"}

package/dist/dispatch/resolve.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Method resolution — the index the dispatcher queries on every call.
+ *
+ * Owns both the index's construction and its lookup contract:
+ * - `buildMethodIndex` is called once at server startup.
+ * - `resolveMethod` is called once per inbound call.
+ *
+ * Each method is indexed under its `BoundMethod.ref`
+ * (`namespace.Owner.method.name`) and under a short alias `Owner.name`.
+ * The short alias is only registered when it is unambiguous — two methods
+ * whose owners live in different namespaces (e.g. class vs interface) and
+ * share the same local name would collide, and we refuse to register the
+ * ambiguous key rather than silently overwriting.
+ *
+ * Inbound names may arrive as `Path`, full `ref`, short alias, a tree path
+ * `/<domain>/<namespace.Owner>/<method>`, or the typed colon-form MethodPath
+ * `/:<domain>:<namespace.Owner>:<method>` (what the kernel forwards when a
+ * caller addresses the method in `:`-delimited form). All shapes normalize to
+ * the same lookup key.
+ */
+import type { Path } from '@astrale-os/kernel-core';
+import type { BoundMethod } from '@astrale-os/kernel-core/domain';
+import type { AnyRemoteHandler } from '../method/single';
+export type MethodIndex = Map<string, BoundMethod<AnyRemoteHandler>>;
+export declare function buildMethodIndex(methods: BoundMethod<AnyRemoteHandler>[]): MethodIndex;
+export declare function resolveMethod(index: MethodIndex, name: Path | string): BoundMethod<AnyRemoteHandler> | null;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/dispatch/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/dispatch/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AAEjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAExD,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAC,CAAA;AAKpE,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,CAAC,gBAAgB,CAAC,EAAE,GAAG,WAAW,CAmBtF;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,IAAI,GAAG,MAAM,GAClB,WAAW,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAEtC"}

package/dist/dispatch/resolve.js

@@ -0,0 +1,65 @@
+/**
+ * Method resolution — the index the dispatcher queries on every call.
+ *
+ * Owns both the index's construction and its lookup contract:
+ * - `buildMethodIndex` is called once at server startup.
+ * - `resolveMethod` is called once per inbound call.
+ *
+ * Each method is indexed under its `BoundMethod.ref`
+ * (`namespace.Owner.method.name`) and under a short alias `Owner.name`.
+ * The short alias is only registered when it is unambiguous — two methods
+ * whose owners live in different namespaces (e.g. class vs interface) and
+ * share the same local name would collide, and we refuse to register the
+ * ambiguous key rather than silently overwriting.
+ *
+ * Inbound names may arrive as `Path`, full `ref`, short alias, a tree path
+ * `/<domain>/<namespace.Owner>/<method>`, or the typed colon-form MethodPath
+ * `/:<domain>:<namespace.Owner>:<method>` (what the kernel forwards when a
+ * caller addresses the method in `:`-delimited form). All shapes normalize to
+ * the same lookup key.
+ */
+const NAMESPACE_PREFIXES = ['class.', 'interface.'];
+const METHOD_INFIX = 'method';
+export function buildMethodIndex(methods) {
+    const index = new Map();
+    const shortFormAmbiguous = new Set();
+    for (const m of methods) {
+        index.set(m.ref, m);
+        const shortForm = `${m.owner}.${m.method}`;
+        if (shortFormAmbiguous.has(shortForm))
+            continue;
+        const existing = index.get(shortForm);
+        if (existing && existing !== m) {
+            index.delete(shortForm);
+            shortFormAmbiguous.add(shortForm);
+            continue;
+        }
+        index.set(shortForm, m);
+    }
+    return index;
+}
+export function resolveMethod(index, name) {
+    return index.get(normalizeMethod(name)) ?? null;
+}
+function normalizeMethod(name) {
+    const raw = typeof name === 'string' ? name : name.raw;
+    if (!raw.startsWith('/'))
+        return raw;
+    // Typed colon-form MethodPath (`/:<domain>:<owner>:<method>`) vs. tree
+    // slash-form (`/<domain>/<owner>/<method>`). The owner segment carries its own
+    // `.` (e.g. `interface.NoteOps`), so the path separator is unambiguous.
+    const separator = raw.startsWith('/:') ? ':' : '/';
+    const segments = raw
+        .replace(/^\/+/, '')
+        .split(separator)
+        .filter((s) => s.length > 0);
+    if (segments.length < 3)
+        return raw;
+    const owner = segments[segments.length - 2];
+    const method = segments[segments.length - 1];
+    if (NAMESPACE_PREFIXES.some((p) => owner.startsWith(p))) {
+        return `${owner}.${METHOD_INFIX}.${method}`;
+    }
+    return `${owner}.${method}`;
+}
+//# sourceMappingURL=resolve.js.map

package/dist/dispatch/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.js","sourceRoot":"","sources":["../../src/dispatch/resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AASH,MAAM,kBAAkB,GAAG,CAAC,QAAQ,EAAE,YAAY,CAAU,CAAA;AAC5D,MAAM,YAAY,GAAG,QAAQ,CAAA;AAE7B,MAAM,UAAU,gBAAgB,CAAC,OAAwC;IACvE,MAAM,KAAK,GAAgB,IAAI,GAAG,EAAE,CAAA;IACpC,MAAM,kBAAkB,GAAG,IAAI,GAAG,EAAU,CAAA;IAE5C,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAA;QAEnB,MAAM,SAAS,GAAG,GAAG,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,MAAM,EAAE,CAAA;QAC1C,IAAI,kBAAkB,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,SAAQ;QAC/C,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;QACrC,IAAI,QAAQ,IAAI,QAAQ,KAAK,CAAC,EAAE,CAAC;YAC/B,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;YACvB,kBAAkB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;YACjC,SAAQ;QACV,CAAC;QACD,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,CAAA;IACzB,CAAC;IAED,OAAO,KAAK,CAAA;AACd,CAAC;AAED,MAAM,UAAU,aAAa,CAC3B,KAAkB,EAClB,IAAmB;IAEnB,OAAO,KAAK,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAA;AACjD,CAAC;AAED,SAAS,eAAe,CAAC,IAAmB;IAC1C,MAAM,GAAG,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAA;IACtD,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,GAAG,CAAA;IACpC,uEAAuE;IACvE,+EAA+E;IAC/E,wEAAwE;IACxE,MAAM,SAAS,GAAG,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAA;IAClD,MAAM,QAAQ,GAAG,GAAG;SACjB,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;SACnB,KAAK,CAAC,SAAS,CAAC;SAChB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;IAC9B,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,GAAG,CAAA;IACnC,MAAM,KAAK,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAE,CAAA;IAC5C,MAAM,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAE,CAAA;IAC7C,IAAI,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACxD,OAAO,GAAG,KAAK,IAAI,YAAY,IAAI,MAAM,EAAE,CAAA;IAC7C,CAAC;IACD,OAAO,GAAG,KAAK,IAAI,MAAM,EAAE,CAAA;AAC7B,CAAC"}

package/dist/dispatch/self.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Self resolution — pipeline step 3.
+ *
+ * `_self` is a path reference to the node the non-static method runs on.
+ * Currently a thin parse: the caller's string becomes a `Path`, and handlers
+ * build recursive paths as `${self.path}::method` (the `Path`'s `toString`
+ * yields its raw form, so template literals work unchanged).
+ *
+ * `resolveSelf` receives the bare self target (`@<id>` or a tree path) — the
+ * method ref travels in a separate dispatch channel, so `::method` never
+ * reaches here. For the `@<id>` form the parsed `Path` is an `IdPath` which
+ * already carries the node id; surfacing it on `SelfResult.id` saves every
+ * worker handler from either parsing `self.path.raw` by hand or doing a
+ * `Node::get` round-trip just to recover the id of the node it's already
+ * operating on.
+ *
+ * Kept as a distinct step so a future implementation can do a real
+ * resolution here (e.g. hydrate a node/accessor) without touching callers.
+ */
+import { Path, type NodeId } from '@astrale-os/kernel-core';
+export type SelfResult = {
+    path: Path;
+    /** Set when `path` is an `IdPath` (i.e. `@<id>::method` calls). */
+    id?: NodeId;
+};
+export declare function resolveSelf(ref: string): SelfResult;
+//# sourceMappingURL=self.d.ts.map

package/dist/dispatch/self.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self.d.ts","sourceRoot":"","sources":["../../src/dispatch/self.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAU,IAAI,EAAE,KAAK,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAEnE,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,IAAI,CAAA;IACV,mEAAmE;IACnE,EAAE,CAAC,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAGnD"}

package/dist/dispatch/self.js

@@ -0,0 +1,25 @@
+/**
+ * Self resolution — pipeline step 3.
+ *
+ * `_self` is a path reference to the node the non-static method runs on.
+ * Currently a thin parse: the caller's string becomes a `Path`, and handlers
+ * build recursive paths as `${self.path}::method` (the `Path`'s `toString`
+ * yields its raw form, so template literals work unchanged).
+ *
+ * `resolveSelf` receives the bare self target (`@<id>` or a tree path) — the
+ * method ref travels in a separate dispatch channel, so `::method` never
+ * reaches here. For the `@<id>` form the parsed `Path` is an `IdPath` which
+ * already carries the node id; surfacing it on `SelfResult.id` saves every
+ * worker handler from either parsing `self.path.raw` by hand or doing a
+ * `Node::get` round-trip just to recover the id of the node it's already
+ * operating on.
+ *
+ * Kept as a distinct step so a future implementation can do a real
+ * resolution here (e.g. hydrate a node/accessor) without touching callers.
+ */
+import { IdPath, Path } from '@astrale-os/kernel-core';
+export function resolveSelf(ref) {
+    const path = Path.parse(ref);
+    return path instanceof IdPath ? { path, id: path.id } : { path };
+}
+//# sourceMappingURL=self.js.map

package/dist/dispatch/self.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"self.js","sourceRoot":"","sources":["../../src/dispatch/self.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,MAAM,EAAE,IAAI,EAAe,MAAM,yBAAyB,CAAA;AAQnE,MAAM,UAAU,WAAW,CAAC,GAAW;IACrC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IAC5B,OAAO,IAAI,YAAY,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAA;AAClE,CAAC"}

package/dist/dispatch/validate.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Param / result validation helpers — Zod `safeParse` wrappers returning a
+ * tagged result. Callers convert a `false` outcome into a typed error:
+ * `SdkValidationError` (input, → 422) or `SdkResultValidationError`
+ * (output, → 500).
+ */
+import type { z } from 'zod';
+export type ValidationResult = {
+    ok: true;
+    data: Record<string, unknown>;
+} | {
+    ok: false;
+    issues: unknown[];
+};
+export declare function validateParams(inputSchema: z.ZodType, params: unknown): ValidationResult;
+/**
+ * Result of validating a handler's output against its `outputSchema`. Unlike
+ * params, an output may be any shape (object, primitive, array), so `data` is
+ * `unknown` rather than `Record<string, unknown>`.
+ */
+export type ResultValidationResult = {
+    ok: true;
+    data: unknown;
+} | {
+    ok: false;
+    issues: unknown[];
+};
+/**
+ * Validate a handler's return value against its `outputSchema`. Mirrors the
+ * kernel's `validateOutput` (`runtime/.../validation/output.ts`) so deployed
+ * domains enforce the same output contract as in-process methods. Returns the
+ * parsed `data` (applies Zod `default`/`transform`/coercions) on success.
+ */
+export declare function validateResult(outputSchema: z.ZodType, result: unknown): ResultValidationResult;
+//# sourceMappingURL=validate.d.ts.map

package/dist/dispatch/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/dispatch/validate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,MAAM,MAAM,gBAAgB,GACxB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAC3C;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAAA;AAEpC,wBAAgB,cAAc,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAMxF;AAED;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAAA;AAEnG;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,sBAAsB,CAM/F"}

package/dist/dispatch/validate.js

@@ -0,0 +1,27 @@
+/**
+ * Param / result validation helpers — Zod `safeParse` wrappers returning a
+ * tagged result. Callers convert a `false` outcome into a typed error:
+ * `SdkValidationError` (input, → 422) or `SdkResultValidationError`
+ * (output, → 500).
+ */
+export function validateParams(inputSchema, params) {
+    const result = inputSchema.safeParse(params);
+    if (result.success) {
+        return { ok: true, data: result.data };
+    }
+    return { ok: false, issues: result.error.issues };
+}
+/**
+ * Validate a handler's return value against its `outputSchema`. Mirrors the
+ * kernel's `validateOutput` (`runtime/.../validation/output.ts`) so deployed
+ * domains enforce the same output contract as in-process methods. Returns the
+ * parsed `data` (applies Zod `default`/`transform`/coercions) on success.
+ */
+export function validateResult(outputSchema, result) {
+    const parsed = outputSchema.safeParse(result);
+    if (parsed.success) {
+        return { ok: true, data: parsed.data };
+    }
+    return { ok: false, issues: parsed.error.issues };
+}
+//# sourceMappingURL=validate.js.map

package/dist/dispatch/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","sourceRoot":"","sources":["../../src/dispatch/validate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,MAAM,UAAU,cAAc,CAAC,WAAsB,EAAE,MAAe;IACpE,MAAM,MAAM,GAAG,WAAW,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;IAC5C,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,IAA+B,EAAE,CAAA;IACnE,CAAC;IACD,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,CAAA;AACnD,CAAC;AASD;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,YAAuB,EAAE,MAAe;IACrE,MAAM,MAAM,GAAG,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;IAC7C,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,CAAA;IACxC,CAAC;IACD,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,CAAA;AACnD,CAAC"}

package/dist/domain/build-spec.d.ts

@@ -0,0 +1,37 @@
+/**
+ * SDK-side spec builder: CompiledDomain → serialize → Graph.
+ *
+ * Serializes BoundMethod[] into FunctionSchema[], generates entries for
+ * inherited methods not covered by the domain's handlers, then delegates
+ * to serialize() for graph blueprint generation.
+ *
+ * Domain-side Methods are remote-bound: dispatch routes through
+ * `binding.remoteUrl` and never reaches the kernel sandbox. We therefore
+ * do NOT stamp `code` on emitted FunctionSchema entries — there is no
+ * sandbox-eval'able body. Only the kernel domain (compiled in-process)
+ * carries `code` strings.
+ *
+ * The emitted graph is absolute — the Tree produced by `serialize()` is
+ * already mounted at `/<origin>`, so `tree.toGraph()` lifts every internal
+ * relative path into its host-graph absolute form. Wire serialization is the
+ * caller's responsibility (`graph.toWire()`).
+ */
+import type { WireGraph } from '@astrale-os/kernel-core';
+import type { Schema } from '@astrale-os/kernel-dsl';
+import type { RemoteDomain } from './define';
+/**
+ * Build the install-ready wire graph for a domain served at `url`: materialize
+ * the domain at its real serving URL (so every binding carries the live URL —
+ * the define-time compile carries none), serialize, and emit the wire form.
+ * This is the graph the kernel installs and re-hashes to verify. There is no
+ * url-less variant: an install graph without bindings is uninstallable (the
+ * kernel install guard rejects it).
+ */
+export declare function buildInstallGraph<S extends Schema>(domain: RemoteDomain<S>, url: string): WireGraph;
+/**
+ * Content hash of the install graph. Delegates the canonical hash to kernel-core's
+ * `hashInstallGraph` — the same algorithm the kernel re-runs on install to verify
+ * the received graph against the signed hash.
+ */
+export declare function buildInstallGraphHash<S extends Schema>(domain: RemoteDomain<S>, url: string): Promise<string>;
+//# sourceMappingURL=build-spec.d.ts.map

package/dist/domain/build-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-spec.d.ts","sourceRoot":"","sources":["../../src/domain/build-spec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAS,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAE/D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAKpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAK5C;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAChD,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EACvB,GAAG,EAAE,MAAM,GACV,SAAS,CAGX;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,MAAM,EACpD,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EACvB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,MAAM,CAAC,CAEjB"}

package/dist/domain/build-spec.js

@@ -0,0 +1,95 @@
+/**
+ * SDK-side spec builder: CompiledDomain → serialize → Graph.
+ *
+ * Serializes BoundMethod[] into FunctionSchema[], generates entries for
+ * inherited methods not covered by the domain's handlers, then delegates
+ * to serialize() for graph blueprint generation.
+ *
+ * Domain-side Methods are remote-bound: dispatch routes through
+ * `binding.remoteUrl` and never reaches the kernel sandbox. We therefore
+ * do NOT stamp `code` on emitted FunctionSchema entries — there is no
+ * sandbox-eval'able body. Only the kernel domain (compiled in-process)
+ * carries `code` strings.
+ *
+ * The emitted graph is absolute — the Tree produced by `serialize()` is
+ * already mounted at `/<origin>`, so `tree.toGraph()` lifts every internal
+ * relative path into its host-graph absolute form. Wire serialization is the
+ * caller's responsibility (`graph.toWire()`).
+ */
+import { hashInstallGraph, serialize, zodToJsonSchema } from '@astrale-os/kernel-core/domain';
+import { extractBinding } from './contract';
+import { materializeRemoteDomain } from './define';
+/**
+ * Build the install-ready wire graph for a domain served at `url`: materialize
+ * the domain at its real serving URL (so every binding carries the live URL —
+ * the define-time compile carries none), serialize, and emit the wire form.
+ * This is the graph the kernel installs and re-hashes to verify. There is no
+ * url-less variant: an install graph without bindings is uninstallable (the
+ * kernel install guard rejects it).
+ */
+export function buildInstallGraph(domain, url) {
+    const { compiled } = materializeRemoteDomain(domain, url);
+    return buildSpecInternal(compiled, domain.methods, url).toWire();
+}
+/**
+ * Content hash of the install graph. Delegates the canonical hash to kernel-core's
+ * `hashInstallGraph` — the same algorithm the kernel re-runs on install to verify
+ * the received graph against the signed hash.
+ */
+export function buildInstallGraphHash(domain, url) {
+    return hashInstallGraph(buildInstallGraph(domain, url));
+}
+// ── Internal ────────────────────────────────────────────────
+function buildSpecInternal(compiled, methods, url) {
+    const serialized = serializeMethodsWithStubs(compiled, methods, url);
+    const tree = serialize(compiled, serialized);
+    // Views / RemoteFunctions are auto-materialized into the Core BEFORE
+    // `compileDomain` runs (see `extend-core.ts`). By the time we reach
+    // `serialize` here the Tree already contains their nodes/edges.
+    return tree.toGraph();
+}
+/**
+ * Serialize BoundMethod[] and generate stubs for methods in compiled.$.methods
+ * that have no corresponding BoundMethod (inherited-sealed, inherited-default).
+ *
+ * Every Method's binding defaults its `remoteUrl` to the serving URL: domain
+ * methods are remote-bound — the kernel dispatches them by redirecting to the
+ * worker — so a method node without a remote binding is uninstallable (the
+ * kernel install guard rejects it). An explicit per-method `remoteUrl` wins.
+ */
+function serializeMethodsWithStubs(compiled, methods, url) {
+    const bound = new Set(methods.map((m) => m.ref));
+    const result = methods.map((m) => serializeFromBoundMethod(m, url));
+    // Generate entries for unbound methods (replaces fillMissingCallables).
+    // No `code` is stamped — domain-side Methods are binding-only. The `ref` MUST
+    // be the QUALIFIED `ResolvedMethod.ref` (`<ns>.<Type>.method.<m>`) — the exact
+    // form `serialize`'s method-node lookup uses; re-deriving a bare `Type.method`
+    // is the F11 bug (interface methods then never resolve → MISSING_HANDLER).
+    for (const classMethods of Object.values(compiled.$.methods)) {
+        for (const rm of Object.values(classMethods)) {
+            const ref = rm.ref;
+            if (bound.has(ref))
+                continue;
+            result.push({
+                ref,
+                inputSchema: { type: 'object' },
+                outputSchema: {},
+                output: 'value',
+                binding: { remoteUrl: url },
+            });
+        }
+    }
+    return result;
+}
+function serializeFromBoundMethod(method, url) {
+    const binding = extractBinding(method.handler);
+    return {
+        ref: method.ref,
+        inputSchema: zodToJsonSchema(method.inputSchema),
+        outputSchema: zodToJsonSchema(method.outputSchema),
+        isStatic: method.isStatic || undefined,
+        output: method.output,
+        binding: binding?.remoteUrl ? binding : { ...binding, remoteUrl: url },
+    };
+}
+//# sourceMappingURL=build-spec.js.map

package/dist/domain/build-spec.js.map

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

package/dist/domain/contract.d.ts

@@ -0,0 +1,17 @@
+/**
+ * BoundMethod → MountableContract translator.
+ *
+ * The narrow view carries only what the server's mount planner reads —
+ * `ref` plus optional `binding` — because the SDK's SdkDispatcher
+ * handles dispatch via KernelAPI.call, not via runtime contract hooks.
+ */
+import type { AuthPolicy, FunctionBinding, MountableContract, RouteBinding } from '@astrale-os/kernel-api/routed';
+import type { BoundMethod } from '@astrale-os/kernel-core/domain';
+import type { AnyRemoteHandler } from '../method/single';
+export declare function toSdkContract(method: BoundMethod<AnyRemoteHandler>): MountableContract;
+export declare function extractBinding(handler: {
+    route?: RouteBinding;
+    remoteUrl?: string;
+    auth?: AuthPolicy;
+}): FunctionBinding | undefined;
+//# sourceMappingURL=contract.d.ts.map

package/dist/domain/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../src/domain/contract.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,iBAAiB,EACjB,YAAY,EACb,MAAM,+BAA+B,CAAA;AACtC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAA;AAEjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAExD,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,CAAC,gBAAgB,CAAC,GAAG,iBAAiB,CAQtF;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE;IACtC,KAAK,CAAC,EAAE,YAAY,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,UAAU,CAAA;CAClB,GAAG,eAAe,GAAG,SAAS,CAQ9B"}

package/dist/domain/contract.js

@@ -0,0 +1,26 @@
+/**
+ * BoundMethod → MountableContract translator.
+ *
+ * The narrow view carries only what the server's mount planner reads —
+ * `ref` plus optional `binding` — because the SDK's SdkDispatcher
+ * handles dispatch via KernelAPI.call, not via runtime contract hooks.
+ */
+export function toSdkContract(method) {
+    const handler = method.handler;
+    const binding = extractBinding(handler);
+    return binding === undefined ? { ref: method.ref } : { ref: method.ref, binding };
+}
+export function extractBinding(handler) {
+    const { route, remoteUrl, auth } = handler;
+    if (route === undefined && remoteUrl === undefined && auth === undefined)
+        return undefined;
+    const binding = {};
+    if (remoteUrl !== undefined)
+        binding.remoteUrl = remoteUrl;
+    if (route !== undefined)
+        binding.route = route;
+    if (auth !== undefined)
+        binding.auth = auth;
+    return binding;
+}
+//# sourceMappingURL=contract.js.map

package/dist/domain/contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../../src/domain/contract.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAYH,MAAM,UAAU,aAAa,CAAC,MAAqC;IACjE,MAAM,OAAO,GAAG,MAAM,CAAC,OAItB,CAAA;IACD,MAAM,OAAO,GAAG,cAAc,CAAC,OAAO,CAAC,CAAA;IACvC,OAAO,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,OAAO,EAAE,CAAA;AACnF,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,OAI9B;IACC,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,OAAO,CAAA;IAC1C,IAAI,KAAK,KAAK,SAAS,IAAI,SAAS,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,SAAS,CAAA;IAC1F,MAAM,OAAO,GAAoB,EAAE,CAAA;IACnC,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,CAAC,SAAS,GAAG,SAAS,CAAA;IAC1D,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,CAAC,KAAK,GAAG,KAAK,CAAA;IAC9C,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,CAAC,IAAI,GAAG,IAAI,CAAA;IAC3C,OAAO,OAAO,CAAA;AAChB,CAAC"}