@cowliss/cli 0.8.0 → 0.10.0

package/dist/guest/driver-emails.d.ts

@@ -0,0 +1,12 @@
+import { GuestModule, GuestOutput } from "./driver.js";
+//#region src/guest/driver-emails.d.ts
+/**
+ * The template half of the driver (spec: Guest protocol). It answers the
+ * two inputs a bundle built from `emails/` can get, `manifest` and
+ * `template`, and it is the only guest entry that imports `render.ts`:
+ * react and react-dom reach a bundle through this file or not at all.
+ * `driver.ts` is the journey half and holds everything both kinds share.
+ */
+declare function runGuest(module: GuestModule, input: unknown): Promise<GuestOutput>;
+//#endregion
+export { runGuest };

package/dist/guest/{driver-BXuYP007.js → driver-emails.js}

@@ -1,5 +1,5 @@
-import { a as manifestOutputSchema, i as journeyStepOutputSchema, o as templateRenderOutputSchema, r as guestInputSchema, t as CapabilityError } from "./journeys-F8Yk8s1P.js";
-import { z } from "zod";
+import { o as templateRenderOutputSchema, r as guestInputSchema, t as CapabilityError } from "./journeys-F8Yk8s1P.js";
+import { n as readManifest, t as asTemplate } from "./driver-poSdZIj8.js";
 import { createElement } from "react";
 import { renderToStaticMarkup } from "react-dom/server.browser";
 
@@ -30,154 +30,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 
-//#endregion
-//#region src/guest/api.ts
-/**
-* The journaled capability implementation (spec: Guest protocol). Every
-* `api` method funnels into `call`, which either replays the matching
-* journal entry or records the pending call and hangs, letting the driver
-* report the suspension.
-*/
-/** A replayed call did not match the journal: the execution cannot continue. */
-var NondeterminismError = class extends Error {
-	expected;
-	actual;
-	constructor(expected, actual) {
-		super(`Journey replay diverged: the journal recorded "${expected.name}" but the code called "${actual.name}" with different arguments`);
-		this.name = "NondeterminismError";
-		this.expected = expected;
-		this.actual = actual;
-	}
-};
-/**
-* Structural equality over JSON values. Key order differs between a
-* literal in journey code and the same object round-tripped through the
-* journal, so comparing serialized forms would report a divergence that
-* is not one.
-*/
-function sameValue(a, b) {
-	if (a === b) return true;
-	if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, index) => sameValue(item, b[index]));
-	if (typeof a !== "object" || typeof b !== "object" || !a || !b) return false;
-	const left = a;
-	const right = b;
-	const keys = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]);
-	for (const key of keys) if (!sameValue(left[key], right[key])) return false;
-	return true;
-}
-function formatLogArg(value) {
-	if (typeof value === "string") return value;
-	try {
-		return JSON.stringify(value) ?? String(value);
-	} catch {
-		return String(value);
-	}
-}
-/**
-* Builds the `api` a journey's `run` receives, over the step's journal.
-* The returned state is the driver's window into the run: the pending
-* call, the captured logs, and the clock the shims read.
-*/
-function createApi(input, journey) {
-	let cursor = 0;
-	let markSuspended = () => {};
-	const state = {
-		clock: { now: input.now },
-		logs: [],
-		pending: null,
-		suspended: new Promise((resolve) => {
-			markSuspended = resolve;
-		})
-	};
-	function call(command) {
-		if (command.name !== "restart" && cursor >= input.limits.calls) throw new CapabilityError("call_limit_exceeded", `Journey exceeded the per-execution limit of ${input.limits.calls} capability calls; use api.restart() for loops`);
-		const entry = input.journal[cursor];
-		if (!entry) {
-			if (!state.pending) {
-				state.pending = command;
-				markSuspended();
-			}
-			return new Promise(() => {});
-		}
-		if (entry.call.name !== command.name || !sameValue(entry.call.args, command.args)) throw new NondeterminismError(entry.call, command);
-		cursor += 1;
-		state.clock.now = cursor < input.journal.length ? entry.at : input.now;
-		if (entry.result.ok) return Promise.resolve(entry.result.value);
-		return Promise.reject(new CapabilityError(entry.result.error.code, entry.result.error.message));
-	}
-	return {
-		api: {
-			sleep: (duration) => call({
-				name: "sleep",
-				args: { duration }
-			}),
-			waitForEvent: (name, options) => call({
-				name: "waitForEvent",
-				args: {
-					event: name,
-					timeout: options.timeout
-				}
-			}),
-			send: {
-				email: (args) => call({
-					name: "send.email",
-					args: {
-						template: args.template,
-						props: args.props,
-						from: args.from ?? journey.from,
-						replyTo: args.replyTo
-					}
-				}),
-				webhook: (args) => call({
-					name: "send.webhook",
-					args
-				})
-			},
-			traits: {
-				set: (key, value) => call({
-					name: "traits.set",
-					args: {
-						key,
-						value
-					}
-				}),
-				unset: (key) => call({
-					name: "traits.unset",
-					args: { key }
-				})
-			},
-			profile: { get: () => call({
-				name: "profile.get",
-				args: {}
-			}) },
-			profiles: { get: (id) => call({
-				name: "profiles.get",
-				args: { id }
-			}) },
-			events: { track: (name, properties) => call({
-				name: "events.track",
-				args: {
-					event: name,
-					properties
-				}
-			}) },
-			log: (...args) => {
-				if (cursor < input.journal.length) return;
-				if (state.logs.length >= input.limits.logLines) return;
-				state.logs.push({
-					level: "info",
-					message: args.map(formatLogArg).join(" ").slice(0, input.limits.logLineBytes)
-				});
-			},
-			restart: (args) => call({
-				name: "restart",
-				args: { event: args?.event }
-			})
-		},
-		state
-	};
-}
-
 //#endregion
 //#region ../../node_modules/.pnpm/domelementtype@2.3.0/node_modules/domelementtype/lib/esm/index.js
 /** Types of elements found in htmlparser2's DOM */
