@cowliss/cli 0.10.0 → 0.11.0

package/blueprints/saas-trial/scenarios/trial-ended.converted.json

@@ -0,0 +1,16 @@
+{
+  "user": {
+    "id": "usr_1",
+    "traits": { "email": "ada@example.com", "firstName": "Ada" }
+  },
+  "events": [{ "at": "5d", "event": "subscription.created" }],
+  "expect": [
+    {
+      "activity": "sendEmail",
+      "input": {
+        "template": "trial-converted",
+        "props": { "firstName": "Ada" }
+      }
+    }
+  ]
+}

package/blueprints/saas-trial/scenarios/trial-ended.expired.json

@@ -0,0 +1,13 @@
+{
+  "user": {
+    "id": "usr_1",
+    "traits": { "email": "ada@example.com", "firstName": "Ada" }
+  },
+  "events": [],
+  "expect": [
+    {
+      "activity": "sendEmail",
+      "input": { "template": "trial-ended", "props": { "firstName": "Ada" } }
+    }
+  ]
+}

package/blueprints/saas-trial/scenarios/trial-ending.activated.json

@@ -0,0 +1,20 @@
+{
+  "user": {
+    "id": "usr_1",
+    "traits": {
+      "email": "ada@example.com",
+      "firstName": "Ada",
+      "activated": true
+    }
+  },
+  "events": [],
+  "expect": [
+    {
+      "activity": "sendEmail",
+      "input": {
+        "template": "trial-ending-activated",
+        "props": { "firstName": "Ada" }
+      }
+    }
+  ]
+}

package/blueprints/saas-trial/scenarios/trial-ending.converted.json

@@ -0,0 +1,12 @@
+{
+  "user": {
+    "id": "usr_1",
+    "traits": {
+      "email": "ada@example.com",
+      "firstName": "Ada",
+      "activated": true
+    }
+  },
+  "events": [{ "at": "5d", "event": "subscription.created" }],
+  "expect": []
+}

package/blueprints/saas-trial/scenarios/trial-ending.unactivated.json

@@ -0,0 +1,16 @@
+{
+  "user": {
+    "id": "usr_1",
+    "traits": { "email": "ada@example.com", "firstName": "Ada" }
+  },
+  "events": [],
+  "expect": [
+    {
+      "activity": "sendEmail",
+      "input": {
+        "template": "trial-ending-unactivated",
+        "props": { "firstName": "Ada" }
+      }
+    }
+  ]
+}

package/blueprints/saas-trial/scenarios/trial-welcome.started.json

@@ -0,0 +1,13 @@
+{
+  "user": {
+    "id": "usr_1",
+    "traits": { "email": "ada@example.com", "firstName": "Ada" }
+  },
+  "events": [],
+  "expect": [
+    {
+      "activity": "sendEmail",
+      "input": { "template": "trial-welcome", "props": { "firstName": "Ada" } }
+    }
+  ]
+}

package/blueprints/saas-trial/segments/activated-users.ts

@@ -0,0 +1,25 @@
+import { defineSegment } from "@cowliss/cli/segments";
+
+/**
+ * Reached the activation milestone: created at least one project, ever.
+ * No trial predicate, so someone who activates and then subscribes stays
+ * in — this is the audience you compare everything else against, and it
+ * would tell you nothing if people dropped out of it on payday.
+ *
+ * Named `activated-users` and not `activated`: a segment name and a
+ * journey key share one namespace per organization, and the journey that
+ * congratulates someone for getting here is called `activated`.
+ *
+ * Change `project.created` to your own milestone here and in
+ * `unactivated.ts` together. A milestone that means one thing in one file
+ * and another in the other is how a person ends up nudged to do what they
+ * have already done.
+ */
+export default defineSegment({
+  description: "Created at least one project.",
+  tags: ["saas", "activation"],
+  match: "all",
+  predicates: [
+    { kind: "event", name: "project.created", op: "performed", atLeast: 1 },
+  ],
+});

package/blueprints/saas-trial/segments/converted.ts

