@astrale-os/sdk 0.4.12 → 0.4.14

package/src/server/service-entry.ts

@@ -0,0 +1,209 @@
+import type { FunctionBinding } from '@astrale-os/kernel-api/routed'
+import type { Node } from '@astrale-os/kernel-core'
+import type { CorsConfig } from '@astrale-os/kernel-server'
+
+import { K } from '@astrale-os/kernel-core'
+import { Hono } from 'hono'
+
+import type { RemoteIdentityConfig } from '../auth/identity.js'
+import type { AnyRemoteFunctionDef } from '../define/remote-function.js'
+import type { Fetcher, WorkerEntry } from './worker-entry.js'
+
+import { makeFunctionContext } from '../auth/function-context.js'
+import { buildFunctionSchemas, DEFAULT_FUNCTIONS_FOLDER } from '../domain/extend-functions.js'
+import {
+  SERVICE_FUNCTIONS_PATH,
+  ServiceFunctionDiscoveryRequestSchema,
+  signServiceFunctionManifest,
+  toServiceFunctionManifestEntries,
+} from '../service/functions.js'
+import { mountAuxiliaryRoutes } from './auxiliary-routes.js'
+import { createAppWorkerEntry } from './worker-entry.js'
+
+export interface ServiceWorkerIdentityEnv {
+  IDENTITY_ISS?: string
+  IDENTITY_SUB?: string
+  IDENTITY_PRIVATE_KEY?: string
+  ASTRALE_KERNEL_AUDIENCE?: string
+}
+
+export interface ServiceWorkerEntryConfig<TEnv extends ServiceWorkerIdentityEnv> {
+  functions?: Record<string, AnyRemoteFunctionDef>
+  functionsFolder?: string
+  cors?: CorsConfig
+  resolveUrl?: (env: TEnv, requestOrigin: string) => string
+  selfBinding?: (env: TEnv) => Fetcher | null | undefined
+  routeSubrequest?: (url: URL, env: TEnv) => Fetcher | null | undefined
+}
+
+/** A Service worker with zero or more first-class kernel Functions.
+ *
+ * The function map is the only declaration: it drives both HTTP routes and the
+ * signed deploy-time manifest. Function identities are read lazily from the
+ * graph after Services has reconciled them, while every Function reuses the
+ * Service's one private signing key. */
+export function serviceWorkerEntry<TEnv extends ServiceWorkerIdentityEnv>(
+  config: ServiceWorkerEntryConfig<TEnv>,
+): WorkerEntry<TEnv> {
+  const functions = config.functions ?? {}
+  const functionsFolder = config.functionsFolder ?? DEFAULT_FUNCTIONS_FOLDER
+
+  return createAppWorkerEntry<TEnv>({
+    buildApp: (url, env) => {
+      const app = new Hono()
+      const serviceIdentity = identityFromEnv(env)
+      const { schemas, bindings } = buildFunctionSchemas(functions, url, functionsFolder)
+      assertLocalBindings(url, bindings)
+      const resolveFunctionIdentity = createFunctionIdentityResolver(env, serviceIdentity)
+
+      app.get('/', (c) => c.json({ ok: true, kind: 'astrale-service' }))
+      app.post(SERVICE_FUNCTIONS_PATH, async (c) => {
+        const parsed = ServiceFunctionDiscoveryRequestSchema.safeParse(
+          await c.req.json().catch(() => null),
+        )
+        if (!parsed.success) {
+          return c.json({ error: 'Invalid service function discovery request' }, 400)
+        }
+        const response = await signServiceFunctionManifest(
+          {
+            version: 1,
+            service: {
+              issuer: serviceIdentity.issuer,
+              subject: serviceIdentity.subject,
+            },
+            functions: toServiceFunctionManifestEntries(schemas),
+          },
+          parsed.data,
+          serviceIdentity,
+        )
+        return c.json(response)
+      })
+
+      mountAuxiliaryRoutes({
+        app,
+        url,
+        remoteFunctions: functions,
+        remoteFunctionBindings: bindings,
+        deps: env,
+        resolveIdentity: (kind, slug) => {
+          if (kind !== 'remoteFunction') {
+            throw new Error(`serviceWorkerEntry cannot resolve ${kind} identity ${slug}`)
+          }
+          return resolveFunctionIdentity(slug)
+        },
+        cors: config.cors ?? { origin: '*' },
+      })
+      return app
+    },
+    resolveUrl: config.resolveUrl ?? ((_env, requestOrigin) => requestOrigin),
+    selfBinding: config.selfBinding,
+    routeSubrequest: config.routeSubrequest,
+  })
+}
+
+function identityFromEnv<TEnv extends ServiceWorkerIdentityEnv>(env: TEnv): RemoteIdentityConfig {
+  return {
+    issuer: required(env, 'IDENTITY_ISS'),
+    subject: required(env, 'IDENTITY_SUB'),
+    privateKey: parsePrivateKey(required(env, 'IDENTITY_PRIVATE_KEY')),
+  }
+}
+
+function createFunctionIdentityResolver<TEnv extends ServiceWorkerIdentityEnv>(
+  env: TEnv,
+  serviceIdentity: RemoteIdentityConfig,
+): (slug: string) => Promise<RemoteIdentityConfig> {
+  const kernelUrl = required(env, 'ASTRALE_KERNEL_AUDIENCE')
+  let cachedAt = 0
+  let identities = new Map<string, { issuer: string; subject: string }>()
+  const ttlMs = 60_000
+
+  return async (slug) => {
+    if (Date.now() - cachedAt >= ttlMs || !identities.has(slug)) {
+      const kernel = await makeFunctionContext(serviceIdentity, env, {
+        ref: 'service',
+        defaultKernelUrl: kernelUrl,
+      }).kernel()
+      const service = await kernel.get(`@${serviceIdentity.subject}`)
+      if (!service) throw new Error(`Service @${serviceIdentity.subject} is not readable`)
+      const folder = await kernel.get(`${service.path.raw}/functions`)
+      const nodes = folder
+        ? await (
+            await kernel.children(folder.path, {
+              classes: [K.$.c('Function').path.class],
+              limit: 500,
+            })
+          ).all()
+        : []
+      identities = readFunctionIdentities(nodes, serviceIdentity.issuer)
+      cachedAt = Date.now()
+    }
+    const identity = identities.get(slug)
+    if (!identity) throw new Error(`Function identity function.${slug} is not registered`)
+    return hostedFunctionIdentity(identity, serviceIdentity)
+  }
+}
+
+/** Reuse only the Service's signing key. A hosted Function's inbound audience
+ * defaults to its own issuer; the Service HTTP origin is merely transport. */
+export function hostedFunctionIdentity(
+  identity: { issuer: string; subject: string },
+  serviceIdentity: RemoteIdentityConfig,
+): RemoteIdentityConfig {
+  return { ...identity, privateKey: serviceIdentity.privateKey }
+}
+
+function readFunctionIdentities(
+  nodes: readonly Node[],
+  serviceIssuer: string,
+): Map<string, { issuer: string; subject: string }> {
+  const result = new Map<string, { issuer: string; subject: string }>()
+  for (const node of nodes) {
+    const ref = node.props[K.$.i('Function').ref.key]
+    const issuer = node.props[K.Identity.iss.key]
+    const subject = node.props[K.Identity.sub.key]
+    if (
+      typeof ref !== 'string' ||
+      !ref.startsWith('function.') ||
+      typeof issuer !== 'string' ||
+      typeof subject !== 'string'
+    ) {
+      continue
+    }
+    if (issuer !== serviceIssuer) {
+      throw new Error(`Function ${ref} does not share its hosting Service issuer`)
+    }
+    result.set(ref.slice('function.'.length), { issuer, subject })
+  }
+  return result
+}
+
+function assertLocalBindings(url: string, bindings: Record<string, FunctionBinding>): void {
+  const origin = new URL(url).origin
+  for (const [slug, binding] of Object.entries(bindings)) {
+    if (!binding.remoteUrl || new URL(binding.remoteUrl).origin !== origin) {
+      throw new Error(`serviceWorkerEntry function.${slug} must be hosted by this Service origin`)
+    }
+  }
+}
+
+function required<TEnv extends ServiceWorkerIdentityEnv>(env: TEnv, key: keyof TEnv): string {
+  const value = env[key]
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(`Missing service variable ${String(key)}`)
+  }
+  return value
+}
+
+function parsePrivateKey(value: string): JsonWebKey {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(value)
+  } catch (error) {
+    throw new Error('IDENTITY_PRIVATE_KEY is not valid JSON', { cause: error })
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('IDENTITY_PRIVATE_KEY is not a JWK object')
+  }
+  return parsed as JsonWebKey
+}

