@lunora/container 1.0.0-alpha.12 → 1.0.0-alpha.13

package/dist/do/index.d.ts

@@ -1,5 +1,5 @@
 import { DurableObject, WorkerEntrypoint } from 'cloudflare:workers';
-import { a as ContainerDefinition, D as DurableObjectJurisdiction } from "../packem_shared/jurisdiction.d-CdUpqfc-.js";
+import { a as ContainerDefinition, D as DurableObjectJurisdiction } from "../packem_shared/jurisdiction.d-8oUUvrew.js";
 /**
  * ContainerStartOptions as they come from worker types
  */
@@ -119,7 +119,7 @@ type OutboundHandler<E = Cloudflare.Env, P = unknown> = {
 type OutboundHandlerParams = Record<string, unknown>;
 type OutboundHandlerParamsOf<THandler> = THandler extends ((req: Request, env: unknown, ctx: OutboundHandlerContext<infer Params>) => Promise<Response> | Response) ? Params : never;
 declare function outboundParams<THandler extends OutboundHandler<unknown, unknown>>(_handler: THandler, params: OutboundHandlerParamsOf<THandler>): OutboundHandlerParamsOf<THandler>;
-type OutboundHandlers<ParamsByMethod extends OutboundHandlerParams, E = Cloudflare.Env> = { [Method in keyof ParamsByMethod]?: OutboundHandler<E, ParamsByMethod[Method]> };
+type OutboundHandlers<ParamsByMethod extends OutboundHandlerParams, E = Cloudflare.Env> = { [Method in keyof ParamsByMethod]?: OutboundHandler<E, ParamsByMethod[Method]>; };
 type OutboundHandlerOverride<Params = unknown> = {
   method: string;
 } & ([Params] extends [undefined] ? {
@@ -485,29 +485,29 @@ declare class Container<Env = Cloudflare.Env> extends DurableObject<Env> {
 }
 type DurableObjectContext = ConstructorParameters<typeof Container>[0];
 /**
-* Base class for the generated Container DO classes. Applies a
-* `defineContainer` definition onto `@cloudflare/containers`' `Container`:
-* port, sleep timeout, internet access, and the container environment (static
-* `env` merged with the declared Worker secrets — a declared-but-unset secret
-* fails fast here rather than starting a container without its credential).
-*
-* Generated subclasses stay one line of behavior:
-*
-* ```ts
-* export class TranscoderContainer extends LunoraContainer {
-*     constructor(ctx: DurableObjectState, env: Env) {
-*         super(ctx, env, transcoder, "transcoder");
-*     }
-* }
-* ```
-* @experimental
-*/
+ * Base class for the generated Container DO classes. Applies a
+ * `defineContainer` definition onto `@cloudflare/containers`' `Container`:
+ * port, sleep timeout, internet access, and the container environment (static
+ * `env` merged with the declared Worker secrets — a declared-but-unset secret
+ * fails fast here rather than starting a container without its credential).
+ *
+ * Generated subclasses stay one line of behavior:
+ *
+ * ```ts
+ * export class TranscoderContainer extends LunoraContainer {
+ *     constructor(ctx: DurableObjectState, env: Env) {
+ *         super(ctx, env, transcoder, "transcoder");
+ *     }
+ * }
+ * ```
+ * @experimental
+ */
 declare class LunoraContainer<Env = unknown> extends Container<Env> {
   /**
-  * Data-residency jurisdiction the app's DOs are pinned to (codegen passes the
-  * schema's `.jurisdiction("…")`). Used to pin the best-effort lifecycle report
-  * to the same region as the root shard. `undefined` ⇒ un-pinned.
-  */
+   * Data-residency jurisdiction the app's DOs are pinned to (codegen passes the
+   * schema's `.jurisdiction("…")`). Used to pin the best-effort lifecycle report
+   * to the same region as the root shard. `undefined` ⇒ un-pinned.
+   */
   private readonly lunoraJurisdiction?;
   /** The `lunora/containers.ts` export name, for lifecycle log correlation. */
   private readonly lunoraName;
@@ -523,76 +523,76 @@ declare class LunoraContainer<Env = unknown> extends Container<Env> {
   private lunoraSecretsStoreResolved?;
   constructor(context: DurableObjectContext, env: Env, definition: ContainerDefinition, exportName?: string, jurisdiction?: DurableObjectJurisdiction);
   /**
-  * Proxy entry for every `ctx.containers.&lt;name>` fetch. Resolves the
-  * `secretsStore` bindings into `envVars` before delegating, so the values
-  * are present when the base implicitly starts the container for this
-  * request — a no-op when `secretsStore` is unset.
-  */
+   * Proxy entry for every `ctx.containers.&lt;name>` fetch. Resolves the
+   * `secretsStore` bindings into `envVars` before delegating, so the values
+   * are present when the base implicitly starts the container for this
+   * request — a no-op when `secretsStore` is unset.
+   */
   override containerFetch(...args: Parameters<Container<Env>["containerFetch"]>): Promise<Response>;
   /**
-  * Explicit start (`ctx.containers.&lt;name>.get(id).start()`). Resolves the
-  * `secretsStore` bindings into `envVars` first, mirroring
-  * {@link containerFetch}. A per-instance `start({ envVars })` replaces the
-  * env set wholesale (base behavior), so the injected values only apply to a
-  * bare `start()` — same as the static `env`/`secrets`. When the caller
-  * supplies its own `envVars` we skip resolution entirely: those values would
-  * be discarded anyway, so a missing/unreadable binding shouldn't fail a start
-  * that never uses them.
-  */
+   * Explicit start (`ctx.containers.&lt;name>.get(id).start()`). Resolves the
+   * `secretsStore` bindings into `envVars` first, mirroring
+   * {@link containerFetch}. A per-instance `start({ envVars })` replaces the
+   * env set wholesale (base behavior), so the injected values only apply to a
+   * bare `start()` — same as the static `env`/`secrets`. When the caller
+   * supplies its own `envVars` we skip resolution entirely: those values would
+   * be discarded anyway, so a missing/unreadable binding shouldn't fail a start
+   * that never uses them.
+   */
   override start(...args: Parameters<Container<Env>["start"]>): Promise<void>;
   override onActivityExpired(): Promise<void>;
   override onError(error: unknown): unknown;
   override onStart(): Promise<void>;
   /**
-  * Hook run when the container's `hardTimeout` elapses (dispatched by the base
-  * scheduler via the run-generation-stamped schedule armed in
-  * {@link onStart}). Default: stop the instance. Override to drain/checkpoint
-  * first. A stale schedule from a previous run, or an already-stopped
-  * instance, is ignored (upstream cloudflare/containers#85).
-  */
+   * Hook run when the container's `hardTimeout` elapses (dispatched by the base
+   * scheduler via the run-generation-stamped schedule armed in
+   * {@link onStart}). Default: stop the instance. Override to drain/checkpoint
+   * first. A stale schedule from a previous run, or an already-stopped
+   * instance, is ignored (upstream cloudflare/containers#85).
+   */
   onHardTimeoutExpired(payload?: {
     generation?: number;
   }): Promise<void>;
   override onStop(parameters: StopParams): Promise<void>;
   /**
-  * Arm the hard-timeout kill via the base scheduler (so it integrates with
-  * the container's own alarm machinery instead of fighting it). Bumps the run
-  * generation and stamps the schedule with it, so {@link onHardTimeoutExpired}
-  * can tell a fresh schedule from a stale one. No-op without a `hardTimeout`.
-  */
+   * Arm the hard-timeout kill via the base scheduler (so it integrates with
+   * the container's own alarm machinery instead of fighting it). Bumps the run
+   * generation and stamps the schedule with it, so {@link onHardTimeoutExpired}
+   * can tell a fresh schedule from a stale one. No-op without a `hardTimeout`.
+   */
   private armHardTimeout;
   /**
-  * Resolve the `secretsStore` bindings (async `.get()`) once and merge the
-  * values into `envVars`, so they're present when the base starts the
-  * container. Memoised on the first call — every later start reuses the
-  * resolved promise. A missing binding or a non-string value fails fast (the
-  * start surfaces the error), the same fail-closed stance the static
-  * `secrets` resolution takes for a missing Worker secret. No-op without
-  * `secretsStore`.
-  */
+   * Resolve the `secretsStore` bindings (async `.get()`) once and merge the
+   * values into `envVars`, so they're present when the base starts the
+   * container. Memoised on the first call — every later start reuses the
+   * resolved promise. A missing binding or a non-string value fails fast (the
+   * start surfaces the error), the same fail-closed stance the static
+   * `secrets` resolution takes for a missing Worker secret. No-op without
+   * `secretsStore`.
+   */
   private resolveSecretsStoreEnv;
   /**
-  * Block until every `readyOn` probe responds with its expected status, or
-  * throw once the readiness budget is spent. Probes run in parallel and hit
-  * the container's TCP port directly (NOT `containerFetch`, which would
-  * recurse back into the start path). No-op without `readyOn`.
-  */
+   * Block until every `readyOn` probe responds with its expected status, or
+   * throw once the readiness budget is spent. Probes run in parallel and hit
+   * the container's TCP port directly (NOT `containerFetch`, which would
+   * recurse back into the start path). No-op without `readyOn`.
+   */
   private awaitContainerReadiness;
   /** Poll one readiness probe until it returns its expected status or the shared deadline passes. */
   private awaitReadinessCheck;
   /**
-  * Best-effort push of `envelope` into the root ShardDO's log buffer so it
-  * also appears in the Studio Logs panel (the terminal already has it via
-  * `emitContainerLifecycle`). Fire-and-forget and fully swallowed: a missing
-  * `SHARD` binding, a missing admin token, or a fetch failure NEVER throws
-  * out of a lifecycle hook — the `console` path stays the source of truth.
-  */
+   * Best-effort push of `envelope` into the root ShardDO's log buffer so it
+   * also appears in the Studio Logs panel (the terminal already has it via
+   * `emitContainerLifecycle`). Fire-and-forget and fully swallowed: a missing
+   * `SHARD` binding, a missing admin token, or a fetch failure NEVER throws
+   * out of a lifecycle hook — the `console` path stays the source of truth.
+   */
   private surfaceInStudioLogs;
   /**
-  * Per-instance correlation id: the Durable Object id, which Cloudflare also
-  * injects into the container as `CLOUDFLARE_DURABLE_OBJECT_ID`. Read
-  * defensively — the id shape varies and isn't worth crashing a hook over.
-  */
+   * Per-instance correlation id: the Durable Object id, which Cloudflare also
+   * injects into the container as `CLOUDFLARE_DURABLE_OBJECT_ID`. Read
+   * defensively — the id shape varies and isn't worth crashing a hook over.
+   */
   private instanceId;
 }
 export { ContainerProxy, LunoraContainer, type OutboundHandler, type OutboundHandlerContext, type OutboundHandlerParams, type OutboundHandlerParamsOf, type OutboundHandlers, outboundParams };