@astrale-os/sdk 0.4.10 → 0.4.12

package/src/defer/index.ts

@@ -0,0 +1,64 @@
+import type { Context } from 'hono'
+
+/** Internal structural host capability; not part of the author-facing SDK contract. */
+export type HandlerExecutionLifetime = {
+  waitUntil(promise: Promise<unknown>): void
+}
+
+/**
+ * Work detached from the current handler result.
+ *
+ * The callback is deliberately lazy: the SDK registers the resulting task with
+ * the active execution backend before it starts. Current request-based hosts
+ * extend their request lifetime; future durable backends may provide stronger
+ * execution guarantees without changing the author-facing API.
+ */
+export type DeferredTask = () => void | PromiseLike<unknown>
+
+export type Defer = (task: DeferredTask) => void
+
+export type HandlerLifecycle = {
+  defer: Defer
+  settle(): Promise<void>
+}
+
+/** Bind detached work to the host, with a safe blocking fallback for other runtimes. */
+export function createHandlerLifecycle(lifetime?: HandlerExecutionLifetime): HandlerLifecycle {
+  const pending: Promise<unknown>[] = []
+
+  return {
+    defer(task) {
+      const promise = Promise.resolve().then(task)
+      if (lifetime) lifetime.waitUntil(promise)
+      else pending.push(promise)
+    },
+    async settle() {
+      if (lifetime || pending.length === 0) return
+
+      // A deferred task may register more work before it settles. Drain until
+      // the lifecycle is stable so non-request runtimes never abandon children.
+      let cursor = 0
+      while (cursor < pending.length) {
+        const batch = pending.slice(cursor)
+        cursor = pending.length
+        const results = await Promise.allSettled(batch)
+        for (const result of results) {
+          if (result.status === 'rejected') {
+            // oxlint-disable-next-line no-console
+            console.error('[sdk] deferred task failed:', result.reason)
+          }
+        }
+      }
+    },
+  }
+}
+
+/** Hono omits its execution context in Node and in lightweight unit tests. */
+export function executionLifetime(c: Context): HandlerExecutionLifetime | undefined {
+  try {
+    const host = c.executionCtx
+    return { waitUntil: (promise) => host.waitUntil(promise) }
+  } catch {
+    return undefined
+  }
+}

package/src/define/index.ts

@@ -1,10 +1,10 @@
-export { defineView } from './view'
-export type { ViewDef, ViewRenderContext } from './view'
+export { defineView } from './view.js'
+export type { ViewDef, ViewRenderContext } from './view.js'
 
-export { defineRemoteFunction } from './remote-function'
+export { defineRemoteFunction } from './remote-function.js'
 export type {
   AnyRemoteFunctionDef,
   RemoteFunctionAuthorizeContext,
   RemoteFunctionContext,
   RemoteFunctionDef,
-} from './remote-function'
+} from './remote-function.js'

package/src/define/remote-function.ts

@@ -23,10 +23,11 @@ import type { BoundClientSessionView } from '@astrale-os/kernel-client/session'
 import type { Context } from 'hono'
 import type { z } from 'zod'
 
-import type { FunctionContextApi } from '../auth/function-context'
-import type { DomainAuthority } from '../auth/issuer-mint'
-import type { AuthForPolicy, CallerContext, KernelForAuth, RemoteEnv } from '../method/context'
-import type { Step } from '../step'
+import type { FunctionContextApi } from '../auth/function-context.js'
+import type { DomainAuthority } from '../auth/issuer-mint.js'
+import type { Defer } from '../defer/index.js'
+import type { AuthForPolicy, CallerContext, KernelForAuth, RemoteEnv } from '../method/context.js'
+import type { Step } from '../step/index.js'
 
 type RemoteFunctionBaseContext<
   TParams,