package/src/server/start.ts

@@ -6,6 +6,7 @@
  * Cloudflare, consumers go through `server.app.fetch` directly.
  */
 
+import type { serve as nodeServe } from '@hono/node-server'
 import type { Hono } from 'hono'
 
 import type { RemoteServerHandle } from './handle.js'
@@ -15,7 +16,7 @@ export async function startNodeServer(app: Hono, port = 3000): Promise<RemoteSer
   // 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')
+  const { serve } = (await import(nodeServerModule)) as { serve: typeof nodeServe }
   // oxlint-disable-next-line no-explicit-any
   const server = serve({ fetch: app.fetch, port }) as any
 

package/src/server/worker-entry.ts

@@ -30,8 +30,8 @@ import { createRemoteServer } from './create.js'
 import { requireEnv } from './require-env.js'
 import { canonicalizeServingUrl } from './serving-url.js'
 
-type Fetcher = { fetch(request: Request): Response | Promise<Response> }
-type App = {
+export type Fetcher = { fetch(request: Request): Response | Promise<Response> }
+export type WorkerApp = {
   fetch(
     request: Request,
     env?: unknown,
@@ -41,7 +41,7 @@ type App = {
 
 /** A built app cached by its serving URL: `origin` for same-origin matching,
  * `app` for in-process self-dispatch. */
-type CachedApp = { origin: string; app: App }
+type CachedApp = { origin: string; app: WorkerApp }
 
 /**
  * Choose where an OUTBOUND subrequest to `u` is routed — or `null` to let the
@@ -137,6 +137,10 @@ export interface WorkerEntryConfig<TDeps> {
   rewriteRequest?: (env: TDeps, request: Request) => Request
 }
 
+export interface AppWorkerEntryConfig<TDeps> extends Omit<WorkerEntryConfig<TDeps>, 'build'> {
+  buildApp: (url: string, env: TDeps) => WorkerApp
+}
+
 export interface WorkerEntry<TDeps> {
   fetch(request: Request, env: TDeps, executionCtx?: ExecutionContext): Response | Promise<Response>
 }
@@ -201,6 +205,15 @@ export function assets<TDeps>(opts: {
 }
 
 export function createWorkerEntry<TDeps>(config: WorkerEntryConfig<TDeps>): WorkerEntry<TDeps> {
+  return createAppWorkerEntry({
+    ...config,
+    buildApp: (url, env) => createRemoteServer<TDeps>(config.build(url, env)).app,
+  })
+}
+
+export function createAppWorkerEntry<TDeps>(
+  config: AppWorkerEntryConfig<TDeps>,
+): WorkerEntry<TDeps> {
   // Cache the built app per distinct resolved URL — plural and bounded. On the
   // request-origin fallback the URL legitimately alternates for one worker
   // (direct http hits vs https-upgraded tunnel hits, workers.dev + custom
@@ -212,10 +225,10 @@ export function createWorkerEntry<TDeps>(config: WorkerEntryConfig<TDeps>): Work
   let self: Fetcher | null = null
   let routeEnv: TDeps | null = null
 
-  function getApp(url: string, env: TDeps): App {
+  function getApp(url: string, env: TDeps): WorkerApp {
     const cached = apps.get(url)
     if (cached) return cached.app
-    const { app } = createRemoteServer<TDeps>(config.build(url, env))
+    const app = config.buildApp(url, env)
     if (apps.size >= MAX_CACHED_APPS) {
       const oldest = apps.keys().next().value
       if (oldest !== undefined) apps.delete(oldest)

package/src/service/functions.ts

@@ -0,0 +1,164 @@
+import type { FunctionBinding } from '@astrale-os/kernel-api/routed'
+import type { FunctionSchema } from '@astrale-os/kernel-core/domain'
+
+import { deriveAllowedAlgorithms } from '@astrale-os/kernel-core'
+import { functionBindingSchema, functionOutputSchema } from '@astrale-os/kernel-core/domain'
+import { importJWK, jwtVerify } from 'jose'
+import { z } from 'zod'
+
+import type { RemoteIdentityConfig } from '../auth/identity.js'
+
+import { signCredential } from '../auth/sign.js'
+
+export const SERVICE_FUNCTIONS_PATH = '/_astrale/functions'
+export const SERVICE_FUNCTIONS_PURPOSE = 'astrale.service-functions.v1'
+
+const JsonSchema = z.record(z.string(), z.unknown())
+
+export const ServiceFunctionManifestEntrySchema = z.object({
+  slug: z.string().regex(/^[a-z][a-z0-9-]*$/),
+  ref: z.string().regex(/^function\.[a-z][a-z0-9-]*$/),
+  inputSchema: JsonSchema,
+  outputSchema: JsonSchema,
+  output: functionOutputSchema.default('value'),
+  binding: functionBindingSchema.unwrap(),
+})
+
+export const ServiceFunctionManifestSchema = z.object({
+  version: z.literal(1),
+  service: z.object({ issuer: z.string().min(1), subject: z.string().min(1) }),
+  functions: z.array(ServiceFunctionManifestEntrySchema).max(500),
+})
+
+export const ServiceFunctionDiscoveryRequestSchema = z.object({
+  kernelIssuer: z.string().url(),
+  nonce: z.string().min(16).max(256),
+})
+
+export const ServiceFunctionDiscoveryResponseSchema = ServiceFunctionManifestSchema.extend({
+  identity: z.object({ credential: z.string().min(1) }),
+})
+
+export type ServiceFunctionManifestEntry = z.infer<typeof ServiceFunctionManifestEntrySchema>
+export type ServiceFunctionManifest = z.infer<typeof ServiceFunctionManifestSchema>
+export type ServiceFunctionDiscoveryRequest = z.infer<typeof ServiceFunctionDiscoveryRequestSchema>
+export type ServiceFunctionDiscoveryResponse = z.infer<
+  typeof ServiceFunctionDiscoveryResponseSchema
+>
+
+export function toServiceFunctionManifestEntries(
+  schemas: readonly FunctionSchema[],
+): ServiceFunctionManifestEntry[] {
+  return schemas
+    .map((schema) => {
+      const slug = schema.ref.slice('function.'.length)
+      return ServiceFunctionManifestEntrySchema.parse({
+        slug,
+        ref: schema.ref,
+        inputSchema: schema.inputSchema,
+        outputSchema: schema.outputSchema,
+        output: schema.output ?? 'value',
+        binding: schema.binding,
+      })
+    })
+    .sort((a, b) => a.slug.localeCompare(b.slug))
+}
+
+export async function signServiceFunctionManifest(
+  manifest: ServiceFunctionManifest,
+  request: ServiceFunctionDiscoveryRequest,
+  identity: RemoteIdentityConfig,
+): Promise<ServiceFunctionDiscoveryResponse> {
+  const parsedManifest = ServiceFunctionManifestSchema.parse(manifest)
+  const manifestHash = await hashServiceFunctionManifest(parsedManifest)
+  const credential = await signCredential(
+    { purpose: SERVICE_FUNCTIONS_PURPOSE, nonce: request.nonce, manifestHash },
+    {
+      issuer: identity.issuer,
+      subject: identity.subject,
+      audience: request.kernelIssuer,
+      privateKey: identity.privateKey,
+      ttl: '2m',
+    },
+  )
+  return { ...parsedManifest, identity: { credential } }
+}
+
+export async function verifyServiceFunctionManifest(
+  input: unknown,
+  expected: {
+    kernelIssuer: string
+    nonce: string
+    serviceIssuer: string
+    serviceSubject: string
+    publicKey: JsonWebKey
+  },
+): Promise<ServiceFunctionDiscoveryResponse> {
+  const response = ServiceFunctionDiscoveryResponseSchema.parse(input)
+  if (
+    response.service.issuer !== expected.serviceIssuer ||
+    response.service.subject !== expected.serviceSubject
+  ) {
+    throw new Error('service function manifest identity does not match the deployed Service')
+  }
+
+  const algorithms = deriveAllowedAlgorithms(expected.publicKey)
+  const algorithm = algorithms[0]
+  if (!algorithm) throw new Error('service function manifest public key has no supported algorithm')
+  const key = await importJWK(expected.publicKey, algorithm)
+  const verified = await jwtVerify(response.identity.credential, key, {
+    algorithms,
+    issuer: expected.serviceIssuer,
+    subject: expected.serviceSubject,
+    audience: expected.kernelIssuer,
+  })
+  const expectedHash = await hashServiceFunctionManifest({
+    version: response.version,
+    service: response.service,
+    functions: response.functions,
+  })
+  if (verified.payload.purpose !== SERVICE_FUNCTIONS_PURPOSE) {
+    throw new Error('service function manifest credential has the wrong purpose')
+  }
+  if (verified.payload.nonce !== expected.nonce) {
+    throw new Error('service function manifest credential has the wrong nonce')
+  }
+  if (verified.payload.manifestHash !== expectedHash) {
+    throw new Error('service function manifest credential does not cover the returned manifest')
+  }
+  return response
+}
+
+export async function hashServiceFunctionManifest(
+  manifest: ServiceFunctionManifest,
+): Promise<string> {
+  const bytes = new TextEncoder().encode(
+    canonicalJson(ServiceFunctionManifestSchema.parse(manifest)),
+  )
+  const digest = await crypto.subtle.digest('SHA-256', bytes)
+  return `sha256:${hex(new Uint8Array(digest))}`
+}
+
+export function functionBindingForManifest(
+  binding: FunctionBinding,
+  auth: 'required' | 'optional' | 'public' | undefined,
+): FunctionBinding {
+  return { ...binding, auth: auth ?? 'required' }
+}
+
+function canonicalJson(value: unknown): string {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value)
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`
+  const entries = Object.entries(value as Record<string, unknown>)
+    .filter(([, item]) => item !== undefined)
+    .sort(([a], [b]) => a.localeCompare(b))
+  return `{${entries
+    .map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`)
+    .join(',')}}`
+}
+
+function hex(bytes: Uint8Array): string {
+  let value = ''
+  for (const byte of bytes) value += byte.toString(16).padStart(2, '0')
+  return value
+}

package/src/service/index.ts

@@ -0,0 +1,18 @@
+export {
+  SERVICE_FUNCTIONS_PATH,
+  SERVICE_FUNCTIONS_PURPOSE,
+  ServiceFunctionDiscoveryRequestSchema,
+  ServiceFunctionDiscoveryResponseSchema,
+  ServiceFunctionManifestEntrySchema,
+  ServiceFunctionManifestSchema,
+  hashServiceFunctionManifest,
+  signServiceFunctionManifest,
+  toServiceFunctionManifestEntries,
+  verifyServiceFunctionManifest,
+} from './functions.js'
+export type {
+  ServiceFunctionDiscoveryRequest,
+  ServiceFunctionDiscoveryResponse,
+  ServiceFunctionManifest,
+  ServiceFunctionManifestEntry,
+} from './functions.js'

package/dist/defer/index.d.ts

@@ -1,24 +0,0 @@
-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 declare function createHandlerLifecycle(lifetime?: HandlerExecutionLifetime): HandlerLifecycle;
-/** Hono omits its execution context in Node and in lightweight unit tests. */
-export declare function executionLifetime(c: Context): HandlerExecutionLifetime | undefined;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/defer/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,uFAAuF;AACvF,MAAM,MAAM,wBAAwB,GAAG;IACrC,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAA;CAC3C,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,IAAI,GAAG,WAAW,CAAC,OAAO,CAAC,CAAA;AAE5D,MAAM,MAAM,KAAK,GAAG,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAA;AAEhD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,KAAK,CAAA;IACZ,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACxB,CAAA;AAED,wFAAwF;AACxF,wBAAgB,sBAAsB,CAAC,QAAQ,CAAC,EAAE,wBAAwB,GAAG,gBAAgB,CA4B5F;AAED,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,GAAG,wBAAwB,GAAG,SAAS,CAOlF"}

package/dist/defer/index.js

@@ -1,42 +0,0 @@
-/** Bind detached work to the host, with a safe blocking fallback for other runtimes. */
-export function createHandlerLifecycle(lifetime) {
-    const pending = [];
-    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) {
-    try {
-        const host = c.executionCtx;
-        return { waitUntil: (promise) => host.waitUntil(promise) };
-    }
-    catch {
-        return undefined;
-    }
-}
-//# sourceMappingURL=index.js.map

package/dist/defer/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/defer/index.ts"],"names":[],"mappings":"AAwBA,wFAAwF;AACxF,MAAM,UAAU,sBAAsB,CAAC,QAAmC;IACxE,MAAM,OAAO,GAAuB,EAAE,CAAA;IAEtC,OAAO;QACL,KAAK,CAAC,IAAI;YACR,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAC5C,IAAI,QAAQ;gBAAE,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,CAAA;;gBACpC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QAC5B,CAAC;QACD,KAAK,CAAC,MAAM;YACV,IAAI,QAAQ,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAM;YAE5C,wEAAwE;YACxE,0EAA0E;YAC1E,IAAI,MAAM,GAAG,CAAC,CAAA;YACd,OAAO,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;gBAC/B,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;gBACnC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAA;gBACvB,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAA;gBAC/C,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;oBAC7B,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;wBACjC,sCAAsC;wBACtC,OAAO,CAAC,KAAK,CAAC,6BAA6B,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;oBAC7D,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;KACF,CAAA;AACH,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,iBAAiB,CAAC,CAAU;IAC1C,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,CAAC,CAAC,YAAY,CAAA;QAC3B,OAAO,EAAE,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAA;IAC5D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAA;IAClB,CAAC;AACH,CAAC"}

package/src/defer/index.ts

@@ -1,64 +0,0 @@
-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
-  }
-}