@@ -0,0 +1,28 @@
+import { defineSegment } from "@cowliss/cli/segments";
+
+/**
+ * Paying: sent `subscription.created` at least once.
+ *
+ * No journey in this blueprint enrolls from it, and that is on purpose.
+ * It is here because it is the number the business watches, because it is
+ * what `trialing` is defined against, and because it is the audience you
+ * want on hand the day you write the programme that comes after the trial
+ * — onboarding, expansion, renewal — which is a different set of files
+ * from this one.
+ *
+ * A segment does not need a journey to earn its place. The dashboard
+ * counts it, and every other audience here is drawn relative to it.
+ */
+export default defineSegment({
+  description: "Subscribed to a paid plan.",
+  tags: ["saas", "revenue"],
+  match: "all",
+  predicates: [
+    {
+      kind: "event",
+      name: "subscription.created",
+      op: "performed",
+      atLeast: 1,
+    },
+  ],
+});

package/blueprints/saas-trial/segments/trialing.ts

@@ -0,0 +1,26 @@
+import { defineSegment } from "@cowliss/cli/segments";
+
+/**
+ * Started a trial and has not subscribed. Both predicates matter: the
+ * first is the trial, the second is what takes someone out of it the
+ * moment they pay, so the trial journeys stop on their own rather than
+ * checking for a subscription at every step.
+ *
+ * A file rather than a trigger's inline definition (ADR 0023) because the
+ * dashboard reads it too: this is the audience whose size is the answer to
+ * "how many trials are open right now".
+ *
+ * `trial.started` is the one event you have to send yourself; the other
+ * three are things your product already does. If yours is called
+ * `Trial Started` or `signup_completed`, change the name here and in
+ * `unactivated.ts` rather than renaming the event in your own app.
+ */
+export default defineSegment({
+  description: "In a trial: started one and has not subscribed.",
+  tags: ["saas", "trial"],
+  match: "all",
+  predicates: [
+    { kind: "event", name: "trial.started", op: "performed", atLeast: 1 },
+    { kind: "event", name: "subscription.created", op: "notPerformed" },
+  ],
+});

package/blueprints/saas-trial/segments/unactivated.ts

@@ -0,0 +1,27 @@
+import { defineSegment } from "@cowliss/cli/segments";
+
+/**
+ * Started a trial and has not reached the activation milestone yet. This
+ * is the audience the whole programme is built around: what people in it
+ * do next decides your conversion rate.
+ *
+ * `project.created` is the milestone, and it is the one line in this
+ * blueprint most people will change. It stands in for the moment someone
+ * has actually used your product rather than looked at it, so pick the
+ * event that means that for yours: a workspace created, a first API call,
+ * a repository connected, a document shared. Whatever you pick, name it
+ * here and in `activated-users.ts`, and the four journeys follow.
+ *
+ * Nobody leaves this audience by waiting. They leave it by activating, and
+ * they never come back, so a journey enrolling from it runs once per
+ * person.
+ */
+export default defineSegment({
+  description: "In a trial and has not created a project yet.",
+  tags: ["saas", "activation"],
+  match: "all",
+  predicates: [
+    { kind: "event", name: "trial.started", op: "performed", atLeast: 1 },
+    { kind: "event", name: "project.created", op: "notPerformed" },
+  ],
+});

package/{examples → blueprints}/winback/journeys/winback.ts

