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

package/README.md

@@ -10,6 +10,8 @@
 
 <!-- END_PACKAGE_OG_IMAGE_PLACEHOLDER -->
 
+> **Experimental** — this package is outside the Lunora 1.0 stability promise: its API may change in any release, without a major version bump.
+
 <br />
 
 <div align="center">

package/dist/bridge.d.mts

@@ -1,5 +1,8 @@
 import { LunoraError } from '@lunora/errors';
-/** A `fetch` implementation — defaults to the runtime global. */
+/**
+ * A `fetch` implementation — defaults to the runtime global.
+ * @experimental
+ */
 type FetchLike = (input: string, init: {
   body: string;
   headers: Record<string, string>;
@@ -10,33 +13,41 @@ type FetchLike = (input: string, init: {
   status: number;
   statusText?: string;
 }>;
+/**
+ * `ContainerBridgeOptions` is part of the experimental `@lunora/container` API and may change without a major version bump.
+ * @experimental
+ */
 interface ContainerBridgeOptions {
   /**
-  * Base URL of the deployed Lunora Worker (no trailing `/_lunora/rpc`), e.g.
-  * `https://my-app.workers.dev`. In a Lunora container, surface it as an
-  * `env` value on the definition.
-  */
+   * Base URL of the deployed Lunora Worker (no trailing `/_lunora/rpc`), e.g.
+   * `https://my-app.workers.dev`. In a Lunora container, surface it as an
+   * `env` value on the definition.
+   */
   baseUrl: string;
   /** Injectable `fetch` (tests / non-global runtimes). Defaults to `globalThis.fetch`. */
   fetch?: FetchLike;
   /**
-  * Bearer token sent as `Authorization: Bearer &lt;token>`. Your Worker's
-  * `resolveIdentity` maps it to the identity the called functions run as.
-  * Pass it to the container as a `secret`, never bake it into the image.
-  */
+   * Bearer token sent as `Authorization: Bearer &lt;token>`. Your Worker's
+   * `resolveIdentity` maps it to the identity the called functions run as.
+   * Pass it to the container as a `secret`, never bake it into the image.
+   */
   token?: string;
 }
-/** Thrown when a Lunora function returns an error envelope. A `LunoraError` subclass carrying the wire `code`. */
+/**
+ * Thrown when a Lunora function returns an error envelope. A `LunoraError` subclass carrying the wire `code`.
+ * @experimental
+ */
 declare class ContainerBridgeError extends LunoraError {
   constructor(code: string, message: string);
 }
 /**
-* Structural mirror of `@lunora/client`'s `FunctionReference` — the typed
-* handle the generated `_generated/api` object carries. Declared locally (not
-* imported) so the bridge stays dependency-free and its `.d.ts` is
-* self-contained; the `__lunoraPhantom` shape matches, so a real `api.x.y`
-* reference is assignable and its arg/return types are inferable.
-*/
+ * Structural mirror of `@lunora/client`'s `FunctionReference` — the typed
+ * handle the generated `_generated/api` object carries. Declared locally (not
+ * imported) so the bridge stays dependency-free and its `.d.ts` is
+ * self-contained; the `__lunoraPhantom` shape matches, so a real `api.x.y`
+ * reference is assignable and its arg/return types are inferable.
+ * @experimental
+ */
 interface BridgeFunctionReference<Args = unknown, Result = unknown> {
   readonly __lunoraPhantom?: {
     args: Args;
@@ -56,6 +67,10 @@ type ResultOfReference<Reference> = Reference extends {
     returns: infer Result;
   };
 } ? Result : never;
+/**
+ * `ContainerBridge` is part of the experimental `@lunora/container` API and may change without a major version bump.
+ * @experimental
+ */
 interface ContainerBridge {
   /** Call an `action` by `namespace:fn` path. Alias of {@link ContainerBridge.call} for intent. */
   action: <Result = unknown>(functionPath: string, args?: Record<string, unknown>, shardKey?: string) => Promise<Result>;
@@ -66,25 +81,26 @@ interface ContainerBridge {
   /** Call a `query` by `namespace:fn` path. Alias of {@link ContainerBridge.call} for intent. */
   query: <Result = unknown>(functionPath: string, args?: Record<string, unknown>, shardKey?: string) => Promise<Result>;
   /**
-  * Fully-typed call via a generated function reference. Pass a reference from
-  * the project's `_generated/api` (e.g. `api.messages.list`) and the args +
-  * result are inferred from it — the typed counterpart to {@link ContainerBridge.call}
-  * for JS/TS containers that can import the generated `api`.
-  */
+   * Fully-typed call via a generated function reference. Pass a reference from
+   * the project's `_generated/api` (e.g. `api.messages.list`) and the args +
+   * result are inferred from it — the typed counterpart to {@link ContainerBridge.call}
+   * for JS/TS containers that can import the generated `api`.
+   */
   run: <Reference extends BridgeFunctionReference>(reference: Reference, args: ArgsOfReference<Reference>, shardKey?: string) => Promise<ResultOfReference<Reference>>;
 }
 /**
-* Build a container→Lunora bridge bound to a Worker URL + token.
-*
-* ```ts
-* const lunora = createContainerBridge({ baseUrl: process.env.LUNORA_URL!, token: process.env.LUNORA_TOKEN });
-* const messages = await lunora.query("messages:list", { limit: 20 });
-* await lunora.mutation("messages:markProcessed", { id });
-* ```
-*
-* `query`/`mutation`/`action` are intent-revealing aliases of one `call` — the
-* wire is identical and the server dispatches by the function's registered
-* kind, so a query path called via `.mutation(...)` still runs as a query.
-*/
+ * Build a container→Lunora bridge bound to a Worker URL + token.
+ *
+ * ```ts
+ * const lunora = createContainerBridge({ baseUrl: process.env.LUNORA_URL!, token: process.env.LUNORA_TOKEN });
+ * const messages = await lunora.query("messages:list", { limit: 20 });
+ * await lunora.mutation("messages:markProcessed", { id });
+ * ```
+ *
+ * `query`/`mutation`/`action` are intent-revealing aliases of one `call` — the
+ * wire is identical and the server dispatches by the function's registered
+ * kind, so a query path called via `.mutation(...)` still runs as a query.
+ * @experimental
+ */
 declare const createContainerBridge: (options: ContainerBridgeOptions) => ContainerBridge;
 export { type BridgeFunctionReference, type ContainerBridge, ContainerBridgeError, type ContainerBridgeOptions, type FetchLike, createContainerBridge };

package/dist/bridge.d.ts

@@ -1,5 +1,8 @@
 import { LunoraError } from '@lunora/errors';
-/** A `fetch` implementation — defaults to the runtime global. */
+/**
+ * A `fetch` implementation — defaults to the runtime global.
+ * @experimental
+ */
 type FetchLike = (input: string, init: {
   body: string;
   headers: Record<string, string>;
@@ -10,33 +13,41 @@ type FetchLike = (input: string, init: {
   status: number;
   statusText?: string;
 }>;
+/**
+ * `ContainerBridgeOptions` is part of the experimental `@lunora/container` API and may change without a major version bump.
+ * @experimental
+ */
 interface ContainerBridgeOptions {
   /**
-  * Base URL of the deployed Lunora Worker (no trailing `/_lunora/rpc`), e.g.
-  * `https://my-app.workers.dev`. In a Lunora container, surface it as an
-  * `env` value on the definition.
-  */
+   * Base URL of the deployed Lunora Worker (no trailing `/_lunora/rpc`), e.g.
+   * `https://my-app.workers.dev`. In a Lunora container, surface it as an
+   * `env` value on the definition.
+   */
   baseUrl: string;
   /** Injectable `fetch` (tests / non-global runtimes). Defaults to `globalThis.fetch`. */
   fetch?: FetchLike;
   /**
-  * Bearer token sent as `Authorization: Bearer &lt;token>`. Your Worker's
-  * `resolveIdentity` maps it to the identity the called functions run as.
-  * Pass it to the container as a `secret`, never bake it into the image.
-  */
+   * Bearer token sent as `Authorization: Bearer &lt;token>`. Your Worker's
+   * `resolveIdentity` maps it to the identity the called functions run as.
+   * Pass it to the container as a `secret`, never bake it into the image.
+   */
   token?: string;
 }
-/** Thrown when a Lunora function returns an error envelope. A `LunoraError` subclass carrying the wire `code`. */
+/**
+ * Thrown when a Lunora function returns an error envelope. A `LunoraError` subclass carrying the wire `code`.
+ * @experimental
+ */
 declare class ContainerBridgeError extends LunoraError {
   constructor(code: string, message: string);
 }
 /**
-* Structural mirror of `@lunora/client`'s `FunctionReference` — the typed
-* handle the generated `_generated/api` object carries. Declared locally (not
-* imported) so the bridge stays dependency-free and its `.d.ts` is
-* self-contained; the `__lunoraPhantom` shape matches, so a real `api.x.y`
-* reference is assignable and its arg/return types are inferable.
-*/
+ * Structural mirror of `@lunora/client`'s `FunctionReference` — the typed
+ * handle the generated `_generated/api` object carries. Declared locally (not
+ * imported) so the bridge stays dependency-free and its `.d.ts` is
+ * self-contained; the `__lunoraPhantom` shape matches, so a real `api.x.y`
+ * reference is assignable and its arg/return types are inferable.
+ * @experimental
+ */
 interface BridgeFunctionReference<Args = unknown, Result = unknown> {
   readonly __lunoraPhantom?: {
     args: Args;
@@ -56,6 +67,10 @@ type ResultOfReference<Reference> = Reference extends {
     returns: infer Result;
   };
 } ? Result : never;
+/**
+ * `ContainerBridge` is part of the experimental `@lunora/container` API and may change without a major version bump.
+ * @experimental
+ */
 interface ContainerBridge {
   /** Call an `action` by `namespace:fn` path. Alias of {@link ContainerBridge.call} for intent. */
   action: <Result = unknown>(functionPath: string, args?: Record<string, unknown>, shardKey?: string) => Promise<Result>;
@@ -66,25 +81,26 @@ interface ContainerBridge {
   /** Call a `query` by `namespace:fn` path. Alias of {@link ContainerBridge.call} for intent. */
   query: <Result = unknown>(functionPath: string, args?: Record<string, unknown>, shardKey?: string) => Promise<Result>;
   /**
-  * Fully-typed call via a generated function reference. Pass a reference from
-  * the project's `_generated/api` (e.g. `api.messages.list`) and the args +
-  * result are inferred from it — the typed counterpart to {@link ContainerBridge.call}
-  * for JS/TS containers that can import the generated `api`.
-  */
+   * Fully-typed call via a generated function reference. Pass a reference from
+   * the project's `_generated/api` (e.g. `api.messages.list`) and the args +
+   * result are inferred from it — the typed counterpart to {@link ContainerBridge.call}
+   * for JS/TS containers that can import the generated `api`.
+   */
   run: <Reference extends BridgeFunctionReference>(reference: Reference, args: ArgsOfReference<Reference>, shardKey?: string) => Promise<ResultOfReference<Reference>>;
 }
 /**
-* Build a container→Lunora bridge bound to a Worker URL + token.
-*
-* ```ts
-* const lunora = createContainerBridge({ baseUrl: process.env.LUNORA_URL!, token: process.env.LUNORA_TOKEN });
-* const messages = await lunora.query("messages:list", { limit: 20 });
-* await lunora.mutation("messages:markProcessed", { id });
-* ```
-*
-* `query`/`mutation`/`action` are intent-revealing aliases of one `call` — the
-* wire is identical and the server dispatches by the function's registered
-* kind, so a query path called via `.mutation(...)` still runs as a query.
-*/
+ * Build a container→Lunora bridge bound to a Worker URL + token.
+ *
+ * ```ts
+ * const lunora = createContainerBridge({ baseUrl: process.env.LUNORA_URL!, token: process.env.LUNORA_TOKEN });
+ * const messages = await lunora.query("messages:list", { limit: 20 });
+ * await lunora.mutation("messages:markProcessed", { id });
+ * ```
+ *
+ * `query`/`mutation`/`action` are intent-revealing aliases of one `call` — the
+ * wire is identical and the server dispatches by the function's registered
+ * kind, so a query path called via `.mutation(...)` still runs as a query.
+ * @experimental
+ */
 declare const createContainerBridge: (options: ContainerBridgeOptions) => ContainerBridge;
 export { type BridgeFunctionReference, type ContainerBridge, ContainerBridgeError, type ContainerBridgeOptions, type FetchLike, createContainerBridge };

package/dist/do/index.d.mts

@@ -1,5 +1,5 @@
 import { DurableObject, WorkerEntrypoint } from 'cloudflare:workers';
-import { a as ContainerDefinition, D as DurableObjectJurisdiction } from "../packem_shared/jurisdiction.d-TwTGkgTg.mjs";
+import { a as ContainerDefinition, D as DurableObjectJurisdiction } from "../packem_shared/jurisdiction.d-8oUUvrew.mjs";
 /**
  * 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,28 +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");
-*     }
-* }
-* ```
-*/
+ * 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;
@@ -522,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 };

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-TwTGkgTg.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,28 +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");
-*     }
-* }
-* ```
-*/
+ * 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;
@@ -522,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 };