@shware/workflow 0.0.0-stage → 0.0.0

package/dist/contract.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.mjs","names":[],"sources":["../src/contract.ts"],"sourcesContent":["import * as z from 'zod/mini';\nimport type * as core from 'zod/v4/core';\nimport { type EventRefs, type UserRefs, event, user } from './dsl';\n\n/**\n * `defineContract({ events, profile })` — the producer/engine contract as Zod\n * schemas, written once in a package both sides import. From it:\n *\n * - `contract.events` / `contract.user` are the DSL's typed reference tables\n *   (what `event<E>()` / `user<U>()` used to be, now derived from the schemas);\n * - `JourneyClient({ contract })` types `track` / `identify` by event name and\n *   checks payloads before sending;\n * - `journeyWorker({ contract })` re-validates every inbound `/events` and\n *   `/identify` — never trusting the caller used the SDK — and refuses a bad\n *   one with a 4xx before anything is stored, woken or started.\n *\n * Supported schemas (v1), synchronous and JSON-shaped: event payloads are\n * object schemas (`z.looseObject` keeps a producer's extra analytics fields,\n * `z.strictObject` refuses them) and may nest objects and arrays; the profile\n * is a flat object of string / number / boolean / enum / literal fields. Input\n * and output must mean the same thing, so defaults, transforms, coercion,\n * custom refinements and async checks are refused when the contract is\n * defined. The Zod instances stay in the host; nothing here changes the IR.\n */\n\ntype ObjectSchema = core.$ZodObject;\n\n/** The declared fields of an object schema — without a loose object's `[key: string]: unknown`, so the DSL only offers fields that were written down. */\nexport type DeclaredOutput<S> =\n  S extends core.$ZodObject<infer Shape>\n    ? core.$InferObjectOutput<Shape, Record<never, never>>\n    : never;\n\nexport interface ContractDefinition<\n  E extends Record<string, ObjectSchema>,\n  P extends ObjectSchema,\n> {\n  events: E;\n  profile: P;\n}\n\n/** One rejected field, with the dotted path the producer can fix. */\nexport interface ContractIssue {\n  path: string;\n  message: string;\n}\n\nexport type ContractResult<T> = { ok: true; data: T } | { ok: false; issues: ContractIssue[] };\n\nexport interface Contract<\n  E extends Record<string, ObjectSchema> = Record<string, ObjectSchema>,\n  P extends ObjectSchema = ObjectSchema,\n> {\n  readonly kind: 'journey-contract';\n  /** The DSL's event reference table: `e.purchase` — payload refs from the declared fields only. */\n  readonly events: EventRefs<{ [K in keyof E]: DeclaredOutput<E[K]> }>;\n  /** The DSL's user-property reference table: `u.name`, plus the system `u.userId`. */\n  readonly user: UserRefs<DeclaredOutput<P> & { userId: string }>;\n  /** The raw schemas, for hosts that need them (validation, docs). */\n  readonly schemas: { readonly events: E; readonly profile: P };\n  /** Every event name the contract declares — what a producer forwards. */\n  readonly eventNames: readonly (keyof E & string)[];\n  isEvent(name: string): name is keyof E & string;\n  /** Validate one event's payload; the parsed value is what may be stored. */\n  parseEvent<K extends keyof E & string>(\n    name: K,\n    payload: unknown\n  ): ContractResult<core.output<E[K]>>;\n  /**\n   * Validate an `/identify` merge patch: omitted fields stay as they are,\n   * `null` removes a field, every provided value is checked against its field\n   * schema, and an undeclared field is refused — a patch, never a full parse\n   * that would fill defaults over fields the caller did not send.\n   */\n  parseProfilePatch(patch: unknown): ContractResult<ProfilePatch<P>>;\n}\n\n/** An `/identify` patch over the profile: any subset of fields, `null` to remove one. */\nexport type ProfilePatch<P> = { [K in keyof DeclaredOutput<P>]?: DeclaredOutput<P>[K] | null };\n\n/** Payload type of one event, for producers: `EventPayload<typeof contract, 'purchase'>`. */\nexport type EventPayload<C, K extends string> =\n  C extends Contract<infer E> ? (K extends keyof E ? core.input<E[K]> : never) : never;\n\nexport function defineContract<E extends Record<string, ObjectSchema>, P extends ObjectSchema>(\n  definition: ContractDefinition<E, P>\n): Contract<E, P> {\n  for (const [name, schema] of Object.entries(definition.events)) {\n    if (name.startsWith('$')) {\n      throw new TypeError(`contract event '${name}': names starting with $ are reserved`);\n    }\n    assertJsonSchema(schema, `event '${name}'`, true);\n  }\n  assertJsonSchema(definition.profile, 'profile', true);\n  const profileShape = (definition.profile._zod.def as core.$ZodObjectDef).shape;\n  for (const [field, schema] of Object.entries(profileShape)) {\n    assertFlatScalar(schema, `profile.${field}`);\n  }\n  const strictProfile = definition.profile._zod.def.catchall?._zod.def.type === 'never';\n\n  const names = Object.keys(definition.events) as (keyof E & string)[];\n  return {\n    kind: 'journey-contract',\n    events: event() as never,\n    user: user() as never,\n    schemas: { events: definition.events, profile: definition.profile },\n    eventNames: names,\n    isEvent: (name): name is keyof E & string => Object.hasOwn(definition.events, name),\n    parseEvent(name, payload) {\n      if (!Object.hasOwn(definition.events, name)) {\n        return { ok: false, issues: [{ path: '', message: `unknown event '${name}'` }] };\n      }\n      return toResult(z.safeParse(definition.events[name], payload));\n    },\n    parseProfilePatch(patch) {\n      if (typeof patch !== 'object' || patch === null || Array.isArray(patch)) {\n        return { ok: false, issues: [{ path: '', message: 'props must be an object' }] };\n      }\n      const issues: ContractIssue[] = [];\n      const data: Record<string, unknown> = {};\n      for (const [field, value] of Object.entries(patch)) {\n        if (!Object.hasOwn(profileShape, field)) {\n          // userId is the request's identity, not a profile field\n          if (strictProfile || field === 'userId') {\n            issues.push({ path: field, message: 'not a declared profile field' });\n          } else {\n            data[field] = value;\n          }\n          continue;\n        }\n        if (value === null) {\n          data[field] = null;\n          continue;\n        }\n        const result = z.safeParse(profileShape[field], value);\n        if (result.success) data[field] = result.data;\n        else issues.push(...prefixed(field, result.error));\n      }\n      return issues.length > 0 ? { ok: false, issues } : { ok: true, data: data as never };\n    },\n  };\n}\n\n/**\n * An event the contract refuses — raised for events a journey emits itself\n * (`.sendEvent()`), which never pass the HTTP ingest: they go through the same\n * check, and a refusal is deterministic, so it is not retried.\n */\nexport class ContractValidationError extends Error {\n  override readonly name = 'ContractValidationError';\n  constructor(\n    readonly event: string,\n    readonly issues: ContractIssue[]\n  ) {\n    super(\n      `event '${event}' refused by the contract: ${issues\n        .map((i) => `${i.path || '(root)'} ${i.message}`)\n        .join('; ')}`\n    );\n  }\n}\n\n/** The one check every event passes, from HTTP or from a journey: declared, and its payload parses. */\nexport function checkEvent(\n  contract: Contract,\n  name: string,\n  payload: unknown\n): ContractResult<Record<string, unknown>> {\n  if (!contract.isEvent(name)) {\n    return {\n      ok: false,\n      issues: [{ path: '', message: `'${String(name)}' is not in the contract` }],\n    };\n  }\n  return contract.parseEvent(name, payload);\n}\n\nexport function isContract(value: unknown): value is Contract {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { kind?: unknown }).kind === 'journey-contract'\n  );\n}\n\nfunction toResult<T>(result: core.util.SafeParseResult<T>): ContractResult<T> {\n  return result.success\n    ? { ok: true, data: result.data }\n    : { ok: false, issues: prefixed('', result.error) };\n}\n\nfunction prefixed(prefix: string, error: core.$ZodError): ContractIssue[] {\n  return error.issues.map((issue) => ({\n    path: [prefix, ...issue.path.map(String)].filter((p) => p !== '').join('.'),\n    message: issue.message,\n  }));\n}\n\n/* ---------------------------- supported schemas ---------------------------- */\n\n/**\n * The schema types a contract may use — JSON shapes that parse synchronously\n * and mean the same before and after parsing. Anything not listed (default,\n * transform, pipe, lazy, promise, custom, date, bigint, …) is refused, and\n * every container is walked so nothing unsupported hides inside one.\n */\nconst ALLOWED = new Set([\n  'object',\n  'array',\n  'tuple',\n  'union',\n  'intersection',\n  'record',\n  'optional',\n  'nullable',\n  'readonly',\n  'nonoptional',\n  'string',\n  'number',\n  'boolean',\n  'null',\n  'enum',\n  'literal',\n  'unknown',\n  'any',\n  'never',\n]);\n\n/** Checks that change the value (`overwrite`: `.trim()`, `.toLowerCase()`, …) or run arbitrary code (`custom`: `.refine()`, async or not). */\nconst REFUSED_CHECKS = new Set(['custom', 'overwrite']);\n\nfunction assertJsonSchema(schema: unknown, where: string, top = false): void {\n  const def = (schema as core.$ZodType | undefined)?._zod?.def;\n  if (def === undefined) throw new TypeError(`contract ${where}: not a Zod schema`);\n  if (top && def.type !== 'object') {\n    throw new TypeError(\n      `contract ${where}: must be an object schema (z.looseObject / z.strictObject)`\n    );\n  }\n  if (!ALLOWED.has(def.type)) {\n    throw new TypeError(\n      `contract ${where}: ${def.type} schemas are not supported (input and output must mean the same JSON, parsed synchronously)`\n    );\n  }\n  if ((def as { coerce?: boolean }).coerce === true) {\n    throw new TypeError(`contract ${where}: coercion (z.coerce) is not supported`);\n  }\n  for (const check of def.checks ?? []) {\n    if (REFUSED_CHECKS.has(check._zod.def.check)) {\n      throw new TypeError(\n        `contract ${where}: ${check._zod.def.check === 'overwrite' ? 'value-changing checks (.overwrite, .trim, …)' : 'custom refinements'} are not supported`\n      );\n    }\n  }\n  const children: [string, unknown][] = [];\n  switch (def.type) {\n    case 'object': {\n      const object = def as core.$ZodObjectDef;\n      for (const [k, v] of Object.entries(object.shape)) children.push([`${where}.${k}`, v]);\n      if (object.catchall !== undefined) children.push([`${where}.*`, object.catchall]);\n      break;\n    }\n    case 'optional':\n    case 'nullable':\n    case 'readonly':\n    case 'nonoptional':\n      children.push([where, (def as unknown as { innerType: unknown }).innerType]);\n      break;\n    case 'array':\n      children.push([`${where}[]`, (def as core.$ZodArrayDef).element]);\n      break;\n    case 'tuple': {\n      const tuple = def as core.$ZodTupleDef;\n      tuple.items.forEach((item, index) => children.push([`${where}[${index}]`, item]));\n      if (tuple.rest !== null) children.push([`${where}[…]`, tuple.rest]);\n      break;\n    }\n    case 'union':\n      for (const option of (def as core.$ZodUnionDef).options) children.push([where, option]);\n      break;\n    case 'intersection': {\n      const intersection = def as core.$ZodIntersectionDef;\n      children.push([where, intersection.left], [where, intersection.right]);\n      break;\n    }\n    case 'record': {\n      const record = def as core.$ZodRecordDef;\n      children.push([`${where}{key}`, record.keyType], [`${where}{}`, record.valueType]);\n      break;\n    }\n    default:\n      break;\n  }\n  for (const [path, child] of children) assertJsonSchema(child, path);\n}\n\nconst SCALARS = new Set(['string', 'number', 'boolean', 'enum', 'literal']);\n\nfunction assertFlatScalar(schema: unknown, where: string): void {\n  let def = (schema as core.$ZodType)._zod.def;\n  if (def.type === 'optional') def = (def as core.$ZodOptionalDef).innerType._zod.def;\n  if (!SCALARS.has(def.type)) {\n    throw new TypeError(\n      `contract ${where}: profile fields must be flat scalars (string, number, boolean, enum, literal), got ${def.type}`\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/dsl/action.cjs

@@ -0,0 +1,29 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_hash = require("../hash.cjs");
+//#region src/dsl/action.ts
+/**
+* Define a custom action. The generic `A` types the args `.run()` accepts —
+* the only type injection point, mirroring `template.email<P>()`:
+*
+*   const syncCrm = action<{ plan: string }>('sync_crm', async ({ plan }, { userId }) => {
+*     await fetch('https://crm.example.com/sync', { method: 'POST', body: JSON.stringify({ userId, plan }) });
+*   });
+*
+*   workflow(...).run(syncCrm, { plan: u.subscription_plan })
+*
+* codeHash comes from `handler.toString()`, so it changes when the code
+* changes and stays put when it does not. Different build pipelines can print
+* the same function differently (minification), which is why the default
+* runtime policy on mismatch is warn, not fail.
+*/
+function action(name, handler) {
+	return {
+		name,
+		codeHash: require_hash.sha256Hex(handler.toString()).slice(0, 32),
+		handler
+	};
+}
+//#endregion
+exports.action = action;
+
+//# sourceMappingURL=action.cjs.map

package/dist/dsl/action.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.cjs","names":["sha256Hex"],"sources":["../../src/dsl/action.ts"],"sourcesContent":["import { sha256Hex } from '../hash';\n\n/**\n * Custom actions — the escape hatch for side effects the built-in nodes do not\n * cover (CRM sync, coupon issuing, outbound webhooks with custom auth, …).\n *\n * Dual-plane model: the *code* solidifies into the Worker bundle at deploy\n * time (it ships with the app, like any other module), while the *identity*\n * solidifies into IR as `{ type: 'action', action: name, args, codeHash }`.\n * The runtime resolves the name against a registry (see engine/actions.ts) and\n * compares codeHash to detect version skew between a pinned IR and the\n * currently deployed implementation.\n *\n * Deliberately NOT supported: custom *conditions*. Branching stays declarative\n * so the canvas can always explain why a user took a path — an action that\n * needs to influence routing writes a property or emits an event, and the\n * decision is expressed as a normal predicate on that data.\n */\n\n/** Runtime context handed to the handler; deliberately small — facts and messaging have their own nodes. */\nexport interface ActionContext {\n  userId: string;\n  /**\n   * `${instanceId}:${nodeId}` — stable across replays and retries of this one\n   * action node. A handler with an external side effect (charging, issuing,\n   * POSTing) must pass it along so the far side collapses the duplicate: the\n   * step body can re-run after the handler already resolved.\n   */\n  idempotencyKey: string;\n}\n\n/**\n * The handler: plain code, executed inside a durable step (`step.do`), so a\n * throw is retried by the runtime and a success is checkpointed — it should be\n * idempotent under retry, which is what `ctx.idempotencyKey` is for. Args\n * arrive with user_property references already resolved to values.\n */\nexport type ActionHandler<A extends object> = (args: A, ctx: ActionContext) => Promise<void> | void;\n\n/**\n * A registered custom action: the named asset `.run()` refers to. Carries the\n * implementation for the runtime registry and the codeHash for the IR pin.\n */\nexport interface ActionRef<A extends object = Record<never, never>> {\n  readonly name: string;\n  /** Hash of the handler's source text at definition time — the code-identity pin recorded in IR. */\n  readonly codeHash: string;\n  /** Method syntax on purpose: bivariant args let refs with different arg shapes share one list (compileBundle, registries). */\n  handler(args: A, ctx: ActionContext): Promise<void> | void;\n}\n\n/**\n * Define a custom action. The generic `A` types the args `.run()` accepts —\n * the only type injection point, mirroring `template.email<P>()`:\n *\n *   const syncCrm = action<{ plan: string }>('sync_crm', async ({ plan }, { userId }) => {\n *     await fetch('https://crm.example.com/sync', { method: 'POST', body: JSON.stringify({ userId, plan }) });\n *   });\n *\n *   workflow(...).run(syncCrm, { plan: u.subscription_plan })\n *\n * codeHash comes from `handler.toString()`, so it changes when the code\n * changes and stays put when it does not. Different build pipelines can print\n * the same function differently (minification), which is why the default\n * runtime policy on mismatch is warn, not fail.\n */\nexport function action<A extends object = Record<never, never>>(\n  name: string,\n  handler: ActionHandler<A>\n): ActionRef<A> {\n  return { name, codeHash: sha256Hex(handler.toString()).slice(0, 32), handler };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkEA,SAAgB,OACd,MACA,SACc;CACd,OAAO;EAAE;EAAM,UAAUA,aAAAA,UAAU,QAAQ,SAAS,CAAC,CAAC,CAAC,MAAM,GAAG,EAAE;EAAG;CAAQ;AAC/E"}

package/dist/dsl/action.d.cts

@@ -0,0 +1,64 @@
+//#region src/dsl/action.d.ts
+/**
+ * Custom actions — the escape hatch for side effects the built-in nodes do not
+ * cover (CRM sync, coupon issuing, outbound webhooks with custom auth, …).
+ *
+ * Dual-plane model: the *code* solidifies into the Worker bundle at deploy
+ * time (it ships with the app, like any other module), while the *identity*
+ * solidifies into IR as `{ type: 'action', action: name, args, codeHash }`.
+ * The runtime resolves the name against a registry (see engine/actions.ts) and
+ * compares codeHash to detect version skew between a pinned IR and the
+ * currently deployed implementation.
+ *
+ * Deliberately NOT supported: custom *conditions*. Branching stays declarative
+ * so the canvas can always explain why a user took a path — an action that
+ * needs to influence routing writes a property or emits an event, and the
+ * decision is expressed as a normal predicate on that data.
+ */
+/** Runtime context handed to the handler; deliberately small — facts and messaging have their own nodes. */
+export interface ActionContext {
+  userId: string;
+  /**
+   * `${instanceId}:${nodeId}` — stable across replays and retries of this one
+   * action node. A handler with an external side effect (charging, issuing,
+   * POSTing) must pass it along so the far side collapses the duplicate: the
+   * step body can re-run after the handler already resolved.
+   */
+  idempotencyKey: string;
+}
+/**
+ * The handler: plain code, executed inside a durable step (`step.do`), so a
+ * throw is retried by the runtime and a success is checkpointed — it should be
+ * idempotent under retry, which is what `ctx.idempotencyKey` is for. Args
+ * arrive with user_property references already resolved to values.
+ */
+export type ActionHandler<A extends object> = (args: A, ctx: ActionContext) => Promise<void> | void;
+/**
+ * A registered custom action: the named asset `.run()` refers to. Carries the
+ * implementation for the runtime registry and the codeHash for the IR pin.
+ */
+export interface ActionRef<A extends object = Record<never, never>> {
+  readonly name: string;
+  /** Hash of the handler's source text at definition time — the code-identity pin recorded in IR. */
+  readonly codeHash: string;
+  /** Method syntax on purpose: bivariant args let refs with different arg shapes share one list (compileBundle, registries). */
+  handler(args: A, ctx: ActionContext): Promise<void> | void;
+}
+/**
+ * Define a custom action. The generic `A` types the args `.run()` accepts —
+ * the only type injection point, mirroring `template.email<P>()`:
+ *
+ *   const syncCrm = action<{ plan: string }>('sync_crm', async ({ plan }, { userId }) => {
+ *     await fetch('https://crm.example.com/sync', { method: 'POST', body: JSON.stringify({ userId, plan }) });
+ *   });
+ *
+ *   workflow(...).run(syncCrm, { plan: u.subscription_plan })
+ *
+ * codeHash comes from `handler.toString()`, so it changes when the code
+ * changes and stays put when it does not. Different build pipelines can print
+ * the same function differently (minification), which is why the default
+ * runtime policy on mismatch is warn, not fail.
+ */
+export declare function action<A extends object = Record<never, never>>(name: string, handler: ActionHandler<A>): ActionRef<A>;
+//#endregion
+//# sourceMappingURL=action.d.cts.map

package/dist/dsl/action.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.d.cts","names":[],"sources":["../../src/dsl/action.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBAoBiB;EACf;;;;;;;EAOA;;;;;;;;YASU,cAAc,qBAAqB,MAAM,GAAG,KAAK,kBAAkB;;;;;iBAM9D,UAAU,mBAAmB;WACnC;;WAEA;;EAET,QAAQ,MAAM,GAAG,KAAK,gBAAgB;;;;;;;;;;;;;;;;;wBAkBxB,OAAO,mBAAmB,sBACxC,cACA,SAAS,cAAc,KACtB,UAAU"}

package/dist/dsl/action.d.mts

@@ -0,0 +1,64 @@
+//#region src/dsl/action.d.ts
+/**
+ * Custom actions — the escape hatch for side effects the built-in nodes do not
+ * cover (CRM sync, coupon issuing, outbound webhooks with custom auth, …).
+ *
+ * Dual-plane model: the *code* solidifies into the Worker bundle at deploy
+ * time (it ships with the app, like any other module), while the *identity*
+ * solidifies into IR as `{ type: 'action', action: name, args, codeHash }`.
+ * The runtime resolves the name against a registry (see engine/actions.ts) and
+ * compares codeHash to detect version skew between a pinned IR and the
+ * currently deployed implementation.
+ *
+ * Deliberately NOT supported: custom *conditions*. Branching stays declarative
+ * so the canvas can always explain why a user took a path — an action that
+ * needs to influence routing writes a property or emits an event, and the
+ * decision is expressed as a normal predicate on that data.
+ */
+/** Runtime context handed to the handler; deliberately small — facts and messaging have their own nodes. */
+export interface ActionContext {
+  userId: string;
+  /**
+   * `${instanceId}:${nodeId}` — stable across replays and retries of this one
+   * action node. A handler with an external side effect (charging, issuing,
+   * POSTing) must pass it along so the far side collapses the duplicate: the
+   * step body can re-run after the handler already resolved.
+   */
+  idempotencyKey: string;
+}
+/**
+ * The handler: plain code, executed inside a durable step (`step.do`), so a
+ * throw is retried by the runtime and a success is checkpointed — it should be
+ * idempotent under retry, which is what `ctx.idempotencyKey` is for. Args
+ * arrive with user_property references already resolved to values.
+ */
+export type ActionHandler<A extends object> = (args: A, ctx: ActionContext) => Promise<void> | void;
+/**
+ * A registered custom action: the named asset `.run()` refers to. Carries the
+ * implementation for the runtime registry and the codeHash for the IR pin.
+ */
+export interface ActionRef<A extends object = Record<never, never>> {
+  readonly name: string;
+  /** Hash of the handler's source text at definition time — the code-identity pin recorded in IR. */
+  readonly codeHash: string;
+  /** Method syntax on purpose: bivariant args let refs with different arg shapes share one list (compileBundle, registries). */
+  handler(args: A, ctx: ActionContext): Promise<void> | void;
+}
+/**
+ * Define a custom action. The generic `A` types the args `.run()` accepts —
+ * the only type injection point, mirroring `template.email<P>()`:
+ *
+ *   const syncCrm = action<{ plan: string }>('sync_crm', async ({ plan }, { userId }) => {
+ *     await fetch('https://crm.example.com/sync', { method: 'POST', body: JSON.stringify({ userId, plan }) });
+ *   });
+ *
+ *   workflow(...).run(syncCrm, { plan: u.subscription_plan })
+ *
+ * codeHash comes from `handler.toString()`, so it changes when the code
+ * changes and stays put when it does not. Different build pipelines can print
+ * the same function differently (minification), which is why the default
+ * runtime policy on mismatch is warn, not fail.
+ */
+export declare function action<A extends object = Record<never, never>>(name: string, handler: ActionHandler<A>): ActionRef<A>;
+//#endregion
+//# sourceMappingURL=action.d.mts.map

package/dist/dsl/action.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.d.mts","names":[],"sources":["../../src/dsl/action.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBAoBiB;EACf;;;;;;;EAOA;;;;;;;;YASU,cAAc,qBAAqB,MAAM,GAAG,KAAK,kBAAkB;;;;;iBAM9D,UAAU,mBAAmB;WACnC;;WAEA;;EAET,QAAQ,MAAM,GAAG,KAAK,gBAAgB;;;;;;;;;;;;;;;;;wBAkBxB,OAAO,mBAAmB,sBACxC,cACA,SAAS,cAAc,KACtB,UAAU"}

package/dist/dsl/action.mjs

@@ -0,0 +1,28 @@
+import { sha256Hex } from "../hash.mjs";
+//#region src/dsl/action.ts
+/**
+* Define a custom action. The generic `A` types the args `.run()` accepts —
+* the only type injection point, mirroring `template.email<P>()`:
+*
+*   const syncCrm = action<{ plan: string }>('sync_crm', async ({ plan }, { userId }) => {
+*     await fetch('https://crm.example.com/sync', { method: 'POST', body: JSON.stringify({ userId, plan }) });
+*   });
+*
+*   workflow(...).run(syncCrm, { plan: u.subscription_plan })
+*
+* codeHash comes from `handler.toString()`, so it changes when the code
+* changes and stays put when it does not. Different build pipelines can print
+* the same function differently (minification), which is why the default
+* runtime policy on mismatch is warn, not fail.
+*/
+function action(name, handler) {
+	return {
+		name,
+		codeHash: sha256Hex(handler.toString()).slice(0, 32),
+		handler
+	};
+}
+//#endregion
+export { action };
+
+//# sourceMappingURL=action.mjs.map

package/dist/dsl/action.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.mjs","names":[],"sources":["../../src/dsl/action.ts"],"sourcesContent":["import { sha256Hex } from '../hash';\n\n/**\n * Custom actions — the escape hatch for side effects the built-in nodes do not\n * cover (CRM sync, coupon issuing, outbound webhooks with custom auth, …).\n *\n * Dual-plane model: the *code* solidifies into the Worker bundle at deploy\n * time (it ships with the app, like any other module), while the *identity*\n * solidifies into IR as `{ type: 'action', action: name, args, codeHash }`.\n * The runtime resolves the name against a registry (see engine/actions.ts) and\n * compares codeHash to detect version skew between a pinned IR and the\n * currently deployed implementation.\n *\n * Deliberately NOT supported: custom *conditions*. Branching stays declarative\n * so the canvas can always explain why a user took a path — an action that\n * needs to influence routing writes a property or emits an event, and the\n * decision is expressed as a normal predicate on that data.\n */\n\n/** Runtime context handed to the handler; deliberately small — facts and messaging have their own nodes. */\nexport interface ActionContext {\n  userId: string;\n  /**\n   * `${instanceId}:${nodeId}` — stable across replays and retries of this one\n   * action node. A handler with an external side effect (charging, issuing,\n   * POSTing) must pass it along so the far side collapses the duplicate: the\n   * step body can re-run after the handler already resolved.\n   */\n  idempotencyKey: string;\n}\n\n/**\n * The handler: plain code, executed inside a durable step (`step.do`), so a\n * throw is retried by the runtime and a success is checkpointed — it should be\n * idempotent under retry, which is what `ctx.idempotencyKey` is for. Args\n * arrive with user_property references already resolved to values.\n */\nexport type ActionHandler<A extends object> = (args: A, ctx: ActionContext) => Promise<void> | void;\n\n/**\n * A registered custom action: the named asset `.run()` refers to. Carries the\n * implementation for the runtime registry and the codeHash for the IR pin.\n */\nexport interface ActionRef<A extends object = Record<never, never>> {\n  readonly name: string;\n  /** Hash of the handler's source text at definition time — the code-identity pin recorded in IR. */\n  readonly codeHash: string;\n  /** Method syntax on purpose: bivariant args let refs with different arg shapes share one list (compileBundle, registries). */\n  handler(args: A, ctx: ActionContext): Promise<void> | void;\n}\n\n/**\n * Define a custom action. The generic `A` types the args `.run()` accepts —\n * the only type injection point, mirroring `template.email<P>()`:\n *\n *   const syncCrm = action<{ plan: string }>('sync_crm', async ({ plan }, { userId }) => {\n *     await fetch('https://crm.example.com/sync', { method: 'POST', body: JSON.stringify({ userId, plan }) });\n *   });\n *\n *   workflow(...).run(syncCrm, { plan: u.subscription_plan })\n *\n * codeHash comes from `handler.toString()`, so it changes when the code\n * changes and stays put when it does not. Different build pipelines can print\n * the same function differently (minification), which is why the default\n * runtime policy on mismatch is warn, not fail.\n */\nexport function action<A extends object = Record<never, never>>(\n  name: string,\n  handler: ActionHandler<A>\n): ActionRef<A> {\n  return { name, codeHash: sha256Hex(handler.toString()).slice(0, 32), handler };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAkEA,SAAgB,OACd,MACA,SACc;CACd,OAAO;EAAE;EAAM,UAAU,UAAU,QAAQ,SAAS,CAAC,CAAC,CAAC,MAAM,GAAG,EAAE;EAAG;CAAQ;AAC/E"}

package/dist/dsl/base.cjs

@@ -0,0 +1,34 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let ms = require("ms");
+ms = require_runtime.__toESM(ms, 1);
+//#region src/dsl/base.ts
+const TIME_OF_DAY = /^([01]\d|2[0-3]):([0-5]\d)$/;
+/**
+* Parse an 'HH:mm' literal to minutes since midnight, throwing on anything the
+* type let through ('9:00', '25:00', 'ab:cd').
+* @internal shared by flow builders, not part of the public API
+*/
+function timeOfDayMinutes(value) {
+	const match = TIME_OF_DAY.exec(value);
+	if (!match) throw new Error(`Invalid time of day: '${value}' (expected 'HH:mm', e.g. '09:00')`);
+	return Number(match[1]) * 60 + Number(match[2]);
+}
+/**
+* Duration parsing delegates to `ms` (typed StringValue); Duration is it's
+* stricter, full-word subset.
+* @internal shared by condition/flow/workflow, not part of the public API
+*/
+function durationIR(value) {
+	const millis = (0, ms.default)(value);
+	if (typeof millis !== "number" || Number.isNaN(millis) || millis < 0) throw new Error(`Invalid duration: '${value}'`);
+	return {
+		value,
+		ms: millis
+	};
+}
+//#endregion
+exports.durationIR = durationIR;
+exports.timeOfDayMinutes = timeOfDayMinutes;
+
+//# sourceMappingURL=base.cjs.map

package/dist/dsl/base.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.cjs","names":[],"sources":["../../src/dsl/base.ts"],"sourcesContent":["import ms from 'ms';\nimport type { DurationIR } from '../ir';\n\n/**\n * Base vocabulary shared by the whole DSL: the schema constraints an app's\n * types must satisfy, and the literal types (durations, weekdays, clock times)\n * the builder methods accept.\n *\n * Type technique: `Duration` is a template-literal union — '1 huor' is a\n * compile error, no runtime validation needed for the common case.\n */\n\n/**\n * Event name → payload shape, supplied by the app (its analytics schema).\n * Constrained to `object` rather than `Record`: interfaces have no implicit\n * index signature, so a Record constraint would reject an interface-defined\n * schema. Event names come from `keyof E`, payloads from `E[N]`.\n */\nexport type EventMap = object;\n\n/**\n * Base shape of user properties; the app extends it with concrete fields.\n * `email` is optional: a profile can exist before (or without) an address,\n * and an email step refuses to send when the recipient is missing.\n */\nexport interface UserPropertyBase {\n  userId: string;\n  email?: string;\n}\n\n/** Duration literal: '1 hour' / '23 hours' / '30 days' — typos fail to compile. */\nexport type Duration = `${number} ${\n  | 'second'\n  | 'seconds'\n  | 'minute'\n  | 'minutes'\n  | 'hour'\n  | 'hours'\n  | 'day'\n  | 'days'\n  | 'week'\n  | 'weeks'}`;\n\nexport type Weekday = 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';\n\n/** 'HH:mm' (24h, leading zeros). The type cannot express digit ranges, so builders validate at runtime via timeOfDayMinutes. */\nexport type TimeOfDay = `${string}:${string}`;\n\nconst TIME_OF_DAY = /^([01]\\d|2[0-3]):([0-5]\\d)$/;\n\n/**\n * Parse an 'HH:mm' literal to minutes since midnight, throwing on anything the\n * type let through ('9:00', '25:00', 'ab:cd').\n * @internal shared by flow builders, not part of the public API\n */\nexport function timeOfDayMinutes(value: TimeOfDay): number {\n  const match = TIME_OF_DAY.exec(value);\n  if (!match) throw new Error(`Invalid time of day: '${value}' (expected 'HH:mm', e.g. '09:00')`);\n  return Number(match[1]) * 60 + Number(match[2]);\n}\n\n/**\n * Duration parsing delegates to `ms` (typed StringValue); Duration is it's\n * stricter, full-word subset.\n * @internal shared by condition/flow/workflow, not part of the public API\n */\nexport function durationIR(value: Duration): DurationIR {\n  const millis = ms(value);\n  if (typeof millis !== 'number' || Number.isNaN(millis) || millis < 0) {\n    throw new Error(`Invalid duration: '${value}'`);\n  }\n  return { value, ms: millis };\n}\n"],"mappings":";;;;;AAgDA,MAAM,cAAc;;;;;;AAOpB,SAAgB,iBAAiB,OAA0B;CACzD,MAAM,QAAQ,YAAY,KAAK,KAAK;CACpC,IAAI,CAAC,OAAO,MAAM,IAAI,MAAM,yBAAyB,MAAM,mCAAmC;CAC9F,OAAO,OAAO,MAAM,EAAE,IAAI,KAAK,OAAO,MAAM,EAAE;AAChD;;;;;;AAOA,SAAgB,WAAW,OAA6B;CACtD,MAAM,UAAA,GAAS,GAAA,QAAA,CAAG,KAAK;CACvB,IAAI,OAAO,WAAW,YAAY,OAAO,MAAM,MAAM,KAAK,SAAS,GACjE,MAAM,IAAI,MAAM,sBAAsB,MAAM,EAAE;CAEhD,OAAO;EAAE;EAAO,IAAI;CAAO;AAC7B"}

package/dist/dsl/base.d.cts

@@ -0,0 +1,45 @@
+import { DurationIR } from "../ir.cjs";
+//#region src/dsl/base.d.ts
+/**
+ * Base vocabulary shared by the whole DSL: the schema constraints an app's
+ * types must satisfy, and the literal types (durations, weekdays, clock times)
+ * the builder methods accept.
+ *
+ * Type technique: `Duration` is a template-literal union — '1 huor' is a
+ * compile error, no runtime validation needed for the common case.
+ */
+/**
+ * Event name → payload shape, supplied by the app (its analytics schema).
+ * Constrained to `object` rather than `Record`: interfaces have no implicit
+ * index signature, so a Record constraint would reject an interface-defined
+ * schema. Event names come from `keyof E`, payloads from `E[N]`.
+ */
+export type EventMap = object;
+/**
+ * Base shape of user properties; the app extends it with concrete fields.
+ * `email` is optional: a profile can exist before (or without) an address,
+ * and an email step refuses to send when the recipient is missing.
+ */
+export interface UserPropertyBase {
+  userId: string;
+  email?: string;
+}
+/** Duration literal: '1 hour' / '23 hours' / '30 days' — typos fail to compile. */
+export type Duration = `${number} ${'second' | 'seconds' | 'minute' | 'minutes' | 'hour' | 'hours' | 'day' | 'days' | 'week' | 'weeks'}`;
+export type Weekday = 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';
+/** 'HH:mm' (24h, leading zeros). The type cannot express digit ranges, so builders validate at runtime via timeOfDayMinutes. */
+export type TimeOfDay = `${string}:${string}`;
+/**
+ * Parse an 'HH:mm' literal to minutes since midnight, throwing on anything the
+ * type let through ('9:00', '25:00', 'ab:cd').
+ * @internal shared by flow builders, not part of the public API
+ */
+export declare function timeOfDayMinutes(value: TimeOfDay): number;
+/**
+ * Duration parsing delegates to `ms` (typed StringValue); Duration is it's
+ * stricter, full-word subset.
+ * @internal shared by condition/flow/workflow, not part of the public API
+ */
+export declare function durationIR(value: Duration): DurationIR;
+//#endregion
+//# sourceMappingURL=base.d.cts.map

package/dist/dsl/base.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.cts","names":[],"sources":["../../src/dsl/base.ts"],"mappings":";;;;;;;;;;;;;;;;YAkBY;;;;;;iBAOK;EACf;EACA;;;YAIU;YAYA;;YAGA;;;;;;wBASI,iBAAiB,OAAO;;;;;;wBAWxB,WAAW,OAAO,WAAW"}

package/dist/dsl/base.d.mts

@@ -0,0 +1,45 @@
+import { DurationIR } from "../ir.mjs";
+//#region src/dsl/base.d.ts
+/**
+ * Base vocabulary shared by the whole DSL: the schema constraints an app's
+ * types must satisfy, and the literal types (durations, weekdays, clock times)
+ * the builder methods accept.
+ *
+ * Type technique: `Duration` is a template-literal union — '1 huor' is a
+ * compile error, no runtime validation needed for the common case.
+ */
+/**
+ * Event name → payload shape, supplied by the app (its analytics schema).
+ * Constrained to `object` rather than `Record`: interfaces have no implicit
+ * index signature, so a Record constraint would reject an interface-defined
+ * schema. Event names come from `keyof E`, payloads from `E[N]`.
+ */
+export type EventMap = object;
+/**
+ * Base shape of user properties; the app extends it with concrete fields.
+ * `email` is optional: a profile can exist before (or without) an address,
+ * and an email step refuses to send when the recipient is missing.
+ */
+export interface UserPropertyBase {
+  userId: string;
+  email?: string;
+}
+/** Duration literal: '1 hour' / '23 hours' / '30 days' — typos fail to compile. */
+export type Duration = `${number} ${'second' | 'seconds' | 'minute' | 'minutes' | 'hour' | 'hours' | 'day' | 'days' | 'week' | 'weeks'}`;
+export type Weekday = 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';
+/** 'HH:mm' (24h, leading zeros). The type cannot express digit ranges, so builders validate at runtime via timeOfDayMinutes. */
+export type TimeOfDay = `${string}:${string}`;
+/**
+ * Parse an 'HH:mm' literal to minutes since midnight, throwing on anything the
+ * type let through ('9:00', '25:00', 'ab:cd').
+ * @internal shared by flow builders, not part of the public API
+ */
+export declare function timeOfDayMinutes(value: TimeOfDay): number;
+/**
+ * Duration parsing delegates to `ms` (typed StringValue); Duration is it's
+ * stricter, full-word subset.
+ * @internal shared by condition/flow/workflow, not part of the public API
+ */
+export declare function durationIR(value: Duration): DurationIR;
+//#endregion
+//# sourceMappingURL=base.d.mts.map

package/dist/dsl/base.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.mts","names":[],"sources":["../../src/dsl/base.ts"],"mappings":";;;;;;;;;;;;;;;;YAkBY;;;;;;iBAOK;EACf;EACA;;;YAIU;YAYA;;YAGA;;;;;;wBASI,iBAAiB,OAAO;;;;;;wBAWxB,WAAW,OAAO,WAAW"}

package/dist/dsl/base.mjs

@@ -0,0 +1,30 @@
+import ms from "ms";
+//#region src/dsl/base.ts
+const TIME_OF_DAY = /^([01]\d|2[0-3]):([0-5]\d)$/;
+/**
+* Parse an 'HH:mm' literal to minutes since midnight, throwing on anything the
+* type let through ('9:00', '25:00', 'ab:cd').
+* @internal shared by flow builders, not part of the public API
+*/
+function timeOfDayMinutes(value) {
+	const match = TIME_OF_DAY.exec(value);
+	if (!match) throw new Error(`Invalid time of day: '${value}' (expected 'HH:mm', e.g. '09:00')`);
+	return Number(match[1]) * 60 + Number(match[2]);
+}
+/**
+* Duration parsing delegates to `ms` (typed StringValue); Duration is it's
+* stricter, full-word subset.
+* @internal shared by condition/flow/workflow, not part of the public API
+*/
+function durationIR(value) {
+	const millis = ms(value);
+	if (typeof millis !== "number" || Number.isNaN(millis) || millis < 0) throw new Error(`Invalid duration: '${value}'`);
+	return {
+		value,
+		ms: millis
+	};
+}
+//#endregion
+export { durationIR, timeOfDayMinutes };
+
+//# sourceMappingURL=base.mjs.map

package/dist/dsl/base.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.mjs","names":[],"sources":["../../src/dsl/base.ts"],"sourcesContent":["import ms from 'ms';\nimport type { DurationIR } from '../ir';\n\n/**\n * Base vocabulary shared by the whole DSL: the schema constraints an app's\n * types must satisfy, and the literal types (durations, weekdays, clock times)\n * the builder methods accept.\n *\n * Type technique: `Duration` is a template-literal union — '1 huor' is a\n * compile error, no runtime validation needed for the common case.\n */\n\n/**\n * Event name → payload shape, supplied by the app (its analytics schema).\n * Constrained to `object` rather than `Record`: interfaces have no implicit\n * index signature, so a Record constraint would reject an interface-defined\n * schema. Event names come from `keyof E`, payloads from `E[N]`.\n */\nexport type EventMap = object;\n\n/**\n * Base shape of user properties; the app extends it with concrete fields.\n * `email` is optional: a profile can exist before (or without) an address,\n * and an email step refuses to send when the recipient is missing.\n */\nexport interface UserPropertyBase {\n  userId: string;\n  email?: string;\n}\n\n/** Duration literal: '1 hour' / '23 hours' / '30 days' — typos fail to compile. */\nexport type Duration = `${number} ${\n  | 'second'\n  | 'seconds'\n  | 'minute'\n  | 'minutes'\n  | 'hour'\n  | 'hours'\n  | 'day'\n  | 'days'\n  | 'week'\n  | 'weeks'}`;\n\nexport type Weekday = 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';\n\n/** 'HH:mm' (24h, leading zeros). The type cannot express digit ranges, so builders validate at runtime via timeOfDayMinutes. */\nexport type TimeOfDay = `${string}:${string}`;\n\nconst TIME_OF_DAY = /^([01]\\d|2[0-3]):([0-5]\\d)$/;\n\n/**\n * Parse an 'HH:mm' literal to minutes since midnight, throwing on anything the\n * type let through ('9:00', '25:00', 'ab:cd').\n * @internal shared by flow builders, not part of the public API\n */\nexport function timeOfDayMinutes(value: TimeOfDay): number {\n  const match = TIME_OF_DAY.exec(value);\n  if (!match) throw new Error(`Invalid time of day: '${value}' (expected 'HH:mm', e.g. '09:00')`);\n  return Number(match[1]) * 60 + Number(match[2]);\n}\n\n/**\n * Duration parsing delegates to `ms` (typed StringValue); Duration is it's\n * stricter, full-word subset.\n * @internal shared by condition/flow/workflow, not part of the public API\n */\nexport function durationIR(value: Duration): DurationIR {\n  const millis = ms(value);\n  if (typeof millis !== 'number' || Number.isNaN(millis) || millis < 0) {\n    throw new Error(`Invalid duration: '${value}'`);\n  }\n  return { value, ms: millis };\n}\n"],"mappings":";;AAgDA,MAAM,cAAc;;;;;;AAOpB,SAAgB,iBAAiB,OAA0B;CACzD,MAAM,QAAQ,YAAY,KAAK,KAAK;CACpC,IAAI,CAAC,OAAO,MAAM,IAAI,MAAM,yBAAyB,MAAM,mCAAmC;CAC9F,OAAO,OAAO,MAAM,EAAE,IAAI,KAAK,OAAO,MAAM,EAAE;AAChD;;;;;;AAOA,SAAgB,WAAW,OAA6B;CACtD,MAAM,SAAS,GAAG,KAAK;CACvB,IAAI,OAAO,WAAW,YAAY,OAAO,MAAM,MAAM,KAAK,SAAS,GACjE,MAAM,IAAI,MAAM,sBAAsB,MAAM,EAAE;CAEhD,OAAO;EAAE;EAAO,IAAI;CAAO;AAC7B"}