@@ -1,10 +1,14 @@
 import { defineJourney } from "@cowliss/cli/journeys";
 
 /**
- * Winback: `purchase_completed` starts (or restarts) an execution and marks
- * the profile as having bought recently; every further purchase inside 30
- * days resets the silence clock; after 30 days of silence the flag is unset
- * and one winback email goes out.
+ * Winback: `purchase_completed` starts an execution and marks the profile as
+ * having bought recently; every further purchase inside 30 days restarts the
+ * execution, which resets the silence clock with a fresh, empty journal;
+ * after 30 days of silence the flag is unset and one winback email goes out.
+ *
+ * `purchase_completed` is a name your own app sends through `track`, not one
+ * Cowliss defines: the only events Cowliss writes itself are the reserved
+ * `system.` ones. Nothing here runs until your app tracks a purchase.
  *
  * `marketing` and no `enrollment`, so each customer is won back once, ever:
  * the purchase that answers the email does not start a second execution.
@@ -12,7 +16,7 @@ import { defineJourney } from "@cowliss/cli/journeys";
  * customer back every time they lapse, say how long to leave between
  * attempts: `enrollment: { cooldown: "180d" }`.
  *
- * Example: add it with `cow add example winback`; rename the purchase event,
+ * Blueprint: add it with `cow add blueprint winback`; rename the purchase event,
  * the flag trait, and the email to your domain's vocabulary.
  */
 export default defineJourney({
@@ -23,8 +27,15 @@ export default defineJourney({
   tags: ["demo", "retention"],
   run: async (_event, api) => {
     await api.traits.set("purchased_recently", true);
-    while (await api.waitForEvent("purchase_completed", { timeout: "30d" })) {
-      // Another purchase inside 30 days: loop to reset the silence timer.
+    const purchase = await api.waitForEvent("purchase_completed", {
+      timeout: "30d",
+    });
+    if (purchase) {
+      // Another purchase inside 30 days: restart to reset the silence timer
+      // with a fresh, empty journal. Looping here instead would journal one
+      // entry per purchase, so the best customer is the one whose execution
+      // eventually fails on the 1,000-call cap.
+      await api.restart({ event: purchase });
     }
     await api.traits.unset("purchased_recently");
     const me = await api.profile.get();

package/blueprints/winback/scenarios/winback.bought-again.json

@@ -0,0 +1,14 @@
+{
+  "user": {
+    "id": "usr_1",
+    "traits": { "email": "ada@example.com", "firstName": "Ada" }
+  },
+  "events": [{ "at": "10d", "event": "purchase_completed" }],
+  "expect": [
+    {
+      "activity": "setTrait",
+      "input": { "key": "purchased_recently", "value": true }
+    },
+    { "activity": "restart" }
+  ]
+}

package/{examples/winback/scenarios/winback.json → blueprints/winback/scenarios/winback.lapsed.json}

@@ -3,10 +3,7 @@
     "id": "usr_1",
     "traits": { "email": "ada@example.com", "firstName": "Ada" }
   },
-  "events": [
-    { "at": "10d", "event": "purchase_completed" },
-    { "at": "25d", "event": "purchase_completed" }
-  ],
+  "events": [],
   "expect": [
     {
       "activity": "setTrait",
@@ -15,7 +12,7 @@
     { "activity": "unsetTrait", "input": { "key": "purchased_recently" } },
     {
       "activity": "sendEmail",
-      "input": { "template": "winback" }
+      "input": { "template": "winback", "props": { "firstName": "Ada" } }
     }
   ]
 }

package/dist/guest/{driver-poSdZIj8.js → driver-B_pjmy5g.js}

@@ -1,4 +1,5 @@
-import { a as manifestOutputSchema, i as journeyStepOutputSchema, r as guestInputSchema, t as CapabilityError } from "./journeys-F8Yk8s1P.js";
+import { n as journeyStepOutputSchema, r as manifestOutputSchema, t as guestInputSchema } from "./journeys-v2-Djgs8U91.js";
+import { CapabilityError } from "./journeys.js";
 import { z } from "zod";
 
 //#region src/guest/api.ts

package/dist/guest/driver-emails.js

@@ -1,5 +1,6 @@
-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 { i as templateRenderOutputSchema, t as guestInputSchema } from "./journeys-v2-Djgs8U91.js";
+import { CapabilityError } from "./journeys.js";
+import { n as readManifest, t as asTemplate } from "./driver-B_pjmy5g.js";
 import { createElement } from "react";
 import { renderToStaticMarkup } from "react-dom/server.browser";
 

package/dist/guest/driver.d.ts

@@ -1,4 +1,4 @@
-import { a as JourneyStepOutput, o as ManifestOutput, s as TemplateRenderOutput } from "./index-EqBCZnpq.js";
+import { c as TemplateRenderOutput, o as JourneyStepOutput, s as ManifestOutput } from "./index-DADBwPaG.js";
 import { n as Template } from "./emails-5GindgMQ.js";
 //#region src/guest/driver.d.ts
 /**

package/dist/guest/driver.js

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

package/dist/guest/{index-EqBCZnpq.d.ts → index-DADBwPaG.d.ts}

@@ -284,6 +284,8 @@ declare const manifestOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         withinDays: z.ZodOptional<z.ZodNumber>;
       }, z.core.$strip>], "kind">>;
     }, z.core.$strict>;
+  }, z.core.$strict>, z.ZodObject<{
+    segment: z.ZodString;
   }, z.core.$strict>]>;
   purpose: z.ZodString;
   enrollment: z.ZodOptional<z.ZodObject<{
@@ -328,18 +330,19 @@ type Duration = z.infer<typeof durationSchema>;
  * 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
- * by the journey and named after its key, so the segment exists because the
- * journey exists and there is no order to get wrong (ADR 0016). The
- * definition is data — validated here, carried on the version, never
- * compiled and never executed.
+ * A segment trigger says which audience in two ways (ADR 0016, ADR 0023).
+ * Inline, carrying the predicate list itself: the push materializes one
+ * segment row per journey that does, owned by the journey and named after
+ * its key. Or by name, naming a `segments/<key>.ts` file of the same push:
+ * the name resolves inside the tree at build time and the push writes that
+ * file's row, so there is still no order to get wrong and no row outside the
+ * repository a trigger can point at. Either way the 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` 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.
+ * Every member is strict, so a journey holding the retired `source` or
+ * `appId` key 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>]>;
@@ -375,6 +378,8 @@ declare const triggerSchema: z.ZodUnion<readonly [z.ZodObject<{
       withinDays: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>], "kind">>;
   }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+  segment: z.ZodString;
 }, z.core.$strict>]>;
 type Trigger = z.infer<typeof triggerSchema>;
 /**
@@ -383,5 +388,51 @@ type Trigger = z.infer<typeof triggerSchema>;
  * everything downstream reads the parsed `Trigger`.
  */
 type TriggerInput = z.input<typeof triggerSchema>;
+/**
+ * One `segments/<key>.ts` file (ADR 0023): an audience several journeys of
+ * one repository enroll from, written once instead of pasted into each
+ * trigger. It carries no bundle and no digest, because it compiles to
+ * nothing: a definition is a predicate list the evaluator folds, so there is
+ * no code for an execution to pin and therefore no version of it.
+ *
+ * Plain rather than strict, for the same reason the other two entries are: a
+ * stored manifest has to keep parsing after a field goes away (ADR 0011).
+ */
+declare const manifestSegmentSchema: z.ZodObject<{
+  key: z.ZodString;
+  tags: z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodString>>, z.ZodTransform<string[], string[]>>;
+  description: z.ZodOptional<z.ZodString>;
+  definition: z.ZodObject<{
+    match: z.ZodDefault<z.ZodEnum<{
+      all: "all";
+      any: "any";
+    }>>;
+    predicates: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"trait">;
+      name: z.ZodString;
+      op: z.ZodEnum<{
+        contains: "contains";
+        eq: "eq";
+        exists: "exists";
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        neq: "neq";
+        notExists: "notExists";
+      }>;
+      value: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"event">;
+      name: z.ZodString;
+      op: z.ZodEnum<{
+        notPerformed: "notPerformed";
+        performed: "performed";
+      }>;
+      atLeast: z.ZodDefault<z.ZodNumber>;
+      withinDays: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>], "kind">>;
+  }, z.core.$strict>;
+}, z.core.$strip>;
 //#endregion
-export { JourneyStepOutput as a, GuestEvent as i, Trigger as n, ManifestOutput as o, TriggerInput as r, TemplateRenderOutput as s, Duration as t };
+export { GuestEvent as a, TemplateRenderOutput as c, manifestSegmentSchema as i, Trigger as n, JourneyStepOutput as o, TriggerInput as r, ManifestOutput as s, Duration as t };

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

@@ -81,6 +81,12 @@ const EXECUTION_LIMITS = {
 const PUSH_LIMITS = {
 	journeys: 100,
 	templates: 200,
+	/**
+	* Segment files (ADR 0023). A segment is a predicate list, not a bundle, so
+	* the ceiling is about how many audiences one program describes rather than
+	* about bytes; a journey's own inline definition costs nothing here.
+	*/
+	segments: 100,
 	bundleBytes: 2097152,
 	sourceBytes: 5242880
 };
@@ -284,20 +290,25 @@ const patternSchema = z.union([onePatternSchema, z.array(onePatternSchema).min(1
 * 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
-* by the journey and named after its key, so the segment exists because the
-* journey exists and there is no order to get wrong (ADR 0016). The
-* definition is data — validated here, carried on the version, never
-* compiled and never executed.
+* A segment trigger says which audience in two ways (ADR 0016, ADR 0023).
+* Inline, carrying the predicate list itself: the push materializes one
+* segment row per journey that does, owned by the journey and named after
+* its key. Or by name, naming a `segments/<key>.ts` file of the same push:
+* the name resolves inside the tree at build time and the push writes that
+* file's row, so there is still no order to get wrong and no row outside the
+* repository a trigger can point at. Either way the 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` 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 }), z.strictObject({ segment: segmentDefinitionSchema })]);
+* Every member is strict, so a journey holding the retired `source` or
+* `appId` key 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 }),
+	z.strictObject({ segment: segmentDefinitionSchema }),
+	z.strictObject({ segment: journeyKeySchema })
+]);
 /**
 * 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
@@ -452,6 +463,40 @@ const manifestTemplateSchema = z.object({
 	propsSchema: z.record(z.string(), z.unknown()),
 	bundle: digestSchema
 });
+/**
+* One `segments/<key>.ts` file (ADR 0023): an audience several journeys of
+* one repository enroll from, written once instead of pasted into each
+* trigger. It carries no bundle and no digest, because it compiles to
+* nothing: a definition is a predicate list the evaluator folds, so there is
+* no code for an execution to pin and therefore no version of it.
+*
+* Plain rather than strict, for the same reason the other two entries are: a
+* stored manifest has to keep parsing after a field goes away (ADR 0011).
+*/
+const manifestSegmentSchema = z.object({
+	key: journeyKeySchema,
+	/** The author's labels, the way a journey and a template carry them. */
+	tags: tagsSchema,
+	/** The author's own sentence about who is in it; absent when unwritten. */
+	description: z.string().trim().max(500, `description must be at most ${500} characters`).optional(),
+	definition: segmentDefinitionSchema
+});
+/**
+* One event pattern the tree reacts to, read off the tree itself: a trigger,
+* a `waitForEvent`, or an event predicate in a segment. Nobody declares it —
+* a second source of truth would disagree with the code the first time an
+* author edited a trigger — so what a build could not read literally is
+* simply absent, which makes the list incomplete and never wrong.
+*
+* The pattern is stored as written: `order.*` is one entry, not an
+* expansion, because it is what the author asked for and what any reader
+* has to match against. `usedBy` names the journeys and segments that named
+* it, sorted, so a reader can say who is waiting.
+*/
+const manifestEventSchema = z.object({
+	pattern: onePatternSchema,
+	usedBy: z.array(z.string())
+});
 function uniqueKeys(items, ctx, path) {
 	const seen = /* @__PURE__ */ new Set();
 	for (const [index, item] of items.entries()) {
@@ -487,6 +532,19 @@ const manifestSchema = z.object({
 	journeys: z.array(manifestJourneySchema).max(PUSH_LIMITS.journeys),
 	templates: z.array(manifestTemplateSchema).max(PUSH_LIMITS.templates),
 	/**
+	* The `segments/` files this project pushes (ADR 0023). Defaulted rather
+	* than required: every manifest stored before segments were files carries
+	* none, and a project with no shared audience still writes the field.
+	*/
+	segments: z.array(manifestSegmentSchema).max(PUSH_LIMITS.segments).default([]),
+	/**
+	* The event patterns this tree reacts to, collected from the journeys
+	* and segments above rather than declared. Defaulted for the same reason
+	* `segments` is: every manifest stored before the collection existed
+	* carries none.
+	*/
+	events: z.array(manifestEventSchema).default([]),
+	/**
 	* 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.
@@ -497,7 +555,22 @@ const manifestSchema = z.object({
 }).superRefine((manifest, ctx) => {
 	uniqueKeys(manifest.journeys, ctx, "journeys");
 	uniqueKeys(manifest.templates, ctx, "templates");
+	uniqueKeys(manifest.segments, ctx, "segments");
 	uniqueKeys(manifest.purposes ?? [], ctx, "purposes");
+	const segmentKeys = new Set(manifest.segments.map((segment) => segment.key));
+	for (const [index, journey] of manifest.journeys.entries()) {
+		const named = "segment" in journey.trigger && typeof journey.trigger.segment === "string" ? journey.trigger.segment : null;
+		if (named !== null && !segmentKeys.has(named)) ctx.addIssue({
+			code: "custom",
+			message: `journey "${journey.key}" enrolls from the segment "${named}", which this push does not carry. Push the segments/${named}.ts file with it, or write the predicate list in the trigger.`,
+			path: [
+				"journeys",
+				index,
+				"trigger",
+				"segment"
+			]
+		});
+	}
 	for (const [index, journey] of manifest.journeys.entries()) if (journey.enrollment && journey.purpose === "transactional") ctx.addIssue({
 		code: "custom",
 		message: `journey "${journey.key}": a transactional journey enrolls on every trigger, so it takes no enrollment cooldown`,
@@ -876,61 +949,4 @@ const journeyScenarioSchema = z.object({
 });
 
 //#endregion
-//#region src/guest/journeys.ts
-/**
-* A capability that failed host-side (an unknown webhook, invalid
-* props, a profile that is not there). The failure is journaled, so a
-* journey that catches it takes the same branch on every replay.
-*/
-var CapabilityError = class extends Error {
-	code;
-	constructor(code, message) {
-		super(message);
-		this.name = "CapabilityError";
-		this.code = code;
-	}
-};
-/**
-* The config half of a journey, validated with the same schema the release
-* manifest is validated with, so a bad trigger, a malformed purpose key, or
-* a `from` that is not an address fails at build time rather than at the
-* first execution. Whether the org declares that purpose, and whether it may
-* send from that domain, are questions only the push can answer.
-*/
-const journeyConfigSchema = manifestJourneySchema.pick({
-	trigger: true,
-	purpose: true,
-	enrollment: true,
-	description: true,
-	from: true,
-	tags: true
-});
-/**
-* Author a journey. Throws at definition time on an invalid config.
-*
-* 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({
-		trigger: input.trigger,
-		purpose: input.purpose,
-		enrollment: input.enrollment,
-		description: input.description,
-		from: input.from,
-		tags: input.tags
-	});
-	if (config.from === void 0) throw new Error("defineJourney needs a \"from\": the address this journey sends as, on a domain your organization verified. Add and verify it on the Domains page (Settings, Domains). For example from: \"Billing <billing@your-domain.com>\".");
-	return {
-		...config,
-		from: config.from,
-		run: input.run
-	};
-}
-
-//#endregion
-export { manifestOutputSchema as a, journeyStepOutputSchema as i, defineJourney as n, templateRenderOutputSchema as o, guestInputSchema as r, CapabilityError as t };
+export { manifestJourneySchema as a, templateRenderOutputSchema as i, journeyStepOutputSchema as n, manifestSegmentSchema as o, manifestOutputSchema as r, guestInputSchema as t };

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-EqBCZnpq.js";
+import { a as GuestEvent, n as Trigger, r as TriggerInput, t as Duration } from "./index-DADBwPaG.js";
 //#region src/guest/journeys.d.ts
 /** The event a journey runs for, or the one a `waitForEvent` resolved with. */
 type Event = GuestEvent;