alepha 0.23.0 → 0.24.0

package/dist/container/core/index.js

@@ -1,231 +0,0 @@
-import { $inject, $module, Alepha, AlephaError, KIND, Primitive, createPrimitive } from "alepha";
-import { $logger } from "alepha/logger";
-//#region ../../src/container/core/providers/ContainerProvider.ts
-/**
-* Abstract transport for `$container` proxies.
-*
-* Concrete subclasses translate a `(container, action, config)` call
-* into an HTTP request that reaches the running container. The default
-* binding on Node throws — apps must register either a
-* `NodeContainerProvider` (with `url` on each primitive) or the
-* Cloudflare workerd variant.
-*/
-var ContainerProvider = class {
-	log = $logger();
-	/**
-	* Invoke a remote action on the container. Subclasses do the work;
-	* 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/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
-	* protected method so workerd and Node providers share the wire
-	* shape — `POST /api/<action>` with the JSON body, query params on
-	* the URL, and the request headers merged in.
-	*/
-	buildRequest(action, config) {
-		const params = new URLSearchParams();
-		if (config.query) {
-			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) {
-			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 = {
-			method: "POST",
-			headers: {
-				"content-type": "application/json",
-				...config.headers ?? {}
-			},
-			body: config.body !== void 0 ? JSON.stringify(config.body) : void 0
-		};
-		return {
-			path,
-			init
-		};
-	}
-};
-//#endregion
-//#region ../../src/container/core/primitives/$container.ts
-/**
-* `$container` — typed RPC client to a containerized Alepha app.
-*
-* Returns a typed Proxy whose method calls map 1:1 to the target
-* controller's `$action` endpoints. The wire format mirrors what a
-* normal Alepha server exposes (`POST /api/<method>` with a JSON body),
-* so the container is literally a tiny Alepha worker.
-*
-* Transport is owned by the active {@link ContainerProvider}:
-* - `target=cloudflare` → `CloudflareContainerProvider` routes through
-*   the Containers binding (`env.<NAME>.getContainer(...).fetch()`).
-* - Node (with `url` set) → `NodeContainerProvider` uses plain
-*   `fetch()` against the configured URL.
-*
-* Build-time, `BuildCloudflareTask.enhanceContainers` walks
-* `alepha.primitives($container)` to emit the matching `wrangler.jsonc`
-* entries and Durable Object class declarations into
-* `main.cloudflare.js`.
-*
-* @example
-* ```ts
-* import { $container } from "alepha/container";
-* import type { RocketController } from "@alepha/rocket";
-*
-* class DeployService {
-*   rocket = $container<RocketController>({
-*     image: "alepha/rocket:latest",
-*     port: 3000,
-*     sleepAfter: "15m",
-*   });
-*
-*   async deploy() {
-*     return this.rocket.createJob({ body: { op: "up" } });
-*   }
-* }
-* ```
-*/
-const $container = (options) => {
-	if (!options.image) throw new AlephaError("$container requires an 'image' option");
-	return createPrimitive(ContainerPrimitive, options).proxy();
-};
-var ContainerPrimitive = class extends Primitive {
-	provider = $inject(ContainerProvider);
-	get name() {
-		return this.options.name ?? this.config.propertyKey;
-	}
-	/**
-	* Build the typed Proxy. The target is the primitive itself so
-	* `instanceof Primitive` keeps working (required by Alepha's
-	* primitive registration in `Alepha.new`). Property reads that match
-	* an own/inherited member return that member; anything else is
-	* treated as an action name and routed through the provider.
-	*/
-	proxy() {
-		const primitive = this;
-		return new Proxy(primitive, { get(target, prop, receiver) {
-			if (typeof prop === "symbol" || prop in target) return Reflect.get(target, prop, receiver);
-			return (config = {}) => primitive.provider.invoke(primitive, prop, config);
-		} });
-	}
-};
-$container[KIND] = ContainerPrimitive;
-//#endregion
-//#region ../../src/container/core/providers/MockContainerProvider.ts
-/**
-* In-process test provider.
-*
-* Resolves the action name against `LinkProvider`'s registered links in
-* the SAME Alepha instance — effectively calling the "containerized"
-* controller as if it were local. Use it in tests: register the
-* controller class on the test container alongside the consumer and
-* substitute `ContainerProvider` with `MockContainerProvider`.
-*
-* @example
-* ```ts
-* const alepha = Alepha.create()
-*   .with(AlephaContainer)
-*   .with(RocketController)
-*   .with(MyApp)
-*   .with({ provide: ContainerProvider, use: MockContainerProvider });
-* ```
-*/
-var MockContainerProvider = class extends ContainerProvider {
-	alepha = $inject(Alepha);
-	async invoke(container, action, config) {
-		const linkProviderClass = await this.loadLinkProvider();
-		return await this.alepha.inject(linkProviderClass).follow(action, {
-			body: config.body,
-			query: config.query,
-			params: config.params,
-			headers: config.headers
-		});
-	}
-	async loadLinkProvider() {
-		try {
-			return (await import("alepha/server/links")).LinkProvider;
-		} catch {
-			throw new AlephaError("MockContainerProvider needs 'alepha/server/links' to be available — add AlephaServerLinks to the test app.");
-		}
-	}
-};
-//#endregion
-//#region ../../src/container/core/providers/NodeContainerProvider.ts
-/**
-* Node (dev / test / non-Cloudflare) container provider.
-*
-* Routes proxy calls through plain `fetch()` against the URL given on
-* the `$container` primitive. If no `url` is supplied, calls throw —
-* v1 deliberately has no Docker spawning. This is the "temporary, not
-* perfect" Node path documented in the spec; the longer-term plan is
-* to plug in a `target=docker` adapter once that lands.
-*/
-var NodeContainerProvider = class extends ContainerProvider {
-	async invoke(container, action, config) {
-		const url = this.resolveUrl(container);
-		if (!url) throw new AlephaError(`Container '${container.name}' has no 'url' configured — NodeContainerProvider cannot reach the container.`);
-		const { path, init } = this.buildRequest(action, config);
-		const response = await fetch(`${url.replace(/\/$/, "")}${path}`, init);
-		if (!response.ok) {
-			const text = await response.text().catch(() => "");
-			throw new AlephaError(`Container '${container.name}' action '${action}' failed: ${response.status} ${response.statusText}${text ? ` — ${text}` : ""}`);
-		}
-		if ((response.headers.get("content-type") ?? "").includes("application/json")) return await response.json();
-		return await response.text();
-	}
-	resolveUrl(container) {
-		const url = container.options.url;
-		return typeof url === "function" ? url() : url;
-	}
-};
-//#endregion
-//#region ../../src/container/core/index.ts
-/**
-* Type-safe RPC clients for ephemeral containerized Alepha apps.
-*
-* **Features:**
-* - `$container<T>()` directive returns a typed Proxy onto a remote
-*   Alepha controller's `$action` endpoints — the wire format is the
-*   same `POST /api/<method>` shape served by every Alepha server.
-* - 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/container` workerd entry).
-* - Build-time integration: `BuildCloudflareTask.enhanceContainers`
-*   emits the matching wrangler bindings and Durable Object class
-*   declarations.
-*
-* The Node binding is the "temporary, not perfect" path documented in
-* the spec — apps need to provide an explicit `url` per primitive
-* until a `target=docker` adapter ships.
-*
-* @module alepha.container
-*/
-const AlephaContainer = $module({
-	name: "alepha.container",
-	primitives: [$container],
-	services: [ContainerProvider],
-	variants: [MockContainerProvider, NodeContainerProvider],
-	register: (alepha) => {
-		alepha.with({
-			optional: true,
-			provide: ContainerProvider,
-			use: alepha.isTest() ? MockContainerProvider : NodeContainerProvider
-		});
-	}
-});
-//#endregion
-export { $container, AlephaContainer, ContainerPrimitive, ContainerProvider, MockContainerProvider, NodeContainerProvider };
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"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/container/core/index.workerd.js

@@ -1,192 +0,0 @@
-import { Container, getContainer } from "@cloudflare/containers";
-import { $inject, $module, Alepha, AlephaError, KIND, Primitive, createPrimitive } from "alepha";
-import { $logger } from "alepha/logger";
-//#region ../../src/container/core/providers/ContainerProvider.ts
-/**
-* Abstract transport for `$container` proxies.
-*
-* Concrete subclasses translate a `(container, action, config)` call
-* into an HTTP request that reaches the running container. The default
-* binding on Node throws — apps must register either a
-* `NodeContainerProvider` (with `url` on each primitive) or the
-* Cloudflare workerd variant.
-*/
-var ContainerProvider = class {
-	log = $logger();
-	/**
-	* Invoke a remote action on the container. Subclasses do the work;
-	* 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/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
-	* protected method so workerd and Node providers share the wire
-	* shape — `POST /api/<action>` with the JSON body, query params on
-	* the URL, and the request headers merged in.
-	*/
-	buildRequest(action, config) {
-		const params = new URLSearchParams();
-		if (config.query) {
-			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) {
-			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 = {
-			method: "POST",
-			headers: {
-				"content-type": "application/json",
-				...config.headers ?? {}
-			},
-			body: config.body !== void 0 ? JSON.stringify(config.body) : void 0
-		};
-		return {
-			path,
-			init
-		};
-	}
-};
-//#endregion
-//#region ../../src/container/core/primitives/$container.ts
-/**
-* `$container` — typed RPC client to a containerized Alepha app.
-*
-* Returns a typed Proxy whose method calls map 1:1 to the target
-* controller's `$action` endpoints. The wire format mirrors what a
-* normal Alepha server exposes (`POST /api/<method>` with a JSON body),
-* so the container is literally a tiny Alepha worker.
-*
-* Transport is owned by the active {@link ContainerProvider}:
-* - `target=cloudflare` → `CloudflareContainerProvider` routes through
-*   the Containers binding (`env.<NAME>.getContainer(...).fetch()`).
-* - Node (with `url` set) → `NodeContainerProvider` uses plain
-*   `fetch()` against the configured URL.
-*
-* Build-time, `BuildCloudflareTask.enhanceContainers` walks
-* `alepha.primitives($container)` to emit the matching `wrangler.jsonc`
-* entries and Durable Object class declarations into
-* `main.cloudflare.js`.
-*
-* @example
-* ```ts
-* import { $container } from "alepha/container";
-* import type { RocketController } from "@alepha/rocket";
-*
-* class DeployService {
-*   rocket = $container<RocketController>({
-*     image: "alepha/rocket:latest",
-*     port: 3000,
-*     sleepAfter: "15m",
-*   });
-*
-*   async deploy() {
-*     return this.rocket.createJob({ body: { op: "up" } });
-*   }
-* }
-* ```
-*/
-const $container = (options) => {
-	if (!options.image) throw new AlephaError("$container requires an 'image' option");
-	return createPrimitive(ContainerPrimitive, options).proxy();
-};
-var ContainerPrimitive = class extends Primitive {
-	provider = $inject(ContainerProvider);
-	get name() {
-		return this.options.name ?? this.config.propertyKey;
-	}
-	/**
-	* Build the typed Proxy. The target is the primitive itself so
-	* `instanceof Primitive` keeps working (required by Alepha's
-	* primitive registration in `Alepha.new`). Property reads that match
-	* an own/inherited member return that member; anything else is
-	* treated as an action name and routed through the provider.
-	*/
-	proxy() {
-		const primitive = this;
-		return new Proxy(primitive, { get(target, prop, receiver) {
-			if (typeof prop === "symbol" || prop in target) return Reflect.get(target, prop, receiver);
-			return (config = {}) => primitive.provider.invoke(primitive, prop, config);
-		} });
-	}
-};
-$container[KIND] = ContainerPrimitive;
-//#endregion
-//#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` 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 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 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);
-		if (!response.ok) {
-			const text = await response.text().catch(() => "");
-			throw new AlephaError(`Container '${container.name}' action '${action}' failed: ${response.status} ${response.statusText}${text ? ` — ${text}` : ""}`);
-		}
-		if ((response.headers.get("content-type") ?? "").includes("application/json")) return await response.json();
-		return await response.text();
-	}
-};
-//#endregion
-//#region ../../src/container/core/index.workerd.ts
-globalThis.__alepha_CloudflareContainer = Container;
-/**
-* Type-safe RPC clients for ephemeral containerized Alepha apps,
-* Cloudflare workerd build.
-*
-* Auto-binds `CloudflareContainerProvider` so `$container()` calls
-* route through `env.<NAME>.getContainer(...).fetch()`. Pair with
-* `BuildCloudflareTask.enhanceContainers` (in `alepha/cli/core`) which
-* emits the wrangler.jsonc bindings and DO class declarations.
-*
-* @module alepha.container
-*/
-const AlephaContainer = $module({
-	name: "alepha.container",
-	primitives: [$container],
-	services: [ContainerProvider, CloudflareContainerProvider],
-	register: (alepha) => {
-		alepha.with({
-			optional: true,
-			provide: ContainerProvider,
-			use: CloudflareContainerProvider
-		});
-	}
-});
-//#endregion
-export { $container, AlephaContainer, CloudflareContainerProvider, ContainerPrimitive, ContainerProvider };
-
-//# sourceMappingURL=index.workerd.js.map

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

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