@@ -83,6 +84,8 @@ export interface RemoteFunctionContext<
 > extends RemoteFunctionBaseContext<TParams, TDeps, TKernel, TAuth> {
   /** Durable-shaped step builder. Inline today, replayable by future backends. */
   step: Step
+  /** Run independent work without making its completion part of this result. */
+  defer: Defer
 }
 
 export type RemoteFunctionDef<

package/src/define/view.ts

@@ -24,9 +24,9 @@ import type { AuthPolicy, FunctionBinding } from '@astrale-os/kernel-api/routed'
 import type { EdgeEndpoint } from '@astrale-os/kernel-dsl'
 import type { Context } from 'hono'
 
-import type { FunctionContextApi } from '../auth/function-context'
-import type { AuthForPolicy } from '../method/context'
-import type { RemoteEnv } from '../method/context'
+import type { FunctionContextApi } from '../auth/function-context.js'
+import type { AuthForPolicy } from '../method/context.js'
+import type { RemoteEnv } from '../method/context.js'
 
 export type ViewRenderContext<TDeps = unknown, TAuth extends AuthPolicy = AuthPolicy> = {
   /** Hono request context — read params, headers, query, etc. */

package/src/deploy/check.ts

@@ -1,9 +1,9 @@
 import { spawnSync } from 'node:child_process'
 import { join } from 'node:path'
 
-import type { Meta } from './meta'
+import type { Meta } from './meta.js'
 
-import { MetaSchema } from './meta'
+import { MetaSchema } from './meta.js'
 
 export type DeployCheckOptions = {
   /** Deployed worker URL (e.g. `https://example.astrale.ai`). */

package/src/deploy/index.ts

@@ -1,2 +1,2 @@
-export { MetaSchema, type Meta } from './meta'
-export { deployCheck, type DeployCheckOptions } from './check'
+export { MetaSchema, type Meta } from './meta.js'
+export { deployCheck, type DeployCheckOptions } from './check.js'

package/src/dispatch/authorize.ts

@@ -11,7 +11,7 @@
  * plain `Error` thrown to deny leaked out as a 500 instead of a 403.
  */
 
-import { AuthorizationDeniedError } from './errors'
+import { AuthorizationDeniedError } from './errors.js'
 
 export async function runAuthorize<C>(
   hook: (ctx: C) => void | Promise<void>,

package/src/dispatch/dispatcher.ts

@@ -17,24 +17,30 @@ import type { BoundMethod, CompiledDomain } from '@astrale-os/kernel-core/domain
 
 import { createNodeBinder } from '@astrale-os/kernel-client/schema'
 
-import type { RemoteIdentityConfig } from '../auth/identity'
-import type { AnyRemoteHandler } from '../method/single'
-import type { MethodIndex } from './resolve'
+import type { RemoteIdentityConfig } from '../auth/identity.js'
+import type { AnyRemoteHandler } from '../method/single.js'
+import type { MethodIndex } from './resolve.js'
 
-import { makeFunctionContext } from '../auth/function-context'
-import { makeDomainAuthority } from '../auth/issuer-mint'
-import { resolveInboundAuth } from '../auth/resolve'
-import { createInlineStep } from '../step'
-import { runAuthorize } from './authorize'
-import { MethodNotFoundError, SdkResultValidationError, SdkValidationError } from './errors'
-import { executeHandler } from './execute'
-import { buildIdentityMap } from './identity'
-import { resolveMethod } from './resolve'
-import { resolveSelf, withBoundNode, type ParsedSelf } from './self'
-import { validateParams, validateResult } from './validate'
+import { makeFunctionContext } from '../auth/function-context.js'
+import { makeDomainAuthority } from '../auth/issuer-mint.js'
+import { resolveInboundAuth } from '../auth/resolve.js'
+import { createHandlerLifecycle, type HandlerExecutionLifetime } from '../defer/index.js'
+import { createInlineStep } from '../step/index.js'
+import { runAuthorize } from './authorize.js'
+import { MethodNotFoundError, SdkResultValidationError, SdkValidationError } from './errors.js'
+import { executeHandler } from './execute.js'
+import { buildIdentityMap } from './identity.js'
+import { resolveMethod } from './resolve.js'
+import { resolveSelf, withBoundNode, type ParsedSelf } from './self.js'
+import { validateParams, validateResult } from './validate.js'
 
 type PathInput = string | { raw: string }
 
+type SdkDispatchOpts = {
+  self?: string
+  lifetime?: HandlerExecutionLifetime
+}
+
 export type SdkDispatcherConfig<TDeps> = {
   /** The compiled domain — source of the method layout and origin-addressed subs. */
   compiled: CompiledDomain
@@ -86,7 +92,7 @@ export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
     params: unknown,
     opts?: { self?: string },
   ): Promise<unknown> {
-    return this.run(path, credential, params, opts?.self)
+    return this.run(path, credential, params, opts)
   }
 
   async stream(
@@ -95,7 +101,7 @@ export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
     params: unknown,
     opts?: { self?: string },
   ): Promise<AsyncGenerator<unknown>> {
-    const result = await this.run(path, credential, params, opts?.self)
+    const result = await this.run(path, credential, params, opts)
     if (!isAsyncGenerator(result)) {
       throw new Error(`Method "${pathToString(path)}" did not return an async generator`)
     }
@@ -111,9 +117,9 @@ export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
     path: PathInput,
     credential: CredentialInput,
     params: unknown,
-    opts?: { self?: string },
+    opts?: SdkDispatchOpts,
   ): Promise<DispatchResult> {
-    const result = await this.run(path, credential, params, opts?.self)
+    const result = await this.run(path, credential, params, opts)
     return isAsyncGenerator(result)
       ? { kind: 'stream', generator: result }
       : { kind: 'value', value: result }
@@ -130,8 +136,9 @@ export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
     path: PathInput,
     credential: CredentialInput,
     params: unknown,
-    selfRef?: string,
+    opts?: SdkDispatchOpts,
   ): Promise<unknown> {
+    const selfRef = opts?.self
     const bound = resolveMethod(this.methods, pathToString(path))
     if (!bound) throw new MethodNotFoundError(pathToString(path))
 
@@ -217,20 +224,37 @@ export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
 
     if (handler.authorize) await runAuthorize(handler.authorize, ctx)
 
-    const result = await executeHandler({
-      handler,
-      ref: bound.ref,
-      ...ctx,
-      step: createInlineStep({
-        scope: {
-          kind: 'method',
-          ref: bound.ref,
-          owner: bound.owner,
-          method: bound.method,
-        },
-      }),
-    })
-    return validateOutput(bound, result)
+    const lifecycle = createHandlerLifecycle(opts?.lifetime)
+    let result: unknown
+    try {
+      result = await executeHandler({
+        handler,
+        ref: bound.ref,
+        ...ctx,
+        step: createInlineStep({
+          scope: {
+            kind: 'method',
+            ref: bound.ref,
+            owner: bound.owner,
+            method: bound.method,
+          },
+        }),
+        defer: lifecycle.defer,
+      })
+    } catch (error) {
+      await lifecycle.settle()
+      throw error
+    }
+
+    if (isAsyncGenerator(result)) {
+      return validateOutputStream(bound, result, lifecycle.settle)
+    }
+
+    try {
+      return validateOutput(bound, result)
+    } finally {
+      await lifecycle.settle()
+    }
   }
 
   private identityFor(bound: BoundMethod<AnyRemoteHandler>): RemoteIdentityConfig {
@@ -268,16 +292,20 @@ function pathToString(path: PathInput): string {
  */
 function validateOutput(bound: BoundMethod<AnyRemoteHandler>, result: unknown): unknown {
   if (bound.output === 'binary') return result
-  if (isAsyncGenerator(result)) return validateOutputStream(bound, result)
   return validateChunk(bound, result)
 }
 
 async function* validateOutputStream(
   bound: BoundMethod<AnyRemoteHandler>,
   gen: AsyncGenerator<unknown>,
+  settle: () => Promise<void>,
 ): AsyncGenerator<unknown> {
-  for await (const chunk of gen) {
-    yield validateChunk(bound, chunk)
+  try {
+    for await (const chunk of gen) {
+      yield validateChunk(bound, chunk)
+    }
+  } finally {
+    await settle()
   }
 }
 

package/src/dispatch/execute.ts

@@ -11,11 +11,12 @@ import type { FnMap } from '@astrale-os/kernel-client'
 import type { BoundClientSessionView } from '@astrale-os/kernel-client/session'
 import type { AuthContext } from '@astrale-os/kernel-core'
 
-import type { FunctionContextApi } from '../auth/function-context'
-import type { DomainAuthority } from '../auth/issuer-mint'
-import type { CallerContext, RemoteEnv } from '../method/context'
-import type { Step } from '../step'
-import type { SelfResult, TypedSelf } from './self'
+import type { FunctionContextApi } from '../auth/function-context.js'
+import type { DomainAuthority } from '../auth/issuer-mint.js'
+import type { Defer } from '../defer/index.js'
+import type { CallerContext, RemoteEnv } from '../method/context.js'
+import type { Step } from '../step/index.js'
+import type { SelfResult, TypedSelf } from './self.js'
 
 // oxlint-disable-next-line no-explicit-any
 type HandlerFn = (...args: any[]) => any
@@ -38,6 +39,7 @@ export type ExecuteParams = {
   domain: DomainAuthority
   fn: FunctionContextApi
   step: Step
+  defer: Defer
 }
 
 export async function executeHandler(ctx: ExecuteParams): Promise<unknown> {
@@ -58,5 +60,6 @@ export async function executeHandler(ctx: ExecuteParams): Promise<unknown> {
     domain: ctx.domain,
     fn: ctx.fn,
     step: ctx.step,
+    defer: ctx.defer,
   })
 }

package/src/dispatch/identity.ts

@@ -25,8 +25,8 @@ import type { BoundMethod, CompiledDomain } from '@astrale-os/kernel-core/domain
 
 import { resolveCallables } from '@astrale-os/kernel-core/domain'
 
-import type { RemoteIdentityConfig } from '../auth/identity'
-import type { AnyRemoteHandler } from '../method/single'
+import type { RemoteIdentityConfig } from '../auth/identity.js'
+import type { AnyRemoteHandler } from '../method/single.js'
 
 /**
  * For each materialized method node, emit its `MethodPath` (semantic,

package/src/dispatch/index.ts

@@ -1,16 +1,16 @@
-export { SdkDispatcher, type SdkDispatcherConfig } from './dispatcher'
-export { resolveMethod, buildMethodIndex, type MethodIndex } from './resolve'
+export { SdkDispatcher, type SdkDispatcherConfig } from './dispatcher.js'
+export { resolveMethod, buildMethodIndex, type MethodIndex } from './resolve.js'
 export {
   validateParams,
   validateResult,
   type ValidationResult,
   type ResultValidationResult,
-} from './validate'
-export { resolveSelf, withBoundNode, type SelfResult, type TypedSelf } from './self'
-export { executeHandler, type ExecuteParams } from './execute'
+} from './validate.js'
+export { resolveSelf, withBoundNode, type SelfResult, type TypedSelf } from './self.js'
+export { executeHandler, type ExecuteParams } from './execute.js'
 export {
   AuthorizationDeniedError,
   MethodNotFoundError,
   SdkValidationError,
   SdkResultValidationError,
-} from './errors'
+} from './errors.js'

package/src/dispatch/resolve.ts

@@ -22,7 +22,7 @@
 import type { Path } from '@astrale-os/kernel-core'
 import type { BoundMethod } from '@astrale-os/kernel-core/domain'
 
-import type { AnyRemoteHandler } from '../method/single'
+import type { AnyRemoteHandler } from '../method/single.js'
 
 export type MethodIndex = Map<string, BoundMethod<AnyRemoteHandler>>
 

package/src/dispatch/self.ts

@@ -25,7 +25,7 @@ import { classPathSchema } from '@astrale-os/kernel-core/domain'
 import { absolutePathSchema } from '@astrale-os/kernel-core/tree'
 import { z } from 'zod'
 
-import type { Kernel } from '../method/context'
+import type { Kernel } from '../method/context.js'
 
 /** The node a non-static method runs on — its full record, id guaranteed. */
 export type ResolvedSelfNode = Node & { id: NodeId }

package/src/domain/build-spec.ts

@@ -24,11 +24,11 @@ import type { Schema } from '@astrale-os/kernel-dsl'
 import { AbsolutePath } from '@astrale-os/kernel-core'
 import { hashInstallGraph, serialize, zodToJsonSchema } from '@astrale-os/kernel-core/domain'
 
-import type { AnyRemoteHandler } from '../method/single'
-import type { RemoteDomain } from './define'
+import type { AnyRemoteHandler } from '../method/single.js'
+import type { RemoteDomain } from './define.js'
 
-import { extractBinding } from './contract'
-import { materializeRemoteDomain } from './define'
+import { extractBinding } from './contract.js'
+import { materializeRemoteDomain } from './define.js'
 
 /**
  * Build the install-ready wire graph for a domain served at `url`: materialize
@@ -93,6 +93,10 @@ function buildSpecInternal(
   const tree = serialize(compiled, [...serialized, ...functionSchemas], {
     views: viewSchemas,
     parent,
+    // An install graph is the domain's signed desired state. Reinstalling it
+    // must converge schema and core material exactly, including removing
+    // properties that disappeared from a newer domain version.
+    onConflict: 'replace',
   })
   return tree.toGraph()
 }

package/src/domain/contract.ts

@@ -14,7 +14,7 @@ import type {
 } from '@astrale-os/kernel-api/routed'
 import type { BoundMethod } from '@astrale-os/kernel-core/domain'
 
-import type { AnyRemoteHandler } from '../method/single'
+import type { AnyRemoteHandler } from '../method/single.js'
 
 export function toSdkContract(method: BoundMethod<AnyRemoteHandler>): MountableContract {
   const handler = method.handler as {

package/src/domain/define.ts

@@ -14,17 +14,17 @@ import type { Core, Schema } from '@astrale-os/kernel-dsl'
 
 import { bindMethods, compileDomain } from '@astrale-os/kernel-core/domain'
 
-import type { DomainManifest } from '../config/define-domain'
-import type { AnyRemoteFunctionDef, ViewDef } from '../define'
-import type { SchemaMethodsImpl } from '../method/class'
-import type { AnyRemoteHandler } from '../method/single'
+import type { DomainManifest } from '../config/define-domain.js'
+import type { AnyRemoteFunctionDef, ViewDef } from '../define/index.js'
+import type { SchemaMethodsImpl } from '../method/class.js'
+import type { AnyRemoteHandler } from '../method/single.js'
 
 import {
   assertFunctionsMatchSchema,
   buildFunctionSchemas,
   DEFAULT_FUNCTIONS_FOLDER,
-} from './extend-functions'
-import { buildViewDeclarations, buildViewSchemas, DEFAULT_VIEWS_FOLDER } from './extend-views'
+} from './extend-functions.js'
+import { buildViewDeclarations, buildViewSchemas, DEFAULT_VIEWS_FOLDER } from './extend-views.js'
 
 export type RemoteDomainConfig<S extends Schema, TDeps> = {
   schema: S

package/src/domain/extend-functions.ts

@@ -22,9 +22,9 @@ import type { Schema } from '@astrale-os/kernel-dsl'
 
 import { zodToJsonSchema } from '@astrale-os/kernel-core/domain'
 
-import type { AnyRemoteFunctionDef } from '../define/remote-function'
+import type { AnyRemoteFunctionDef } from '../define/remote-function.js'
 
-import { resolveBinding } from './binding'
+import { resolveBinding } from './binding.js'
 
 /**
  * Default URL segment for a function's worker route (`<url>/functions/<slug>`).

package/src/domain/extend-views.ts

@@ -29,9 +29,9 @@ import {
   type EdgeEndpoint,
 } from '@astrale-os/kernel-dsl'
 
-import type { ViewDef } from '../define/view'
+import type { ViewDef } from '../define/view.js'
 
-import { joinWorkerPath, resolveBinding } from './binding'
+import { joinWorkerPath, resolveBinding } from './binding.js'
 
 /**
  * Default URL segment for a view's worker route (`<url>/views/<slug>`). Names the

package/src/domain/index.ts

@@ -1,4 +1,4 @@
-export { defineRemoteDomain } from './define'
-export type { RemoteDomain, RemoteDomainConfig } from './define'
-export { buildInstallGraph, buildInstallGraphHash } from './build-spec'
-export { toSdkContract } from './contract'
+export { defineRemoteDomain } from './define.js'
+export type { RemoteDomain, RemoteDomainConfig } from './define.js'
+export { buildInstallGraph, buildInstallGraphHash } from './build-spec.js'
+export { toSdkContract } from './contract.js'

package/src/index.ts

@@ -14,15 +14,15 @@ export type {
   ClassMethodsImpl,
   InterfaceMethodsImpl,
   SchemaMethodsImpl,
-} from './method'
-export { remoteMethod, remoteClassMethods, remoteInterfaceMethods } from './method'
+} from './method/index.js'
+export { remoteMethod, remoteClassMethods, remoteInterfaceMethods } from './method/index.js'
 
 // ─── Domain configuration (astrale.config.ts) ────────────────────────────
 // The author-facing way to declare a standalone domain + how it deploys. The
 // runtime-domain COMPILER (`defineRemoteDomain`) is internal machinery — reach
 // it via the `@astrale-os/sdk/domain` subpath when hand-rolling a worker, or
 // (preferred) use `domainWorkerEntry` from `@astrale-os/sdk/server`.
-export { defineDomain, deploy, defineAdapter } from './config'
+export { defineDomain, deploy, defineAdapter } from './config/index.js'
 export type {
   DefineDomainConfig,
   DomainDefinition,
@@ -35,10 +35,10 @@ export type {
   DomainInfo,
   WatchCtx,
   WatchHandle,
-} from './config'
+} from './config/index.js'
 
 // ─── Install graph (advanced) ────────────────────────────────────────────
-export { buildInstallGraph, buildInstallGraphHash } from './domain'
+export { buildInstallGraph, buildInstallGraphHash } from './domain/index.js'
 
 // ─── Graph patching (advanced) ────────────────────────────────────────
 // Author-facing patch types, re-exported from kernel-core (the single source).
@@ -67,17 +67,20 @@ export type {
 // the reserved views / functions folder, keyed by its map slug; the same
 // entry's `render` / `execute` (+ auth hooks) is mounted as a worker route by
 // `createRemoteServer`.
-export { defineView, defineRemoteFunction } from './define'
+export { defineView, defineRemoteFunction } from './define/index.js'
 export type {
   ViewDef,
   ViewRenderContext,
   RemoteFunctionAuthorizeContext,
   RemoteFunctionDef,
   RemoteFunctionContext,
-} from './define'
+} from './define/index.js'
 
 // ─── Durable-shaped steps ────────────────────────────────────────────────
-export type { Step } from './step'
+export type { Step } from './step/index.js'
+
+// ─── Request lifecycle ───────────────────────────────────────────────────
+export type { Defer, DeferredTask } from './defer/index.js'
 
 // ─── Server ──────────────────────────────────────────────────────────────
 // `createRemoteServer` dynamically imports `@hono/node-server` via `./server/start`.
@@ -91,8 +94,8 @@ export type { Step } from './step'
 // module load time. Exporting it from the barrel poisons browser bundlers
 // (Vite/esbuild) that transitively load every re-export. Consumers that need it
 // import from './deploy' directly.
-export { MetaSchema } from './deploy/meta'
-export type { Meta } from './deploy/meta'
+export { MetaSchema } from './deploy/meta.js'
+export type { Meta } from './deploy/meta.js'
 
 // ─── Route binding (re-exported from kernel-api for consumer convenience) ─
 export type {
@@ -107,22 +110,22 @@ export type {
 } from '@astrale-os/kernel-api/routed'
 
 // ─── Auth ────────────────────────────────────────────────────────────────
-export type { RemoteIdentityConfig, AuthenticateResult } from './auth'
+export type { RemoteIdentityConfig, AuthenticateResult } from './auth/index.js'
 export type {
   DomainAuthority,
   FunctionContextApi,
   FunctionCredentialOptions,
   FunctionKernelOptions,
   MintIssuedParams,
-} from './auth'
+} from './auth/index.js'
 export {
   authenticateRequest,
   buildComposedGrant,
   makeFunctionContext,
   signCredential,
-} from './auth'
-export { AuthMissingError, AuthInvalidError } from './auth'
-export { assertPerm, requireOwnership, READ, EDIT, USE, SHARE, ALL } from './auth'
+} from './auth/index.js'
+export { AuthMissingError, AuthInvalidError } from './auth/index.js'
+export { assertPerm, requireOwnership, READ, EDIT, USE, SHARE, ALL } from './auth/index.js'
 export type {
   AuthContext,
   Attestation,
@@ -134,11 +137,11 @@ export type {
 export { selfGrant } from '@astrale-os/kernel-core'
 
 // ─── Dispatch (escape hatch for custom integrations) ─────────────────────
-export { SdkDispatcher, type SdkDispatcherConfig } from './dispatch'
+export { SdkDispatcher, type SdkDispatcherConfig } from './dispatch/index.js'
 export {
   AuthorizationDeniedError,
   MethodNotFoundError,
   SdkValidationError,
   SdkResultValidationError,
-} from './dispatch'
-export type { SelfResult, TypedSelf } from './dispatch'
+} from './dispatch/index.js'
+export type { SelfResult, TypedSelf } from './dispatch/index.js'

package/src/method/class.ts

@@ -25,9 +25,9 @@ import type {
 } from '@astrale-os/kernel-core/domain'
 import type { ImplementableOwnKeys, Schema } from '@astrale-os/kernel-dsl'
 
-import type { TypedSelf } from '../dispatch/self'
-import type { DomainKernel } from './context'
-import type { MethodImpl, RemoteHandler } from './single'
+import type { TypedSelf } from '../dispatch/self.js'
+import type { DomainKernel } from './context.js'
+import type { MethodImpl, RemoteHandler } from './single.js'
 
 /** Per-class method implementations for a remote domain. */
 export type ClassMethodsImpl<

package/src/method/context.ts

@@ -14,9 +14,10 @@ import type { BoundClientSessionView } from '@astrale-os/kernel-client/session'
 import type { AuthContext } from '@astrale-os/kernel-core'
 import type { Schema } from '@astrale-os/kernel-dsl'
 
-import type { FunctionContextApi } from '../auth/function-context'
-import type { DomainAuthority } from '../auth/issuer-mint'
-import type { Step } from '../step'
+import type { FunctionContextApi } from '../auth/function-context.js'
+import type { DomainAuthority } from '../auth/issuer-mint.js'
+import type { Defer } from '../defer/index.js'
+import type { Step } from '../step/index.js'
 
 export type { GraphApi } from '@astrale-os/kernel-client/graph'
 
@@ -127,4 +128,6 @@ export interface RemoteContext<
 > extends RemoteBaseContext<TParams, TSelf, TDeps, TKernel, TAuth> {
   /** Durable-shaped step builder. Inline today, replayable by future backends. */
   step: Step
+  /** Run independent work without making its completion part of this result. */
+  defer: Defer
 }