@astrale-os/sdk 0.4.0 → 0.4.2

package/src/auth/kernel-client.ts

@@ -29,7 +29,7 @@ import {
 
 import type { RemoteIdentityConfig } from './identity'
 
-import { buildComposedExpr, buildComposedGrant, buildSelfExpr, buildSelfGrant } from './compose'
+import { buildComposedExpr, buildComposedGrant, buildSelfExpr } from './compose'
 import { signCredential } from './sign'
 
 const DELEGATION_TTL_SECONDS = 3600
@@ -75,20 +75,6 @@ export async function bindKernel(
   )
 }
 
-/**
- * Build a `BoundClientSessionView` authenticated as the FUNCTION'S OWN
- * identity — no inbound delegation, authority = the function's own grants
- * only. The seam behind `selfKernel` for public/webhook handlers: an HMAC- or
- * signature-verified webhook can act on the graph as itself after verifying
- * the upstream. Next-hop mints delegate self only.
- */
-export async function bindSelfKernel(
-  kernelUrl: string,
-  config: RemoteIdentityConfig,
-): Promise<BoundClientSessionView<FnMap>> {
-  return bindSession(kernelUrl, config, buildSelfGrant().grant, () => buildSelfExpr())
-}
-
 /**
  * Shared session construction: sign a credential as this function's identity
  * carrying `grant`, bind the session to it, and wire the lazy NEXT-HOP mint.
@@ -122,7 +108,10 @@ async function bindSession(
     schema: getRegistry(kernelUrl),
     pool: getPool(kernelUrl),
     delegation: {
-      mint: delegationMintVia(() => session, credential),
+      mint: delegationMintVia(
+        () => session,
+        () => credential,
+      ),
       ttl: DELEGATION_TTL_SECONDS,
     },
     delegationPolicy: {
@@ -136,43 +125,29 @@ async function bindSession(
 /**
  * Bind a session to a PRE-SIGNED credential — no delegation mint, no composed
  * grant; the credential IS the authority. The seam behind
- * `DomainIssuer.sessionFor` (a worker acting as an identity it issues). Pool +
+ * `DomainAuthority.sessionFor` (a worker acting as an identity it issues). Pool +
  * schema registry are the same per-URL caches the composed sessions use.
  */
 export function bindCredentialSession(
   kernelUrl: string,
   credential: string,
+  opts: { delegation?: UnresolvedIdentityExpr } = {},
 ): BoundClientSessionView<FnMap> {
-  const session = new ClientSession<FnMap>({
+  const session: ClientSession<FnMap> = new ClientSession<FnMap>({
     default: kernelUrl,
     schema: getRegistry(kernelUrl),
     pool: getPool(kernelUrl),
+    delegation: {
+      mint: delegationMintVia(
+        () => session,
+        () => credential,
+      ),
+      ttl: DELEGATION_TTL_SECONDS,
+    },
+    delegationPolicy: {
+      ...allowAllDelegations({ default: kernelUrl }),
+      delegationFor: () => opts.delegation ?? buildSelfExpr(),
+    },
   })
   return session.as(credential)
 }
-
-/**
- * Build the `selfKernel` accessor handed to remote-function handlers.
- * Resolves the kernel URL from the explicit argument or `deps.KERNEL_URL`
- * (a public request carries no credential, so the parent kernel cannot be
- * inferred — it must be configured).
- */
-export function makeSelfKernel(
-  identity: RemoteIdentityConfig,
-  deps: unknown,
-): (kernelUrl?: string) => Promise<BoundClientSessionView<FnMap>> {
-  return async (kernelUrl?: string) => {
-    const env = deps as { INSTANCE_KERNEL_URL?: unknown; KERNEL_URL?: unknown } | null | undefined
-    // Prefer the INSTANCE kernel (the graph this domain is installed on);
-    // KERNEL_URL on managed services is the HOST kernel (the box) — wrong
-    // graph for domain writes, kept only as a last-resort fallback.
-    const url = kernelUrl ?? env?.INSTANCE_KERNEL_URL ?? env?.KERNEL_URL
-    if (typeof url !== 'string' || url.length === 0) {
-      throw new Error(
-        'selfKernel: no kernel URL — pass one explicitly or set INSTANCE_KERNEL_URL in the ' +
-          'worker env (managed deploys set it automatically).',
-      )
-    }
-    return bindSelfKernel(url, identity)
-  }
-}

package/src/cli/publish.ts

@@ -176,7 +176,7 @@ export async function publishSchema(args: {
     error(
       `No schema package found (no package.json at ./schema or the current dir). A schema\n` +
         `  package declares peerDependencies (@astrale-os/kernel-core + kernel-dsl + zod) and a\n` +
-        `  publishConfig that repoints main/exports to ./dist — see domains/workspace/schema.`,
+        `  publishConfig that repoints main/exports to ./dist — see domains/shell/schema.`,
     )
     return 1
   }

package/src/config/define-domain.ts

@@ -153,7 +153,7 @@ export interface DefineDomainConfig<S extends Schema, TDeps, TEnv = unknown> {
    * `has_parent` position: the domain's `installed_in` edge and EVERY typed
    * address (`/:<origin>`, `/:<origin>:Class`, …) stay ROOT-mounted, so
    * addressing is unchanged. A platform domain that must stay top-level sets its
-   * own origin path (e.g. `'/workspace.astrale.ai'`).
+   * own origin path (e.g. `'/shell.astrale.ai'`).
    */
   path?: string
   /**

package/src/define/index.ts

@@ -4,6 +4,7 @@ export type { ViewDef, ViewRenderContext } from './view'
 export { defineRemoteFunction } from './remote-function'
 export type {
   AnyRemoteFunctionDef,
+  RemoteFunctionAuthorizeContext,
   RemoteFunctionContext,
   RemoteFunctionDef,
 } from './remote-function'

package/src/define/remote-function.ts

@@ -23,11 +23,12 @@ import type { BoundClientSessionView } from '@astrale-os/kernel-client/session'
 import type { Context } from 'hono'
 import type { z } from 'zod'
 
-import type { DomainIssuer } from '../auth/issuer-mint'
-import type { CallRemoteFn } from '../dispatch/call-remote'
-import type { AuthForPolicy, KernelForAuth } from '../method/context'
+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'
 
-export type RemoteFunctionContext<
+type RemoteFunctionBaseContext<
   TParams,
   TDeps = unknown,
   TKernel = BoundClientSessionView<FnMap> | null,
@@ -45,6 +46,8 @@ export type RemoteFunctionContext<
   auth: AuthForPolicy<TAuth>
   /** Typed dependency container injected at server startup. */
   deps: TDeps
+  /** Local serving metadata. */
+  env: RemoteEnv
   /**
    * `BoundClientSessionView` to the parent kernel, bound to the composed
    * credential `union(delegation, self)` — same shape as `RemoteContext.kernel`
@@ -53,32 +56,33 @@ export type RemoteFunctionContext<
    * `kernel.createNode` / `kernel.mutate(patch)`, …) over the `function.get` /
    * `function.mutate` syscalls. Nullability follows {@link KernelForAuth} of the
    * function's `auth`: non-null for the default `'required'`, `… | null` for
-   * `'optional'`, `null` for `'public'` (use {@link RemoteFunctionContext.selfKernel}
-   * there, after verifying the upstream).
+   * `'optional'`, `null` for `'public'` (use `ctx.fn.kernel()` there, after
+   * verifying the upstream).
    */
   kernel: TKernel
-  /**
-   * Mint seam for identities THIS DOMAIN issues — same contract as
-   * {@link RemoteContext.issuer}.
-   */
-  issuer: DomainIssuer
-  /**
-   * Call another worker's remote method, re-minting the credential for the
-   * target's audience. Same contract as {@link RemoteContext.callRemote}: throws
-   * on a public/unauthenticated request; needs `USE` on
-   * `Identity.mintDelegationCredential` + the target method's grants.
-   */
-  callRemote: CallRemoteFn
-  /**
-   * Acquire a kernel session authenticated as THIS FUNCTION'S OWN identity —
-   * authority = the function's own grants only, no caller delegation. The
-   * webhook seam: when an `auth: 'public'` upstream can't carry an Astrale
-   * token (HMAC-signature webhooks, Stripe-style), VERIFY THE UPSTREAM'S
-   * SIGNATURE FIRST, then act on the graph as yourself. `kernelUrl` defaults
-   * to `deps.KERNEL_URL` (set automatically on managed deploys); pass it
-   * explicitly for other targets.
-   */
-  selfKernel: (kernelUrl?: string) => Promise<BoundClientSessionView<FnMap>>
+  /** Inbound kernel/peer context. Present only for authenticated invocations. */
+  caller?: CallerContext
+  /** Mint seam for identities THIS DOMAIN issues. */
+  domain: DomainAuthority
+  /** Current function identity tools. */
+  fn: FunctionContextApi
+}
+
+export type RemoteFunctionAuthorizeContext<
+  TParams,
+  TDeps = unknown,
+  TKernel = BoundClientSessionView<FnMap> | null,
+  TAuth extends AuthPolicy = AuthPolicy,
+> = RemoteFunctionBaseContext<TParams, TDeps, TKernel, TAuth>
+
+export interface RemoteFunctionContext<
+  TParams,
+  TDeps = unknown,
+  TKernel = BoundClientSessionView<FnMap> | null,
+  TAuth extends AuthPolicy = AuthPolicy,
+> extends RemoteFunctionBaseContext<TParams, TDeps, TKernel, TAuth> {
+  /** Durable-shaped step builder. Inline today, replayable by future backends. */
+  step: Step
 }
 
 export type RemoteFunctionDef<
@@ -107,12 +111,12 @@ export type RemoteFunctionDef<
    * so it drives `ctx.auth` and {@link KernelForAuth} on the
    * `execute`/`authorize` context: omit it (or `'required'`) makes both
    * non-null; `'optional'` widens them to `... | null`; `'public'` makes them
-   * `null` (webhooks reach the graph via `ctx.selfKernel`).
+   * `null` (webhooks reach the graph via `ctx.fn.kernel()`).
    */
   auth?: TAuth
   /** Optional pre-execute authorization. Throw to deny. */
   authorize?: (
-    ctx: RemoteFunctionContext<TParams, TDeps, KernelForAuth<TAuth>, TAuth>,
+    ctx: RemoteFunctionAuthorizeContext<TParams, TDeps, KernelForAuth<TAuth>, TAuth>,
   ) => void | Promise<void>
   /** The function body. May be async. */
   execute: (

package/src/define/view.ts

@@ -21,12 +21,12 @@
  */
 
 import type { AuthPolicy, FunctionBinding } from '@astrale-os/kernel-api/routed'
-import type { FnMap } from '@astrale-os/kernel-client'
-import type { BoundClientSessionView } from '@astrale-os/kernel-client/session'
 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'
 
 export type ViewRenderContext<TDeps = unknown, TAuth extends AuthPolicy = AuthPolicy> = {
   /** Hono request context — read params, headers, query, etc. */
@@ -45,14 +45,10 @@ export type ViewRenderContext<TDeps = unknown, TAuth extends AuthPolicy = AuthPo
   auth: AuthForPolicy<TAuth>
   /** Typed dependency container injected at server startup. */
   deps: TDeps
-  /**
-   * Kernel session authenticated as THE VIEW'S OWN identity (its grants
-   * only) — the seam for a server-rendered view that reads the graph (e.g.
-   * a public list page). Grant the view's function identity narrow READ on
-   * what it renders (in a seed), never root. Dials the INSTANCE kernel
-   * (`deps.INSTANCE_KERNEL_URL`, set by managed deploys) unless overridden.
-   */
-  selfKernel: (kernelUrl?: string) => Promise<BoundClientSessionView<FnMap>>
+  /** Local serving metadata. */
+  env: RemoteEnv
+  /** View function identity tools. Use `fn.kernel()` for server-rendered graph reads. */
+  fn: FunctionContextApi
 }
 
 export type ViewDef<TDeps = unknown, TAuth extends AuthPolicy = AuthPolicy> = {

package/src/dispatch/dispatcher.ts

@@ -22,10 +22,11 @@ import type { RemoteIdentityConfig } from '../auth/identity'
 import type { AnyRemoteHandler } from '../method/single'
 import type { MethodIndex } from './resolve'
 
-import { makeIssuerMint } from '../auth/issuer-mint'
+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 { makeCallRemote } from './call-remote'
 import { MethodNotFoundError, SdkResultValidationError, SdkValidationError } from './errors'
 import { executeHandler } from './execute'
 import { buildIdentityMap } from './identity'
@@ -51,7 +52,7 @@ export type SdkDispatcherConfig<TDeps> = {
    * install (the URL it fetched the domain at).
    */
   issuer: string
-  /** The worker's serving URL (`config.url`) — exposed to handlers as `ctx.url`. */
+  /** The worker's serving URL (`config.url`) — exposed to handlers as `ctx.env.url`. */
   url: string
   /**
    * The domain schema. When present, non-static handlers receive the rich,
@@ -189,7 +190,6 @@ export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
       authorize?: (ctx: unknown) => void | Promise<void>
     }
     const handlerParams = validation.data
-    const callRemote = makeCallRemote(kernel)
     // Enrich the parsed self with the lazy `node()` accessor, bound to this
     // request's kernel (null when the auth policy yields none — `node()` then
     // rejects). Done here, not in `resolveSelf`, so the parse stays kernel-free.
@@ -200,20 +200,46 @@ export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
         ? withBoundNode(parsedSelf, kernel, this.binder, bound.owner)
         : withNode(parsedSelf, kernel)
       : undefined
+    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: handlerParams,
       auth,
       self,
       deps: this.deps,
-      url: this.url,
+      env: { url: this.url },
       kernel,
-      issuer: makeIssuerMint(fnIdentity),
-      callRemote,
+      ...(caller !== undefined ? { caller } : {}),
+      domain: makeDomainAuthority(fnIdentity),
+      fn: makeFunctionContext(fnIdentity, this.deps, {
+        ref: bound.ref,
+        ...(kernelUrl !== undefined ? { defaultKernelUrl: kernelUrl } : {}),
+      }),
     }
 
     if (handler.authorize) await runAuthorize(handler.authorize, ctx)
 
-    const result = await executeHandler({ handler, ref: bound.ref, ...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)
   }
 

package/src/dispatch/execute.ts

@@ -11,8 +11,10 @@ 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 { DomainIssuer } from '../auth/issuer-mint'
-import type { CallRemoteFn } from './call-remote'
+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'
 
 // oxlint-disable-next-line no-explicit-any
@@ -29,11 +31,13 @@ export type ExecuteParams = {
   /** Untyped fallback ({@link withNode}) or the rich typed self ({@link withBoundNode}). */
   self: SelfResult | TypedSelf<unknown> | undefined
   deps: unknown
-  url: string
+  env: RemoteEnv
   kernel: BoundClientSessionView<FnMap> | null
-  /** Mint seam for identities this domain issues (`ctx.issuer`). */
-  issuer: DomainIssuer
-  callRemote: CallRemoteFn
+  caller?: CallerContext
+  /** Mint seam for identities this domain issues. */
+  domain: DomainAuthority
+  fn: FunctionContextApi
+  step: Step
 }
 
 export async function executeHandler(ctx: ExecuteParams): Promise<unknown> {
@@ -48,9 +52,11 @@ export async function executeHandler(ctx: ExecuteParams): Promise<unknown> {
     auth: ctx.auth,
     self: ctx.self,
     deps: ctx.deps,
-    url: ctx.url,
+    env: ctx.env,
     kernel: ctx.kernel,
-    issuer: ctx.issuer,
-    callRemote: ctx.callRemote,
+    ...(ctx.caller !== undefined ? { caller: ctx.caller } : {}),
+    domain: ctx.domain,
+    fn: ctx.fn,
+    step: ctx.step,
   })
 }

package/src/dispatch/index.ts

@@ -8,7 +8,6 @@ export {
 } from './validate'
 export { resolveSelf, withBoundNode, type SelfResult, type TypedSelf } from './self'
 export { executeHandler, type ExecuteParams } from './execute'
-export { makeCallRemote, type CallRemoteFn, type KernelCaller } from './call-remote'
 export {
   AuthorizationDeniedError,
   MethodNotFoundError,

package/src/index.ts

@@ -6,6 +6,7 @@ export type {
   GraphApi,
   Kernel,
   KernelForAuth,
+  RemoteAuthorizeContext,
   RemoteContext,
   RemoteHandler,
   MethodImpl,
@@ -66,7 +67,16 @@ export type {
 // entry's `render` / `execute` (+ auth hooks) is mounted as a worker route by
 // `createRemoteServer`.
 export { defineView, defineRemoteFunction } from './define'
-export type { ViewDef, ViewRenderContext, RemoteFunctionDef, RemoteFunctionContext } from './define'
+export type {
+  ViewDef,
+  ViewRenderContext,
+  RemoteFunctionAuthorizeContext,
+  RemoteFunctionDef,
+  RemoteFunctionContext,
+} from './define'
+
+// ─── Durable-shaped steps ────────────────────────────────────────────────
+export type { Step } from './step'
 
 // ─── Server ──────────────────────────────────────────────────────────────
 // `createRemoteServer` dynamically imports `@hono/node-server` via `./server/start`.
@@ -97,12 +107,17 @@ export type {
 
 // ─── Auth ────────────────────────────────────────────────────────────────
 export type { RemoteIdentityConfig, AuthenticateResult } from './auth'
-export type { DomainIssuer, MintIssuedParams } from './auth'
+export type {
+  DomainAuthority,
+  FunctionContextApi,
+  FunctionCredentialOptions,
+  FunctionKernelOptions,
+  MintIssuedParams,
+} from './auth'
 export {
   authenticateRequest,
-  bindSelfKernel,
   buildComposedGrant,
-  makeSelfKernel,
+  makeFunctionContext,
   signCredential,
 } from './auth'
 export { AuthMissingError, AuthInvalidError } from './auth'
@@ -125,4 +140,4 @@ export {
   SdkValidationError,
   SdkResultValidationError,
 } from './dispatch'
-export type { SelfResult, TypedSelf, CallRemoteFn, KernelCaller } from './dispatch'
+export type { SelfResult, TypedSelf } from './dispatch'

package/src/method/context.ts

@@ -4,7 +4,8 @@
  * Assembled by the dispatch pipeline before calling `execute`. Carries the
  * validated params, the resolved auth context, the bound node instance (for
  * non-static methods), the typed dependency container, and a
- * `BoundClientSessionView` to call back into the parent kernel.
+ * `BoundClientSessionView` to call back into the parent kernel, plus explicit
+ * `domain`, `caller`, and `fn` namespaces for identity-sensitive work.
  */
 
 import type { AuthPolicy } from '@astrale-os/kernel-api/routed'
@@ -12,8 +13,9 @@ 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 { DomainIssuer } from '../auth/issuer-mint'
-import type { CallRemoteFn } from '../dispatch/call-remote'
+import type { FunctionContextApi } from '../auth/function-context'
+import type { DomainAuthority } from '../auth/issuer-mint'
+import type { Step } from '../step'
 
 export type { GraphApi } from '@astrale-os/kernel-client/graph'
 
@@ -33,8 +35,8 @@ export type Kernel = BoundClientSessionView<FnMap>
  *   - `'required'` (the default) — the dispatcher rejects a credentialless call
  *     before `execute`, so the kernel is ALWAYS present → non-null.
  *   - `'optional'` — a kernel only when a credential was supplied → `… | null`.
- *   - `'public'` — never any inbound credential → `null`. (Public handlers that
- *     must touch the graph use `selfKernel` after verifying their own upstream.)
+ *   - `'public'` — never any inbound credential → `null`. Public handlers that
+ *     must touch the graph use `ctx.fn.kernel()` after verifying their upstream.
  *
  * Distributes over a `AuthPolicy` union (e.g. when `auth` is typed but not a
  * literal) to the widened `Kernel | null` — the safe superset, matching the
@@ -57,7 +59,19 @@ export type AuthForPolicy<TAuth extends AuthPolicy> = TAuth extends 'public'
     ? AuthContext | null
     : AuthContext
 
-export type RemoteContext<
+export type RemoteEnv = {
+  /** This worker's canonical serving URL. */
+  url: string
+}
+
+export type CallerContext = {
+  /** Issuer of the inbound kernel/peer credential. */
+  iss: string
+  /** Kernel URL associated with this invocation. */
+  url: string
+}
+
+type RemoteBaseContext<
   TParams,
   TSelf,
   TDeps,
@@ -76,8 +90,8 @@ export type RemoteContext<
   self: TSelf
   /** Typed dependency container injected at server startup. */
   deps: TDeps
-  /** The worker's own serving URL */
-  url: string
+  /** Local serving metadata. */
+  env: RemoteEnv
   /**
    * `BoundClientSessionView` to the parent kernel, bound to the composed
    * credential `union(delegation, self)`. Its nullability is `{@link
@@ -88,26 +102,34 @@ export type RemoteContext<
    * plus `kernel.createNode` / `kernel.updateNode` /
    * `kernel.deleteNode` / `kernel.createEdge` / `kernel.updateEdge` /
    * `kernel.deleteEdge` / `kernel.mutate(patch)`) over the `function.get` /
-   * `function.mutate` syscalls. For ANOTHER worker's remote method use
-   * {@link RemoteContext.callRemote} — `kernel.call` to a remote method fails the
-   * audience check.
+   * `function.mutate` syscalls. Remote-bound calls are made with
+   * `kernel.call(...)`; the client follows redirects and remints the next-hop
+   * delegation under the current bound authority.
    */
   kernel: TKernel
-  /**
-   * Mint seam for identities THIS DOMAIN issues (`iss` = this worker): sign a
-   * credential for a domain-owned principal (an App identity, a role umbrella,
-   * a managed user) and optionally open a kernel session AS it. See
-   * {@link DomainIssuer}. The kernel enforces trust/frozen/grant rules — this
-   * only signs under the worker's own issuer.
-   */
-  issuer: DomainIssuer
-  /**
-   * Call another worker's remote method (a Function with `binding.remoteUrl`),
-   * re-minting the credential for the target's audience so it isn't rejected at
-   * authentication. Throws on a public/unauthenticated request (no credential
-   * to mint from). The calling Function's identity must hold `USE` on
-   * `Identity.mintDelegationCredential` AND the target method's own grants —
-   * `callRemote` fixes the audience, not authorization.
-   */
-  callRemote: CallRemoteFn
+  /** Inbound kernel/peer context. Present only for authenticated invocations. */
+  caller?: CallerContext
+  /** Mint seam for identities THIS DOMAIN issues (`iss` = this worker). */
+  domain: DomainAuthority
+  /** Current function identity tools: grant-bearing credentials and self-bound kernels. */
+  fn: FunctionContextApi
+}
+
+export type RemoteAuthorizeContext<
+  TParams,
+  TSelf,
+  TDeps,
+  TKernel = Kernel | null,
+  TAuth extends AuthPolicy = AuthPolicy,
+> = RemoteBaseContext<TParams, TSelf, TDeps, TKernel, TAuth>
+
+export interface RemoteContext<
+  TParams,
+  TSelf,
+  TDeps,
+  TKernel = Kernel | null,
+  TAuth extends AuthPolicy = AuthPolicy,
+> extends RemoteBaseContext<TParams, TSelf, TDeps, TKernel, TAuth> {
+  /** Durable-shaped step builder. Inline today, replayable by future backends. */
+  step: Step
 }

package/src/method/index.ts

@@ -1,4 +1,11 @@
-export type { AuthForPolicy, GraphApi, Kernel, KernelForAuth, RemoteContext } from './context'
+export type {
+  AuthForPolicy,
+  GraphApi,
+  Kernel,
+  KernelForAuth,
+  RemoteAuthorizeContext,
+  RemoteContext,
+} from './context'
 export type {
   RemoteHandler,
   AnyRemoteHandler,

package/src/method/single.ts

@@ -10,7 +10,7 @@ import type {
 import type { Schema } from '@astrale-os/kernel-dsl'
 
 import type { TypedSelf } from '../dispatch/self'
-import type { KernelForAuth, RemoteContext } from './context'
+import type { KernelForAuth, RemoteAuthorizeContext, RemoteContext } from './context'
 
 /**
  * Remote method handler. `execute` is optional only for binding stubs; any
@@ -47,7 +47,7 @@ export type RemoteHandler<TParams, TResult, TSelf, TDeps, TAuth extends AuthPoli
    * has_perm checks remain authoritative; this is additive gating.
    */
   authorize?: (
-    ctx: RemoteContext<TParams, TSelf, TDeps, KernelForAuth<TAuth>, TAuth>,
+    ctx: RemoteAuthorizeContext<TParams, TSelf, TDeps, KernelForAuth<TAuth>, TAuth>,
   ) => void | Promise<void>
 }