@astrale-os/sdk 0.1.1 → 0.1.3

package/src/define/remote-function.ts

@@ -48,6 +48,16 @@ export type RemoteFunctionContext<TParams, TDeps = unknown> = {
    * `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>>
 }
 
 export type RemoteFunctionDef<TParams = unknown, TResult = unknown, TDeps = unknown> = {

package/src/server/auxiliary-routes.ts

@@ -39,6 +39,7 @@ import type { ViewDef } from '../define/view'
 import type { CallRemoteFn } from '../dispatch/call-remote'
 import type { AuxIdentityMap } from '../dispatch/identity'
 
+import { makeSelfKernel } from '../auth/kernel-client'
 import { resolveInboundAuth } from '../auth/resolve'
 import { runAuthorize } from '../dispatch/authorize'
 import { makeCallRemote } from '../dispatch/call-remote'
@@ -124,12 +125,13 @@ export function mountAuxiliaryRoutes<TDeps>(config: AuxiliaryRoutesConfig<TDeps>
         identity,
         corsHeaders,
         run: async ({ c, auth, kernel, callRemote }) => {
+          const selfKernel = makeSelfKernel(identity, deps)
           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 ctx = { params: validation.data, c, auth, deps, kernel, callRemote }
+          const ctx = { params: validation.data, c, auth, deps, kernel, callRemote, selfKernel }
           if (def.authorize) await runAuthorize(def.authorize, ctx)
           const result = await def.execute(ctx)
           const outValidation = validateResult(def.outputSchema, result)

package/src/server/start.ts

@@ -11,7 +11,11 @@ import type { Hono } from 'hono'
 import type { RemoteServerHandle } from './handle'
 
 export async function startNodeServer(app: Hono, port = 3000): Promise<RemoteServerHandle> {
-  const { serve } = await import('@hono/node-server')
+  // Opaque specifier: the `./server` barrel re-exports this module, so worker
+  // bundles (wrangler/esbuild) traverse it even though they never call it. A
+  // literal import() would make them resolve the optional peer and fail.
+  const nodeServerModule = '@hono/node-server'
+  const { serve } = (await import(nodeServerModule)) as typeof import('@hono/node-server')
   // oxlint-disable-next-line no-explicit-any
   const server = serve({ fetch: app.fetch, port }) as any