@cowliss/cli 0.3.0 → 0.5.0

package/dist/guest/{journeys-BcbIxxI-.js → journeys-C8j8Sqvl.js}

@@ -9,16 +9,6 @@ const DOCS_URL = "https://docs.cowliss.com";
 */
 const CLERK_ORG_SUBJECT_PREFIX = "org_";
 /**
-* The two fixed environments every org has (spec: Environments). An app
-* belongs to one, so the environment of every write is the app's;
-* profiles, identifiers, events, memberships, journey instances,
-* deliveries, violations, quarantine, the address ledger, and idempotency
-* keys are per environment, while the catalog, sending domains, the
-* suppression mirror, billing, and journey code are shared. A third
-* environment is a one-line change here plus the mirrored db enum.
-*/
-const ENVIRONMENTS = ["development", "production"];
-/**
 * Fixed consent purposes for the prototype. Consent is a per-purpose map on
 * the profile, checked at send-step execution time.
 *
@@ -51,8 +41,8 @@ const EXECUTION_LIMITS = {
 	logLines: 100,
 	logLineBytes: 1024
 };
-/** Per release: manifest counts, bundle size, and the source tarball. */
-const RELEASE_LIMITS = {
+/** Per push: manifest counts, bundle size, and the source tarball. */
+const PUSH_LIMITS = {
 	journeys: 100,
 	templates: 200,
 	bundleBytes: 2097152,
@@ -66,65 +56,13 @@ const RELEASE_LIMITS = {
 const COW_CONFIG_SCHEMA_PATH = "/schemas/cow.json";
 const COW_CONFIG_SCHEMA_URL = `${DOCS_URL}${COW_CONFIG_SCHEMA_PATH}`;
 
-//#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.
-*/
-const projectNameSchema = z.string().trim().min(1).max(200);
-/**
-* `cow.json` (spec: Project layout): the org, and which of its projects this
-* directory is. The environment is always a flag, and auth never lives in
-* the project. Strict, so a typo'd key is a build error rather than a
-* silently ignored setting.
-*/
-const cowConfigSchema = z.strictObject({
-	$schema: z.url().optional(),
-	orgId: z.string().startsWith(CLERK_ORG_SUBJECT_PREFIX, "orgId must be a Clerk org id"),
-	/**
-	* 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.
-	*/
-	project: projectNameSchema,
-	/** Overrides the API the CLI talks to; the hosted product needs none. */
-	apiUrl: z.url().optional(),
-	/**
-	* Overrides the dashboard `cow login` opens. Paired with `apiUrl`: a
-	* login against one Cowliss's dashboard yields a token the other's API
-	* rejects, so a config that names an API names its dashboard too.
-	*/
-	webUrl: z.url().optional()
-}).meta({
-	title: "cow.json",
-	description: "A cow project: the organization and the project it deploys to."
-});
-
-//#endregion
-//#region ../../packages/shared/src/environments.ts
-/**
-* The environment on the wire: the source's `environment` field, the
-* `X-Cow-Environment` header admin calls select with, and the
-* `environment` column every per-environment DTO carries.
-*/
-const environmentSchema = z.enum(ENVIRONMENTS);
-/**
-* The environments a shared definition (a segment, a journey) declares it
-* works on: a non-empty list of distinct values. A definition declaring none
-* would be dead code with a row behind it, and a repeated value is a typo
-* rather than an intent, which is the rule `defineJourney` applies too.
-*/
-const environmentsSchema = z.array(environmentSchema).min(1, "at least one environment is required").refine((values) => new Set(values).size === values.length, { message: "environments must not repeat" });
-
 //#endregion
 //#region ../../packages/shared/src/journeys-v2/manifest.ts
 /**
-* The release manifest (spec: Build; Push and compile): what `cow build`
+* The pushed manifest (spec: Build; Push and compile): what `cow build`
 * extracts from a project and `cow push` uploads with the bundles. The
-* server validates it with these schemas, compiles every bundle, and stores
-* the compiled form on the release row.
+* server validates it with these schemas, compiles every bundle whose key
+* changed, and stores that entry on the version it creates.
 */
 /**
 * A journey or template key: the file basename under `journeys/` or
@@ -147,6 +85,50 @@ const journeyKeySchema = z.string().max(64).regex(JOURNEY_KEY_PATTERN, "key must
 */
 const tagsSchema = z.array(z.string().trim().min(1).max(50, "a tag must be at most 50 characters")).max(20, "a journey or template takes at most 20 tags").default([]).transform((tags) => [...new Set(tags)]);
 /**
+* A consent purpose key: camelCase, matching the fixed `emailMarketing` and
+* `dataProcessing`. Purposes are keys in the `consent` map a customer reads
+* on their own profile, which is why they are not the kebab-case of a
+* journey key.
+*/
+const CONSENT_PURPOSE_KEY_PATTERN = /^[a-z][a-zA-Z0-9]*$/;
+/**
+* One purpose key wherever a key is named rather than declared: a journey's
+* `purpose`, and the keys of the consent patch an identify carries. The set
+* a key is checked against is the org's declared rows, which no schema can
+* see, so validation here is the shape only; the deploy and the ingestion
+* write refuse a key the org has not declared.
+*/
+const consentPurposeKeySchema = z.string().max(50, "a purpose key must be at most 50 characters").regex(CONSENT_PURPOSE_KEY_PATTERN, "a consent purpose key must be camelCase (a letter first, then letters and digits)");
+/**
+* One purpose a project declares in `cow.json` (spec: Decisions). A declared
+* purpose is marketing-class and sits under the `emailMarketing` umbrella,
+* so `denied` is the only default it may carry: the purpose is absent on
+* every profile that already exists, and a granted default would answer for
+* all of them at once.
+*
+* The field stays required rather than disappearing, so every `cow.json` and
+* every stored manifest written before this still parses, and the column
+* behind it still holds `granted` for the seeded `dataProcessing` row: this
+* is a refusal at declaration time, not a narrower storage shape.
+*
+* The two fixed purposes cannot be declared. They are seeded for every org
+* and owned by no project, so a project redeclaring one would be renaming
+* the master switch every other project's journeys hang off.
+*/
+const declaredPurposeSchema = z.strictObject({
+	key: consentPurposeKeySchema.refine((key) => !CONSENT_PURPOSES.includes(key), `${CONSENT_PURPOSES.join(" and ")} are fixed purposes and cannot be declared`),
+	/** What the dashboard and the account modal render beside the switch. */
+	label: z.string().trim().min(1).max(50, "a purpose label must be at most 50 characters"),
+	/** What the purpose means for a profile whose map does not answer it. */
+	default: z.literal("denied", "a declared purpose's \"default\" must be \"denied\": nobody has answered it yet, and a granted default would opt every profile you already have into it")
+});
+/**
+* The purposes one project declares. Capped low the way tags are: a purpose
+* is a category a recipient reads on a preferences switch, not a taxonomy.
+* Absent means the project declares none, which is every project today.
+*/
+const purposesSchema = z.array(declaredPurposeSchema).max(20, "a project declares at most 20 consent purposes");
+/**
 * A matcher field: one pattern or a non-empty list of them, a list being a
 * disjunction. See `matchesPattern` in ../patterns for the dialect (`*`
 * only) and for why a pattern whose literal prefix is not `system.` never
@@ -160,7 +142,7 @@ const patternSchema = z.union([onePatternSchema, z.array(onePatternSchema).min(1
 * reuses it.
 *
 * Both members are strict, so a journey holding the retired `source` key
-* fails to compile a release instead of silently triggering on every app.
+* fails to compile instead of silently triggering on every app.
 * There is deliberately no pipe filter: a trigger narrows by the app the
 * write is attributed to, the same token a segment definition names.
 */
@@ -168,14 +150,29 @@ const triggerSchema = z.union([z.strictObject({
 	event: patternSchema,
 	appId: patternSchema.optional()
 }), z.strictObject({ segment: z.string().min(1) })]);
+/**
+* A destination's name: the token a journey addresses it by, in a
+* `send.webhook` call or a journey's `senderIdentity`.
+*
+* Defined here rather than beside the destinations contract, and imported
+* from here by it, because a journey manifest names one and the guest layer
+* is bundled into every tenant module: importing it the other way round
+* would pull the Drizzle destinations table into all of them.
+*/
+const destinationNameSchema = z.string().trim().min(1, "name is required").max(100, "name must be at most 100 characters");
 /** A content address: `sha256:` plus the lowercase hex digest. */
 const digestSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/, "digest must be sha256:<64 hex>");
-/** The names of the capability calls a journey may make. */
+/**
+* The names of the capability calls a journey may make. Grouped by verb and
+* then channel (`send.email`, not `email.send`), because the verb is the
+* thing a journey author is choosing between and the name should read the
+* way the code is written.
+*/
 const COMMAND_NAMES = [
 	"sleep",
 	"waitForEvent",
-	"email.send",
-	"webhook.send",
+	"send.email",
+	"send.webhook",
 	"traits.set",
 	"traits.unset",
 	"profile.get",
@@ -184,23 +181,65 @@ const COMMAND_NAMES = [
 	"restart"
 ];
 /**
-* One entry of the step spine `cow build` records by running `run` once
-* against a recording stub. Display only, never trusted: a journey's real
-* control flow is whatever its code does at runtime. `detail` names the
-* template, destination, event, or trait key when the call has one.
+* What a spine entry can be: every capability call, plus the control flow
+* `cow build` reads off the journey's source: an `if` (a condition, with
+* `steps` and `otherwise`), a `loop` (with `steps` as its body), and the `end`
+* of a path.
 */
+const SPINE_ENTRY_NAMES = [
+	...COMMAND_NAMES,
+	"if",
+	"loop",
+	"end"
+];
 const spineEntrySchema = z.object({
-	name: z.enum(COMMAND_NAMES),
-	detail: z.string().max(200).optional()
-});
+	name: z.enum(SPINE_ENTRY_NAMES),
+	detail: z.string().max(200).optional(),
+	/**
+	* The sender identity a `send.email` call named for itself, overriding
+	* the journey's own. Present only when the author wrote one on the call,
+	* which is what lets the deploy warning and the journey detail page name
+	* the override without re-reading the code.
+	*/
+	senderIdentity: z.string().max(100).optional(),
+	/** A `waitForEvent` timeout, as the author wrote it. */
+	timeout: z.string().max(50).optional(),
+	get steps() {
+		return z.array(spineEntrySchema).optional();
+	},
+	get otherwise() {
+		return z.array(spineEntrySchema).optional();
+	}
+}).meta({ id: "JourneySpineEntry" });
+/**
+* One journey in a stored manifest. A plain (non-strict) object on purpose:
+* a manifest pushed before the author's rollout gate went away still carries
+* `environments`, and every stored manifest has to keep parsing for good
+* (ADR 0011). Zod strips the key, and the journey runs wherever the
+* per-environment enabled flag says it runs, which is the one gate there is.
+*/
 const manifestJourneySchema = z.object({
 	key: journeyKeySchema,
 	/** The author's labels; the dashboard's only grouping. */
 	tags: tagsSchema,
 	trigger: triggerSchema,
-	purpose: z.enum(CONSENT_PURPOSES),
-	/** The author's rollout gate: the journey is active only in these. */
-	environments: environmentsSchema,
+	/**
+	* A fixed purpose or one the project declares. Checked against the org's
+	* declared set at push time, not here: a manifest is built and pushed
+	* without ever reaching the org whose rows say what exists.
+	*/
+	purpose: consentPurposeKeySchema,
+	/**
+	* The sender identity every `send.email` in this journey goes out as,
+	* unless the call names its own. A name, never a `dst_` id: an org has one
+	* row per environment, so an id would send in production and fail in
+	* development, which is the one thing a journey must not do.
+	*
+	* Optional here and required at `defineJourney`, exactly like `purposes`: a
+	* version pushed before the field existed carries none and its stored
+	* manifest still parses. The author's build is where the error is useful.
+	*/
+	senderIdentity: destinationNameSchema.optional(),
 	spine: z.array(spineEntrySchema),
 	bundle: digestSchema
 });
@@ -230,40 +269,87 @@ function uniqueKeys(items, ctx, path) {
 		seen.add(item.key);
 	}
 }