@@ -5482,173 +5334,20 @@ function renderTemplateModule(template, props) {
 }
 
 //#endregion
-//#region src/guest/shims.ts
+//#region src/guest/driver-emails.ts
 /**
-* A hash of the seed string into a 32-bit state (FNV-1a). The seed derives
-* from the execution id, so the same execution replays the same numbers.
-*/
-function hashSeed(seed) {
-	let hash = 2166136261;
-	for (let index = 0; index < seed.length; index += 1) {
-		hash ^= seed.charCodeAt(index);
-		hash = Math.imul(hash, 16777619);
-	}
-	return hash >>> 0;
-}
-/** mulberry32: small, fast, and good enough for journey branching. */
-function mulberry32(seed) {
-	let state = hashSeed(seed);
-	return () => {
-		state = state + 1831565813 | 0;
-		let value = Math.imul(state ^ state >>> 15, 1 | state);
-		value = value + Math.imul(value ^ value >>> 7, 61 | value) ^ value;
-		return ((value ^ value >>> 14) >>> 0) / 4294967296;
-	};
-}
-const BLOCKED = [
-	"setTimeout",
-	"setInterval",
-	"setImmediate",
-	"fetch",
-	"XMLHttpRequest",
-	"queueMicrotask"
-];
-function blocked(name) {
-	return () => {
-		throw new CapabilityError("capability_unavailable", `${name} is not available in journeys: use the api object, which is journaled and replays exactly`);
-	};
-}
-/**
-* Installs the shims and returns the undo. Call it before user code runs
-* and restore in a `finally`, so a driver embedded in a Node process does
-* not leak a frozen clock into its host.
-*/
-function installShims(options) {
-	const globals = globalThis;
-	const saved = /* @__PURE__ */ new Map();
-	const save = (name) => {
-		saved.set(name, name in globals ? globals[name] : void 0);
-	};
-	const RealDate = Date;
-	class GuestDate extends RealDate {
-		constructor(...args) {
-			if (args.length === 0) super(options.clock.now);
-			else super(...args);
-		}
-		static now() {
-			return options.clock.now;
-		}
-	}
-	save("Date");
-	globals.Date = GuestDate;
-	const realRandom = Math.random;
-	Math.random = mulberry32(options.seed);
-	for (const name of BLOCKED) {
-		save(name);
-		globals[name] = blocked(name);
-	}
-	return () => {
-		Math.random = realRandom;
-		for (const [name, value] of saved) if (value === void 0) delete globals[name];
-		else globals[name] = value;
-	};
-}
-
-//#endregion
-//#region src/guest/driver.ts
-function asJourney(module) {
-	const journey = module.default;
-	if (!journey || typeof journey.run !== "function") throw new Error("Journey module must default-export defineJourney({ ... }) with a run function");
-	return journey;
-}
-function asTemplate(module) {
-	const template = module;
-	if (typeof template.default !== "function" || !template.props) throw new Error("Template module must export a default component and a zod `props` schema");
-	return template;
-}
-function readManifest(module) {
-	if (module.default && typeof module.default.run === "function") {
-		const journey = asJourney(module);
-		return manifestOutputSchema.parse({
-			kind: "journey",
-			trigger: journey.trigger,
-			purpose: journey.purpose,
-			enrollment: journey.enrollment,
-			description: journey.description,
-			from: journey.from,
-			tags: journey.tags
-		});
-	}
-	const template = asTemplate(module);
-	return manifestOutputSchema.parse({
-		kind: "template",
-		tags: template.tags,
-		sendClass: template.sendClass ?? "marketing",
-		verifyLink: template.verifyLink ?? false,
-		unsubscribeLink: template.unsubscribeLink ?? false,
-		propsSchema: z.toJSONSchema(template.props, { target: "draft-2020-12" })
-	});
-}
-async function runJourneyStep(module, input) {
-	const journey = asJourney(module);
-	const { api, state } = createApi(input, journey);
-	const restore = installShims({
-		clock: state.clock,
-		seed: input.seed
-	});
-	try {
-		if (await Promise.race([journey.run(input.event, api).then(() => true), state.suspended.then(() => false)])) return journeyStepOutput({
-			status: "done",
-			logs: state.logs
-		});
-		return journeyStepOutput({
-			status: "suspend",
-			call: state.pending,
-			logs: state.logs
-		});
-	} catch (error) {
-		if (error instanceof NondeterminismError) return journeyStepOutput({
-			status: "error",
-			error: {
-				code: "journey_nondeterministic",
-				message: error.message
-			},
-			nondeterministic: {
-				expected: error.expected,
-				actual: error.actual
-			},
-			logs: state.logs
-		});
-		const thrown = error instanceof Error ? error : new Error(String(error));
-		return journeyStepOutput({
-			status: "error",
-			error: {
-				code: "journey_error",
-				message: thrown.message,
-				stack: thrown.stack
-			},
-			logs: state.logs
-		});
-	} finally {
-		restore();
-	}
-}
-function journeyStepOutput(output) {
-	return journeyStepOutputSchema.parse(output);
-}
-/**
-* Runs one guest invocation. `module` is the tenant module namespace the
-* bundle's entry imported; `input` is the raw JSON the host handed over.
+* The template half of the driver (spec: Guest protocol). It answers the
+* two inputs a bundle built from `emails/` can get, `manifest` and
+* `template`, and it is the only guest entry that imports `render.ts`:
+* react and react-dom reach a bundle through this file or not at all.
+* `driver.ts` is the journey half and holds everything both kinds share.
 */
 async function runGuest(module, input) {
 	const parsed = guestInputSchema.parse(input);
 	if (parsed.kind === "manifest") return readManifest(module);
-	if (parsed.kind === "template") return renderTemplate(module, parsed);
-	return runJourneyStep(module, parsed);
-}
-function renderTemplate(module, input) {
-	return templateRenderOutputSchema.parse(renderTemplateModule(asTemplate(module), input.props));
+	if (parsed.kind === "journey") throw new Error("A template bundle cannot run a journey step.");
+	return templateRenderOutputSchema.parse(renderTemplateModule(asTemplate(module), parsed.props));
 }
 
 //#endregion
