@beignet/core 0.0.25 → 0.0.27

package/src/server/server.ts

@@ -71,6 +71,7 @@ import {
   enterActiveRequestContext,
   readContextActor,
   readContextTenant,
+  runWithActiveRequestContext,
   setActiveRequestIdentity,
 } from "./request-context.js";
 import type {
@@ -428,10 +429,31 @@ export interface ServerInstance<
    * tasks, and background work.
    *
    * Requires `context.service` to be declared in `createServer(...)`.
+   *
+   * Only call this from long-lived runtimes such as servers, workers, and
+   * `bun test`. It enters the ambient correlation context with
+   * `AsyncLocalStorage.enterWith`, and resuming that frame across top-level
+   * await crashes Bun 1.3.x in plain scripts. Seeds and one-off scripts must
+   * use `runServiceContext(...)` instead.
    */
   createServiceContext: (
     ...args: ServiceContextInputArgs<ServiceInput>
   ) => Promise<Ctx>;
+  /**
+   * Build a service context and run `fn` inside a scoped ambient correlation
+   * frame, returning its result.
+   *
+   * This is the script-safe counterpart to `createServiceContext(...)`: the
+   * ambient frame is entered with `AsyncLocalStorage.run`, so plain scripts
+   * such as seeds and one-off maintenance work stay safe under top-level
+   * await. Requires `context.service` to be declared in `createServer(...)`.
+   */
+  runServiceContext: <T>(
+    ...args: [
+      ...ServiceContextInputArgs<ServiceInput>,
+      fn: (ctx: Ctx) => T | Promise<T>,
+    ]
+  ) => Promise<T>;
   /**
    * Contract configs registered through the `routes` option.
    */
@@ -2032,6 +2054,11 @@ export async function createServer<
   ];
   const contracts = options.routes ? contractsFromRoutes(options.routes) : [];
 
+  // Fail startup on hook misconfiguration before provider setup runs.
+  for (const hook of hooks) {
+    hook.validate?.({ contracts });
+  }
+
   const resolvedContext = resolveServerContext<Ctx, FinalPorts, ServiceInput>(
     options.context,
   );
@@ -2089,6 +2116,46 @@ export async function createServer<
     ambient.tenant = readContextTenant(ctx);
     return ctx;
   };
+  const runServiceContext = async <T>(
+    ...args: [
+      ...ServiceContextInputArgs<ServiceInput>,
+      fn: (ctx: Ctx) => T | Promise<T>,
+    ]
+  ): Promise<T> => {
+    const serviceFactory = resolvedContext.service;
+    if (!serviceFactory) {
+      throw new Error(
+        "Define context.service in createServer(...) to create service contexts.",
+      );
+    }
+
+    const fn = args[args.length - 1] as (ctx: Ctx) => T | Promise<T>;
+    const input = (args.length > 1 ? args[0] : undefined) as ServiceInput;
+    const { requestId, trace } = instrumentation.createServiceCorrelation();
+    const ambient: ActiveRequestContext = {
+      requestId,
+      traceId: trace.traceId,
+      spanId: trace.spanId,
+      parentSpanId: trace.parentSpanId,
+      traceparent: trace.traceparent,
+    };
+    // AsyncLocalStorage.run scopes the ambient frame to this callback, so the
+    // caller's continuation never resumes through an enterWith frame — the
+    // pattern that crashes Bun 1.3.x in plain scripts under top-level await.
+    return runWithActiveRequestContext(ambient, async () => {
+      const ctx = finalizeContext(
+        await serviceFactory({
+          ports: finalPorts,
+          input,
+          requestId,
+          trace,
+        }),
+      );
+      ambient.actor = readContextActor(ctx);
+      ambient.tenant = readContextTenant(ctx);
+      return await fn(ctx);
+    });
+  };
   const contextRuntime = {
     createRequestContext,
     finalizeContext,
@@ -2426,6 +2493,7 @@ export async function createServer<
     },
     createRequestContext: (req) => createRequestContext(req),
     createServiceContext,
+    runServiceContext,
     contracts,
     stop,
     ports: finalPorts,

package/src/tasks/index.ts

@@ -121,6 +121,29 @@ export interface RunTaskOptions<Ctx> {
   ctx: Ctx;
 }
 
+/**
+ * Arguments `beignet task run` passes to the app's `createTaskContext` and
+ * `stopTaskContext` exports in `server/tasks.ts`.
+ */
+export interface TaskRunContextArgs<T extends TaskDef = TaskDef> {
+  /**
+   * Task definition being run.
+   */
+  task: T;
+  /**
+   * Stable task name being run.
+   */
+  taskName: string;
+  /**
+   * Schema-parsed task input.
+   */
+  input: unknown;
+  /**
+   * Tenant id or slug from `--tenant`, resolved by the app.
+   */
+  tenant?: string;
+}
+
 /**
  * Context-bound operational task helper factory.
  */