alepha 0.21.2 → 0.22.0

package/dist/{containers → container}/core/index.d.ts

@@ -1,9 +1,7 @@
-import * as _$alepha from "alepha";
 import { Alepha, KIND, Primitive } from "alepha";
-import * as _$alepha_logger0 from "alepha/logger";
 import { DurationLike } from "alepha/datetime";
 
-//#region ../../src/containers/core/interfaces/ContainerOptions.d.ts
+//#region ../../src/container/core/interfaces/ContainerOptions.d.ts
 /**
  * Options for the `$container` primitive.
  *
@@ -65,7 +63,7 @@ interface ContainerPrimitiveOptions {
   maxInstances?: number;
 }
 //#endregion
-//#region ../../src/containers/core/providers/ContainerProvider.d.ts
+//#region ../../src/container/core/providers/ContainerProvider.d.ts
 interface ContainerInvokeConfig {
   body?: unknown;
   query?: Record<string, unknown>;
@@ -82,7 +80,7 @@ interface ContainerInvokeConfig {
  * Cloudflare workerd variant.
  */
 declare abstract class ContainerProvider {
-  protected readonly log: _$alepha_logger0.Logger;
+  protected readonly log: import("alepha/logger").Logger;
   /**
    * Invoke a remote action on the container. Subclasses do the work;
    * the default implementation rejects to make missing wiring obvious.
@@ -100,7 +98,7 @@ declare abstract class ContainerProvider {
   };
 }
 //#endregion
-//#region ../../src/containers/core/primitives/$container.d.ts
+//#region ../../src/container/core/primitives/$container.d.ts
 /**
  * `$container` — typed RPC client to a containerized Alepha app.
  *
@@ -122,7 +120,7 @@ declare abstract class ContainerProvider {
  *
  * @example
  * ```ts
- * import { $container } from "alepha/containers";
+ * import { $container } from "alepha/container";
  * import type { RocketController } from "@alepha/rocket";
  *
  * class DeployService {
@@ -170,7 +168,7 @@ declare class ContainerPrimitive extends Primitive<ContainerPrimitiveOptions> {
   proxy<T extends object = any>(): ContainerProxy<T>;
 }
 //#endregion
-//#region ../../src/containers/core/providers/MockContainerProvider.d.ts
+//#region ../../src/container/core/providers/MockContainerProvider.d.ts
 /**
  * In-process test provider.
  *
@@ -183,7 +181,7 @@ declare class ContainerPrimitive extends Primitive<ContainerPrimitiveOptions> {
  * @example
  * ```ts
  * const alepha = Alepha.create()
- *   .with(AlephaContainers)
+ *   .with(AlephaContainer)
  *   .with(RocketController)
  *   .with(MyApp)
  *   .with({ provide: ContainerProvider, use: MockContainerProvider });
@@ -195,7 +193,7 @@ declare class MockContainerProvider extends ContainerProvider {
   protected loadLinkProvider(): Promise<any>;
 }
 //#endregion
-//#region ../../src/containers/core/providers/NodeContainerProvider.d.ts
+//#region ../../src/container/core/providers/NodeContainerProvider.d.ts
 /**
  * Node (dev / test / non-Cloudflare) container provider.
  *
@@ -210,7 +208,7 @@ declare class NodeContainerProvider extends ContainerProvider {
   protected resolveUrl(container: ContainerPrimitive): string | undefined;
 }
 //#endregion
-//#region ../../src/containers/core/index.d.ts
+//#region ../../src/container/core/index.d.ts
 /**
  * Type-safe RPC clients for ephemeral containerized Alepha apps.
  *
@@ -221,7 +219,7 @@ declare class NodeContainerProvider extends ContainerProvider {
  * - Pluggable transport: Node (plain `fetch` against a configured URL),
  *   Mock (in-process call via `LinkProvider.follow` for tests),
  *   Cloudflare workerd (`getContainer().fetch()` through the Containers
- *   binding — see `alepha/containers` workerd entry).
+ *   binding — see `alepha/container` workerd entry).
  * - Build-time integration: `BuildCloudflareTask.enhanceContainers`
  *   emits the matching wrangler bindings and Durable Object class
  *   declarations.
@@ -230,9 +228,9 @@ declare class NodeContainerProvider extends ContainerProvider {
  * the spec — apps need to provide an explicit `url` per primitive
  * until a `target=docker` adapter ships.
  *
- * @module alepha.containers
+ * @module alepha.container
  */
-declare const AlephaContainers: _$alepha.Service<_$alepha.Module>;
+declare const AlephaContainer: import("alepha").Service<import("alepha").Module>;
 //#endregion
-export { $container, AlephaContainers, ContainerInvokeConfig, ContainerPrimitive, ContainerPrimitiveOptions, ContainerProvider, ContainerProxy, MockContainerProvider, NodeContainerProvider };
+export { $container, AlephaContainer, ContainerInvokeConfig, ContainerPrimitive, ContainerPrimitiveOptions, ContainerProvider, ContainerProxy, MockContainerProvider, NodeContainerProvider };
 //# sourceMappingURL=index.d.ts.map

package/dist/container/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/container/core/interfaces/ContainerOptions.ts","../../../src/container/core/providers/ContainerProvider.ts","../../../src/container/core/primitives/$container.ts","../../../src/container/core/providers/MockContainerProvider.ts","../../../src/container/core/providers/NodeContainerProvider.ts","../../../src/container/core/index.ts"],"mappings":";;;;;;;AAWA;;;;;;UAAiB,yBAAA;EA8Bf;;;;;;EAvBA,IAAA;EAiDY;AAAA;;;;AC/Dd;EDsBE,KAAA;;;;;;;;EASA,GAAA;EC7BQ;;;;EDmCR,IAAA;ECjCgB;AAAA;AAYlB;;;ED4BE,UAAA,GAAa,YAAA;EClBH;;;EDuBV,OAAA,GAAU,MAAM;ECLoB;;;;;EDYpC,YAAA;EChCE;;;;;EDuCF,YAAA;AAAA;;;UC/De,qBAAA;EACf,IAAA;EACA,KAAA,GAAQ,MAAA;EACR,MAAA,GAAS,MAAA;EACT,OAAA,GAAU,MAAA;AAAA;;;;;;;;;;uBAYU,iBAAA;EAAA,mBACD,GAAA,0BAAG,MAAA;ED8CV;AAAA;;;ECxCC,MAAA,CACX,SAAA,EAAW,kBAAA,EACX,MAAA,UACA,MAAA,EAAQ,qBAAA,GACP,OAAA;EA3BY;;;;;;EAAA,UAyCL,YAAA,CACR,MAAA,UACA,MAAA,EAAQ,qBAAA;IACL,IAAA;IAAc,IAAA,EAAM,WAAA;EAAA;AAAA;;;;ADrC3B;;;;;;;;;;;;;;;AAwDc;;;;AC/Dd;;;;;;;;;;;;;;;;AAIkB;cCiCL,UAAA;EAAA,yBAA8B,OAAA,EAChC,yBAAA,GACR,cAAA,CAAe,CAAA;EAAA;;;;;;;;;;;;KAkBN,cAAA,mCACE,CAAA,GAAI,CAAA,CAAE,CAAA,eAAe,IAAA,6BACzB,IAAA,EAAM,CAAA,KAAM,OAAA,CAAQ,OAAA,CAAQ,CAAA,MAC/B,MAAA;EACC,IAAA;EACA,KAAA;EACA,MAAA;AAAA,MACI,OAAA;AAAA,cAGC,kBAAA,SAA2B,SAAA,CAAU,yBAAA;EAAA,mBAC7B,QAAA,EAAQ,iBAAA;EAAA,IAEhB,IAAA;ED1BQ;;;AAAiB;;;;ECqC7B,KAAA,4BAAiC,cAAA,CAAe,CAAA;AAAA;;;;AF1EzD;;;;;;;;;;;;;;;AAwDc;;cG1CD,qBAAA,SAA8B,iBAAA;EAAA,mBACtB,MAAA,EAAM,MAAA;EAEH,MAAA,CACpB,SAAA,EAAW,kBAAA,EACX,MAAA,UACA,MAAA,EAAQ,qBAAA,GACP,OAAA;EAAA,UAmBa,gBAAA,IAAoB,OAAA;AAAA;;;;;AHxCtC;;;;;;;cIKa,qBAAA,SAA8B,iBAAA;EACnB,MAAA,CACpB,SAAA,EAAW,kBAAA,EACX,MAAA,UACA,MAAA,EAAQ,qBAAA,GACP,OAAA;EAAA,UA2BO,UAAA,CAAW,SAAA,EAAW,kBAAA;AAAA;;;;;;;;;;;;;;;;;AJmBpB;;;;AC/Dd;;;cIiCa,eAAA,mBAAe,OAAA,kBAAA,MAAA"}

package/dist/{containers → container}/core/index.js

@@ -1,6 +1,6 @@
 import { $inject, $module, Alepha, AlephaError, KIND, Primitive, createPrimitive } from "alepha";
 import { $logger } from "alepha/logger";
-//#region ../../src/containers/core/providers/ContainerProvider.ts
+//#region ../../src/container/core/providers/ContainerProvider.ts
 /**
 * Abstract transport for `$container` proxies.
 *
@@ -17,7 +17,7 @@ var ContainerProvider = class {
 	* the default implementation rejects to make missing wiring obvious.
 	*/
 	async invoke(container, action, config) {
-		throw new AlephaError(`No ContainerProvider configured for container '${container.name}' (action '${action}'). Set up alepha/containers via AlephaContainers and either supply 'url' (Node) or build for target=cloudflare.`);
+		throw new AlephaError(`No ContainerProvider configured for container '${container.name}' (action '${action}'). Set up alepha/container via AlephaContainer and either supply 'url' (Node) or build for target=cloudflare.`);
 	}
 	/**
 	* Helper: build the fetch path/body for an action call. Kept as a
@@ -31,7 +31,16 @@ var ContainerProvider = class {
 			for (const [k, v] of Object.entries(config.query)) if (v !== void 0 && v !== null) params.set(k, String(v));
 		}
 		let path = `/api/${action}`;
-		if (config.params) for (const [k, v] of Object.entries(config.params)) path = path.replace(`:${k}`, encodeURIComponent(String(v)));
+		if (config.params) {
+			const tail = [];
+			for (const [k, v] of Object.entries(config.params)) {
+				const placeholder = `:${k}`;
+				const encoded = encodeURIComponent(String(v));
+				if (path.includes(placeholder)) path = path.replace(placeholder, encoded);
+				else tail.push(encoded);
+			}
+			if (tail.length) path += `/${tail.join("/")}`;
+		}
 		const search = params.toString();
 		if (search) path += `?${search}`;
 		const init = {
@@ -49,7 +58,7 @@ var ContainerProvider = class {
 	}
 };
 //#endregion
-//#region ../../src/containers/core/primitives/$container.ts
+//#region ../../src/container/core/primitives/$container.ts
 /**
 * `$container` — typed RPC client to a containerized Alepha app.
 *
@@ -71,7 +80,7 @@ var ContainerProvider = class {
 *
 * @example
 * ```ts
-* import { $container } from "alepha/containers";
+* import { $container } from "alepha/container";
 * import type { RocketController } from "@alepha/rocket";
 *
 * class DeployService {
@@ -113,7 +122,7 @@ var ContainerPrimitive = class extends Primitive {
 };
 $container[KIND] = ContainerPrimitive;
 //#endregion
-//#region ../../src/containers/core/providers/MockContainerProvider.ts
+//#region ../../src/container/core/providers/MockContainerProvider.ts
 /**
 * In-process test provider.
 *
@@ -126,7 +135,7 @@ $container[KIND] = ContainerPrimitive;
 * @example
 * ```ts
 * const alepha = Alepha.create()
-*   .with(AlephaContainers)
+*   .with(AlephaContainer)
 *   .with(RocketController)
 *   .with(MyApp)
 *   .with({ provide: ContainerProvider, use: MockContainerProvider });
@@ -152,7 +161,7 @@ var MockContainerProvider = class extends ContainerProvider {
 	}
 };
 //#endregion
-//#region ../../src/containers/core/providers/NodeContainerProvider.ts
+//#region ../../src/container/core/providers/NodeContainerProvider.ts
 /**
 * Node (dev / test / non-Cloudflare) container provider.
 *
@@ -181,7 +190,7 @@ var NodeContainerProvider = class extends ContainerProvider {
 	}
 };
 //#endregion
-//#region ../../src/containers/core/index.ts
+//#region ../../src/container/core/index.ts
 /**
 * Type-safe RPC clients for ephemeral containerized Alepha apps.
 *
@@ -192,7 +201,7 @@ var NodeContainerProvider = class extends ContainerProvider {
 * - Pluggable transport: Node (plain `fetch` against a configured URL),
 *   Mock (in-process call via `LinkProvider.follow` for tests),
 *   Cloudflare workerd (`getContainer().fetch()` through the Containers
-*   binding — see `alepha/containers` workerd entry).
+*   binding — see `alepha/container` workerd entry).
 * - Build-time integration: `BuildCloudflareTask.enhanceContainers`
 *   emits the matching wrangler bindings and Durable Object class
 *   declarations.
@@ -201,10 +210,10 @@ var NodeContainerProvider = class extends ContainerProvider {
 * the spec — apps need to provide an explicit `url` per primitive
 * until a `target=docker` adapter ships.
 *
-* @module alepha.containers
+* @module alepha.container
 */
-const AlephaContainers = $module({
-	name: "alepha.containers",
+const AlephaContainer = $module({
+	name: "alepha.container",
 	primitives: [$container],
 	services: [ContainerProvider],
 	variants: [MockContainerProvider, NodeContainerProvider],
@@ -217,6 +226,6 @@ const AlephaContainers = $module({
 	}
 });
 //#endregion
-export { $container, AlephaContainers, ContainerPrimitive, ContainerProvider, MockContainerProvider, NodeContainerProvider };
+export { $container, AlephaContainer, ContainerPrimitive, ContainerProvider, MockContainerProvider, NodeContainerProvider };
 
 //# sourceMappingURL=index.js.map

package/dist/container/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/container/core/providers/ContainerProvider.ts","../../../src/container/core/primitives/$container.ts","../../../src/container/core/providers/MockContainerProvider.ts","../../../src/container/core/providers/NodeContainerProvider.ts","../../../src/container/core/index.ts"],"sourcesContent":["import { AlephaError } from \"alepha\";\nimport { $logger } from \"alepha/logger\";\nimport type { ContainerPrimitive } from \"../primitives/$container.ts\";\n\nexport interface ContainerInvokeConfig {\n  body?: unknown;\n  query?: Record<string, unknown>;\n  params?: Record<string, unknown>;\n  headers?: Record<string, string>;\n}\n\n/**\n * Abstract transport for `$container` proxies.\n *\n * Concrete subclasses translate a `(container, action, config)` call\n * into an HTTP request that reaches the running container. The default\n * binding on Node throws — apps must register either a\n * `NodeContainerProvider` (with `url` on each primitive) or the\n * Cloudflare workerd variant.\n */\nexport abstract class ContainerProvider {\n  protected readonly log = $logger();\n\n  /**\n   * Invoke a remote action on the container. Subclasses do the work;\n   * the default implementation rejects to make missing wiring obvious.\n   */\n  public async invoke(\n    container: ContainerPrimitive,\n    action: string,\n    config: ContainerInvokeConfig,\n  ): Promise<unknown> {\n    void config;\n    throw new AlephaError(\n      `No ContainerProvider configured for container '${container.name}' (action '${action}'). ` +\n        `Set up alepha/container via AlephaContainer and either supply 'url' (Node) or build for target=cloudflare.`,\n    );\n  }\n\n  /**\n   * Helper: build the fetch path/body for an action call. Kept as a\n   * protected method so workerd and Node providers share the wire\n   * shape — `POST /api/<action>` with the JSON body, query params on\n   * the URL, and the request headers merged in.\n   */\n  protected buildRequest(\n    action: string,\n    config: ContainerInvokeConfig,\n  ): { path: string; init: RequestInit } {\n    const params = new URLSearchParams();\n    if (config.query) {\n      for (const [k, v] of Object.entries(config.query)) {\n        if (v !== undefined && v !== null) params.set(k, String(v));\n      }\n    }\n\n    // Match the route Alepha generates server-side when no explicit\n    // `path:` is set on `$action`: `/${name}` with one `/:<key>`\n    // segment appended per param. Params that match a `:key`\n    // placeholder are substituted in place; any remaining params are\n    // appended in declaration order so `params: {id:\"abc\"}` against a\n    // proxy action `getDeploy` yields `/api/getDeploy/abc`.\n    let path = `/api/${action}`;\n    if (config.params) {\n      const tail: string[] = [];\n      for (const [k, v] of Object.entries(config.params)) {\n        const placeholder = `:${k}`;\n        const encoded = encodeURIComponent(String(v));\n        if (path.includes(placeholder)) {\n          path = path.replace(placeholder, encoded);\n        } else {\n          tail.push(encoded);\n        }\n      }\n      if (tail.length) path += `/${tail.join(\"/\")}`;\n    }\n\n    const search = params.toString();\n    if (search) path += `?${search}`;\n\n    const init: RequestInit = {\n      method: \"POST\",\n      headers: {\n        \"content-type\": \"application/json\",\n        ...(config.headers ?? {}),\n      },\n      body: config.body !== undefined ? JSON.stringify(config.body) : undefined,\n    };\n\n    return { path, init };\n  }\n}\n","import { $inject, AlephaError, createPrimitive, KIND, Primitive } from \"alepha\";\nimport type { ContainerPrimitiveOptions } from \"../interfaces/ContainerOptions.ts\";\nimport { ContainerProvider } from \"../providers/ContainerProvider.ts\";\n\n/**\n * `$container` — typed RPC client to a containerized Alepha app.\n *\n * Returns a typed Proxy whose method calls map 1:1 to the target\n * controller's `$action` endpoints. The wire format mirrors what a\n * normal Alepha server exposes (`POST /api/<method>` with a JSON body),\n * so the container is literally a tiny Alepha worker.\n *\n * Transport is owned by the active {@link ContainerProvider}:\n * - `target=cloudflare` → `CloudflareContainerProvider` routes through\n *   the Containers binding (`env.<NAME>.getContainer(...).fetch()`).\n * - Node (with `url` set) → `NodeContainerProvider` uses plain\n *   `fetch()` against the configured URL.\n *\n * Build-time, `BuildCloudflareTask.enhanceContainers` walks\n * `alepha.primitives($container)` to emit the matching `wrangler.jsonc`\n * entries and Durable Object class declarations into\n * `main.cloudflare.js`.\n *\n * @example\n * ```ts\n * import { $container } from \"alepha/container\";\n * import type { RocketController } from \"@alepha/rocket\";\n *\n * class DeployService {\n *   rocket = $container<RocketController>({\n *     image: \"alepha/rocket:latest\",\n *     port: 3000,\n *     sleepAfter: \"15m\",\n *   });\n *\n *   async deploy() {\n *     return this.rocket.createJob({ body: { op: \"up\" } });\n *   }\n * }\n * ```\n */\nexport const $container = <T extends object = any>(\n  options: ContainerPrimitiveOptions,\n): ContainerProxy<T> => {\n  if (!options.image) {\n    throw new AlephaError(\"$container requires an 'image' option\");\n  }\n  const instance = createPrimitive(ContainerPrimitive, options);\n  return instance.proxy() as ContainerProxy<T>;\n};\n\n/**\n * Typed proxy returned by `$container<T>()`. Each `$action` member of\n * `T` becomes a callable returning the action's response body.\n *\n * The runtime shape is a `Proxy(primitive)` — own-property reads hit the\n * underlying `ContainerPrimitive` (so `alepha.primitives($container)`\n * still finds it via the `instanceof Primitive` check inside\n * `Alepha.new()`), and anything else is treated as an action name and\n * routed through the active `ContainerProvider`.\n */\nexport type ContainerProxy<T extends object> = {\n  [K in keyof T]: T[K] extends (...args: infer A) => infer R\n    ? (...args: A) => Promise<Awaited<R>>\n    : (config?: {\n        body?: unknown;\n        query?: unknown;\n        params?: unknown;\n      }) => Promise<any>;\n};\n\nexport class ContainerPrimitive extends Primitive<ContainerPrimitiveOptions> {\n  protected readonly provider = $inject(ContainerProvider);\n\n  public get name(): string {\n    return this.options.name ?? this.config.propertyKey;\n  }\n\n  /**\n   * Build the typed Proxy. The target is the primitive itself so\n   * `instanceof Primitive` keeps working (required by Alepha's\n   * primitive registration in `Alepha.new`). Property reads that match\n   * an own/inherited member return that member; anything else is\n   * treated as an action name and routed through the provider.\n   */\n  public proxy<T extends object = any>(): ContainerProxy<T> {\n    const primitive = this;\n    return new Proxy(primitive as any, {\n      get(target: any, prop: string | symbol, receiver: any) {\n        if (typeof prop === \"symbol\" || prop in target) {\n          return Reflect.get(target, prop, receiver);\n        }\n        return (config: any = {}) =>\n          primitive.provider.invoke(primitive, prop as string, config);\n      },\n    }) as ContainerProxy<T>;\n  }\n}\n\n$container[KIND] = ContainerPrimitive;\n","import { $inject, Alepha, AlephaError } from \"alepha\";\nimport type { ContainerPrimitive } from \"../primitives/$container.ts\";\nimport {\n  type ContainerInvokeConfig,\n  ContainerProvider,\n} from \"./ContainerProvider.ts\";\n\n/**\n * In-process test provider.\n *\n * Resolves the action name against `LinkProvider`'s registered links in\n * the SAME Alepha instance — effectively calling the \"containerized\"\n * controller as if it were local. Use it in tests: register the\n * controller class on the test container alongside the consumer and\n * substitute `ContainerProvider` with `MockContainerProvider`.\n *\n * @example\n * ```ts\n * const alepha = Alepha.create()\n *   .with(AlephaContainer)\n *   .with(RocketController)\n *   .with(MyApp)\n *   .with({ provide: ContainerProvider, use: MockContainerProvider });\n * ```\n */\nexport class MockContainerProvider extends ContainerProvider {\n  protected readonly alepha = $inject(Alepha);\n\n  public override async invoke(\n    container: ContainerPrimitive,\n    action: string,\n    config: ContainerInvokeConfig,\n  ): Promise<unknown> {\n    void container;\n    // Lazy-resolve LinkProvider so tests that don't load `alepha/server/links`\n    // still get a clear error message.\n    const linkProviderClass = await this.loadLinkProvider();\n    const linkProvider = this.alepha.inject(linkProviderClass) as {\n      follow: (\n        name: string,\n        config?: Record<string, unknown>,\n      ) => Promise<unknown>;\n    };\n    return await linkProvider.follow(action, {\n      body: config.body,\n      query: config.query,\n      params: config.params,\n      headers: config.headers,\n    });\n  }\n\n  protected async loadLinkProvider(): Promise<any> {\n    try {\n      const mod = await import(\"alepha/server/links\");\n      return mod.LinkProvider;\n    } catch {\n      throw new AlephaError(\n        \"MockContainerProvider needs 'alepha/server/links' to be available — add AlephaServerLinks to the test app.\",\n      );\n    }\n  }\n}\n","import { AlephaError } from \"alepha\";\nimport type { ContainerPrimitive } from \"../primitives/$container.ts\";\nimport {\n  type ContainerInvokeConfig,\n  ContainerProvider,\n} from \"./ContainerProvider.ts\";\n\n/**\n * Node (dev / test / non-Cloudflare) container provider.\n *\n * Routes proxy calls through plain `fetch()` against the URL given on\n * the `$container` primitive. If no `url` is supplied, calls throw —\n * v1 deliberately has no Docker spawning. This is the \"temporary, not\n * perfect\" Node path documented in the spec; the longer-term plan is\n * to plug in a `target=docker` adapter once that lands.\n */\nexport class NodeContainerProvider extends ContainerProvider {\n  public override async invoke(\n    container: ContainerPrimitive,\n    action: string,\n    config: ContainerInvokeConfig,\n  ): Promise<unknown> {\n    const url = this.resolveUrl(container);\n    if (!url) {\n      throw new AlephaError(\n        `Container '${container.name}' has no 'url' configured — NodeContainerProvider cannot reach the container.`,\n      );\n    }\n\n    const { path, init } = this.buildRequest(action, config);\n    const response = await fetch(`${url.replace(/\\/$/, \"\")}${path}`, init);\n\n    if (!response.ok) {\n      const text = await response.text().catch(() => \"\");\n      throw new AlephaError(\n        `Container '${container.name}' action '${action}' failed: ${response.status} ${response.statusText}${\n          text ? ` — ${text}` : \"\"\n        }`,\n      );\n    }\n\n    const contentType = response.headers.get(\"content-type\") ?? \"\";\n    if (contentType.includes(\"application/json\")) {\n      return await response.json();\n    }\n    return await response.text();\n  }\n\n  protected resolveUrl(container: ContainerPrimitive): string | undefined {\n    const url = container.options.url;\n    return typeof url === \"function\" ? url() : url;\n  }\n}\n","import { $module } from \"alepha\";\nimport { $container } from \"./primitives/$container.ts\";\nimport { ContainerProvider } from \"./providers/ContainerProvider.ts\";\nimport { MockContainerProvider } from \"./providers/MockContainerProvider.ts\";\nimport { NodeContainerProvider } from \"./providers/NodeContainerProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./interfaces/ContainerOptions.ts\";\nexport * from \"./primitives/$container.ts\";\nexport * from \"./providers/ContainerProvider.ts\";\nexport * from \"./providers/MockContainerProvider.ts\";\nexport * from \"./providers/NodeContainerProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Type-safe RPC clients for ephemeral containerized Alepha apps.\n *\n * **Features:**\n * - `$container<T>()` directive returns a typed Proxy onto a remote\n *   Alepha controller's `$action` endpoints — the wire format is the\n *   same `POST /api/<method>` shape served by every Alepha server.\n * - Pluggable transport: Node (plain `fetch` against a configured URL),\n *   Mock (in-process call via `LinkProvider.follow` for tests),\n *   Cloudflare workerd (`getContainer().fetch()` through the Containers\n *   binding — see `alepha/container` workerd entry).\n * - Build-time integration: `BuildCloudflareTask.enhanceContainers`\n *   emits the matching wrangler bindings and Durable Object class\n *   declarations.\n *\n * The Node binding is the \"temporary, not perfect\" path documented in\n * the spec — apps need to provide an explicit `url` per primitive\n * until a `target=docker` adapter ships.\n *\n * @module alepha.container\n */\nexport const AlephaContainer = $module({\n  name: \"alepha.container\",\n  primitives: [$container],\n  services: [ContainerProvider],\n  variants: [MockContainerProvider, NodeContainerProvider],\n  register: (alepha) => {\n    alepha.with({\n      optional: true,\n      provide: ContainerProvider,\n      use: alepha.isTest() ? MockContainerProvider : NodeContainerProvider,\n    });\n  },\n});\n"],"mappings":"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"}

package/dist/{containers → container}/core/index.workerd.js

@@ -1,6 +1,7 @@
+import { Container, getContainer } from "@cloudflare/containers";
 import { $inject, $module, Alepha, AlephaError, KIND, Primitive, createPrimitive } from "alepha";
 import { $logger } from "alepha/logger";
-//#region ../../src/containers/core/providers/ContainerProvider.ts
+//#region ../../src/container/core/providers/ContainerProvider.ts
 /**
 * Abstract transport for `$container` proxies.
 *
@@ -17,7 +18,7 @@ var ContainerProvider = class {
 	* the default implementation rejects to make missing wiring obvious.
 	*/
 	async invoke(container, action, config) {
-		throw new AlephaError(`No ContainerProvider configured for container '${container.name}' (action '${action}'). Set up alepha/containers via AlephaContainers and either supply 'url' (Node) or build for target=cloudflare.`);
+		throw new AlephaError(`No ContainerProvider configured for container '${container.name}' (action '${action}'). Set up alepha/container via AlephaContainer and either supply 'url' (Node) or build for target=cloudflare.`);
 	}
 	/**
 	* Helper: build the fetch path/body for an action call. Kept as a
@@ -31,7 +32,16 @@ var ContainerProvider = class {
 			for (const [k, v] of Object.entries(config.query)) if (v !== void 0 && v !== null) params.set(k, String(v));
 		}
 		let path = `/api/${action}`;
-		if (config.params) for (const [k, v] of Object.entries(config.params)) path = path.replace(`:${k}`, encodeURIComponent(String(v)));
+		if (config.params) {
+			const tail = [];
+			for (const [k, v] of Object.entries(config.params)) {
+				const placeholder = `:${k}`;
+				const encoded = encodeURIComponent(String(v));
+				if (path.includes(placeholder)) path = path.replace(placeholder, encoded);
+				else tail.push(encoded);
+			}
+			if (tail.length) path += `/${tail.join("/")}`;
+		}
 		const search = params.toString();
 		if (search) path += `?${search}`;
 		const init = {
@@ -49,7 +59,7 @@ var ContainerProvider = class {
 	}
 };
 //#endregion
-//#region ../../src/containers/core/primitives/$container.ts
+//#region ../../src/container/core/primitives/$container.ts
 /**
 * `$container` — typed RPC client to a containerized Alepha app.
 *
@@ -71,7 +81,7 @@ var ContainerProvider = class {
 *
 * @example
 * ```ts
-* import { $container } from "alepha/containers";
+* import { $container } from "alepha/container";
 * import type { RocketController } from "@alepha/rocket";
 *
 * class DeployService {
@@ -113,28 +123,32 @@ var ContainerPrimitive = class extends Primitive {
 };
 $container[KIND] = ContainerPrimitive;
 //#endregion
-//#region ../../src/containers/core/providers/CloudflareContainerProvider.ts
+//#region ../../src/container/core/providers/CloudflareContainerProvider.ts
 /**
 * Cloudflare Workers (workerd) container provider.
 *
-* Routes proxy calls through the Cloudflare Containers binding bound on
-* `env.<NAME>`, using a single shared instance per container
-* (`getContainer(env.NAME, "shared")`). The binding is generated by
-* `BuildCloudflareTask.enhanceContainers` from the `$container`
-* primitives discovered in the app.
+* Routes proxy calls through the Cloudflare Containers binding bound
+* on `env.<NAME>`, using a single shared instance per container.
+* `getContainer` from `@cloudflare/containers` is a free function (not
+* a method on the binding) — it takes the DO namespace and an id and
+* returns a stub with a `.fetch()` method targeting the running
+* container instance.
 *
-* The runtime `env` object is pulled from the Alepha store key
-* `cloudflare.env` — the worker entry point publishes it there on every
-* fetch (`__alepha.set("cloudflare.env", env)`).
+* The binding is generated by `BuildCloudflareTask.enhanceContainers`
+* from the `$container` primitives discovered in the app. The runtime
+* `env` object is pulled from the Alepha store key `cloudflare.env`
+* — the worker entry point publishes it there on every fetch
+* (`__alepha.set("cloudflare.env", env)`).
 */
 var CloudflareContainerProvider = class extends ContainerProvider {
 	alepha = $inject(Alepha);
 	async invoke(container, action, config) {
 		const env = this.alepha.store.get("cloudflare.env");
 		if (!env) throw new AlephaError(`CloudflareContainerProvider could not resolve 'cloudflare.env' from the store — is the app running on workerd?`);
-		const binding = env[container.name.toUpperCase()];
-		if (!binding?.getContainer) throw new AlephaError(`Cloudflare Containers binding '${container.name.toUpperCase()}' not found on env — check wrangler.jsonc.`);
-		const instance = binding.getContainer("shared");
+		const bindingName = container.name.toUpperCase();
+		const binding = env[bindingName];
+		if (!binding) throw new AlephaError(`Cloudflare Containers binding '${bindingName}' not found on env — check wrangler.jsonc.`);
+		const instance = getContainer(binding, "shared");
 		const { path, init } = this.buildRequest(action, config);
 		const request = new Request(`http://container${path}`, init);
 		const response = await instance.fetch(request);
@@ -147,7 +161,8 @@ var CloudflareContainerProvider = class extends ContainerProvider {
 	}
 };
 //#endregion
-//#region ../../src/containers/core/index.workerd.ts
+//#region ../../src/container/core/index.workerd.ts
+globalThis.__alepha_CloudflareContainer = Container;
 /**
 * Type-safe RPC clients for ephemeral containerized Alepha apps,
 * Cloudflare workerd build.
@@ -157,10 +172,10 @@ var CloudflareContainerProvider = class extends ContainerProvider {
 * `BuildCloudflareTask.enhanceContainers` (in `alepha/cli/core`) which
 * emits the wrangler.jsonc bindings and DO class declarations.
 *
-* @module alepha.containers
+* @module alepha.container
 */
-const AlephaContainers = $module({
-	name: "alepha.containers",
+const AlephaContainer = $module({
+	name: "alepha.container",
 	primitives: [$container],
 	services: [ContainerProvider, CloudflareContainerProvider],
 	register: (alepha) => {
@@ -172,6 +187,6 @@ const AlephaContainers = $module({
 	}
 });
 //#endregion
-export { $container, AlephaContainers, CloudflareContainerProvider, ContainerPrimitive, ContainerProvider };
+export { $container, AlephaContainer, CloudflareContainerProvider, ContainerPrimitive, ContainerProvider };
 
 //# sourceMappingURL=index.workerd.js.map

package/dist/container/core/index.workerd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.workerd.js","names":[],"sources":["../../../src/container/core/providers/ContainerProvider.ts","../../../src/container/core/primitives/$container.ts","../../../src/container/core/providers/CloudflareContainerProvider.ts","../../../src/container/core/index.workerd.ts"],"sourcesContent":["import { AlephaError } from \"alepha\";\nimport { $logger } from \"alepha/logger\";\nimport type { ContainerPrimitive } from \"../primitives/$container.ts\";\n\nexport interface ContainerInvokeConfig {\n  body?: unknown;\n  query?: Record<string, unknown>;\n  params?: Record<string, unknown>;\n  headers?: Record<string, string>;\n}\n\n/**\n * Abstract transport for `$container` proxies.\n *\n * Concrete subclasses translate a `(container, action, config)` call\n * into an HTTP request that reaches the running container. The default\n * binding on Node throws — apps must register either a\n * `NodeContainerProvider` (with `url` on each primitive) or the\n * Cloudflare workerd variant.\n */\nexport abstract class ContainerProvider {\n  protected readonly log = $logger();\n\n  /**\n   * Invoke a remote action on the container. Subclasses do the work;\n   * the default implementation rejects to make missing wiring obvious.\n   */\n  public async invoke(\n    container: ContainerPrimitive,\n    action: string,\n    config: ContainerInvokeConfig,\n  ): Promise<unknown> {\n    void config;\n    throw new AlephaError(\n      `No ContainerProvider configured for container '${container.name}' (action '${action}'). ` +\n        `Set up alepha/container via AlephaContainer and either supply 'url' (Node) or build for target=cloudflare.`,\n    );\n  }\n\n  /**\n   * Helper: build the fetch path/body for an action call. Kept as a\n   * protected method so workerd and Node providers share the wire\n   * shape — `POST /api/<action>` with the JSON body, query params on\n   * the URL, and the request headers merged in.\n   */\n  protected buildRequest(\n    action: string,\n    config: ContainerInvokeConfig,\n  ): { path: string; init: RequestInit } {\n    const params = new URLSearchParams();\n    if (config.query) {\n      for (const [k, v] of Object.entries(config.query)) {\n        if (v !== undefined && v !== null) params.set(k, String(v));\n      }\n    }\n\n    // Match the route Alepha generates server-side when no explicit\n    // `path:` is set on `$action`: `/${name}` with one `/:<key>`\n    // segment appended per param. Params that match a `:key`\n    // placeholder are substituted in place; any remaining params are\n    // appended in declaration order so `params: {id:\"abc\"}` against a\n    // proxy action `getDeploy` yields `/api/getDeploy/abc`.\n    let path = `/api/${action}`;\n    if (config.params) {\n      const tail: string[] = [];\n      for (const [k, v] of Object.entries(config.params)) {\n        const placeholder = `:${k}`;\n        const encoded = encodeURIComponent(String(v));\n        if (path.includes(placeholder)) {\n          path = path.replace(placeholder, encoded);\n        } else {\n          tail.push(encoded);\n        }\n      }\n      if (tail.length) path += `/${tail.join(\"/\")}`;\n    }\n\n    const search = params.toString();\n    if (search) path += `?${search}`;\n\n    const init: RequestInit = {\n      method: \"POST\",\n      headers: {\n        \"content-type\": \"application/json\",\n        ...(config.headers ?? {}),\n      },\n      body: config.body !== undefined ? JSON.stringify(config.body) : undefined,\n    };\n\n    return { path, init };\n  }\n}\n","import { $inject, AlephaError, createPrimitive, KIND, Primitive } from \"alepha\";\nimport type { ContainerPrimitiveOptions } from \"../interfaces/ContainerOptions.ts\";\nimport { ContainerProvider } from \"../providers/ContainerProvider.ts\";\n\n/**\n * `$container` — typed RPC client to a containerized Alepha app.\n *\n * Returns a typed Proxy whose method calls map 1:1 to the target\n * controller's `$action` endpoints. The wire format mirrors what a\n * normal Alepha server exposes (`POST /api/<method>` with a JSON body),\n * so the container is literally a tiny Alepha worker.\n *\n * Transport is owned by the active {@link ContainerProvider}:\n * - `target=cloudflare` → `CloudflareContainerProvider` routes through\n *   the Containers binding (`env.<NAME>.getContainer(...).fetch()`).\n * - Node (with `url` set) → `NodeContainerProvider` uses plain\n *   `fetch()` against the configured URL.\n *\n * Build-time, `BuildCloudflareTask.enhanceContainers` walks\n * `alepha.primitives($container)` to emit the matching `wrangler.jsonc`\n * entries and Durable Object class declarations into\n * `main.cloudflare.js`.\n *\n * @example\n * ```ts\n * import { $container } from \"alepha/container\";\n * import type { RocketController } from \"@alepha/rocket\";\n *\n * class DeployService {\n *   rocket = $container<RocketController>({\n *     image: \"alepha/rocket:latest\",\n *     port: 3000,\n *     sleepAfter: \"15m\",\n *   });\n *\n *   async deploy() {\n *     return this.rocket.createJob({ body: { op: \"up\" } });\n *   }\n * }\n * ```\n */\nexport const $container = <T extends object = any>(\n  options: ContainerPrimitiveOptions,\n): ContainerProxy<T> => {\n  if (!options.image) {\n    throw new AlephaError(\"$container requires an 'image' option\");\n  }\n  const instance = createPrimitive(ContainerPrimitive, options);\n  return instance.proxy() as ContainerProxy<T>;\n};\n\n/**\n * Typed proxy returned by `$container<T>()`. Each `$action` member of\n * `T` becomes a callable returning the action's response body.\n *\n * The runtime shape is a `Proxy(primitive)` — own-property reads hit the\n * underlying `ContainerPrimitive` (so `alepha.primitives($container)`\n * still finds it via the `instanceof Primitive` check inside\n * `Alepha.new()`), and anything else is treated as an action name and\n * routed through the active `ContainerProvider`.\n */\nexport type ContainerProxy<T extends object> = {\n  [K in keyof T]: T[K] extends (...args: infer A) => infer R\n    ? (...args: A) => Promise<Awaited<R>>\n    : (config?: {\n        body?: unknown;\n        query?: unknown;\n        params?: unknown;\n      }) => Promise<any>;\n};\n\nexport class ContainerPrimitive extends Primitive<ContainerPrimitiveOptions> {\n  protected readonly provider = $inject(ContainerProvider);\n\n  public get name(): string {\n    return this.options.name ?? this.config.propertyKey;\n  }\n\n  /**\n   * Build the typed Proxy. The target is the primitive itself so\n   * `instanceof Primitive` keeps working (required by Alepha's\n   * primitive registration in `Alepha.new`). Property reads that match\n   * an own/inherited member return that member; anything else is\n   * treated as an action name and routed through the provider.\n   */\n  public proxy<T extends object = any>(): ContainerProxy<T> {\n    const primitive = this;\n    return new Proxy(primitive as any, {\n      get(target: any, prop: string | symbol, receiver: any) {\n        if (typeof prop === \"symbol\" || prop in target) {\n          return Reflect.get(target, prop, receiver);\n        }\n        return (config: any = {}) =>\n          primitive.provider.invoke(primitive, prop as string, config);\n      },\n    }) as ContainerProxy<T>;\n  }\n}\n\n$container[KIND] = ContainerPrimitive;\n","import { getContainer } from \"@cloudflare/containers\";\nimport { $inject, Alepha, AlephaError } from \"alepha\";\nimport type { ContainerPrimitive } from \"../primitives/$container.ts\";\nimport {\n  type ContainerInvokeConfig,\n  ContainerProvider,\n} from \"./ContainerProvider.ts\";\n\n/**\n * Cloudflare Workers (workerd) container provider.\n *\n * Routes proxy calls through the Cloudflare Containers binding bound\n * on `env.<NAME>`, using a single shared instance per container.\n * `getContainer` from `@cloudflare/containers` is a free function (not\n * a method on the binding) — it takes the DO namespace and an id and\n * returns a stub with a `.fetch()` method targeting the running\n * container instance.\n *\n * The binding is generated by `BuildCloudflareTask.enhanceContainers`\n * from the `$container` primitives discovered in the app. The runtime\n * `env` object is pulled from the Alepha store key `cloudflare.env`\n * — the worker entry point publishes it there on every fetch\n * (`__alepha.set(\"cloudflare.env\", env)`).\n */\nexport class CloudflareContainerProvider extends ContainerProvider {\n  protected readonly alepha = $inject(Alepha);\n\n  public override async invoke(\n    container: ContainerPrimitive,\n    action: string,\n    config: ContainerInvokeConfig,\n  ): Promise<unknown> {\n    const env = this.alepha.store.get(\"cloudflare.env\") as\n      | Record<string, unknown>\n      | undefined;\n    if (!env) {\n      throw new AlephaError(\n        `CloudflareContainerProvider could not resolve 'cloudflare.env' from the store — is the app running on workerd?`,\n      );\n    }\n\n    const bindingName = container.name.toUpperCase();\n    const binding = env[bindingName];\n    if (!binding) {\n      throw new AlephaError(\n        `Cloudflare Containers binding '${bindingName}' not found on env — check wrangler.jsonc.`,\n      );\n    }\n\n    const instance = getContainer(binding as never, \"shared\");\n    const { path, init } = this.buildRequest(action, config);\n    const request = new Request(`http://container${path}`, init);\n    const response = await instance.fetch(request);\n\n    if (!response.ok) {\n      const text = await response.text().catch(() => \"\");\n      throw new AlephaError(\n        `Container '${container.name}' action '${action}' failed: ${response.status} ${response.statusText}${\n          text ? ` — ${text}` : \"\"\n        }`,\n      );\n    }\n\n    const contentType = response.headers.get(\"content-type\") ?? \"\";\n    if (contentType.includes(\"application/json\")) {\n      return await response.json();\n    }\n    return await response.text();\n  }\n}\n","import { Container } from \"@cloudflare/containers\";\nimport { $module } from \"alepha\";\nimport { $container } from \"./primitives/$container.ts\";\nimport { CloudflareContainerProvider } from \"./providers/CloudflareContainerProvider.ts\";\nimport { ContainerProvider } from \"./providers/ContainerProvider.ts\";\n\n// Stash the Cloudflare Containers `Container` base class on globalThis\n// so `BuildCloudflareTask`'s post-Vite-emitted entry\n// (`dist/main.cloudflare.js`) can declare\n// `class <T> extends globalThis.__alepha_CloudflareContainer` without\n// introducing a bare `@cloudflare/containers` specifier.\n//\n// The entry is written AFTER Vite — anything Vite hasn't seen\n// survives as an unresolved import all the way to workerd (where the\n// upload is `no_bundle: true`). This side-effect runs whenever an app\n// imports anything from `alepha/container` (Vite picks this file via\n// the `workerd` export condition), so by the time the entry's\n// `import \"./index.js\"` finishes, the global is set and the\n// `extends` expression resolves.\n(globalThis as any).__alepha_CloudflareContainer = Container;\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./interfaces/ContainerOptions.ts\";\nexport * from \"./primitives/$container.ts\";\nexport * from \"./providers/CloudflareContainerProvider.ts\";\nexport * from \"./providers/ContainerProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Type-safe RPC clients for ephemeral containerized Alepha apps,\n * Cloudflare workerd build.\n *\n * Auto-binds `CloudflareContainerProvider` so `$container()` calls\n * route through `env.<NAME>.getContainer(...).fetch()`. Pair with\n * `BuildCloudflareTask.enhanceContainers` (in `alepha/cli/core`) which\n * emits the wrangler.jsonc bindings and DO class declarations.\n *\n * @module alepha.container\n */\nexport const AlephaContainer = $module({\n  name: \"alepha.container\",\n  primitives: [$container],\n  services: [ContainerProvider, CloudflareContainerProvider],\n  register: (alepha) => {\n    alepha.with({\n      optional: true,\n      provide: ContainerProvider,\n      use: CloudflareContainerProvider,\n    });\n  },\n});\n"],"mappings":"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"}

package/dist/core/index.browser.js

@@ -2532,6 +2532,31 @@ var Alepha = class Alepha {
 		return instance;
 	}
 	/**
+	* Merge additional environment variables into the env store at runtime.
+	*
+	* Serverless entrypoints (Cloudflare Workers) receive their secrets and
+	* vars on the runtime `env` binding rather than `process.env`, so they are
+	* absent from `alepha.env` — which is frozen at `create()` from
+	* `process.env`. Call this from the entrypoint to lift the binding's string
+	* values into `alepha.env`, so `$env` and `alepha.env.*` resolve them (e.g.
+	* `PUBLIC_URL`).
+	*
+	* Only string values are lifted; non-string bindings (D1, R2, KV, queues,
+	* …) are skipped. Existing env values win, so explicit configuration is
+	* never clobbered. The env cache is cleared so subsequent `$env` reads see
+	* the merged values.
+	*/
+	loadEnv(env) {
+		const incoming = {};
+		for (const [key, value] of Object.entries(env)) if (typeof value === "string") incoming[key] = value;
+		this.store.set("env", {
+			...incoming,
+			...this.env
+		});
+		this.cacheEnv.clear();
+		return this;
+	}
+	/**
 	* Applies environment variables to the provided schema and state object.
 	*
 	* It replaces also all templated $ENV inside string values.
@@ -2591,6 +2616,7 @@ var Alepha = class Alepha {
 		return graph;
 	}
 	dump() {
+		const providers = this.graph();
 		const env = {};
 		for (const [schema] of this.cacheEnv.entries()) {
 			const ref = schema;
@@ -2606,7 +2632,7 @@ var Alepha = class Alepha {
 		}
 		return {
 			env,
-			providers: this.graph()
+			providers
 		};
 	}
 	services(base) {