-export { runGuest as t };
+export { runGuest };

package/dist/guest/driver-poSdZIj8.js

@@ -0,0 +1,320 @@
+import { a as manifestOutputSchema, i as journeyStepOutputSchema, r as guestInputSchema, t as CapabilityError } from "./journeys-F8Yk8s1P.js";
+import { z } from "zod";
+
+//#region src/guest/api.ts
+/**
+* The journaled capability implementation (spec: Guest protocol). Every
+* `api` method funnels into `call`, which either replays the matching
+* journal entry or records the pending call and hangs, letting the driver
+* report the suspension.
+*/
+/** A replayed call did not match the journal: the execution cannot continue. */
+var NondeterminismError = class extends Error {
+	expected;
+	actual;
+	constructor(expected, actual) {
+		super(`Journey replay diverged: the journal recorded "${expected.name}" but the code called "${actual.name}" with different arguments`);
+		this.name = "NondeterminismError";
+		this.expected = expected;
+		this.actual = actual;
+	}
+};
+/**
+* Structural equality over JSON values. Key order differs between a
+* literal in journey code and the same object round-tripped through the
+* journal, so comparing serialized forms would report a divergence that
+* is not one.
+*/
+function sameValue(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, index) => sameValue(item, b[index]));
+	if (typeof a !== "object" || typeof b !== "object" || !a || !b) return false;
+	const left = a;
+	const right = b;
+	const keys = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]);
+	for (const key of keys) if (!sameValue(left[key], right[key])) return false;
+	return true;
+}
+function formatLogArg(value) {
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+/**
+* Builds the `api` a journey's `run` receives, over the step's journal.
+* The returned state is the driver's window into the run: the pending
+* call, the captured logs, and the clock the shims read.
+*/
+function createApi(input, journey) {
+	let cursor = 0;
+	let markSuspended = () => {};
+	const state = {
+		clock: { now: input.now },
+		logs: [],
+		pending: null,
+		suspended: new Promise((resolve) => {
+			markSuspended = resolve;
+		})
+	};
+	function call(command) {
+		if (command.name !== "restart" && cursor >= input.limits.calls) throw new CapabilityError("call_limit_exceeded", `Journey exceeded the per-execution limit of ${input.limits.calls} capability calls; use api.restart() for loops`);
+		const entry = input.journal[cursor];
+		if (!entry) {
+			if (!state.pending) {
+				state.pending = command;
+				markSuspended();
+			}
+			return new Promise(() => {});
+		}
+		if (entry.call.name !== command.name || !sameValue(entry.call.args, command.args)) throw new NondeterminismError(entry.call, command);
+		cursor += 1;
+		state.clock.now = cursor < input.journal.length ? entry.at : input.now;
+		if (entry.result.ok) return Promise.resolve(entry.result.value);
+		return Promise.reject(new CapabilityError(entry.result.error.code, entry.result.error.message));
+	}
+	return {
+		api: {
+			sleep: (duration) => call({
+				name: "sleep",
+				args: { duration }
+			}),
+			waitForEvent: (name, options) => call({
+				name: "waitForEvent",
+				args: {
+					event: name,
+					timeout: options.timeout
+				}
+			}),
+			send: {
+				email: (args) => call({
+					name: "send.email",
+					args: {
+						template: args.template,
+						props: args.props,
+						from: args.from ?? journey.from,
+						replyTo: args.replyTo
+					}
+				}),
+				webhook: (args) => call({
+					name: "send.webhook",
+					args
+				})
+			},
+			traits: {
+				set: (key, value) => call({
+					name: "traits.set",
+					args: {
+						key,
+						value
+					}
+				}),
+				unset: (key) => call({
+					name: "traits.unset",
+					args: { key }
+				})
+			},
+			profile: { get: () => call({
+				name: "profile.get",
+				args: {}
+			}) },
+			profiles: { get: (id) => call({
+				name: "profiles.get",
+				args: { id }
+			}) },
+			events: { track: (name, properties) => call({
+				name: "events.track",
+				args: {
+					event: name,
+					properties
+				}
+			}) },
+			log: (...args) => {
+				if (cursor < input.journal.length) return;
+				if (state.logs.length >= input.limits.logLines) return;
+				state.logs.push({
+					level: "info",
+					message: args.map(formatLogArg).join(" ").slice(0, input.limits.logLineBytes)
+				});
+			},
+			restart: (args) => call({
+				name: "restart",
+				args: { event: args?.event }
+			})
+		},
+		state
+	};
+}
+
+//#endregion
+//#region src/guest/shims.ts
+/**
+* A hash of the seed string into a 32-bit state (FNV-1a). The seed derives
+* from the execution id, so the same execution replays the same numbers.
+*/
+function hashSeed(seed) {
+	let hash = 2166136261;
+	for (let index = 0; index < seed.length; index += 1) {
+		hash ^= seed.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return hash >>> 0;
+}
+/** mulberry32: small, fast, and good enough for journey branching. */
+function mulberry32(seed) {
+	let state = hashSeed(seed);
+	return () => {
+		state = state + 1831565813 | 0;
+		let value = Math.imul(state ^ state >>> 15, 1 | state);
+		value = value + Math.imul(value ^ value >>> 7, 61 | value) ^ value;
+		return ((value ^ value >>> 14) >>> 0) / 4294967296;
+	};
+}
+const BLOCKED = [
+	"setTimeout",
+	"setInterval",
+	"setImmediate",
+	"fetch",
+	"XMLHttpRequest",
+	"queueMicrotask"
+];
+function blocked(name) {
+	return () => {
+		throw new CapabilityError("capability_unavailable", `${name} is not available in journeys: use the api object, which is journaled and replays exactly`);
+	};
+}
+/**
+* Installs the shims and returns the undo. Call it before user code runs
+* and restore in a `finally`, so a driver embedded in a Node process does
+* not leak a frozen clock into its host.
+*/
+function installShims(options) {
+	const globals = globalThis;
+	const saved = /* @__PURE__ */ new Map();
+	const save = (name) => {
+		saved.set(name, name in globals ? globals[name] : void 0);
+	};
+	const RealDate = Date;
+	class GuestDate extends RealDate {
+		constructor(...args) {
+			if (args.length === 0) super(options.clock.now);
+			else super(...args);
+		}
+		static now() {
+			return options.clock.now;
+		}
+	}
+	save("Date");
+	globals.Date = GuestDate;
+	const realRandom = Math.random;
+	Math.random = mulberry32(options.seed);
+	for (const name of BLOCKED) {
+		save(name);
+		globals[name] = blocked(name);
+	}
+	return () => {
+		Math.random = realRandom;
+		for (const [name, value] of saved) if (value === void 0) delete globals[name];
+		else globals[name] = value;
+	};
+}
+
+//#endregion
+//#region src/guest/driver.ts
+function asJourney(module) {
+	const journey = module.default;
+	if (!journey || typeof journey.run !== "function") throw new Error("Journey module must default-export defineJourney({ ... }) with a run function");
+	return journey;
+}
+function asTemplate(module) {
+	const template = module;
+	if (typeof template.default !== "function" || !template.props) throw new Error("Template module must export a default component and a zod `props` schema");
+	return template;
+}
+function readManifest(module) {
+	if (module.default && typeof module.default.run === "function") {
+		const journey = asJourney(module);
+		return manifestOutputSchema.parse({
+			kind: "journey",
+			trigger: journey.trigger,
+			purpose: journey.purpose,
+			enrollment: journey.enrollment,
+			description: journey.description,
+			from: journey.from,
+			tags: journey.tags
+		});
+	}
+	const template = asTemplate(module);
+	return manifestOutputSchema.parse({
+		kind: "template",
+		tags: template.tags,
+		sendClass: template.sendClass ?? "marketing",
+		verifyLink: template.verifyLink ?? false,
+		unsubscribeLink: template.unsubscribeLink ?? false,
+		propsSchema: z.toJSONSchema(template.props, { target: "draft-2020-12" })
+	});
+}
+async function runJourneyStep(module, input) {
+	const journey = asJourney(module);
+	const { api, state } = createApi(input, journey);
+	const restore = installShims({
+		clock: state.clock,
+		seed: input.seed
+	});
+	try {
+		if (await Promise.race([journey.run(input.event, api).then(() => true), state.suspended.then(() => false)])) return journeyStepOutput({
+			status: "done",
+			logs: state.logs
+		});
+		return journeyStepOutput({
+			status: "suspend",
+			call: state.pending,
+			logs: state.logs
+		});
+	} catch (error) {
+		if (error instanceof NondeterminismError) return journeyStepOutput({
+			status: "error",
+			error: {
+				code: "journey_nondeterministic",
+				message: error.message
+			},
+			nondeterministic: {
+				expected: error.expected,
+				actual: error.actual
+			},
+			logs: state.logs
+		});
+		const thrown = error instanceof Error ? error : new Error(String(error));
+		return journeyStepOutput({
+			status: "error",
+			error: {
+				code: "journey_error",
+				message: thrown.message,
+				stack: thrown.stack
+			},
+			logs: state.logs
+		});
+	} finally {
+		restore();
+	}
+}
+function journeyStepOutput(output) {
+	return journeyStepOutputSchema.parse(output);
+}
+/**
+* Runs one guest invocation against a journey bundle. `module` is the tenant
+* module namespace the bundle's entry imported; `input` is the raw JSON the
+* host handed over. A `template` input is a host bug, not a tenant one: this
+* bundle was built from `journeys/` and carries no renderer.
+*/
+async function runGuest(module, input) {
+	const parsed = guestInputSchema.parse(input);
+	if (parsed.kind === "manifest") return readManifest(module);
+	if (parsed.kind === "template") throw new Error("A journey bundle cannot render a template.");
+	return runJourneyStep(module, parsed);
+}
+
+//#endregion
+export { readManifest as n, runGuest as r, asTemplate as t };

package/dist/guest/driver.d.ts

@@ -1,21 +1,34 @@
 import { a as JourneyStepOutput, o as ManifestOutput, s as TemplateRenderOutput } from "./index-EqBCZnpq.js";
+import { n as Template } from "./emails-5GindgMQ.js";
 //#region src/guest/driver.d.ts
 /**
  * The in-process driver: JSON in, JSON out (spec: Guest protocol). One
- * bundle is one module is one journey or one template, and this turns the
- * three inputs into the three outputs. `wasi.ts` wraps it for the sandbox;
+ * bundle is one module is one journey or one template, and this turns that
+ * bundle's inputs into its outputs. `wasi.ts` wraps it for the sandbox;
  * the simulator and the tests call `runGuest` directly.
  *
+ * There are two drivers, one per kind, because a bundle only pays for the
+ * one it is. This is the journey half: `manifest` and `journey`. The
+ * template half lives in `driver-emails.ts` and is the only one that
+ * imports `render.ts`, so react and react-dom (197KB minified) stay out of
+ * every journey bundle. `build/index.ts` picks the driver by source kind
+ * when it composes an entry; everything both kinds need is here and
+ * imported by that file.
+ *
  * Every output is validated with the shared schema before it leaves, so a
  * guest bug surfaces here rather than as a host-side parse failure.
  */
 /** A compiled bundle's module namespace, as `import * as module` sees it. */
 type GuestModule = Record<string, unknown>;
 type GuestOutput = JourneyStepOutput | TemplateRenderOutput | ManifestOutput;
+declare function asTemplate(module: GuestModule): Template;
+declare function readManifest(module: GuestModule): ManifestOutput;
 /**
- * Runs one guest invocation. `module` is the tenant module namespace the
- * bundle's entry imported; `input` is the raw JSON the host handed over.
+ * Runs one guest invocation against a journey bundle. `module` is the tenant
+ * module namespace the bundle's entry imported; `input` is the raw JSON the
+ * host handed over. A `template` input is a host bug, not a tenant one: this
+ * bundle was built from `journeys/` and carries no renderer.
  */
 declare function runGuest(module: GuestModule, input: unknown): Promise<GuestOutput>;
 //#endregion
-export { GuestModule, GuestOutput, runGuest };
+export { GuestModule, GuestOutput, asTemplate, readManifest, runGuest };

package/dist/guest/driver.js

@@ -1,3 +1,3 @@
-import { t as runGuest } from "./driver-BXuYP007.js";
+import { n as readManifest, r as runGuest, t as asTemplate } from "./driver-poSdZIj8.js";
 
-export { runGuest };
+export { asTemplate, readManifest, runGuest };

package/dist/guest/emails-5GindgMQ.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { ReactElement } from "react";
+//#region ../../packages/shared/src/constants.d.ts
+/**
+ * The two classes of send, declared on the template rather than passed per
+ * call so the class cannot drift between two sends of the same message.
+ *
+ * Marketing is everything a journey sends on the org's behalf: it carries
+ * the RFC 8058 unsubscribe headers and runs the full gate list.
+ * Transactional is the developer's own operational mail (a receipt, an
+ * export-is-ready notice): it carries neither header and skips consent and
+ * the per-user frequency cap, because an unsubscribe link on an invoice is
+ * wrong and a receipt must not silently vanish for anyone who once left a
+ * newsletter. Suppression, the quota, the sending pause, and the from-domain
+ * check still apply to both: those bound cost and protect the shared SES
+ * account, and none of them are about what the recipient asked for.
+ */
+declare const SEND_CLASSES: readonly ["marketing", "transactional"];
+type SendClass = (typeof SEND_CLASSES)[number];
+//#endregion
+//#region src/guest/emails.d.ts
+/** A template's subject line, computed from the props it declares. */
+type Subject<Schema extends z.ZodType> = (props: z.infer<Schema>) => string;
+/**
+ * The shape `emails/<key>.tsx` exports. `cow build` reads `props` (turned
+ * into JSON Schema in the manifest and into `.cow/types.d.ts`), `subject`,
+ * and the optional metadata below it; the sandbox renders `default`.
+ */
+type Template<Schema extends z.ZodType = z.ZodType> = {
+  default: (props: z.infer<Schema>) => ReactElement;
+  props: Schema;
+  subject: Subject<Schema> | string;
+  /** Defaults to "marketing". */
+  sendClass?: SendClass;
+  /** The author's labels; the dashboard's only grouping. Defaults to none. */
+  tags?: string[];
+  /** True asks the host to mint a signed `verifyUrl` prop at send time. */
+  verifyLink?: boolean;
+  /**
+   * True asks the host to mint a signed `unsubscribeUrl` prop at send time,
+   * for the author's own footer link. Leave it off and a marketing template
+   * still gets a platform footer with the link appended at send time.
+   */
+  unsubscribeLink?: boolean;
+};
+//#endregion
+export { Template as n, SendClass as r, Subject as t };

package/dist/guest/emails.d.ts

@@ -1,47 +1,2 @@
-import { z } from "zod";
-import { ReactElement } from "react";
-//#region ../../packages/shared/src/constants.d.ts
-/**
- * The two classes of send, declared on the template rather than passed per
- * call so the class cannot drift between two sends of the same message.
- *
- * Marketing is everything a journey sends on the org's behalf: it carries
- * the RFC 8058 unsubscribe headers and runs the full gate list.
- * Transactional is the developer's own operational mail (a receipt, an
- * export-is-ready notice): it carries neither header and skips consent and
- * the per-user frequency cap, because an unsubscribe link on an invoice is
- * wrong and a receipt must not silently vanish for anyone who once left a
- * newsletter. Suppression, the quota, the sending pause, and the from-domain
- * check still apply to both: those bound cost and protect the shared SES
- * account, and none of them are about what the recipient asked for.
- */
-declare const SEND_CLASSES: readonly ["marketing", "transactional"];
-type SendClass = (typeof SEND_CLASSES)[number];
-//#endregion
-//#region src/guest/emails.d.ts
-/** A template's subject line, computed from the props it declares. */
-type Subject<Schema extends z.ZodType> = (props: z.infer<Schema>) => string;
-/**
- * The shape `emails/<key>.tsx` exports. `cow build` reads `props` (turned
- * into JSON Schema in the manifest and into `.cow/types.d.ts`), `subject`,
- * and the optional metadata below it; the sandbox renders `default`.
- */
-type Template<Schema extends z.ZodType = z.ZodType> = {
-  default: (props: z.infer<Schema>) => ReactElement;
-  props: Schema;
-  subject: Subject<Schema> | string;
-  /** Defaults to "marketing". */
-  sendClass?: SendClass;
-  /** The author's labels; the dashboard's only grouping. Defaults to none. */
-  tags?: string[];
-  /** True asks the host to mint a signed `verifyUrl` prop at send time. */
-  verifyLink?: boolean;
-  /**
-   * True asks the host to mint a signed `unsubscribeUrl` prop at send time,
-   * for the author's own footer link. Leave it off and a marketing template
-   * still gets a platform footer with the link appended at send time.
-   */
-  unsubscribeLink?: boolean;
-};
-//#endregion
+import { n as Template, r as SendClass, t as Subject } from "./emails-5GindgMQ.js";
 export { type SendClass, Subject, Template };

package/dist/guest/wasi.d.ts

@@ -1,6 +1,8 @@
-import { GuestModule } from "./driver.js";
+import { GuestModule, GuestOutput } from "./driver.js";
 //#region src/guest/wasi.d.ts
+/** The kind-specific driver the entry hands over. */
+type RunGuest = (module: GuestModule, input: unknown) => Promise<GuestOutput>;
 /** Drives one invocation of the module this bundle was built for. */
-declare function main(module: GuestModule): void;
+declare function main(module: GuestModule, runGuest: RunGuest): void;
 //#endregion
 export { main };

package/dist/guest/wasi.js

@@ -1,5 +1,3 @@
-import { t as runGuest } from "./driver-BXuYP007.js";
-
 //#region src/guest/wasi.ts
 const STDIN = 0;
 const STDOUT = 1;
@@ -27,7 +25,7 @@ function write(fd, text) {
 	Javy.IO.writeSync(fd, new TextEncoder().encode(text));
 }
 /** Drives one invocation of the module this bundle was built for. */
-function main(module) {
+function main(module, runGuest) {
 	const fail = (error) => {
 		write(STDERR, error instanceof Error ? error.message : String(error));
 		throw error;

package/dist/index.js

@@ -3170,8 +3170,15 @@ const insertAppSchema = createInsertSchema(apps$1);
 const bytea = customType({ dataType: () => "bytea" });
 /**
 * What an artifact is: a journey or template bundle as `cow build` emitted
-* it, the wasm module the server compiled from it, or the gzipped source
-* tarball of the repo the push was built from.
+* it, or the gzipped source tarball of the repo the push was built from.
+*
+* `module` is still a value of the Postgres enum and no longer a value here
+* (ticket 22/05). Compiled modules are not stored: a module is a
+* deterministic function of its bundle, so the rows were Postgres caching
+* what the sandbox's own disk cache already holds, at about 2MB each of
+* which 1.34MB is the QuickJS engine Javy links into every one. Dropping
+* the enum value itself would mean recreating the type and rewriting the
+* column, for a label nothing writes.
 */
 const artifactKindEnum = pgEnum("artifact_kind", [
 	"bundle",
@@ -4395,10 +4402,16 @@ const versionStatusEnum = pgEnum("version_status", [
 * use; an execution pins the journey version it started on for its whole
 * life (ADR 0004).
 *
-* `moduleDigest` is the content address and is null until the compile
-* settles: a version that never compiled has no module to be addressed by,
-* and Postgres leaves nulls out of the unique index, so a key that fails to
-* compile twice records both failures.
+* The content address is the manifest's `bundle`, which is what the
+* developer actually pushed. `moduleDigest` is a derived compile result,
+* null until the compile settles and rewritable afterwards: the toolchain
+* that produced it is ours, not the tenant's, so bumping Javy is a
+* background recompile rather than a new version in a customer's history
+* (ADR 0011, amended 2026-09-19).
+*
+* The uniqueness that follows is "one ready version per key per bundle": a
+* key whose bundle does not compile records every attempt, and the next
+* push of that bundle is a retry rather than a duplicate.
 *
 * `pushedAt` is the ordering key rather than a creation stamp, because an
 * unchanged key gets no new version: a push that re-sends bytes a version
@@ -4430,7 +4443,7 @@ const versions$1 = pgTable("versions", {
 	}),
 	error: text("error")
 }, (table) => [
-	uniqueIndex("versions_org_id_kind_key_module_digest_unique").on(table.orgId, table.kind, table.key, table.moduleDigest),
+	uniqueIndex("versions_org_id_kind_key_bundle_unique").on(table.orgId, table.kind, table.key, sql`(${table.manifest}->>'bundle')`).where(sql`${table.status} = 'ready'`),
 	index("versions_org_id_kind_key_pushed_at_idx").on(table.orgId, table.kind, table.key, table.pushedAt),
 	index("versions_org_id_push_id_idx").on(table.orgId, table.pushId),
 	foreignKey({
@@ -6343,15 +6356,23 @@ const versionSchema = selectVersionSchema.extend({
 * version" column shows (the short digest, when it was pushed, whether it
 * compiled) and the push its source archive lives on. The manifest entry is
 * left out, because a journey row already carries what its own entry says.
+*
+* `bundle` is lifted out of that entry because it is the version's address:
+* it is there from the moment the push lands, and it does not move when a
+* recompile rewrites `moduleDigest` (ADR 0011, amended 2026-09-19). The
+* compiled module's digest is not on the wire at all; nothing outside the
+* sandbox has a use for it.
 */
 const versionSummarySchema = selectVersionSchema.pick({
 	id: true,
 	status: true,
-	moduleDigest: true,
 	pushId: true,
 	appId: true,
 	error: true
-}).extend({ pushedAt: z.iso.datetime() });
+}).extend({
+	pushedAt: z.iso.datetime(),
+	bundle: digestSchema
+});
 /**
 * A push as the API reports it, with the versions it created: `cow push`
 * returns as soon as the upload is stored, so what is compiling, what is
@@ -8136,11 +8157,15 @@ const CONFIG_FILES = [
 * cannot be inlined). There is no `src/` fallback: a missing
 * build surfaces here as an unresolved import rather than as a second code
 * path whose only job is to hide it.
+*
+* `guest` and `guest-emails` are the two drivers and a bundle links exactly
+* one, picked by source kind (`DRIVER`).
 */
 const GUEST_ALIAS = {
 	"@cowliss/cli/journeys": guestFile("journeys"),
 	"@cowliss/cli/emails": guestFile("emails"),
 	"@cowliss/cli/guest": guestFile("guest"),
+	"@cowliss/cli/guest-emails": guestFile("guest-emails"),
 	"@cowliss/cli/guest-wasi": guestFile("guest-wasi"),
 	"@cowliss/cli/guest-prelude": guestFile("guest-prelude")
 };
@@ -8325,23 +8350,33 @@ async function bundle(projectDir, outFile, entry) {
 	};
 }
 /**
+* The driver a bundle links, one per kind. Only the template one imports
+* the renderer, so naming it from a journey entry is what used to put react
+* and react-dom in all 95 journey bundles (`guest/driver.ts`).
+*/
+const DRIVER = {
+	journeys: "@cowliss/cli/guest",
+	emails: "@cowliss/cli/guest-emails"
+};
+/**
 * The artifact the sandbox compiles: stdin in, stdout out, no exports. The
 * prelude is imported first on purpose: ESM evaluates in import order, and
 * its `MessageChannel` and `console` walls have to stand before react-dom
 * or tenant code initializes.
 */
-function wasiEntry(file) {
+function wasiEntry(file, kind) {
 	return `import "@cowliss/cli/guest-prelude";
 import * as module from ${JSON.stringify(file)};
 import { main } from "@cowliss/cli/guest-wasi";
-main(module);
+import { runGuest } from ${JSON.stringify(DRIVER[kind])};
+main(module, runGuest);
 `;
 }
 /** The local twin: the same graph, importable by Node for the manifest and `cow test`. */
-function nodeEntry(file) {
+function nodeEntry(file, kind) {
 	return `import * as module from ${JSON.stringify(file)};
 export { module };
-export { runGuest } from "@cowliss/cli/guest";
+export { runGuest } from ${JSON.stringify(DRIVER[kind])};
 `;
 }
 let messagePortsUnreffed = false;
@@ -8495,7 +8530,7 @@ async function buildProject(projectDir) {
 	const bundles = await Promise.all(files.map(async (source) => {
 		const nodeFile = join(outDir, "node", source.kind, `${source.key}.mjs`);
 		const wasiFile = join(outDir, "bundles", source.kind, `${source.key}.js`);
-		const [wasi, node] = await Promise.all([bundle(projectDir, wasiFile, wasiEntry(source.file)), bundle(projectDir, nodeFile, nodeEntry(source.file))]);
+		const [wasi, node] = await Promise.all([bundle(projectDir, wasiFile, wasiEntry(source.file, source.kind)), bundle(projectDir, nodeFile, nodeEntry(source.file, source.kind))]);
 		await writeFile(nodeFile, node.code);
 		await writeFile(`${nodeFile}.map`, node.map);
 		await writeFile(wasiFile, wasi.code);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cowliss/cli",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "type": "module",
   "bin": {
     "cow": "./dist/index.js"
@@ -18,6 +18,10 @@
       "types": "./dist/guest/driver.d.ts",
       "default": "./dist/guest/driver.js"
     },
+    "./guest-emails": {
+      "types": "./dist/guest/driver-emails.d.ts",
+      "default": "./dist/guest/driver-emails.js"
+    },
     "./guest-wasi": {
       "types": "./dist/guest/wasi.d.ts",
       "default": "./dist/guest/wasi.js"
@@ -37,6 +41,18 @@
     "tar": "^7.5.22",
     "zod": "^4.4.3"
   },
+  "peerDependencies": {
+    "react": "^19",
+    "react-dom": "^19"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@babel/types": "^7.29.8",
     "@cowliss/api-client": "0.0.0",