-/** What `cow build` writes to `.cow/build/manifest.json` and `cow push` sends. */
+/**
+* What `cow build` writes to `.cow/build/manifest.json`, and the shape a
+* push row stores for good, entry by entry, on the versions it creates.
+*
+* `protocol` is any positive integer rather than the current constant on
+* purpose: a version is immutable and an execution stays pinned to the one
+* it started on, so the day the protocol is bumped every stored push must
+* still parse, or the runner and every API response the client validates
+* break at once for any org with history. The literal lives at push time
+* only (`createPushBodySchema`), which is where a stale CLI is the
+* developer's own fixable problem, and the runner refuses a version built
+* for another protocol with a message naming both numbers.
+*/
 const manifestSchema = z.object({
-	protocol: z.literal(1),
+	protocol: z.number().int().positive(),
 	/** The `@cowliss/cli` version the project was built with. */
 	sdk: z.string().min(1),
-	journeys: z.array(manifestJourneySchema).max(RELEASE_LIMITS.journeys),
-	templates: z.array(manifestTemplateSchema).max(RELEASE_LIMITS.templates),
+	journeys: z.array(manifestJourneySchema).max(PUSH_LIMITS.journeys),
+	templates: z.array(manifestTemplateSchema).max(PUSH_LIMITS.templates),
+	/**
+	* The consent purposes this project declares, copied from `cow.json`.
+	* Optional rather than defaulted: a push made before purposes existed
+	* carries none, and its stored manifest still parses.
+	*/
+	purposes: purposesSchema.optional(),
 	/** Digest of the gzipped source tarball. */
 	source: digestSchema
 }).superRefine((manifest, ctx) => {
 	uniqueKeys(manifest.journeys, ctx, "journeys");
 	uniqueKeys(manifest.templates, ctx, "templates");
+	uniqueKeys(manifest.purposes ?? [], ctx, "purposes");
 });
 /**
-* The manifest as the release row stores it once compilation succeeded:
-* the pushed manifest plus the compiled module digest per key, and the
-* digest of the Javy engine plugin the toolchain that compiled them was
-* built from.
-*
-* Journeys and templates are keyed separately because they share a key
-* space: `welcome.ts` and `welcome.tsx` are one journey and the email it
-* sends in every example, and a flat map would let one overwrite the other.
-*
-* `plugin` is a toolchain record, not a linked artifact: modules are
-* statically linked, so the plugin bytes are inside each module. It says
-* which engine compiled the release, which is what a later bug report or a
-* reproducible rebuild needs.
+* One entry of a stored manifest: what a version is a snapshot of. Journeys
+* and templates are kept apart because they share a key space (`welcome.ts`
+* and `welcome.tsx` are one journey and the email it sends in every
+* example), and the version's own `kind` says which of the two this is.
 */
