@astrale-os/sdk 0.3.0 → 0.4.2

package/src/server/auxiliary-routes.ts

@@ -36,16 +36,15 @@ import { buildCorsHeaders, type CorsConfig } from '@astrale-os/kernel-server'
 import type { RemoteIdentityConfig } from '../auth/identity'
 import type { AnyRemoteFunctionDef } from '../define/remote-function'
 import type { ViewDef } from '../define/view'
-import type { CallRemoteFn } from '../dispatch/call-remote'
 import type { AuxIdentityMap } from '../dispatch/identity'
 
-import { makeIssuerMint } from '../auth/issuer-mint'
-import { makeSelfKernel } from '../auth/kernel-client'
+import { makeFunctionContext } from '../auth/function-context'
+import { makeDomainAuthority } from '../auth/issuer-mint'
 import { resolveInboundAuth } from '../auth/resolve'
 import { runAuthorize } from '../dispatch/authorize'
-import { makeCallRemote } from '../dispatch/call-remote'
 import { SdkResultValidationError, SdkValidationError } from '../dispatch/errors'
 import { validateParams, validateResult } from '../dispatch/validate'
+import { createInlineStep } from '../step'
 
 export type AuxiliaryRoutesConfig<TDeps> = {
   app: Hono
@@ -100,16 +99,23 @@ export function mountAuxiliaryRoutes<TDeps>(config: AuxiliaryRoutesConfig<TDeps>
         auth: def.auth,
         identity,
         corsHeaders,
-        // Views are transport-only (iframe HTML/redirect) — the kernel client
-        // built by `resolveInboundAuth` is intentionally NOT forwarded. Code
-        // inside the loaded iframe talks back to the kernel via the shell
-        // (WebSocket), not via this worker route. SERVER-rendered views that
-        // read the graph use `selfKernel` instead: the view's OWN identity,
-        // narrow grants (the cold-agent gate run had to deep-import SDK
-        // internals for exactly this — now it's the supported seam).
-        run: async ({ c, params, auth }) => {
-          const selfKernel = makeSelfKernel(identity, deps)
-          const ctx = { c, params, auth, deps, selfKernel }
+        // Views are transport-only (iframe HTML/redirect). SERVER-rendered
+        // views that read the graph use `ctx.fn.kernel()`: the view's own
+        // identity, with narrow grants.
+        run: async ({ c, params, auth, kernel }) => {
+          const inboundIss = auth?.credential?.verified?.iss as string | undefined
+          const kernelUrl = kernel?.default ?? inboundIss
+          const ctx = {
+            c,
+            params,
+            auth,
+            deps,
+            env: { url },
+            fn: makeFunctionContext(identity, deps, {
+              ref: `view.${slug}`,
+              ...(kernelUrl !== undefined ? { defaultKernelUrl: kernelUrl } : {}),
+            }),
+          }
           if (def.authorize) await runAuthorize(def.authorize, ctx)
           return def.render!(ctx)
         },
@@ -130,26 +136,40 @@ export function mountAuxiliaryRoutes<TDeps>(config: AuxiliaryRoutesConfig<TDeps>
         auth: def.auth,
         identity,
         corsHeaders,
-        run: async ({ c, auth, kernel, callRemote }) => {
-          const selfKernel = makeSelfKernel(identity, deps)
+        run: async ({ c, auth, kernel }) => {
           const rawBody: unknown = await c.req.json().catch(() => ({}))
           const validation = validateParams(def.inputSchema, rawBody)
           if (!validation.ok) {
             throw new SdkValidationError(validation.issues as SdkValidationError['issues'])
           }
-          const issuer = makeIssuerMint(identity)
+          const inboundIss = auth?.credential?.verified?.iss as string | undefined
+          const kernelUrl = kernel?.default ?? inboundIss
+          const caller =
+            auth && inboundIss
+              ? {
+                  iss: inboundIss,
+                  url: kernelUrl ?? inboundIss,
+                }
+              : undefined
           const ctx = {
             params: validation.data,
             c,
             auth,
             deps,
+            env: { url },
             kernel,
-            issuer,
-            callRemote,
-            selfKernel,
+            ...(caller !== undefined ? { caller } : {}),
+            domain: makeDomainAuthority(identity),
+            fn: makeFunctionContext(identity, deps, {
+              ref: `function.${slug}`,
+              ...(kernelUrl !== undefined ? { defaultKernelUrl: kernelUrl } : {}),
+            }),
           }
           if (def.authorize) await runAuthorize(def.authorize, ctx)
-          const result = await def.execute(ctx)
+          const result = await def.execute({
+            ...ctx,
+            step: createInlineStep({ scope: { kind: 'function', ref: `function.${slug}`, slug } }),
+          })
           const outValidation = validateResult(def.outputSchema, result)
           if (!outValidation.ok) {
             throw new SdkResultValidationError(
@@ -188,7 +208,6 @@ type RunArgs = {
   params: Record<string, string>
   auth: AuthContext | null
   kernel: BoundClientSessionView<FnMap> | null
-  callRemote: CallRemoteFn
 }
 
 type MountEntryArgs = {
@@ -264,7 +283,6 @@ function mountEntry(args: MountEntryArgs): void {
         params: { ...hostParams, ...pathParams },
         auth: resolvedAuth,
         kernel,
-        callRemote: makeCallRemote(kernel),
       })
       return applyCorsToResponse(response, corsHeaders)
     } catch (err) {

package/src/server/create.ts

@@ -47,7 +47,7 @@ export function createRemoteServer<TDeps>(config: RemoteServerConfig<TDeps>): Re
     deps: config.deps,
     privateKey: config.privateKey,
     issuer: iss,
-    // The canonicalized serving URL, NOT the raw config.url: `ctx.url` is
+    // The canonicalized serving URL, NOT the raw config.url: `ctx.env.url` is
     // documented as the worker's `iss` identity, so the two must be one value.
     url: iss,
   })

package/src/step/index.ts

@@ -0,0 +1,4 @@
+export { createInlineStep } from './inline'
+export type { InlineStepOptions, StepExecutor } from './inline'
+export { buildStepRun } from './step'
+export type { FunctionStepScope, MethodStepScope, Step, StepRun, StepScope } from './step'

package/src/step/inline.ts

@@ -0,0 +1,38 @@
+import type { Step, StepRun, StepScope } from './step'
+
+import { buildStepRun, roundTripStepResult } from './step'
+
+export type StepExecutor = <T>(run: StepRun, handler: () => T | Promise<T>) => Promise<T>
+
+export type InlineStepOptions = {
+  scope?: StepScope
+  execute?: StepExecutor
+}
+
+export function createInlineStep(options: InlineStepOptions = {}): Step {
+  const occurrences = new Map<string, number>()
+  const execute = options.execute ?? inlineExecute
+
+  return {
+    async run(id, handler) {
+      const run = buildStepRun(id, options.scope, nextOccurrence(id, options.scope, occurrences))
+      return execute(run, handler)
+    },
+  }
+}
+
+async function inlineExecute<T>(run: StepRun, handler: () => T | Promise<T>): Promise<T> {
+  const result = await handler()
+  return roundTripStepResult(run.key, result)
+}
+
+function nextOccurrence(
+  id: string,
+  scope: StepScope | undefined,
+  occurrences: Map<string, number>,
+): number {
+  const run = buildStepRun(id, scope, 0)
+  const occurrence = occurrences.get(run.key) ?? 0
+  occurrences.set(run.key, occurrence + 1)
+  return occurrence
+}

package/src/step/step.ts

@@ -0,0 +1,95 @@
+export type Step = {
+  run<T>(id: string, handler: () => T | Promise<T>): Promise<T>
+}
+
+export type MethodStepScope = {
+  kind: 'method'
+  ref: string
+  owner: string
+  method: string
+}
+
+export type FunctionStepScope = {
+  kind: 'function'
+  ref: string
+  slug: string
+}
+
+export type StepScope = MethodStepScope | FunctionStepScope
+
+export type StepRun = {
+  /** The author-provided id, normalized to the local id inside this scope. */
+  id: string
+  /** Backend-facing durable key, qualified by the method/function scope. */
+  key: string
+  /** Zero-based occurrence for repeated ids in one execution. */
+  occurrence: number
+  scope?: StepScope
+}
+
+export function requireStepId(id: string): string {
+  if (typeof id !== 'string' || id.trim() === '') {
+    throw new TypeError('step.run: id must be a non-empty string')
+  }
+  return id
+}
+
+export function buildStepRun(
+  id: string,
+  scope: StepScope | undefined,
+  occurrence: number,
+): StepRun {
+  const stepId = requireStepId(localStepId(id, scope))
+  const key = scope ? `${canonicalScope(scope)}.${stepId}` : stepId
+  return {
+    id: stepId,
+    key,
+    occurrence,
+    ...(scope ? { scope } : {}),
+  }
+}
+
+export function roundTripStepResult<T>(id: string, value: T): T {
+  if (value === undefined) return value
+
+  let serialized: string | undefined
+  try {
+    serialized = JSON.stringify(value)
+  } catch (err) {
+    throw new TypeError(
+      `step.run("${id}"): result must be JSON-serializable: ${
+        err instanceof Error ? err.message : String(err)
+      }`,
+    )
+  }
+
+  if (serialized === undefined) {
+    throw new TypeError(`step.run("${id}"): result must be JSON-serializable`)
+  }
+
+  return JSON.parse(serialized) as T
+}
+
+function localStepId(id: string, scope: StepScope | undefined): string {
+  if (!scope) return id
+
+  for (const prefix of scopePrefixes(scope)) {
+    const scoped = `${prefix}.`
+    if (id.startsWith(scoped) && id.length > scoped.length) return id.slice(scoped.length)
+  }
+
+  return id
+}
+
+function scopePrefixes(scope: StepScope): string[] {
+  switch (scope.kind) {
+    case 'method':
+      return [scope.ref, `${scope.owner}.${scope.method}`]
+    case 'function':
+      return [scope.ref, `function.${scope.slug}`]
+  }
+}
+
+function canonicalScope(scope: StepScope): string {
+  return scope.ref
+}

package/dist/deploy/hash-spec.d.ts

@@ -1,9 +0,0 @@
-/**
- * Hash a `spec.json` file deterministically. Only the schema payload
- * (`nodes` + `edges`) is hashed — the `meta` block carries `builtAt`
- * timestamps that would poison drift detection.
- *
- * Returns `sha256:<hex>`.
- */
-export declare function hashSpecFile(path: string): string;
-//# sourceMappingURL=hash-spec.d.ts.map

package/dist/deploy/hash-spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash-spec.d.ts","sourceRoot":"","sources":["../../src/deploy/hash-spec.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKjD"}

package/dist/deploy/hash-spec.js

@@ -1,29 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readFileSync } from 'node:fs';
-const HASH_ALGORITHM = 'sha256';
-/**
- * Hash a `spec.json` file deterministically. Only the schema payload
- * (`nodes` + `edges`) is hashed — the `meta` block carries `builtAt`
- * timestamps that would poison drift detection.
- *
- * Returns `sha256:<hex>`.
- */
-export function hashSpecFile(path) {
-    const raw = readFileSync(path, 'utf-8');
-    const parsed = JSON.parse(raw);
-    const canonical = canonicalJson({ nodes: parsed.nodes ?? [], edges: parsed.edges ?? [] });
-    return `${HASH_ALGORITHM}:${createHash(HASH_ALGORITHM).update(canonical).digest('hex')}`;
-}
-function canonicalJson(value) {
-    if (value === null || typeof value !== 'object')
-        return JSON.stringify(value);
-    if (Array.isArray(value))
-        return '[' + value.map(canonicalJson).join(',') + ']';
-    const keys = Object.keys(value).sort();
-    return ('{' +
-        keys
-            .map((k) => JSON.stringify(k) + ':' + canonicalJson(value[k]))
-            .join(',') +
-        '}');
-}
-//# sourceMappingURL=hash-spec.js.map

package/dist/deploy/hash-spec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash-spec.js","sourceRoot":"","sources":["../../src/deploy/hash-spec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAEtC,MAAM,cAAc,GAAG,QAAQ,CAAA;AAE/B;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,MAAM,GAAG,GAAG,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;IACvC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAyC,CAAA;IACtE,MAAM,SAAS,GAAG,aAAa,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,EAAE,EAAE,CAAC,CAAA;IACzF,OAAO,GAAG,cAAc,IAAI,UAAU,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAA;AAC1F,CAAC;AAED,SAAS,aAAa,CAAC,KAAc;IACnC,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;IAC7E,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,CAAA;IAC/E,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,KAAgC,CAAC,CAAC,IAAI,EAAE,CAAA;IACjE,OAAO,CACL,GAAG;QACH,IAAI;aACD,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,aAAa,CAAE,KAAiC,CAAC,CAAC,CAAC,CAAC,CAAC;aAC1F,IAAI,CAAC,GAAG,CAAC;QACZ,GAAG,CACJ,CAAA;AACH,CAAC"}

package/dist/dispatch/call-remote.d.ts

@@ -1,39 +0,0 @@
-/**
- * `ctx.callRemote` — call ANOTHER worker's remote method from a handler.
- *
- * A worker's `kernel.call('/dom/class.X/method', …)` signs `aud = <kernel>`,
- * which is correct for a **kernel syscall** (it runs in the kernel) but is
- * rejected by a **remote method** (a Function with `binding.remoteUrl`, i.e.
- * another worker) — the target worker verifies `aud` against its own identity
- * and throws `Credential audience mismatch` at authentication.
- *
- * `callRemote` is now a thin wrapper over the bound kernel session: the kernel
- * resolves a remote-bound path to a redirect carrying the worker's URL and its
- * `iss`, and the session (configured in `bindKernel`) follows it reactively —
- * minting a kernel-signed delegation envelope scoped to that `iss` via the
- * caller's own `@<subject>::mintDelegationCredential`, then dialing the worker.
- * Instance-method `self` is injected by the kernel resolver into the redirect,
- * so a bare `kernel.call(path, params)` is all that's needed here.
- *
- * Prerequisite (authorization, unchanged): the calling Function's identity must
- * hold `USE` on `Identity.mintDelegationCredential` AND the target method's own
- * grants — the session only fixes the audience (authentication), not grants.
- */
-import type { ClientSessionCallOptions } from '@astrale-os/kernel-client/session';
-/**
- * The minimal kernel-call surface: dynamic method dispatch by path string. The
- * bound kernel session view (`BoundClientSessionView`) satisfies it structurally,
- * as does any test double. Exported as the public narrow caller contract so
- * handlers can depend on it instead of the wide, generic session view.
- */
-export type KernelCaller = {
-    call: (method: string, params: unknown, opts?: ClientSessionCallOptions) => Promise<unknown>;
-};
-export type CallRemoteFn = (path: string, params?: Record<string, unknown>) => Promise<unknown>;
-/**
- * Build the `callRemote` helper for one handler invocation. `kernel` is the
- * handler's bound kernel view (or `null` for a public/unauthenticated request,
- * where `callRemote` cannot mint and throws on use).
- */
-export declare function makeCallRemote(kernel: KernelCaller | null): CallRemoteFn;
-//# sourceMappingURL=call-remote.d.ts.map

package/dist/dispatch/call-remote.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"call-remote.d.ts","sourceRoot":"","sources":["../../src/dispatch/call-remote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAA;AAEjF;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,wBAAwB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CAC7F,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE/F;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,GAAG,YAAY,CAWxE"}

package/dist/dispatch/call-remote.js

@@ -1,37 +0,0 @@
-/**
- * `ctx.callRemote` — call ANOTHER worker's remote method from a handler.
- *
- * A worker's `kernel.call('/dom/class.X/method', …)` signs `aud = <kernel>`,
- * which is correct for a **kernel syscall** (it runs in the kernel) but is
- * rejected by a **remote method** (a Function with `binding.remoteUrl`, i.e.
- * another worker) — the target worker verifies `aud` against its own identity
- * and throws `Credential audience mismatch` at authentication.
- *
- * `callRemote` is now a thin wrapper over the bound kernel session: the kernel
- * resolves a remote-bound path to a redirect carrying the worker's URL and its
- * `iss`, and the session (configured in `bindKernel`) follows it reactively —
- * minting a kernel-signed delegation envelope scoped to that `iss` via the
- * caller's own `@<subject>::mintDelegationCredential`, then dialing the worker.
- * Instance-method `self` is injected by the kernel resolver into the redirect,
- * so a bare `kernel.call(path, params)` is all that's needed here.
- *
- * Prerequisite (authorization, unchanged): the calling Function's identity must
- * hold `USE` on `Identity.mintDelegationCredential` AND the target method's own
- * grants — the session only fixes the audience (authentication), not grants.
- */
-/**
- * Build the `callRemote` helper for one handler invocation. `kernel` is the
- * handler's bound kernel view (or `null` for a public/unauthenticated request,
- * where `callRemote` cannot mint and throws on use).
- */
-export function makeCallRemote(kernel) {
-    return async (path, params = {}) => {
-        if (!kernel) {
-            throw new Error('callRemote requires an authenticated request — no kernel credential (public method?)');
-        }
-        // The bound session auto-follows the kernel's redirect and mints for the
-        // worker's `iss`; a remote-bound path therefore just works as a kernel.call.
-        return kernel.call(path, params);
-    };
-}
-//# sourceMappingURL=call-remote.js.map

package/dist/dispatch/call-remote.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"call-remote.js","sourceRoot":"","sources":["../../src/dispatch/call-remote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAgBH;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,MAA2B;IACxD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,EAAE,EAAE,EAAE;QACjC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CACb,sFAAsF,CACvF,CAAA;QACH,CAAC;QACD,yEAAyE;QACzE,6EAA6E;QAC7E,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;IAClC,CAAC,CAAA;AACH,CAAC"}

package/dist/domain/extend-core.d.ts

@@ -1,49 +0,0 @@
-/**
- * Build an augmented `Core<S>` that includes auto-materialized View and
- * standalone-function nodes (one per entry in `defineRemoteDomain`'s `views` /
- * `remoteFunctions` config), plus their parent Folder + optional `view_for`
- * edges. Returns the resolved effective bindings alongside so callers don't
- * recompute them.
- *
- * Standalone callables (the former `RemoteFunction` class) are materialized as
- * the canonical kernel `Function` node class — "remote" is just a `binding`,
- * not a distinct kind, so there is no per-domain class to configure.
- *
- * Conflicts: if the user core already declares a top-level node at
- * `<viewsFolder>` or `<functionsFolder>`, throws — the auto-materialization
- * reserves those slugs.
- */
-import type { FunctionBinding } from '@astrale-os/kernel-api/routed';
-import type { AnyEdgeDef, AnyNodeDef, Core, Schema } from '@astrale-os/kernel-dsl';
-import type { AnyRemoteFunctionDef } from '../define/remote-function';
-import type { ViewDef } from '../define/view';
-export declare const DEFAULT_VIEWS_FOLDER = "views";
-export declare const DEFAULT_FUNCTIONS_FOLDER = "functions";
-export type ExtendCoreConfig = {
-    schema: Schema;
-    origin: string;
-    userCore?: Core;
-    /**
-     * The worker's serving URL — the base every auto-materialized binding
-     * resolves against. OMITTED at define time (the URL is known only to the
-     * spec producers): the aux nodes then materialize structure-only (paths,
-     * names, refs — what identity/subs resolution needs) with no `binding`
-     * stamped and empty binding maps. Every install graph comes from a
-     * `materializeRemoteDomain(domain, url)` call where it is present.
-     */
-    url?: string;
-    viewClass?: AnyNodeDef;
-    viewForEdgeClass?: AnyEdgeDef;
-    viewsFolder?: string;
-    views?: Record<string, ViewDef<any>>;
-    functionsFolder?: string;
-    remoteFunctions?: Record<string, AnyRemoteFunctionDef>;
-};
-export type ExtendCoreResult = {
-    core: Core;
-    viewBindings: Record<string, FunctionBinding>;
-    remoteFunctionBindings: Record<string, FunctionBinding>;
-};
-export declare function extendCore(config: ExtendCoreConfig): ExtendCoreResult;
-export declare function resolveBinding(override: FunctionBinding | undefined, url: string, folderSlug: string, slug: string): FunctionBinding;
-//# sourceMappingURL=extend-core.d.ts.map

package/dist/domain/extend-core.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"extend-core.d.ts","sourceRoot":"","sources":["../../src/domain/extend-core.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AACpE,OAAO,KAAK,EACV,UAAU,EACV,UAAU,EACV,IAAI,EAGJ,MAAM,EACP,MAAM,wBAAwB,CAAA;AAY/B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AACrE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAE7C,eAAO,MAAM,oBAAoB,UAAU,CAAA;AAC3C,eAAO,MAAM,wBAAwB,cAAc,CAAA;AAGnD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,IAAI,CAAA;IACf;;;;;;;OAOG;IACH,GAAG,CAAC,EAAE,MAAM,CAAA;IAEZ,SAAS,CAAC,EAAE,UAAU,CAAA;IACtB,gBAAgB,CAAC,EAAE,UAAU,CAAA;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAA;IAEpC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAA;CACvD,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,IAAI,CAAA;IACV,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IAC7C,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;CACxD,CAAA;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,CAuFrE;AAQD,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,eAAe,GAAG,SAAS,EACrC,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,GACX,eAAe,CAWjB"}

package/dist/domain/extend-core.js

@@ -1,190 +0,0 @@
-/**
- * Build an augmented `Core<S>` that includes auto-materialized View and
- * standalone-function nodes (one per entry in `defineRemoteDomain`'s `views` /
- * `remoteFunctions` config), plus their parent Folder + optional `view_for`
- * edges. Returns the resolved effective bindings alongside so callers don't
- * recompute them.
- *
- * Standalone callables (the former `RemoteFunction` class) are materialized as
- * the canonical kernel `Function` node class — "remote" is just a `binding`,
- * not a distinct kind, so there is no per-domain class to configure.
- *
- * Conflicts: if the user core already declares a top-level node at
- * `<viewsFolder>` or `<functionsFolder>`, throws — the auto-materialization
- * reserves those slugs.
- */
-import { Folder, K, KernelSchema } from '@astrale-os/kernel-core';
-import { buildCorePath } from '@astrale-os/kernel-dsl';
-/** Canonical node class for standalone callables (the former `RemoteFunction`). */
-const FUNCTION_CLASS = KernelSchema.classes.Function;
-/** Canonical node class for GUI views. */
-const VIEW_CLASS = KernelSchema.classes.View;
-/** Canonical edge class linking a View to its target. */
-const VIEW_FOR_EDGE_CLASS = KernelSchema.classes.view_for;
-export const DEFAULT_VIEWS_FOLDER = 'views';
-export const DEFAULT_FUNCTIONS_FOLDER = 'functions';
-const SLUG_RE = /^[a-z][a-z0-9-]*$/;
-export function extendCore(config) {
-    const { schema, origin, userCore, url, viewClass = VIEW_CLASS, viewForEdgeClass = VIEW_FOR_EDGE_CLASS, viewsFolder = DEFAULT_VIEWS_FOLDER, views, functionsFolder = DEFAULT_FUNCTIONS_FOLDER, remoteFunctions, } = config;
-    validateInputs(config);
-    const nodes = userCore ? [...userCore.__nodes] : [];
-    const edges = userCore ? [...userCore.__edges] : [];
-    const viewBindings = {};
-    const remoteFunctionBindings = {};
-    const enableUiHandshake = viewClass === VIEW_CLASS;
-    if (views && viewClass) {
-        // Enforce ViewDef's documented exclusivity: `mount` (SPA route) cannot be
-        // combined with `render` (inline HTML handler) or an explicit `binding` —
-        // silently ignoring one of them would deploy a view that behaves
-        // differently than its definition reads.
-        for (const [slug, def] of Object.entries(views)) {
-            if (def.mount && (def.render || def.binding)) {
-                throw new Error(`defineRemoteDomain: view "${slug}" sets \`mount\` together with ` +
-                    `${def.render ? '`render`' : '`binding`'} — they are mutually exclusive.`);
-            }
-        }
-        assertNoConflict(nodes, origin, viewsFolder);
-        addFolderAndEntries({
-            origin,
-            folderSlug: viewsFolder,
-            nodes,
-            entries: Object.entries(views).map(([slug, def]) => {
-                const binding = url
-                    ? def.mount
-                        ? { remoteUrl: joinWorkerPath(url, def.mount) }
-                        : resolveBinding(def.binding, url, viewsFolder, slug)
-                    : undefined;
-                if (binding)
-                    viewBindings[slug] = binding;
-                return {
-                    slug,
-                    nodeClass: viewClass,
-                    data: buildViewData(slug, binding, def, enableUiHandshake),
-                    edges: buildViewForEdges(slug, def, viewForEdgeClass, viewsFolder, origin),
-                };
-            }),
-            edges,
-        });
-    }
-    if (remoteFunctions) {
-        assertNoConflict(nodes, origin, functionsFolder);
-        addFolderAndEntries({
-            origin,
-            folderSlug: functionsFolder,
-            nodes,
-            entries: Object.entries(remoteFunctions).map(([slug, def]) => {
-                const binding = url ? resolveBinding(def.binding, url, functionsFolder, slug) : undefined;
-                if (binding)
-                    remoteFunctionBindings[slug] = binding;
-                return {
-                    slug,
-                    // Standalone callables materialize as the canonical kernel Function class.
-                    nodeClass: FUNCTION_CLASS,
-                    data: {
-                        ...buildFunctionData(slug, binding),
-                        [K.$.i('Function').ref.key]: def.ref ?? `function.${slug}`,
-                    },
-                    edges: [],
-                };
-            }),
-            edges,
-        });
-    }
-    return {
-        core: { schema, domain: origin, __nodes: nodes, __edges: edges },
-        viewBindings,
-        remoteFunctionBindings,
-    };
-}
-/** Join a worker-relative mount path onto the serving url (single slash). */
-function joinWorkerPath(url, mount) {
-    const base = url.replace(/\/+$/, '');
-    return `${base}/${mount.replace(/^\/+/, '')}`;
-}
-export function resolveBinding(override, url, folderSlug, slug) {
-    // Same trailing-slash discipline as `joinWorkerPath` — a `url` ending in `/`
-    // must not produce `//` in the binding (the kernel pins iss by exact string).
-    const base = url.replace(/\/+$/, '');
-    if (override) {
-        return {
-            ...override,
-            remoteUrl: override.remoteUrl ?? `${base}/${folderSlug}/${slug}`,
-        };
-    }
-    return { remoteUrl: `${base}/${folderSlug}/${slug}` };
-}
-// ── Internal ───────────────────────────────────────────────────────────────
-function validateInputs(config) {
-    if (config.views) {
-        for (const slug of Object.keys(config.views)) {
-            if (!SLUG_RE.test(slug)) {
-                throw new Error(`defineRemoteDomain: invalid view slug "${slug}" — must match ${SLUG_RE}.`);
-            }
-        }
-    }
-    if (config.remoteFunctions) {
-        for (const slug of Object.keys(config.remoteFunctions)) {
-            if (!SLUG_RE.test(slug)) {
-                throw new Error(`defineRemoteDomain: invalid remote-function slug "${slug}" — must match ${SLUG_RE}.`);
-            }
-        }
-    }
-}
-function assertNoConflict(nodes, origin, folderSlug) {
-    const folderPath = buildCorePath(origin, [folderSlug]);
-    if (nodes.some((n) => n.path === folderPath)) {
-        throw new Error(`defineRemoteDomain: top-level core slug "${folderSlug}" is reserved by ` +
-            'SDK auto-materialization. Move the conflicting node or rename the ' +
-            '`viewsFolder` / `functionsFolder` config.');
-    }
-}
-function addFolderAndEntries(args) {
-    const { origin, folderSlug, entries, nodes, edges } = args;
-    const folderPath = buildCorePath(origin, [folderSlug]);
-    nodes.push({
-        path: folderPath,
-        def: Folder,
-        data: { [K.Named.name.key]: folderSlug },
-    });
-    for (const entry of entries) {
-        nodes.push({
-            path: buildCorePath(origin, [folderSlug, entry.slug]),
-            def: entry.nodeClass,
-            data: entry.data,
-            parent: folderPath,
-        });
-        for (const e of entry.edges)
-            edges.push(e);
-    }
-}
-function buildFunctionData(slug, binding) {
-    // Match the kernel-core schema serializer which JSON-stringifies the
-    // `Function.binding` value on Function nodes (see
-    // kernel/core/domain/serialize/schema.ts). The kernel install validator
-    // checks `typeof binding === 'string'` then parses; storing a raw object
-    // trips the validator with "missing remote binding" even when the object IS
-    // the binding. No binding at all (define-time, no url) → no prop stamped.
-    return {
-        [K.Named.name.key]: slug,
-        ...(binding ? { [K.$.i('Function').binding.key]: JSON.stringify(binding) } : {}),
-    };
-}
-function buildViewData(slug, binding, def, enableUiHandshake) {
-    const handshake = def.handshake ?? (def.render ? 'none' : undefined);
-    return {
-        ...buildFunctionData(slug, binding),
-        ...(enableUiHandshake && handshake ? { [K.UI.handshake.key]: handshake } : {}),
-    };
-}
-function buildViewForEdges(slug, def, edgeClass, viewsFolder, origin) {
-    if (!def.viewFor || !edgeClass)
-        return [];
-    const targets = Array.isArray(def.viewFor) ? def.viewFor : [def.viewFor];
-    const from = buildCorePath(origin, [viewsFolder, slug]);
-    return targets.map((target) => ({
-        from,
-        edge: edgeClass,
-        to: target,
-    }));
-}
-//# sourceMappingURL=extend-core.js.map