@cowliss/cli 0.7.0 → 0.9.0

package/dist/guest/driver.d.ts

@@ -1,21 +1,34 @@
-import { a as JourneyStepOutput, o as ManifestOutput, s as TemplateRenderOutput } from "./index-3PMqJKmc.js";
+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-C1bsCjZT.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/{index-3PMqJKmc.d.ts → index-EqBCZnpq.d.ts}

@@ -252,14 +252,12 @@ declare const manifestOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   tags: z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodString>>, z.ZodTransform<string[], string[]>>;
   trigger: z.ZodUnion<readonly [z.ZodObject<{
     event: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-    appId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
   }, z.core.$strict>, z.ZodObject<{
     segment: z.ZodObject<{
       match: z.ZodDefault<z.ZodEnum<{
         all: "all";
         any: "any";
       }>>;
-      appId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
       predicates: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"trait">;
         name: z.ZodString;
@@ -323,9 +321,12 @@ type ManifestOutput = z.infer<typeof manifestOutputSchema>;
 declare const durationSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
 type Duration = z.infer<typeof durationSchema>;
 /**
- * What starts a journey: an event (optionally narrowed to an app id or a
- * list of them), or entry into the segment the trigger itself describes.
- * The registry DTO in `../journeys` reuses it.
+ * What starts a journey: an event, or entry into the segment the trigger
+ * itself describes. The registry DTO in `../journeys` reuses it.
+ *
+ * No trigger names an app (ADR 0022): a repository is one app, the journey
+ * row carries its `app_id`, and the runtime compares that with the event's.
+ * An `appId` here would be a second way to say it, and the way to leak.
  *
  * A segment trigger carries the predicate list, not a name: the push
  * materializes one segment row per journey that inlines a definition, owned
@@ -334,22 +335,20 @@ type Duration = z.infer<typeof durationSchema>;
  * definition is data — validated here, carried on the version, never
  * compiled and never executed.
  *
- * Both members are strict, so a journey holding the retired `source` key, or
- * the retired `{ segment: "name" }` form, fails to build instead of silently
- * triggering on every app or on nothing. There is deliberately no pipe
- * filter: a trigger narrows by the app the write is attributed to, the same
- * token a segment definition names.
+ * Both members are strict, so a journey holding the retired `source` or
+ * `appId` key, or the retired `{ segment: "name" }` form, fails to build
+ * instead of silently triggering on every app or on nothing. There is
+ * deliberately no pipe filter and no app filter: the journey's own app is
+ * the only narrowing there is.
  */
 declare const triggerSchema: z.ZodUnion<readonly [z.ZodObject<{
   event: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-  appId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
 }, z.core.$strict>, z.ZodObject<{
   segment: z.ZodObject<{
     match: z.ZodDefault<z.ZodEnum<{
       all: "all";
       any: "any";
     }>>;
-    appId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
     predicates: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
       kind: z.ZodLiteral<"trait">;
       name: z.ZodString;

package/dist/guest/{journeys-Dpsp225V.js → journeys-F8Yk8s1P.js}

@@ -4,6 +4,34 @@ import { z } from "zod";
 /** The public docs site, for the mail and the pages that point people at it. */
 const DOCS_URL = "https://docs.cowliss.com";
 /**
+* Stripe-style ID prefixes per resource type, so ids in logs, URLs, and
+* payloads are self-describing.
+*/
+const ID_PREFIXES = {
+	user: "usr_",
+	event: "evt_",
+	identifier: "idn_",
+	segment: "seg_",
+	/** The attribution unit: a readable `app_<slug>`, not a TypeID. */
+	app: "app_",
+	/** One inbound pipe into an app; a TypeID like everything else. */
+	source: "src_",
+	webhook: "whk_",
+	push: "psh_",
+	version: "ver_",
+	execution: "exe_",
+	delivery: "dlv_",
+	violation: "vio_",
+	quarantineEntry: "qtn_",
+	idempotencyKey: "idk_",
+	abuseEvent: "abu_",
+	suppression: "sup_",
+	senderDomain: "dom_",
+	journeyRun: "run_",
+	topup: "top_",
+	emailAddress: "eml_"
+};
+/**
 * Clerk ID prefix marking an organization-scoped subject. Ingestion API keys
 * must resolve to an org subject; user-scoped keys are rejected.
 */
@@ -71,21 +99,18 @@ const COW_CONFIG_SCHEMA_URL = `${DOCS_URL}${COW_CONFIG_SCHEMA_PATH}`;
 * history, combined with `all` or `any`. Deliberately flat — nested predicate groups are YAGNI for the
 * prototype, and a flat list keeps the pure evaluator a fold.
 *
-* `appId` scopes the EVENT side of a definition only. Traits are
-* per-profile and profiles merge across apps, so there is nothing
-* app-shaped to filter on the trait side.
-*
-* A definition and the membership it produces are both the
-* organization's.
+* A definition names no app (ADR 0022): the segment row's own `app_id` is
+* the one app it evaluates, so the events and the profiles it reads are
+* that app's and there is nothing to filter by here.
 *
 * Apart from `./segments` because a journey's trigger carries a definition
 * and the trigger schema is bundled into the wasm guest, where an edge to
 * `@cowliss/db` (which `./segments` has, for the row schema) is a hard
 * bundler failure. Nothing here imports anything but zod.
 *
-* The object is strict: a definition holding the retired `sourceId` key
-* (which meant the app) fails loudly instead of parsing as an unfiltered
-* definition that evaluates over every app. There is deliberately no pipe
+* The object is strict: a definition holding the retired `sourceId` or
+* `appId` key (both of which meant the app) fails loudly instead of parsing
+* as an unfiltered definition that evaluates over every app. There is deliberately no pipe
 * filter here — filtering by source is a later feature, and accepting one
 * now would make a stale `sourceId` parse as a filter on a pipe that does
 * not exist and silently match nothing.
@@ -138,15 +163,8 @@ const segmentPredicateSchema = z.discriminatedUnion("kind", [z.object({
 	/** Rolling window, relative to evaluation time; absent means all history. */
 	withinDays: z.number().int().min(1).optional()
 })]).refine((predicate) => predicate.kind !== "trait" || VALUELESS_TRAIT_OPS.includes(predicate.op) || predicate.value !== void 0, { message: "value is required unless op is exists or notExists" });
-const appIdSchema = z.string().trim().min(1);
 const segmentDefinitionSchema = z.strictObject({
 	match: z.enum(["all", "any"]).default("all"),
-	/**
-	* Optional app filter over the event side; null/absent spans apps.
-	* A list matches any of the named apps, which is how one definition
-	* names the development and the production id of the same app.
-	*/
-	appId: z.union([appIdSchema, z.array(appIdSchema).min(1)]).nullish(),
 	predicates: z.array(segmentPredicateSchema).min(1, "at least one predicate is required")
 });
 
@@ -259,9 +277,12 @@ const purposesSchema = z.array(declaredPurposeSchema).max(20, "a project declare
 const onePatternSchema = z.string().min(1).max(200, "a pattern must be at most 200 characters");
 const patternSchema = z.union([onePatternSchema, z.array(onePatternSchema).min(1).max(20, "a matcher takes at most 20 patterns")]);
 /**
-* What starts a journey: an event (optionally narrowed to an app id or a
-* list of them), or entry into the segment the trigger itself describes.
-* The registry DTO in `../journeys` reuses it.
+* What starts a journey: an event, or entry into the segment the trigger
+* itself describes. The registry DTO in `../journeys` reuses it.
+*
+* No trigger names an app (ADR 0022): a repository is one app, the journey
+* row carries its `app_id`, and the runtime compares that with the event's.
+* An `appId` here would be a second way to say it, and the way to leak.
 *
 * A segment trigger carries the predicate list, not a name: the push
 * materializes one segment row per journey that inlines a definition, owned
@@ -270,16 +291,13 @@ const patternSchema = z.union([onePatternSchema, z.array(onePatternSchema).min(1
 * definition is data — validated here, carried on the version, never
 * compiled and never executed.
 *
-* Both members are strict, so a journey holding the retired `source` key, or
-* the retired `{ segment: "name" }` form, fails to build instead of silently
-* triggering on every app or on nothing. There is deliberately no pipe
-* filter: a trigger narrows by the app the write is attributed to, the same
-* token a segment definition names.
+* Both members are strict, so a journey holding the retired `source` or
+* `appId` key, or the retired `{ segment: "name" }` form, fails to build
+* instead of silently triggering on every app or on nothing. There is
+* deliberately no pipe filter and no app filter: the journey's own app is
+* the only narrowing there is.
 */
-const triggerSchema = z.union([z.strictObject({
-	event: patternSchema,
-	appId: patternSchema.optional()
-}), z.strictObject({ segment: segmentDefinitionSchema })]);
+const triggerSchema = z.union([z.strictObject({ event: patternSchema }), z.strictObject({ segment: segmentDefinitionSchema })]);
 /**
 * The address half of a from-header: a local part, an `@`, and a dotted
 * domain. Deliberately narrower than RFC 5322 (no quoted local parts, no
@@ -501,30 +519,56 @@ const versionManifestSchema = z.union([manifestJourneySchema, manifestTemplateSc
 //#endregion
 //#region ../../packages/shared/src/journeys-v2/config.ts
 /**
-* A project's name: what `cow init` asked for, and what the `projects` row
-* stores. Lives here rather than beside the release DTOs because `cow.json`
-* is the file a developer types it into; `createProjectBodySchema` reuses it.
+* An app id as `cow.json` carries it: the readable `app_<slug>`
+* `appIdFromName` derives, which is the one id a developer types by hand.
+*
+* It lives here rather than beside the app DTOs in ../apps because that
+* module imports the Drizzle schema, which neither the wasmtime guest nor
+* the Temporal workflow isolate can carry, and because `cow.json` is the
+* file a developer types it into. Everything that names an app on the wire
+* reuses it.
+*/
+const appIdSchema = z.string().trim().max(200).regex(new RegExp(`^${ID_PREFIXES.app}[a-z0-9]+(-[a-z0-9]+)*$`), "an app id looks like \"app_website\"");
+/**
+* A source id: the one inbound pipe an ingestion or send call names. It
+* lives beside `appIdSchema` for the same two reasons — the sources module
+* imports the Drizzle schema, and both are ids that travel on the wire — and
+* it has the same shape, so a bare `src_` is refused here rather than at the
+* database.
+*
+* The prefixes above and here are interpolated raw; `journeys-v2.test.ts`
+* asserts they are plain `<word>_` literals, so none of them can quietly
+* change what these patterns match.
 */
-const projectNameSchema = z.string().trim().min(1).max(200);
+const sourceIdSchema = z.string().trim().max(200).regex(new RegExp(`^${ID_PREFIXES.source}[a-z0-9_]+$`), "a source id looks like \"src_01j8x…\"");
 /**
-* `cow.json` (spec: Project layout): the org, and which of its projects this
-* directory is. Auth never lives in the project. Strict, so a typo'd key
-* is a build error rather than a silently ignored setting.
+* A Clerk organization id, as `cow.json` spells it. Exported beside
+* `appIdSchema` because the push body carries the org the file names so the
+* server can refuse a push aimed at another one (ADR 0022).
+*/
+const orgIdSchema = z.string().trim().max(200).startsWith(CLERK_ORG_SUBJECT_PREFIX, "orgId must be a Clerk org id");
+/**
+* `cow.json` (spec: Project layout): the org, and which of its apps this
+* repository pushes to. Auth never lives in the file. Strict, so a typo'd
+* key is a build error rather than a silently ignored setting — which is
+* also what turns the retired `project` key into a refusal (`cow build`
+* says what to rename it to).
 */
 const cowConfigSchema = z.strictObject({
 	$schema: z.url().optional(),
-	orgId: z.string().startsWith(CLERK_ORG_SUBJECT_PREFIX, "orgId must be a Clerk org id"),
+	orgId: orgIdSchema,
 	/**
-	* Which project of the org this directory pushes to. One org can hold
-	* several, one per repo, each with its own release sequence and its own
-	* slice of the deployed journeys, so every project says which it is.
+	* Which app of the org this repository pushes to (ADR 0022). The app is
+	* the push unit: it owns the journey and template keys, and `cow
+	* status`, `cow enable --all` and `cow pull` all resolve against it. One
+	* repository is one app, so no journey file names one.
 	*/
-	project: projectNameSchema,
+	appId: appIdSchema,
 	/**
-	* The consent purposes this project declares. They are org-wide, so two
-	* projects declaring one key must agree on its label and default or the
-	* deploy is refused; a deploy adds and updates them and never deletes
-	* one, because profiles hold answers against them.
+	* The consent purposes this repository declares. They are org-wide, so
+	* two apps declaring one key must agree on its label and default or the
+	* push is refused; a push adds and updates them and never deletes one,
+	* because profiles hold answers against them.
 	*/
 	purposes: purposesSchema.optional(),
 	/** Overrides the API the CLI talks to; the hosted product needs none. */
@@ -537,7 +581,7 @@ const cowConfigSchema = z.strictObject({
 	webUrl: z.url().optional()
 }).meta({
 	title: "cow.json",
-	description: "A cow project: the organization and the project it pushes to."
+	description: "A cow project: the organization and the app it pushes to."
 });
 
 //#endregion
@@ -866,6 +910,10 @@ const journeyConfigSchema = manifestJourneySchema.pick({
 *
 * There is no environment gate here: an organization has one data space, and
 * a journey runs wherever it is on and nowhere else (ADR 0011, ADR 0013).
+*
+* There is no app gate either. A journey belongs to the one app `cow.json`
+* names, so it only ever sees that app's events, profiles and segments
+* (ADR 0022); a trigger naming an app is refused rather than honoured.
 */
 function defineJourney(input) {
 	const config = journeyConfigSchema.parse({

package/dist/guest/journeys.d.ts

@@ -1,4 +1,4 @@
-import { i as GuestEvent, n as Trigger, r as TriggerInput, t as Duration } from "./index-3PMqJKmc.js";
+import { i as GuestEvent, n as Trigger, r as TriggerInput, t as Duration } from "./index-EqBCZnpq.js";
 //#region src/guest/journeys.d.ts
 /** The event a journey runs for, or the one a `waitForEvent` resolved with. */
 type Event = GuestEvent;
@@ -32,10 +32,10 @@ declare class CapabilityError extends Error {
   constructor(code: string, message: string);
 }
 /**
- * The project's templates, keyed by template key. `cow build` writes the
+ * The repository's templates, keyed by template key. `cow build` writes the
  * real interface into `.cow/types.d.ts` and TypeScript merges it into this
  * one, which is what types `api.send.email`. Empty here on purpose: a
- * project that has not built yet still compiles, with string keys.
+ * repository that has not built yet still compiles, with string keys.
  */
 interface CowTemplates {}
 type TemplateKey = keyof CowTemplates extends never ? string : keyof CowTemplates;
@@ -122,8 +122,8 @@ type JourneyConfig = {
   trigger: Trigger;
   /**
    * Why this journey contacts someone: `marketing`, `transactional`, or a
-   * purpose this project declares in `cow.json`. The key's shape is checked
-   * here; that the org declares it is checked when the release is deployed.
+   * purpose this repository declares in `cow.json`. The key's shape is
+   * checked here; that the org declares it is checked when the push lands.
    */
   purpose: string;
   /**
@@ -167,12 +167,17 @@ type Journey = JourneyConfig & {
  *
  * There is no environment gate here: an organization has one data space, and
  * a journey runs wherever it is on and nowhere else (ADR 0011, ADR 0013).
+ *
+ * There is no app gate either. A journey belongs to the one app `cow.json`
+ * names, so it only ever sees that app's events, profiles and segments
+ * (ADR 0022); a trigger naming an app is refused rather than honoured.
  */
 declare function defineJourney(input: Omit<JourneyConfig, "tags" | "trigger"> & {
   /**
-   * What starts it: `{ event }`, or `{ segment }` carrying the predicate
-   * list of the segment this journey enrolls from. Written form, so a
-   * predicate can leave `match` and `atLeast` out.
+   * What starts it: `{ event }`, one event-name pattern or a list of
+   * them, or `{ segment }` carrying the predicate list of the segment
+   * this journey enrolls from. Written form, so a predicate can leave
+   * `match` and `atLeast` out. No app: the repository's app is the scope.
    */
   trigger: TriggerInput;
   tags?: string[];

package/dist/guest/journeys.js

@@ -1,3 +1,3 @@
-import { n as defineJourney, t as CapabilityError } from "./journeys-Dpsp225V.js";
+import { n as defineJourney, t as CapabilityError } from "./journeys-F8Yk8s1P.js";
 
 export { CapabilityError, defineJourney };

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-C1bsCjZT.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;