-const compiledManifestSchema = manifestSchema.safeExtend({
-	modules: z.object({
-		journeys: z.record(journeyKeySchema, digestSchema),
-		templates: z.record(journeyKeySchema, digestSchema)
-	}),
-	plugin: digestSchema
+const versionManifestSchema = z.union([manifestJourneySchema, manifestTemplateSchema]);
+
+//#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.
+*/
+const projectNameSchema = z.string().trim().min(1).max(200);
+/**
+* `cow.json` (spec: Project layout): the org, and which of its projects this
+* directory is. The environment is always a flag, and auth never lives in
+* the project. Strict, so a typo'd key is a build error rather than a
+* silently ignored setting.
+*/
+const cowConfigSchema = z.strictObject({
+	$schema: z.url().optional(),
+	orgId: z.string().startsWith(CLERK_ORG_SUBJECT_PREFIX, "orgId must be a Clerk org id"),
+	/**
+	* 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.
+	*/
+	project: projectNameSchema,
+	/**
+	* 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.
+	*/
+	purposes: purposesSchema.optional(),
+	/** Overrides the API the CLI talks to; the hosted product needs none. */
+	apiUrl: z.url().optional(),
+	/**
+	* Overrides the dashboard `cow login` opens. Paired with `apiUrl`: a
+	* login against one Cowliss's dashboard yields a token the other's API
+	* rejects, so a config that names an API names its dashboard too.
+	*/
+	webUrl: z.url().optional()
+}).meta({
+	title: "cow.json",
+	description: "A cow project: the organization and the project it pushes to."
 });
 
 //#endregion
@@ -308,14 +394,21 @@ const commandSchema = z.discriminatedUnion("name", [
 		})
 	}),
 	z.object({
-		name: z.literal("email.send"),
+		name: z.literal("send.email"),
 		args: z.strictObject({
 			template: journeyKeySchema,
-			props: properties
+			props: properties,
+			/**
+			* Which sender identity this mail leaves as, by name. Required, and
+			* the guest SDK fills in the journey's own when the call does not name
+			* one, so the host has one resolution path and never has to read the
+			* manifest to find a sender.
+			*/
+			senderIdentity: destinationNameSchema
 		})
 	}),
 	z.object({
-		name: z.literal("webhook.send"),
+		name: z.literal("send.webhook"),
 		args: z.strictObject({
 			destination: z.string().min(1),
 			payload: properties
@@ -392,7 +485,7 @@ const executionLimitsSchema = z.object({
 	logLineBytes: z.number().int().positive()
 });
 const journeyStepInputSchema = z.object({
-	protocol: z.literal(1),
+	protocol: z.literal(2),
 	kind: z.literal("journey"),
 	key: journeyKeySchema,
 	event: guestEventSchema,
@@ -432,7 +525,7 @@ const journeyStepOutputSchema = z.discriminatedUnion("status", [
 	})
 ]);
 const templateRenderInputSchema = z.object({
-	protocol: z.literal(1),
+	protocol: z.literal(2),
 	kind: z.literal("template"),
 	key: journeyKeySchema,
 	props: properties
@@ -451,7 +544,7 @@ const manifestInputSchema = z.object({ kind: z.literal("manifest") });
 const manifestOutputSchema = z.discriminatedUnion("kind", [manifestJourneySchema.pick({
 	trigger: true,
 	purpose: true,
-	environments: true,
+	senderIdentity: true,
 	tags: true
 }).extend({ kind: z.literal("journey") }), manifestTemplateSchema.pick({
 	sendClass: true,
@@ -563,22 +656,29 @@ var CapabilityError = class extends Error {
 };
 /**
 * The config half of a journey, validated with the same schema the release
-* manifest is validated with, so a bad trigger or an unknown purpose fails
-* at build time rather than at the first execution.
+* manifest is validated with, so a bad trigger or a malformed purpose key
+* fails at build time rather than at the first execution. Whether the org
+* declares that purpose is a question only the deploy can answer.
 */
 const journeyConfigSchema = manifestJourneySchema.pick({
 	trigger: true,
 	purpose: true,
-	environments: true,
+	senderIdentity: true,
 	tags: true
-});
-/** Author a journey. Throws at definition time on an invalid config. */
+}).extend({ senderIdentity: destinationNameSchema });
+/**
+* Author a journey. Throws at definition time on an invalid config.
+*
+* There is no environment gate here: a journey runs wherever it is enabled,
+* and nowhere else (ADR 0011). A source that still passes `environments` is
+* a typecheck error in `cow build`, which is where the author can fix it.
+*/
 function defineJourney(input) {
 	return {
 		...journeyConfigSchema.parse({
 			trigger: input.trigger,
 			purpose: input.purpose,
-			environments: input.environments ?? [...ENVIRONMENTS],
+			senderIdentity: input.senderIdentity,
 			tags: input.tags
 		}),
 		run: input.run

package/dist/guest/journeys.d.ts

@@ -1,5 +1,4 @@
-import { n as Duration, r as GuestEvent, t as Trigger } from "./index-heC1gFE_.js";
-import { n as Environment, t as ConsentPurpose } from "./constants-OZrYz4I2.js";
+import { n as Duration, r as GuestEvent, t as Trigger } from "./index-BDj02EsQ.js";
 //#region src/guest/journeys.d.ts
 /** The event a journey runs for, or the one a `waitForEvent` resolved with. */
 type Event = GuestEvent;
@@ -13,12 +12,12 @@ type Profile = {
   id: string;
   traits: Record<string, unknown>;
   /** Consent state per purpose; the send gates read it host-side too. */
-  consent: Record<ConsentPurpose, boolean>;
+  consent: Record<string, boolean>;
   identifiers: Record<string, string>;
   /** Names of the segments the profile is currently in. */
   segments: string[];
 };
-/** What `api.email.send` resolves to once the host accepted the send. */
+/** What `api.send.email` resolves to once the host accepted the send. */
 type EmailSendResult = {
   deliveryId: string;
   status: string;
@@ -35,7 +34,7 @@ declare class CapabilityError extends Error {
 /**
  * The project'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.email.send`. Empty here on purpose: a
+ * one, which is what types `api.send.email`. Empty here on purpose: a
  * project that has not built yet still compiles, with string keys.
  */
 interface CowTemplates {}
@@ -60,14 +59,22 @@ type Api = {
   waitForEvent(pattern: string | string[], options: {
     timeout: Duration;
   }): Promise<Event | null>;
-  email: {
-    send<Key extends TemplateKey>(args: {
+  /**
+   * The two things a journey sends. Grouped by the verb rather than by the
+   * channel, because the verb is what an author is choosing between.
+   */
+  send: {
+    email<Key extends TemplateKey>(args: {
       template: Key;
       props: TemplateProps<Key>;
+      /**
+       * Send this one mail from a different sender identity than the
+       * journey's own. A name the organization has configured, resolved in
+       * the environment the execution is running in.
+       */
+      senderIdentity?: string;
     }): Promise<EmailSendResult>;
-  };
-  webhook: {
-    send(args: {
+    webhook(args: {
       destination: string;
       payload: Record<string, unknown>;
     }): Promise<void>;
@@ -108,18 +115,37 @@ type Api = {
  */
 type JourneyConfig = {
   trigger: Trigger;
-  purpose: ConsentPurpose;
-  /** The author's rollout gate; defaults to every environment. */
-  environments: Environment[];
+  /**
+   * A fixed purpose (`emailMarketing`, `dataProcessing`) or one 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: string;
+  /**
+   * The sender identity every `api.send.email` in this journey goes out as:
+   * the name of one your organization has configured, or `cowliss-default`
+   * for the address Cowliss gives you with nothing to set up. A single send
+   * can override it.
+   *
+   * Required, and named here rather than in a settings page, so the address
+   * a journey sends from is readable in the journey's own source. It is
+   * resolved per environment, which is why it is a name and not an id.
+   */
+  senderIdentity: string;
   /** The author's labels; the dashboard's only grouping. Defaults to none. */
   tags: string[];
 };
 type Journey = JourneyConfig & {
   run: (event: Event, api: Api) => Promise<void>;
 };
-/** Author a journey. Throws at definition time on an invalid config. */
-declare function defineJourney(input: Omit<JourneyConfig, "environments" | "tags"> & {
-  environments?: Environment[];
+/**
+ * Author a journey. Throws at definition time on an invalid config.
+ *
+ * There is no environment gate here: a journey runs wherever it is enabled,
+ * and nowhere else (ADR 0011). A source that still passes `environments` is
+ * a typecheck error in `cow build`, which is where the author can fix it.
+ */
+declare function defineJourney(input: Omit<JourneyConfig, "tags"> & {
   tags?: string[];
   run: (event: Event, api: Api) => Promise<void>;
 }): Journey;

package/dist/guest/journeys.js

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

package/dist/guest/wasi.js

@@ -1,4 +1,4 @@
-import { t as runGuest } from "./driver-M6LQVMr2.js";
+import { t as runGuest } from "./driver-14FnzM-h.js";
 
 //#region src/guest/wasi.ts
 const STDIN = 0;