@shware/workflow 0.0.0-stage → 0.1.0

package/dist/dsl/refs.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs.cjs","names":[],"sources":["../../src/dsl/refs.ts"],"sourcesContent":["import type { EventMap, UserPropertyBase } from './base';\n\n/**\n * Reference tables — the DSL's only two type-injection points (drizzle's\n * column-object pattern): `u = user<UserProperty>()` and `e = event<Event>()`.\n * Every other function in the DSL is generic-free and reads types off these\n * references.\n *\n * Type technique: phantom types. `UserPropertyRef<T>` carries the property's\n * type in an optional, never-assigned `__t` — purely so free functions like\n * `eq` can infer T from the reference. At runtime a ref is just\n * `{ type, path }`, produced by a Proxy on property access.\n */\n\n/**\n * User-property reference (drizzle's column equivalent), shared by predicates\n * (eq/gt/…) and message-prop personalization. The phantom type __t is how a\n * free function reads the property's type off the reference.\n */\nexport interface UserPropertyRef<T> {\n  readonly type: 'user_property';\n  readonly path: string;\n  readonly __t?: T;\n}\n\n/** Event reference: the argument to `performed`; future payload where-clauses and value refs hang off it. */\nexport interface EventRef<P = unknown> {\n  readonly type: 'event_ref';\n  readonly name: string;\n  readonly __p?: P;\n}\n\n/** Property reference table: `u.subscription_status` is a UserPropertyRef (drizzle's `users.email`). */\nexport type UserRefs<U> = { readonly [K in keyof U]-?: UserPropertyRef<U[K]> };\n\n/** Event reference table: `e.purchase` is an EventRef. */\nexport type EventRefs<E> = { readonly [K in keyof E]-?: EventRef<E[K]> };\n\n/**\n * Build the reference tables: the app calls each once in its schema module and\n * exports the result (implemented with a Proxy — property access *is* the reference).\n *\n *   export const u = user<UserProperty>();\n *   export const e = event<Event>();\n *\n * From then on predicates and personalization are all property access:\n * eq(u.subscription_status, 'active'), performed(e.purchase, { within: '30 days' }),\n * { plan: u.subscription_plan }.\n *\n * Properties are deliberately single-level: the data source is a database\n * table and is naturally flat, so nested paths are out of scope.\n */\nexport function user<U extends UserPropertyBase>(): UserRefs<U> {\n  return new Proxy({} as UserRefs<U>, {\n    get: (_target, prop) => ({ type: 'user_property', path: String(prop) }),\n  });\n}\n\nexport function event<E extends EventMap>(): EventRefs<E> {\n  return new Proxy({} as EventRefs<E>, {\n    get: (_target, prop) => ({ type: 'event_ref', name: String(prop) }),\n  });\n}\n\nexport type PropInput<T> = T | UserPropertyRef<T>;\nexport type PropsInput<P> = { [K in keyof P]: PropInput<P[K]> };\n\n/** Props may be omitted when a template declares none, and are required when it does. */\nexport type MessageArgs<P> =\n  Record<never, never> extends P ? [props?: PropsInput<P>] : [props: PropsInput<P>];\n\n/* ------------------------------ payload references ----------------------------- */\n\n/**\n * Where a payload ref keeps its own state. A payload ref doubles as the table\n * of its sub-fields, so every *string* key it answered for itself shadowed an\n * author's field of that name: with a payload field called `path`,\n * `performed(e.page_view, (p) => eq(p.path, '/pricing'))` type-checked, handed\n * `prop()` the ref's own prefix instead of a sub-ref, and compiled to a\n * *profile* predicate on a property named 'path' — a mistake that only\n * surfaced later, as a zod error nowhere near the line that caused it. A symbol\n * key cannot be reached by `p.<field>`, so no field name can collide with it.\n */\nexport const PAYLOAD_PATH: unique symbol = Symbol('workflow.payloadPath');\n\n/**\n * Event-payload reference: what a `where` callback's parameter hands out. The\n * path it carries is dotted for nested fields ('tags.utm_source'). Predicates\n * accept it alongside UserPropertyRef and compile to a `payload` condition —\n * which is only valid inside `performed({ where })` / the event trigger's\n * `where` (compileBundle enforces the placement).\n */\nexport interface PayloadRef<T> {\n  readonly [PAYLOAD_PATH]: string;\n  readonly __t?: T;\n}\n\n/** A payload field ref that is itself an object also acts as a table of its sub-field refs. */\nexport type PayloadRefNode<T> = [NonNullable<T>] extends [object]\n  ? PayloadRef<T> & {\n      readonly [K in keyof NonNullable<T> & string]-?: PayloadRefNode<NonNullable<T>[K]>;\n    }\n  : PayloadRef<T>;\n\n/** Payload reference table for an event's payload P — the `p` in `where: (p) => eq(p.platform, 'web')`. */\nexport type PayloadRefs<P> = [P] extends [object]\n  ? { readonly [K in keyof P & string]-?: PayloadRefNode<P[K]> }\n  : Record<string, PayloadRef<unknown>>;\n\n/**\n * Nested Proxy: every string key extends the dotted path, so an author's field\n * may be named anything — including `path` or `type`. The ref's own path reads\n * off PAYLOAD_PATH, the one key a field name cannot spell.\n * @internal used by performed() and trigger.event() to hand `p` to a where callback\n */\nexport function payloadRefs<P>(prefix = ''): PayloadRefs<P> {\n  return new Proxy({} as PayloadRefs<P>, {\n    get: (_target, prop) => {\n      if (prop === PAYLOAD_PATH) return prefix;\n      // Other symbols are the runtime's own probes (inspection, iteration, thenable checks), never fields\n      if (typeof prop === 'symbol') return undefined;\n      return payloadRefs(prefix === '' ? prop : `${prefix}.${prop}`);\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAoDA,SAAgB,OAAgD;CAC9D,OAAO,IAAI,MAAM,CAAC,GAAkB,EAClC,MAAM,SAAS,UAAU;EAAE,MAAM;EAAiB,MAAM,OAAO,IAAI;CAAE,GACvE,CAAC;AACH;AAEA,SAAgB,QAA0C;CACxD,OAAO,IAAI,MAAM,CAAC,GAAmB,EACnC,MAAM,SAAS,UAAU;EAAE,MAAM;EAAa,MAAM,OAAO,IAAI;CAAE,GACnE,CAAC;AACH;;;;;;;;;;;AAqBA,MAAa,eAA8B,OAAO,sBAAsB;;;;;;;AAgCxE,SAAgB,YAAe,SAAS,IAAoB;CAC1D,OAAO,IAAI,MAAM,CAAC,GAAqB,EACrC,MAAM,SAAS,SAAS;EACtB,IAAI,SAAS,cAAc,OAAO;EAElC,IAAI,OAAO,SAAS,UAAU,OAAO,KAAA;EACrC,OAAO,YAAY,WAAW,KAAK,OAAO,GAAG,OAAO,GAAG,MAAM;CAC/D,EACF,CAAC;AACH"}

package/dist/dsl/refs.d.cts

@@ -0,0 +1,88 @@
+import { EventMap, UserPropertyBase } from "./base.cjs";
+//#region src/dsl/refs.d.ts
+/**
+ * Reference tables — the DSL's only two type-injection points (drizzle's
+ * column-object pattern): `u = user<UserProperty>()` and `e = event<Event>()`.
+ * Every other function in the DSL is generic-free and reads types off these
+ * references.
+ *
+ * Type technique: phantom types. `UserPropertyRef<T>` carries the property's
+ * type in an optional, never-assigned `__t` — purely so free functions like
+ * `eq` can infer T from the reference. At runtime a ref is just
+ * `{ type, path }`, produced by a Proxy on property access.
+ */
+/**
+ * User-property reference (drizzle's column equivalent), shared by predicates
+ * (eq/gt/…) and message-prop personalization. The phantom type __t is how a
+ * free function reads the property's type off the reference.
+ */
+export interface UserPropertyRef<T> {
+  readonly type: 'user_property';
+  readonly path: string;
+  readonly __t?: T;
+}
+/** Event reference: the argument to `performed`; future payload where-clauses and value refs hang off it. */
+export interface EventRef<P = unknown> {
+  readonly type: 'event_ref';
+  readonly name: string;
+  readonly __p?: P;
+}
+/** Property reference table: `u.subscription_status` is a UserPropertyRef (drizzle's `users.email`). */
+export type UserRefs<U> = { readonly [K in keyof U]-?: UserPropertyRef<U[K]>; };
+/** Event reference table: `e.purchase` is an EventRef. */
+export type EventRefs<E> = { readonly [K in keyof E]-?: EventRef<E[K]>; };
+/**
+ * Build the reference tables: the app calls each once in its schema module and
+ * exports the result (implemented with a Proxy — property access *is* the reference).
+ *
+ *   export const u = user<UserProperty>();
+ *   export const e = event<Event>();
+ *
+ * From then on predicates and personalization are all property access:
+ * eq(u.subscription_status, 'active'), performed(e.purchase, { within: '30 days' }),
+ * { plan: u.subscription_plan }.
+ *
+ * Properties are deliberately single-level: the data source is a database
+ * table and is naturally flat, so nested paths are out of scope.
+ */
+export declare function user<U extends UserPropertyBase>(): UserRefs<U>;
+export declare function event<E extends EventMap>(): EventRefs<E>;
+export type PropInput<T> = T | UserPropertyRef<T>;
+export type PropsInput<P> = { [K in keyof P]: PropInput<P[K]>; };
+/** Props may be omitted when a template declares none, and are required when it does. */
+export type MessageArgs<P> = Record<never, never> extends P ? [props?: PropsInput<P>] : [props: PropsInput<P>];
+/**
+ * Where a payload ref keeps its own state. A payload ref doubles as the table
+ * of its sub-fields, so every *string* key it answered for itself shadowed an
+ * author's field of that name: with a payload field called `path`,
+ * `performed(e.page_view, (p) => eq(p.path, '/pricing'))` type-checked, handed
+ * `prop()` the ref's own prefix instead of a sub-ref, and compiled to a
+ * *profile* predicate on a property named 'path' — a mistake that only
+ * surfaced later, as a zod error nowhere near the line that caused it. A symbol
+ * key cannot be reached by `p.<field>`, so no field name can collide with it.
+ */
+export declare const PAYLOAD_PATH: unique symbol;
+/**
+ * Event-payload reference: what a `where` callback's parameter hands out. The
+ * path it carries is dotted for nested fields ('tags.utm_source'). Predicates
+ * accept it alongside UserPropertyRef and compile to a `payload` condition —
+ * which is only valid inside `performed({ where })` / the event trigger's
+ * `where` (compileBundle enforces the placement).
+ */
+export interface PayloadRef<T> {
+  readonly [PAYLOAD_PATH]: string;
+  readonly __t?: T;
+}
+/** A payload field ref that is itself an object also acts as a table of its sub-field refs. */
+export type PayloadRefNode<T> = [NonNullable<T>] extends [object] ? PayloadRef<T> & { readonly [K in keyof NonNullable<T> & string]-?: PayloadRefNode<NonNullable<T>[K]>; } : PayloadRef<T>;
+/** Payload reference table for an event's payload P — the `p` in `where: (p) => eq(p.platform, 'web')`. */
+export type PayloadRefs<P> = [P] extends [object] ? { readonly [K in keyof P & string]-?: PayloadRefNode<P[K]>; } : Record<string, PayloadRef<unknown>>;
+/**
+ * Nested Proxy: every string key extends the dotted path, so an author's field
+ * may be named anything — including `path` or `type`. The ref's own path reads
+ * off PAYLOAD_PATH, the one key a field name cannot spell.
+ * @internal used by performed() and trigger.event() to hand `p` to a where callback
+ */
+export declare function payloadRefs<P>(prefix?: string): PayloadRefs<P>;
+//#endregion
+//# sourceMappingURL=refs.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"refs.d.cts","names":[],"sources":["../../src/dsl/refs.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBAmBiB,gBAAgB;WACtB;WACA;WACA,MAAM;;;iBAIA,SAAS;WACf;WACA;WACA,MAAM;;;YAIL,SAAS,iBAAiB,WAAW,MAAM,gBAAgB,EAAE;;YAG7D,UAAU,iBAAiB,WAAW,MAAM,SAAS,EAAE;;;;;;;;;;;;;;;wBAgBnD,KAAK,UAAU,qBAAqB,SAAS;wBAM7C,MAAM,UAAU,aAAa,UAAU;YAM3C,UAAU,KAAK,IAAI,gBAAgB;YACnC,WAAW,QAAQ,WAAW,IAAI,UAAU,EAAE;;YAG9C,YAAY,KACtB,6BAA6B,KAAK,QAAQ,WAAW,OAAO,OAAO,WAAW;;;;;;;;;;;qBAcnE;;;;;;;;iBASI,WAAW;YAChB;WACD,MAAM;;;YAIL,eAAe,MAAM,YAAY,uBACzC,WAAW,iBACC,WAAW,YAAY,gBAAgB,eAAe,YAAY,GAAG,SAEjF,WAAW;;YAGH,YAAY,MAAM,kCACd,WAAW,eAAe,eAAe,EAAE,SACvD,eAAe;;;;;;;wBAQH,YAAY,GAAG,kBAAc,YAAY"}

package/dist/dsl/refs.d.mts

@@ -0,0 +1,88 @@
+import { EventMap, UserPropertyBase } from "./base.mjs";
+//#region src/dsl/refs.d.ts
+/**
+ * Reference tables — the DSL's only two type-injection points (drizzle's
+ * column-object pattern): `u = user<UserProperty>()` and `e = event<Event>()`.
+ * Every other function in the DSL is generic-free and reads types off these
+ * references.
+ *
+ * Type technique: phantom types. `UserPropertyRef<T>` carries the property's
+ * type in an optional, never-assigned `__t` — purely so free functions like
+ * `eq` can infer T from the reference. At runtime a ref is just
+ * `{ type, path }`, produced by a Proxy on property access.
+ */
+/**
+ * User-property reference (drizzle's column equivalent), shared by predicates
+ * (eq/gt/…) and message-prop personalization. The phantom type __t is how a
+ * free function reads the property's type off the reference.
+ */
+export interface UserPropertyRef<T> {
+  readonly type: 'user_property';
+  readonly path: string;
+  readonly __t?: T;
+}
+/** Event reference: the argument to `performed`; future payload where-clauses and value refs hang off it. */
+export interface EventRef<P = unknown> {
+  readonly type: 'event_ref';
+  readonly name: string;
+  readonly __p?: P;
+}
+/** Property reference table: `u.subscription_status` is a UserPropertyRef (drizzle's `users.email`). */
+export type UserRefs<U> = { readonly [K in keyof U]-?: UserPropertyRef<U[K]>; };
+/** Event reference table: `e.purchase` is an EventRef. */
+export type EventRefs<E> = { readonly [K in keyof E]-?: EventRef<E[K]>; };
+/**
+ * Build the reference tables: the app calls each once in its schema module and
+ * exports the result (implemented with a Proxy — property access *is* the reference).
+ *
+ *   export const u = user<UserProperty>();
+ *   export const e = event<Event>();
+ *
+ * From then on predicates and personalization are all property access:
+ * eq(u.subscription_status, 'active'), performed(e.purchase, { within: '30 days' }),
+ * { plan: u.subscription_plan }.
+ *
+ * Properties are deliberately single-level: the data source is a database
+ * table and is naturally flat, so nested paths are out of scope.
+ */
+export declare function user<U extends UserPropertyBase>(): UserRefs<U>;
+export declare function event<E extends EventMap>(): EventRefs<E>;
+export type PropInput<T> = T | UserPropertyRef<T>;
+export type PropsInput<P> = { [K in keyof P]: PropInput<P[K]>; };
+/** Props may be omitted when a template declares none, and are required when it does. */
+export type MessageArgs<P> = Record<never, never> extends P ? [props?: PropsInput<P>] : [props: PropsInput<P>];
+/**
+ * Where a payload ref keeps its own state. A payload ref doubles as the table
+ * of its sub-fields, so every *string* key it answered for itself shadowed an
+ * author's field of that name: with a payload field called `path`,
+ * `performed(e.page_view, (p) => eq(p.path, '/pricing'))` type-checked, handed
+ * `prop()` the ref's own prefix instead of a sub-ref, and compiled to a
+ * *profile* predicate on a property named 'path' — a mistake that only
+ * surfaced later, as a zod error nowhere near the line that caused it. A symbol
+ * key cannot be reached by `p.<field>`, so no field name can collide with it.
+ */
+export declare const PAYLOAD_PATH: unique symbol;
+/**
+ * Event-payload reference: what a `where` callback's parameter hands out. The
+ * path it carries is dotted for nested fields ('tags.utm_source'). Predicates
+ * accept it alongside UserPropertyRef and compile to a `payload` condition —
+ * which is only valid inside `performed({ where })` / the event trigger's
+ * `where` (compileBundle enforces the placement).
+ */
+export interface PayloadRef<T> {
+  readonly [PAYLOAD_PATH]: string;
+  readonly __t?: T;
+}
+/** A payload field ref that is itself an object also acts as a table of its sub-field refs. */
+export type PayloadRefNode<T> = [NonNullable<T>] extends [object] ? PayloadRef<T> & { readonly [K in keyof NonNullable<T> & string]-?: PayloadRefNode<NonNullable<T>[K]>; } : PayloadRef<T>;
+/** Payload reference table for an event's payload P — the `p` in `where: (p) => eq(p.platform, 'web')`. */
+export type PayloadRefs<P> = [P] extends [object] ? { readonly [K in keyof P & string]-?: PayloadRefNode<P[K]>; } : Record<string, PayloadRef<unknown>>;
+/**
+ * Nested Proxy: every string key extends the dotted path, so an author's field
+ * may be named anything — including `path` or `type`. The ref's own path reads
+ * off PAYLOAD_PATH, the one key a field name cannot spell.
+ * @internal used by performed() and trigger.event() to hand `p` to a where callback
+ */
+export declare function payloadRefs<P>(prefix?: string): PayloadRefs<P>;
+//#endregion
+//# sourceMappingURL=refs.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"refs.d.mts","names":[],"sources":["../../src/dsl/refs.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBAmBiB,gBAAgB;WACtB;WACA;WACA,MAAM;;;iBAIA,SAAS;WACf;WACA;WACA,MAAM;;;YAIL,SAAS,iBAAiB,WAAW,MAAM,gBAAgB,EAAE;;YAG7D,UAAU,iBAAiB,WAAW,MAAM,SAAS,EAAE;;;;;;;;;;;;;;;wBAgBnD,KAAK,UAAU,qBAAqB,SAAS;wBAM7C,MAAM,UAAU,aAAa,UAAU;YAM3C,UAAU,KAAK,IAAI,gBAAgB;YACnC,WAAW,QAAQ,WAAW,IAAI,UAAU,EAAE;;YAG9C,YAAY,KACtB,6BAA6B,KAAK,QAAQ,WAAW,OAAO,OAAO,WAAW;;;;;;;;;;;qBAcnE;;;;;;;;iBASI,WAAW;YAChB;WACD,MAAM;;;YAIL,eAAe,MAAM,YAAY,uBACzC,WAAW,iBACC,WAAW,YAAY,gBAAgB,eAAe,YAAY,GAAG,SAEjF,WAAW;;YAGH,YAAY,MAAM,kCACd,WAAW,eAAe,eAAe,EAAE,SACvD,eAAe;;;;;;;wBAQH,YAAY,GAAG,kBAAc,YAAY"}

package/dist/dsl/refs.mjs

@@ -0,0 +1,55 @@
+//#region src/dsl/refs.ts
+/**
+* Build the reference tables: the app calls each once in its schema module and
+* exports the result (implemented with a Proxy — property access *is* the reference).
+*
+*   export const u = user<UserProperty>();
+*   export const e = event<Event>();
+*
+* From then on predicates and personalization are all property access:
+* eq(u.subscription_status, 'active'), performed(e.purchase, { within: '30 days' }),
+* { plan: u.subscription_plan }.
+*
+* Properties are deliberately single-level: the data source is a database
+* table and is naturally flat, so nested paths are out of scope.
+*/
+function user() {
+	return new Proxy({}, { get: (_target, prop) => ({
+		type: "user_property",
+		path: String(prop)
+	}) });
+}
+function event() {
+	return new Proxy({}, { get: (_target, prop) => ({
+		type: "event_ref",
+		name: String(prop)
+	}) });
+}
+/**
+* Where a payload ref keeps its own state. A payload ref doubles as the table
+* of its sub-fields, so every *string* key it answered for itself shadowed an
+* author's field of that name: with a payload field called `path`,
+* `performed(e.page_view, (p) => eq(p.path, '/pricing'))` type-checked, handed
+* `prop()` the ref's own prefix instead of a sub-ref, and compiled to a
+* *profile* predicate on a property named 'path' — a mistake that only
+* surfaced later, as a zod error nowhere near the line that caused it. A symbol
+* key cannot be reached by `p.<field>`, so no field name can collide with it.
+*/
+const PAYLOAD_PATH = Symbol("workflow.payloadPath");
+/**
+* Nested Proxy: every string key extends the dotted path, so an author's field
+* may be named anything — including `path` or `type`. The ref's own path reads
+* off PAYLOAD_PATH, the one key a field name cannot spell.
+* @internal used by performed() and trigger.event() to hand `p` to a where callback
+*/
+function payloadRefs(prefix = "") {
+	return new Proxy({}, { get: (_target, prop) => {
+		if (prop === PAYLOAD_PATH) return prefix;
+		if (typeof prop === "symbol") return void 0;
+		return payloadRefs(prefix === "" ? prop : `${prefix}.${prop}`);
+	} });
+}
+//#endregion
+export { PAYLOAD_PATH, event, payloadRefs, user };
+
+//# sourceMappingURL=refs.mjs.map

package/dist/dsl/refs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs.mjs","names":[],"sources":["../../src/dsl/refs.ts"],"sourcesContent":["import type { EventMap, UserPropertyBase } from './base';\n\n/**\n * Reference tables — the DSL's only two type-injection points (drizzle's\n * column-object pattern): `u = user<UserProperty>()` and `e = event<Event>()`.\n * Every other function in the DSL is generic-free and reads types off these\n * references.\n *\n * Type technique: phantom types. `UserPropertyRef<T>` carries the property's\n * type in an optional, never-assigned `__t` — purely so free functions like\n * `eq` can infer T from the reference. At runtime a ref is just\n * `{ type, path }`, produced by a Proxy on property access.\n */\n\n/**\n * User-property reference (drizzle's column equivalent), shared by predicates\n * (eq/gt/…) and message-prop personalization. The phantom type __t is how a\n * free function reads the property's type off the reference.\n */\nexport interface UserPropertyRef<T> {\n  readonly type: 'user_property';\n  readonly path: string;\n  readonly __t?: T;\n}\n\n/** Event reference: the argument to `performed`; future payload where-clauses and value refs hang off it. */\nexport interface EventRef<P = unknown> {\n  readonly type: 'event_ref';\n  readonly name: string;\n  readonly __p?: P;\n}\n\n/** Property reference table: `u.subscription_status` is a UserPropertyRef (drizzle's `users.email`). */\nexport type UserRefs<U> = { readonly [K in keyof U]-?: UserPropertyRef<U[K]> };\n\n/** Event reference table: `e.purchase` is an EventRef. */\nexport type EventRefs<E> = { readonly [K in keyof E]-?: EventRef<E[K]> };\n\n/**\n * Build the reference tables: the app calls each once in its schema module and\n * exports the result (implemented with a Proxy — property access *is* the reference).\n *\n *   export const u = user<UserProperty>();\n *   export const e = event<Event>();\n *\n * From then on predicates and personalization are all property access:\n * eq(u.subscription_status, 'active'), performed(e.purchase, { within: '30 days' }),\n * { plan: u.subscription_plan }.\n *\n * Properties are deliberately single-level: the data source is a database\n * table and is naturally flat, so nested paths are out of scope.\n */\nexport function user<U extends UserPropertyBase>(): UserRefs<U> {\n  return new Proxy({} as UserRefs<U>, {\n    get: (_target, prop) => ({ type: 'user_property', path: String(prop) }),\n  });\n}\n\nexport function event<E extends EventMap>(): EventRefs<E> {\n  return new Proxy({} as EventRefs<E>, {\n    get: (_target, prop) => ({ type: 'event_ref', name: String(prop) }),\n  });\n}\n\nexport type PropInput<T> = T | UserPropertyRef<T>;\nexport type PropsInput<P> = { [K in keyof P]: PropInput<P[K]> };\n\n/** Props may be omitted when a template declares none, and are required when it does. */\nexport type MessageArgs<P> =\n  Record<never, never> extends P ? [props?: PropsInput<P>] : [props: PropsInput<P>];\n\n/* ------------------------------ payload references ----------------------------- */\n\n/**\n * Where a payload ref keeps its own state. A payload ref doubles as the table\n * of its sub-fields, so every *string* key it answered for itself shadowed an\n * author's field of that name: with a payload field called `path`,\n * `performed(e.page_view, (p) => eq(p.path, '/pricing'))` type-checked, handed\n * `prop()` the ref's own prefix instead of a sub-ref, and compiled to a\n * *profile* predicate on a property named 'path' — a mistake that only\n * surfaced later, as a zod error nowhere near the line that caused it. A symbol\n * key cannot be reached by `p.<field>`, so no field name can collide with it.\n */\nexport const PAYLOAD_PATH: unique symbol = Symbol('workflow.payloadPath');\n\n/**\n * Event-payload reference: what a `where` callback's parameter hands out. The\n * path it carries is dotted for nested fields ('tags.utm_source'). Predicates\n * accept it alongside UserPropertyRef and compile to a `payload` condition —\n * which is only valid inside `performed({ where })` / the event trigger's\n * `where` (compileBundle enforces the placement).\n */\nexport interface PayloadRef<T> {\n  readonly [PAYLOAD_PATH]: string;\n  readonly __t?: T;\n}\n\n/** A payload field ref that is itself an object also acts as a table of its sub-field refs. */\nexport type PayloadRefNode<T> = [NonNullable<T>] extends [object]\n  ? PayloadRef<T> & {\n      readonly [K in keyof NonNullable<T> & string]-?: PayloadRefNode<NonNullable<T>[K]>;\n    }\n  : PayloadRef<T>;\n\n/** Payload reference table for an event's payload P — the `p` in `where: (p) => eq(p.platform, 'web')`. */\nexport type PayloadRefs<P> = [P] extends [object]\n  ? { readonly [K in keyof P & string]-?: PayloadRefNode<P[K]> }\n  : Record<string, PayloadRef<unknown>>;\n\n/**\n * Nested Proxy: every string key extends the dotted path, so an author's field\n * may be named anything — including `path` or `type`. The ref's own path reads\n * off PAYLOAD_PATH, the one key a field name cannot spell.\n * @internal used by performed() and trigger.event() to hand `p` to a where callback\n */\nexport function payloadRefs<P>(prefix = ''): PayloadRefs<P> {\n  return new Proxy({} as PayloadRefs<P>, {\n    get: (_target, prop) => {\n      if (prop === PAYLOAD_PATH) return prefix;\n      // Other symbols are the runtime's own probes (inspection, iteration, thenable checks), never fields\n      if (typeof prop === 'symbol') return undefined;\n      return payloadRefs(prefix === '' ? prop : `${prefix}.${prop}`);\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;AAoDA,SAAgB,OAAgD;CAC9D,OAAO,IAAI,MAAM,CAAC,GAAkB,EAClC,MAAM,SAAS,UAAU;EAAE,MAAM;EAAiB,MAAM,OAAO,IAAI;CAAE,GACvE,CAAC;AACH;AAEA,SAAgB,QAA0C;CACxD,OAAO,IAAI,MAAM,CAAC,GAAmB,EACnC,MAAM,SAAS,UAAU;EAAE,MAAM;EAAa,MAAM,OAAO,IAAI;CAAE,GACnE,CAAC;AACH;;;;;;;;;;;AAqBA,MAAa,eAA8B,OAAO,sBAAsB;;;;;;;AAgCxE,SAAgB,YAAe,SAAS,IAAoB;CAC1D,OAAO,IAAI,MAAM,CAAC,GAAqB,EACrC,MAAM,SAAS,SAAS;EACtB,IAAI,SAAS,cAAc,OAAO;EAElC,IAAI,OAAO,SAAS,UAAU,OAAO,KAAA;EACrC,OAAO,YAAY,WAAW,KAAK,OAAO,GAAG,OAAO,GAAG,MAAM;CAC/D,EACF,CAAC;AACH"}

package/dist/dsl/template.cjs

@@ -0,0 +1,65 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_templates = require("../templates.cjs");
+//#region src/dsl/template.ts
+const makeTemplate = (channel) => (key) => ({
+	channel,
+	key
+});
+/**
+* Unbound template references, props typed by hand. Email and push refs come
+* from the registries (`templates<Emails, Pushes>()`), which type both key and
+* props; this is the low-level form for channels without a registry (sms,
+* slack, …) and for tests.
+*
+*   const alert = template.slack<{ plan: string }>('cs_churn_alert');
+*/
+const template = {
+	email: makeTemplate("email"),
+	sms: makeTemplate("sms"),
+	push: makeTemplate("push"),
+	inApp: makeTemplate("in_app"),
+	slack: makeTemplate("slack"),
+	discord: makeTemplate("discord"),
+	survey: makeTemplate("survey")
+};
+/**
+* Template references derived from the registries themselves: **the
+* registries type the keys** — an unregistered key fails to compile, and a
+* push template is not accepted where an email is — and each template's
+* `props` schema types its use sites. Templates are registered once; the
+* config takes the registries, the workflows take the references:
+*
+*   export const registry = { email, push };
+*   export const t = templates(registry);
+*   flow.email(t.email.welcome, { name: u.name });
+*
+* Each reference is a plain `{ channel, key }` built from the registry's own
+* keys; no template is rendered, and the registries are left untouched.
+*/
+function templates(registry) {
+	return {
+		email: refTable("email", registry.email, require_templates.isEmailTemplate),
+		push: refTable("push", registry.push, require_templates.isPushTemplate),
+		discord: refTable("discord", registry.discord, require_templates.isDiscordTemplate),
+		slack: refTable("slack", registry.slack, require_templates.isSlackTemplate)
+	};
+}
+const ARTICLE = {
+	email: "an email",
+	push: "a push",
+	discord: "a Discord",
+	slack: "a Slack"
+};
+function refTable(channel, entries, is) {
+	const table = Object.create(null);
+	for (const [key, entry] of Object.entries(entries ?? {})) {
+		if (!is(entry)) throw new TypeError(`templates(): '${key}' in the ${channel} registry is not ${ARTICLE[channel]} template`);
+		table[key] = template[channel](key);
+	}
+	return Object.freeze(table);
+}
+//#endregion
+exports.template = template;
+exports.templates = templates;
+
+//# sourceMappingURL=template.cjs.map

package/dist/dsl/template.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.cjs","names":["isEmailTemplate","isPushTemplate","isDiscordTemplate","isSlackTemplate"],"sources":["../../src/dsl/template.ts"],"sourcesContent":["/**\n * Templates — named message-content assets. The DSL only ever holds a\n * reference ({ channel, key, phantom props }); the content itself (react-email\n * components) lives in the app and meets the reference again in the studio and\n * at send time via the registry.\n *\n * Type technique: `templates(registry)` derives the references from the\n * registries so **the registries type the keys** — an unregistered key fails\n * to compile — while `PropsOf<M>` reads the props contract off each template's\n * Zod schema, so it is written exactly once.\n */\n\nimport type * as core from 'zod/v4/core';\nimport {\n  type DiscordTemplate,\n  type EmailTemplate,\n  type PropsSchema,\n  type PushTemplate,\n  type SlackTemplate,\n  isDiscordTemplate,\n  isEmailTemplate,\n  isPushTemplate,\n  isSlackTemplate,\n} from '../templates';\n\nexport type Channel = 'email' | 'sms' | 'push' | 'in_app' | 'slack' | 'discord' | 'survey';\n\nexport type EmptyProps = Record<never, never>;\n\n/**\n * Template reference: a top-level named asset, reusable across workflows and\n * versioned on its own. The props shape is declared here and checked at use.\n */\nexport interface TemplateRef<C extends Channel = Channel, P extends object = EmptyProps> {\n  readonly channel: C;\n  readonly key: string;\n  readonly __props?: P;\n}\n\nexport interface TemplateFactory {\n  email<P extends object = EmptyProps>(key: string): TemplateRef<'email', P>;\n  sms<P extends object = EmptyProps>(key: string): TemplateRef<'sms', P>;\n  push<P extends object = EmptyProps>(key: string): TemplateRef<'push', P>;\n  inApp<P extends object = EmptyProps>(key: string): TemplateRef<'in_app', P>;\n  slack<P extends object = EmptyProps>(key: string): TemplateRef<'slack', P>;\n  discord<P extends object = EmptyProps>(key: string): TemplateRef<'discord', P>;\n  survey<P extends object = EmptyProps>(key: string): TemplateRef<'survey', P>;\n}\n\nconst makeTemplate =\n  <C extends Channel>(channel: C) =>\n  <P extends object = EmptyProps>(key: string): TemplateRef<C, P> => ({ channel, key });\n\n/**\n * Unbound template references, props typed by hand. Email and push refs come\n * from the registries (`templates<Emails, Pushes>()`), which type both key and\n * props; this is the low-level form for channels without a registry (sms,\n * slack, …) and for tests.\n *\n *   const alert = template.slack<{ plan: string }>('cs_churn_alert');\n */\nexport const template: TemplateFactory = {\n  email: makeTemplate('email'),\n  sms: makeTemplate('sms'),\n  push: makeTemplate('push'),\n  inApp: makeTemplate('in_app'),\n  slack: makeTemplate('slack'),\n  discord: makeTemplate('discord'),\n  survey: makeTemplate('survey'),\n};\n\n/* ----------------------------- Template registry ---------------------------- */\n\n/** Template props: the input type of the template's Zod `props` schema — what the DSL passes. */\nexport type PropsOf<M> = M extends\n  | EmailTemplate<infer S>\n  | PushTemplate<infer S>\n  | DiscordTemplate<infer S, never>\n  | SlackTemplate<infer S, never>\n  ? core.input<S> extends object\n    ? core.input<S>\n    : EmptyProps\n  : never;\n\n/**\n * The channel registries: what the config registers as `templates` and what\n * `templates()` derives the references from — one type for both. Leave it\n * inferred, or check it with `satisfies TemplateRegistry`: annotating a value\n * as the bare type widens the keys to `string`.\n */\nexport interface TemplateRegistry<\n  E extends Readonly<Record<string, EmailTemplate>> = Readonly<Record<string, EmailTemplate>>,\n  P extends Readonly<Record<string, PushTemplate>> = Readonly<Record<string, PushTemplate>>,\n> {\n  readonly email?: E;\n  readonly push?: P;\n  /** Discord webhook templates, each typed by the host's Env its `webhook` reads. */\n  readonly discord?: Readonly<Record<string, DiscordTemplate<PropsSchema, never>>>;\n  readonly slack?: Readonly<Record<string, SlackTemplate<PropsSchema, never>>>;\n}\n\n/** One channel's registry in `R`, without the `undefined` of an optional field; `never` when absent. */\ntype ChannelRegistry<R, K extends 'email' | 'push' | 'discord' | 'slack'> = K extends keyof R\n  ? Exclude<R[K], undefined>\n  : never;\n\n/** One reference per registered key, each typed by its own template's `props`. */\nexport type TemplateRefTable<C extends Channel, R> = {\n  readonly [K in keyof R & string]: TemplateRef<C, PropsOf<R[K]>>;\n};\n\n/** `t.email.<key>` / `t.push.<key>`; a channel the registry leaves out is an empty table. */\nexport interface TemplateRefs<R extends TemplateRegistry> {\n  readonly email: [ChannelRegistry<R, 'email'>] extends [never]\n    ? EmptyProps\n    : TemplateRefTable<'email', ChannelRegistry<R, 'email'>>;\n  readonly push: [ChannelRegistry<R, 'push'>] extends [never]\n    ? EmptyProps\n    : TemplateRefTable<'push', ChannelRegistry<R, 'push'>>;\n  readonly discord: [ChannelRegistry<R, 'discord'>] extends [never]\n    ? EmptyProps\n    : TemplateRefTable<'discord', ChannelRegistry<R, 'discord'>>;\n  readonly slack: [ChannelRegistry<R, 'slack'>] extends [never]\n    ? EmptyProps\n    : TemplateRefTable<'slack', ChannelRegistry<R, 'slack'>>;\n}\n\n/**\n * Template references derived from the registries themselves: **the\n * registries type the keys** — an unregistered key fails to compile, and a\n * push template is not accepted where an email is — and each template's\n * `props` schema types its use sites. Templates are registered once; the\n * config takes the registries, the workflows take the references:\n *\n *   export const registry = { email, push };\n *   export const t = templates(registry);\n *   flow.email(t.email.welcome, { name: u.name });\n *\n * Each reference is a plain `{ channel, key }` built from the registry's own\n * keys; no template is rendered, and the registries are left untouched.\n */\nexport function templates<const R extends TemplateRegistry>(registry: R): TemplateRefs<R> {\n  return {\n    email: refTable('email', registry.email, isEmailTemplate),\n    push: refTable('push', registry.push, isPushTemplate),\n    discord: refTable('discord', registry.discord, isDiscordTemplate),\n    slack: refTable('slack', registry.slack, isSlackTemplate),\n  } as unknown as TemplateRefs<R>;\n}\n\nconst ARTICLE: Record<'email' | 'push' | 'discord' | 'slack', string> = {\n  email: 'an email',\n  push: 'a push',\n  discord: 'a Discord',\n  slack: 'a Slack',\n};\n\nfunction refTable(\n  channel: 'email' | 'push' | 'discord' | 'slack',\n  entries: Readonly<Record<string, unknown>> | undefined,\n  is: (value: unknown) => boolean\n): Readonly<Record<string, TemplateRef>> {\n  const table: Record<string, TemplateRef> = Object.create(null);\n  for (const [key, entry] of Object.entries(entries ?? {})) {\n    if (!is(entry)) {\n      throw new TypeError(\n        `templates(): '${key}' in the ${channel} registry is not ${ARTICLE[channel]} template`\n      );\n    }\n    table[key] = template[channel](key);\n  }\n  return Object.freeze(table);\n}\n"],"mappings":";;;AAiDA,MAAM,gBACgB,aACY,SAAoC;CAAE;CAAS;AAAI;;;;;;;;;AAUrF,MAAa,WAA4B;CACvC,OAAO,aAAa,OAAO;CAC3B,KAAK,aAAa,KAAK;CACvB,MAAM,aAAa,MAAM;CACzB,OAAO,aAAa,QAAQ;CAC5B,OAAO,aAAa,OAAO;CAC3B,SAAS,aAAa,SAAS;CAC/B,QAAQ,aAAa,QAAQ;AAC/B;;;;;;;;;;;;;;;AAwEA,SAAgB,UAA4C,UAA8B;CACxF,OAAO;EACL,OAAO,SAAS,SAAS,SAAS,OAAOA,kBAAAA,eAAe;EACxD,MAAM,SAAS,QAAQ,SAAS,MAAMC,kBAAAA,cAAc;EACpD,SAAS,SAAS,WAAW,SAAS,SAASC,kBAAAA,iBAAiB;EAChE,OAAO,SAAS,SAAS,SAAS,OAAOC,kBAAAA,eAAe;CAC1D;AACF;AAEA,MAAM,UAAkE;CACtE,OAAO;CACP,MAAM;CACN,SAAS;CACT,OAAO;AACT;AAEA,SAAS,SACP,SACA,SACA,IACuC;CACvC,MAAM,QAAqC,OAAO,OAAO,IAAI;CAC7D,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,WAAW,CAAC,CAAC,GAAG;EACxD,IAAI,CAAC,GAAG,KAAK,GACX,MAAM,IAAI,UACR,iBAAiB,IAAI,WAAW,QAAQ,mBAAmB,QAAQ,SAAS,UAC9E;EAEF,MAAM,OAAO,SAAS,QAAQ,CAAC,GAAG;CACpC;CACA,OAAO,OAAO,OAAO,KAAK;AAC5B"}

package/dist/dsl/template.d.cts

@@ -0,0 +1,75 @@
+import { DiscordTemplate, EmailTemplate, PropsSchema, PushTemplate, SlackTemplate } from "../templates.cjs";
+import * as core from "zod/v4/core";
+//#region src/dsl/template.d.ts
+export type Channel = 'email' | 'sms' | 'push' | 'in_app' | 'slack' | 'discord' | 'survey';
+export type EmptyProps = Record<never, never>;
+/**
+ * Template reference: a top-level named asset, reusable across workflows and
+ * versioned on its own. The props shape is declared here and checked at use.
+ */
+export interface TemplateRef<C extends Channel = Channel, P extends object = EmptyProps> {
+  readonly channel: C;
+  readonly key: string;
+  readonly __props?: P;
+}
+export interface TemplateFactory {
+  email<P extends object = EmptyProps>(key: string): TemplateRef<'email', P>;
+  sms<P extends object = EmptyProps>(key: string): TemplateRef<'sms', P>;
+  push<P extends object = EmptyProps>(key: string): TemplateRef<'push', P>;
+  inApp<P extends object = EmptyProps>(key: string): TemplateRef<'in_app', P>;
+  slack<P extends object = EmptyProps>(key: string): TemplateRef<'slack', P>;
+  discord<P extends object = EmptyProps>(key: string): TemplateRef<'discord', P>;
+  survey<P extends object = EmptyProps>(key: string): TemplateRef<'survey', P>;
+}
+/**
+ * Unbound template references, props typed by hand. Email and push refs come
+ * from the registries (`templates<Emails, Pushes>()`), which type both key and
+ * props; this is the low-level form for channels without a registry (sms,
+ * slack, …) and for tests.
+ *
+ *   const alert = template.slack<{ plan: string }>('cs_churn_alert');
+ */
+export declare const template: TemplateFactory;
+/** Template props: the input type of the template's Zod `props` schema — what the DSL passes. */
+export type PropsOf<M> = M extends EmailTemplate<infer S> | PushTemplate<infer S> | DiscordTemplate<infer S, never> | SlackTemplate<infer S, never> ? core.input<S> extends object ? core.input<S> : EmptyProps : never;
+/**
+ * The channel registries: what the config registers as `templates` and what
+ * `templates()` derives the references from — one type for both. Leave it
+ * inferred, or check it with `satisfies TemplateRegistry`: annotating a value
+ * as the bare type widens the keys to `string`.
+ */
+export interface TemplateRegistry<E extends Readonly<Record<string, EmailTemplate>> = Readonly<Record<string, EmailTemplate>>, P extends Readonly<Record<string, PushTemplate>> = Readonly<Record<string, PushTemplate>>> {
+  readonly email?: E;
+  readonly push?: P;
+  /** Discord webhook templates, each typed by the host's Env its `webhook` reads. */
+  readonly discord?: Readonly<Record<string, DiscordTemplate<PropsSchema, never>>>;
+  readonly slack?: Readonly<Record<string, SlackTemplate<PropsSchema, never>>>;
+}
+/** One channel's registry in `R`, without the `undefined` of an optional field; `never` when absent. */
+type ChannelRegistry<R, K extends 'email' | 'push' | 'discord' | 'slack'> = K extends keyof R ? Exclude<R[K], undefined> : never;
+/** One reference per registered key, each typed by its own template's `props`. */
+export type TemplateRefTable<C extends Channel, R> = { readonly [K in keyof R & string]: TemplateRef<C, PropsOf<R[K]>>; };
+/** `t.email.<key>` / `t.push.<key>`; a channel the registry leaves out is an empty table. */
+export interface TemplateRefs<R extends TemplateRegistry> {
+  readonly email: [ChannelRegistry<R, 'email'>] extends [never] ? EmptyProps : TemplateRefTable<'email', ChannelRegistry<R, 'email'>>;
+  readonly push: [ChannelRegistry<R, 'push'>] extends [never] ? EmptyProps : TemplateRefTable<'push', ChannelRegistry<R, 'push'>>;
+  readonly discord: [ChannelRegistry<R, 'discord'>] extends [never] ? EmptyProps : TemplateRefTable<'discord', ChannelRegistry<R, 'discord'>>;
+  readonly slack: [ChannelRegistry<R, 'slack'>] extends [never] ? EmptyProps : TemplateRefTable<'slack', ChannelRegistry<R, 'slack'>>;
+}
+/**
+ * Template references derived from the registries themselves: **the
+ * registries type the keys** — an unregistered key fails to compile, and a
+ * push template is not accepted where an email is — and each template's
+ * `props` schema types its use sites. Templates are registered once; the
+ * config takes the registries, the workflows take the references:
+ *
+ *   export const registry = { email, push };
+ *   export const t = templates(registry);
+ *   flow.email(t.email.welcome, { name: u.name });
+ *
+ * Each reference is a plain `{ channel, key }` built from the registry's own
+ * keys; no template is rendered, and the registries are left untouched.
+ */
+export declare function templates<const R extends TemplateRegistry>(registry: R): TemplateRefs<R>;
+//#endregion
+//# sourceMappingURL=template.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.cts","names":[],"sources":["../../src/dsl/template.ts"],"mappings":";;;YAyBY;YAEA,aAAa;;;;;iBAMR,YAAY,UAAU,UAAU,SAAS,mBAAmB;WAClE,SAAS;WACT;WACA,UAAU;;iBAGJ;EACf,MAAM,mBAAmB,YAAY,cAAc,qBAAqB;EACxE,IAAI,mBAAmB,YAAY,cAAc,mBAAmB;EACpE,KAAK,mBAAmB,YAAY,cAAc,oBAAoB;EACtE,MAAM,mBAAmB,YAAY,cAAc,sBAAsB;EACzE,MAAM,mBAAmB,YAAY,cAAc,qBAAqB;EACxE,QAAQ,mBAAmB,YAAY,cAAc,uBAAuB;EAC5E,OAAO,mBAAmB,YAAY,cAAc,sBAAsB;;;;;;;;;;qBAe/D,UAAU;;YAaX,QAAQ,KAAK,UACrB,oBAAoB,KACpB,mBAAmB,KACnB,sBAAsB,YACtB,oBAAoB,YACpB,KAAK,MAAM,oBACT,KAAK,MAAM,KACX;;;;;;;iBASW,iBACf,UAAU,SAAS,eAAe,kBAAkB,SAAS,eAAe,iBAC5E,UAAU,SAAS,eAAe,iBAAiB,SAAS,eAAe;WAElE,QAAQ;WACR,OAAO;;WAEP,UAAU,SAAS,eAAe,gBAAgB;WAClD,QAAQ,SAAS,eAAe,cAAc;;;KAIpD,gBAAgB,GAAG,oDAAoD,gBAAgB,IACxF,QAAQ,EAAE;;YAIF,iBAAiB,UAAU,SAAS,iBACpC,WAAW,aAAa,YAAY,GAAG,QAAQ,EAAE;;iBAI5C,aAAa,UAAU;WAC7B,QAAQ,gBAAgB,+BAC7B,aACA,0BAA0B,gBAAgB;WACrC,OAAO,gBAAgB,8BAC5B,aACA,yBAAyB,gBAAgB;WACpC,UAAU,gBAAgB,iCAC/B,aACA,4BAA4B,gBAAgB;WACvC,QAAQ,gBAAgB,+BAC7B,aACA,0BAA0B,gBAAgB;;;;;;;;;;;;;;;;wBAiBhC,gBAAgB,UAAU,kBAAkB,UAAU,IAAI,aAAa"}

package/dist/dsl/template.d.mts

@@ -0,0 +1,75 @@
+import { DiscordTemplate, EmailTemplate, PropsSchema, PushTemplate, SlackTemplate } from "../templates.mjs";
+import * as core from "zod/v4/core";
+//#region src/dsl/template.d.ts
+export type Channel = 'email' | 'sms' | 'push' | 'in_app' | 'slack' | 'discord' | 'survey';
+export type EmptyProps = Record<never, never>;
+/**
+ * Template reference: a top-level named asset, reusable across workflows and
+ * versioned on its own. The props shape is declared here and checked at use.
+ */
+export interface TemplateRef<C extends Channel = Channel, P extends object = EmptyProps> {
+  readonly channel: C;
+  readonly key: string;
+  readonly __props?: P;
+}
+export interface TemplateFactory {
+  email<P extends object = EmptyProps>(key: string): TemplateRef<'email', P>;
+  sms<P extends object = EmptyProps>(key: string): TemplateRef<'sms', P>;
+  push<P extends object = EmptyProps>(key: string): TemplateRef<'push', P>;
+  inApp<P extends object = EmptyProps>(key: string): TemplateRef<'in_app', P>;
+  slack<P extends object = EmptyProps>(key: string): TemplateRef<'slack', P>;
+  discord<P extends object = EmptyProps>(key: string): TemplateRef<'discord', P>;
+  survey<P extends object = EmptyProps>(key: string): TemplateRef<'survey', P>;
+}
+/**
+ * Unbound template references, props typed by hand. Email and push refs come
+ * from the registries (`templates<Emails, Pushes>()`), which type both key and
+ * props; this is the low-level form for channels without a registry (sms,
+ * slack, …) and for tests.
+ *
+ *   const alert = template.slack<{ plan: string }>('cs_churn_alert');
+ */
+export declare const template: TemplateFactory;
+/** Template props: the input type of the template's Zod `props` schema — what the DSL passes. */
+export type PropsOf<M> = M extends EmailTemplate<infer S> | PushTemplate<infer S> | DiscordTemplate<infer S, never> | SlackTemplate<infer S, never> ? core.input<S> extends object ? core.input<S> : EmptyProps : never;
+/**
+ * The channel registries: what the config registers as `templates` and what
+ * `templates()` derives the references from — one type for both. Leave it
+ * inferred, or check it with `satisfies TemplateRegistry`: annotating a value
+ * as the bare type widens the keys to `string`.
+ */
+export interface TemplateRegistry<E extends Readonly<Record<string, EmailTemplate>> = Readonly<Record<string, EmailTemplate>>, P extends Readonly<Record<string, PushTemplate>> = Readonly<Record<string, PushTemplate>>> {
+  readonly email?: E;
+  readonly push?: P;
+  /** Discord webhook templates, each typed by the host's Env its `webhook` reads. */
+  readonly discord?: Readonly<Record<string, DiscordTemplate<PropsSchema, never>>>;
+  readonly slack?: Readonly<Record<string, SlackTemplate<PropsSchema, never>>>;
+}
+/** One channel's registry in `R`, without the `undefined` of an optional field; `never` when absent. */
+type ChannelRegistry<R, K extends 'email' | 'push' | 'discord' | 'slack'> = K extends keyof R ? Exclude<R[K], undefined> : never;
+/** One reference per registered key, each typed by its own template's `props`. */
+export type TemplateRefTable<C extends Channel, R> = { readonly [K in keyof R & string]: TemplateRef<C, PropsOf<R[K]>>; };
+/** `t.email.<key>` / `t.push.<key>`; a channel the registry leaves out is an empty table. */
+export interface TemplateRefs<R extends TemplateRegistry> {
+  readonly email: [ChannelRegistry<R, 'email'>] extends [never] ? EmptyProps : TemplateRefTable<'email', ChannelRegistry<R, 'email'>>;
+  readonly push: [ChannelRegistry<R, 'push'>] extends [never] ? EmptyProps : TemplateRefTable<'push', ChannelRegistry<R, 'push'>>;
+  readonly discord: [ChannelRegistry<R, 'discord'>] extends [never] ? EmptyProps : TemplateRefTable<'discord', ChannelRegistry<R, 'discord'>>;
+  readonly slack: [ChannelRegistry<R, 'slack'>] extends [never] ? EmptyProps : TemplateRefTable<'slack', ChannelRegistry<R, 'slack'>>;
+}
+/**
+ * Template references derived from the registries themselves: **the
+ * registries type the keys** — an unregistered key fails to compile, and a
+ * push template is not accepted where an email is — and each template's
+ * `props` schema types its use sites. Templates are registered once; the
+ * config takes the registries, the workflows take the references:
+ *
+ *   export const registry = { email, push };
+ *   export const t = templates(registry);
+ *   flow.email(t.email.welcome, { name: u.name });
+ *
+ * Each reference is a plain `{ channel, key }` built from the registry's own
+ * keys; no template is rendered, and the registries are left untouched.
+ */
+export declare function templates<const R extends TemplateRegistry>(registry: R): TemplateRefs<R>;
+//#endregion
+//# sourceMappingURL=template.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.mts","names":[],"sources":["../../src/dsl/template.ts"],"mappings":";;;YAyBY;YAEA,aAAa;;;;;iBAMR,YAAY,UAAU,UAAU,SAAS,mBAAmB;WAClE,SAAS;WACT;WACA,UAAU;;iBAGJ;EACf,MAAM,mBAAmB,YAAY,cAAc,qBAAqB;EACxE,IAAI,mBAAmB,YAAY,cAAc,mBAAmB;EACpE,KAAK,mBAAmB,YAAY,cAAc,oBAAoB;EACtE,MAAM,mBAAmB,YAAY,cAAc,sBAAsB;EACzE,MAAM,mBAAmB,YAAY,cAAc,qBAAqB;EACxE,QAAQ,mBAAmB,YAAY,cAAc,uBAAuB;EAC5E,OAAO,mBAAmB,YAAY,cAAc,sBAAsB;;;;;;;;;;qBAe/D,UAAU;;YAaX,QAAQ,KAAK,UACrB,oBAAoB,KACpB,mBAAmB,KACnB,sBAAsB,YACtB,oBAAoB,YACpB,KAAK,MAAM,oBACT,KAAK,MAAM,KACX;;;;;;;iBASW,iBACf,UAAU,SAAS,eAAe,kBAAkB,SAAS,eAAe,iBAC5E,UAAU,SAAS,eAAe,iBAAiB,SAAS,eAAe;WAElE,QAAQ;WACR,OAAO;;WAEP,UAAU,SAAS,eAAe,gBAAgB;WAClD,QAAQ,SAAS,eAAe,cAAc;;;KAIpD,gBAAgB,GAAG,oDAAoD,gBAAgB,IACxF,QAAQ,EAAE;;YAIF,iBAAiB,UAAU,SAAS,iBACpC,WAAW,aAAa,YAAY,GAAG,QAAQ,EAAE;;iBAI5C,aAAa,UAAU;WAC7B,QAAQ,gBAAgB,+BAC7B,aACA,0BAA0B,gBAAgB;WACrC,OAAO,gBAAgB,8BAC5B,aACA,yBAAyB,gBAAgB;WACpC,UAAU,gBAAgB,iCAC/B,aACA,4BAA4B,gBAAgB;WACvC,QAAQ,gBAAgB,+BAC7B,aACA,0BAA0B,gBAAgB;;;;;;;;;;;;;;;;wBAiBhC,gBAAgB,UAAU,kBAAkB,UAAU,IAAI,aAAa"}

package/dist/dsl/template.mjs

@@ -0,0 +1,63 @@
+import { isDiscordTemplate, isEmailTemplate, isPushTemplate, isSlackTemplate } from "../templates.mjs";
+//#region src/dsl/template.ts
+const makeTemplate = (channel) => (key) => ({
+	channel,
+	key
+});
+/**
+* Unbound template references, props typed by hand. Email and push refs come
+* from the registries (`templates<Emails, Pushes>()`), which type both key and
+* props; this is the low-level form for channels without a registry (sms,
+* slack, …) and for tests.
+*
+*   const alert = template.slack<{ plan: string }>('cs_churn_alert');
+*/
+const template = {
+	email: makeTemplate("email"),
+	sms: makeTemplate("sms"),
+	push: makeTemplate("push"),
+	inApp: makeTemplate("in_app"),
+	slack: makeTemplate("slack"),
+	discord: makeTemplate("discord"),
+	survey: makeTemplate("survey")
+};
+/**
+* Template references derived from the registries themselves: **the
+* registries type the keys** — an unregistered key fails to compile, and a
+* push template is not accepted where an email is — and each template's
+* `props` schema types its use sites. Templates are registered once; the
+* config takes the registries, the workflows take the references:
+*
+*   export const registry = { email, push };
+*   export const t = templates(registry);
+*   flow.email(t.email.welcome, { name: u.name });
+*
+* Each reference is a plain `{ channel, key }` built from the registry's own
+* keys; no template is rendered, and the registries are left untouched.
+*/
+function templates(registry) {
+	return {
+		email: refTable("email", registry.email, isEmailTemplate),
+		push: refTable("push", registry.push, isPushTemplate),
+		discord: refTable("discord", registry.discord, isDiscordTemplate),
+		slack: refTable("slack", registry.slack, isSlackTemplate)
+	};
+}
+const ARTICLE = {
+	email: "an email",
+	push: "a push",
+	discord: "a Discord",
+	slack: "a Slack"
+};
+function refTable(channel, entries, is) {
+	const table = Object.create(null);
+	for (const [key, entry] of Object.entries(entries ?? {})) {
+		if (!is(entry)) throw new TypeError(`templates(): '${key}' in the ${channel} registry is not ${ARTICLE[channel]} template`);
+		table[key] = template[channel](key);
+	}
+	return Object.freeze(table);
+}
+//#endregion
+export { template, templates };
+
+//# sourceMappingURL=template.mjs.map

package/dist/dsl/template.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.mjs","names":[],"sources":["../../src/dsl/template.ts"],"sourcesContent":["/**\n * Templates — named message-content assets. The DSL only ever holds a\n * reference ({ channel, key, phantom props }); the content itself (react-email\n * components) lives in the app and meets the reference again in the studio and\n * at send time via the registry.\n *\n * Type technique: `templates(registry)` derives the references from the\n * registries so **the registries type the keys** — an unregistered key fails\n * to compile — while `PropsOf<M>` reads the props contract off each template's\n * Zod schema, so it is written exactly once.\n */\n\nimport type * as core from 'zod/v4/core';\nimport {\n  type DiscordTemplate,\n  type EmailTemplate,\n  type PropsSchema,\n  type PushTemplate,\n  type SlackTemplate,\n  isDiscordTemplate,\n  isEmailTemplate,\n  isPushTemplate,\n  isSlackTemplate,\n} from '../templates';\n\nexport type Channel = 'email' | 'sms' | 'push' | 'in_app' | 'slack' | 'discord' | 'survey';\n\nexport type EmptyProps = Record<never, never>;\n\n/**\n * Template reference: a top-level named asset, reusable across workflows and\n * versioned on its own. The props shape is declared here and checked at use.\n */\nexport interface TemplateRef<C extends Channel = Channel, P extends object = EmptyProps> {\n  readonly channel: C;\n  readonly key: string;\n  readonly __props?: P;\n}\n\nexport interface TemplateFactory {\n  email<P extends object = EmptyProps>(key: string): TemplateRef<'email', P>;\n  sms<P extends object = EmptyProps>(key: string): TemplateRef<'sms', P>;\n  push<P extends object = EmptyProps>(key: string): TemplateRef<'push', P>;\n  inApp<P extends object = EmptyProps>(key: string): TemplateRef<'in_app', P>;\n  slack<P extends object = EmptyProps>(key: string): TemplateRef<'slack', P>;\n  discord<P extends object = EmptyProps>(key: string): TemplateRef<'discord', P>;\n  survey<P extends object = EmptyProps>(key: string): TemplateRef<'survey', P>;\n}\n\nconst makeTemplate =\n  <C extends Channel>(channel: C) =>\n  <P extends object = EmptyProps>(key: string): TemplateRef<C, P> => ({ channel, key });\n\n/**\n * Unbound template references, props typed by hand. Email and push refs come\n * from the registries (`templates<Emails, Pushes>()`), which type both key and\n * props; this is the low-level form for channels without a registry (sms,\n * slack, …) and for tests.\n *\n *   const alert = template.slack<{ plan: string }>('cs_churn_alert');\n */\nexport const template: TemplateFactory = {\n  email: makeTemplate('email'),\n  sms: makeTemplate('sms'),\n  push: makeTemplate('push'),\n  inApp: makeTemplate('in_app'),\n  slack: makeTemplate('slack'),\n  discord: makeTemplate('discord'),\n  survey: makeTemplate('survey'),\n};\n\n/* ----------------------------- Template registry ---------------------------- */\n\n/** Template props: the input type of the template's Zod `props` schema — what the DSL passes. */\nexport type PropsOf<M> = M extends\n  | EmailTemplate<infer S>\n  | PushTemplate<infer S>\n  | DiscordTemplate<infer S, never>\n  | SlackTemplate<infer S, never>\n  ? core.input<S> extends object\n    ? core.input<S>\n    : EmptyProps\n  : never;\n\n/**\n * The channel registries: what the config registers as `templates` and what\n * `templates()` derives the references from — one type for both. Leave it\n * inferred, or check it with `satisfies TemplateRegistry`: annotating a value\n * as the bare type widens the keys to `string`.\n */\nexport interface TemplateRegistry<\n  E extends Readonly<Record<string, EmailTemplate>> = Readonly<Record<string, EmailTemplate>>,\n  P extends Readonly<Record<string, PushTemplate>> = Readonly<Record<string, PushTemplate>>,\n> {\n  readonly email?: E;\n  readonly push?: P;\n  /** Discord webhook templates, each typed by the host's Env its `webhook` reads. */\n  readonly discord?: Readonly<Record<string, DiscordTemplate<PropsSchema, never>>>;\n  readonly slack?: Readonly<Record<string, SlackTemplate<PropsSchema, never>>>;\n}\n\n/** One channel's registry in `R`, without the `undefined` of an optional field; `never` when absent. */\ntype ChannelRegistry<R, K extends 'email' | 'push' | 'discord' | 'slack'> = K extends keyof R\n  ? Exclude<R[K], undefined>\n  : never;\n\n/** One reference per registered key, each typed by its own template's `props`. */\nexport type TemplateRefTable<C extends Channel, R> = {\n  readonly [K in keyof R & string]: TemplateRef<C, PropsOf<R[K]>>;\n};\n\n/** `t.email.<key>` / `t.push.<key>`; a channel the registry leaves out is an empty table. */\nexport interface TemplateRefs<R extends TemplateRegistry> {\n  readonly email: [ChannelRegistry<R, 'email'>] extends [never]\n    ? EmptyProps\n    : TemplateRefTable<'email', ChannelRegistry<R, 'email'>>;\n  readonly push: [ChannelRegistry<R, 'push'>] extends [never]\n    ? EmptyProps\n    : TemplateRefTable<'push', ChannelRegistry<R, 'push'>>;\n  readonly discord: [ChannelRegistry<R, 'discord'>] extends [never]\n    ? EmptyProps\n    : TemplateRefTable<'discord', ChannelRegistry<R, 'discord'>>;\n  readonly slack: [ChannelRegistry<R, 'slack'>] extends [never]\n    ? EmptyProps\n    : TemplateRefTable<'slack', ChannelRegistry<R, 'slack'>>;\n}\n\n/**\n * Template references derived from the registries themselves: **the\n * registries type the keys** — an unregistered key fails to compile, and a\n * push template is not accepted where an email is — and each template's\n * `props` schema types its use sites. Templates are registered once; the\n * config takes the registries, the workflows take the references:\n *\n *   export const registry = { email, push };\n *   export const t = templates(registry);\n *   flow.email(t.email.welcome, { name: u.name });\n *\n * Each reference is a plain `{ channel, key }` built from the registry's own\n * keys; no template is rendered, and the registries are left untouched.\n */\nexport function templates<const R extends TemplateRegistry>(registry: R): TemplateRefs<R> {\n  return {\n    email: refTable('email', registry.email, isEmailTemplate),\n    push: refTable('push', registry.push, isPushTemplate),\n    discord: refTable('discord', registry.discord, isDiscordTemplate),\n    slack: refTable('slack', registry.slack, isSlackTemplate),\n  } as unknown as TemplateRefs<R>;\n}\n\nconst ARTICLE: Record<'email' | 'push' | 'discord' | 'slack', string> = {\n  email: 'an email',\n  push: 'a push',\n  discord: 'a Discord',\n  slack: 'a Slack',\n};\n\nfunction refTable(\n  channel: 'email' | 'push' | 'discord' | 'slack',\n  entries: Readonly<Record<string, unknown>> | undefined,\n  is: (value: unknown) => boolean\n): Readonly<Record<string, TemplateRef>> {\n  const table: Record<string, TemplateRef> = Object.create(null);\n  for (const [key, entry] of Object.entries(entries ?? {})) {\n    if (!is(entry)) {\n      throw new TypeError(\n        `templates(): '${key}' in the ${channel} registry is not ${ARTICLE[channel]} template`\n      );\n    }\n    table[key] = template[channel](key);\n  }\n  return Object.freeze(table);\n}\n"],"mappings":";;AAiDA,MAAM,gBACgB,aACY,SAAoC;CAAE;CAAS;AAAI;;;;;;;;;AAUrF,MAAa,WAA4B;CACvC,OAAO,aAAa,OAAO;CAC3B,KAAK,aAAa,KAAK;CACvB,MAAM,aAAa,MAAM;CACzB,OAAO,aAAa,QAAQ;CAC5B,OAAO,aAAa,OAAO;CAC3B,SAAS,aAAa,SAAS;CAC/B,QAAQ,aAAa,QAAQ;AAC/B;;;;;;;;;;;;;;;AAwEA,SAAgB,UAA4C,UAA8B;CACxF,OAAO;EACL,OAAO,SAAS,SAAS,SAAS,OAAO,eAAe;EACxD,MAAM,SAAS,QAAQ,SAAS,MAAM,cAAc;EACpD,SAAS,SAAS,WAAW,SAAS,SAAS,iBAAiB;EAChE,OAAO,SAAS,SAAS,SAAS,OAAO,eAAe;CAC1D;AACF;AAEA,MAAM,UAAkE;CACtE,OAAO;CACP,MAAM;CACN,SAAS;CACT,OAAO;AACT;AAEA,SAAS,SACP,SACA,SACA,IACuC;CACvC,MAAM,QAAqC,OAAO,OAAO,IAAI;CAC7D,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,WAAW,CAAC,CAAC,GAAG;EACxD,IAAI,CAAC,GAAG,KAAK,GACX,MAAM,IAAI,UACR,iBAAiB,IAAI,WAAW,QAAQ,mBAAmB,QAAQ,SAAS,UAC9E;EAEF,MAAM,OAAO,SAAS,QAAQ,CAAC,GAAG;CACpC;CACA,OAAO,OAAO,OAAO,KAAK;AAC5B"}