@shware/workflow 0.0.0-stage → 0.0.0

package/dist/postgres-js.cjs

@@ -0,0 +1,42 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_store_postgres = require("./store/postgres.cjs");
+let postgres = require("postgres");
+postgres = require_runtime.__toESM(postgres, 1);
+//#region src/postgres-js.ts
+/**
+* `@shware/workflow/postgres-js` — the Postgres store over postgres.js
+* (`postgres` is an optional peer dependency; import this subpath only when
+* you use it). On Cloudflare the connection string is Hyperdrive's.
+*/
+/** postgres.js → the store's minimal client. Inside `begin` every statement runs on the transaction client; the store never nests, so an inner `transaction` continues on the same one. */
+function postgresJsClient(sql, inTransaction = false) {
+	return {
+		query: (text, params = []) => sql.unsafe(text, params),
+		transaction: (fn) => inTransaction ? fn(postgresJsClient(sql, true)) : sql.begin((tx) => fn(postgresJsClient(tx, true)))
+	};
+}
+/**
+* Open a Postgres-backed store for one request or workflow run. The lease's
+* `close` ends the client — a Worker cannot share a socket across requests,
+* and Hyperdrive keeps the real pool next to the database.
+*/
+function postgresJsStore(connectionString, options = {}) {
+	const { connection, ...storeOptions } = options;
+	const sql = (0, postgres.default)(connectionString, {
+		max: 1,
+		idle_timeout: 2,
+		fetch_types: false,
+		prepare: true,
+		...connection
+	});
+	return {
+		store: new require_store_postgres.PostgresJourneyStore(postgresJsClient(sql), storeOptions),
+		close: () => sql.end({ timeout: 5 })
+	};
+}
+//#endregion
+exports.postgresJsClient = postgresJsClient;
+exports.postgresJsStore = postgresJsStore;
+
+//# sourceMappingURL=postgres-js.cjs.map

package/dist/postgres-js.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-js.cjs","names":["PostgresJourneyStore"],"sources":["../src/postgres-js.ts"],"sourcesContent":["import postgres from 'postgres';\nimport type { StoreLease } from './store/index';\nimport {\n  PostgresJourneyStore,\n  type PostgresJourneyStoreOptions,\n  type SqlClientLike,\n} from './store/postgres';\n\n/**\n * `@shware/workflow/postgres-js` — the Postgres store over postgres.js\n * (`postgres` is an optional peer dependency; import this subpath only when\n * you use it). On Cloudflare the connection string is Hyperdrive's.\n */\n\n/** postgres.js → the store's minimal client. Inside `begin` every statement runs on the transaction client; the store never nests, so an inner `transaction` continues on the same one. */\nexport function postgresJsClient(\n  sql: postgres.Sql | postgres.TransactionSql,\n  inTransaction = false\n): SqlClientLike {\n  return {\n    query: <T>(text: string, params: readonly unknown[] = []) =>\n      sql.unsafe(text, params as never) as unknown as Promise<T[]>,\n    transaction: <T>(fn: (tx: SqlClientLike) => Promise<T>) =>\n      inTransaction\n        ? fn(postgresJsClient(sql, true))\n        : ((sql as postgres.Sql).begin((tx) => fn(postgresJsClient(tx, true))) as Promise<T>),\n  };\n}\n\nexport interface PostgresJsStoreOptions extends PostgresJourneyStoreOptions {\n  /**\n   * postgres.js options. Defaults suit a Worker with Hyperdrive: one\n   * connection per request/run, closed after 2 s idle, no type fetch on\n   * connect, prepared statements (Hyperdrive caches them).\n   */\n  connection?: postgres.Options<Record<string, never>>;\n}\n\n/**\n * Open a Postgres-backed store for one request or workflow run. The lease's\n * `close` ends the client — a Worker cannot share a socket across requests,\n * and Hyperdrive keeps the real pool next to the database.\n */\nexport function postgresJsStore(\n  connectionString: string,\n  options: PostgresJsStoreOptions = {}\n): Required<StoreLease> {\n  const { connection, ...storeOptions } = options;\n  const sql = postgres(connectionString, {\n    max: 1,\n    // A journey run lives for days: between steps it sleeps or waits, and a run holding its\n    // connection through that holds one per sleeping instance — hundreds of them exhaust the\n    // database. Idle connections close and the next query opens a fresh one.\n    idle_timeout: 2,\n    fetch_types: false,\n    prepare: true,\n    ...connection,\n  });\n  return {\n    store: new PostgresJourneyStore(postgresJsClient(sql), storeOptions),\n    close: () => sql.end({ timeout: 5 }),\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAeA,SAAgB,iBACd,KACA,gBAAgB,OACD;CACf,OAAO;EACL,QAAW,MAAc,SAA6B,CAAC,MACrD,IAAI,OAAO,MAAM,MAAe;EAClC,cAAiB,OACf,gBACI,GAAG,iBAAiB,KAAK,IAAI,CAAC,IAC5B,IAAqB,OAAO,OAAO,GAAG,iBAAiB,IAAI,IAAI,CAAC,CAAC;CAC3E;AACF;;;;;;AAgBA,SAAgB,gBACd,kBACA,UAAkC,CAAC,GACb;CACtB,MAAM,EAAE,YAAY,GAAG,iBAAiB;CACxC,MAAM,OAAA,GAAM,SAAA,QAAA,CAAS,kBAAkB;EACrC,KAAK;EAIL,cAAc;EACd,aAAa;EACb,SAAS;EACT,GAAG;CACL,CAAC;CACD,OAAO;EACL,OAAO,IAAIA,uBAAAA,qBAAqB,iBAAiB,GAAG,GAAG,YAAY;EACnE,aAAa,IAAI,IAAI,EAAE,SAAS,EAAE,CAAC;CACrC;AACF"}

package/dist/postgres-js.d.cts

@@ -0,0 +1,28 @@
+import { SqlClientLike } from "./store/sql.cjs";
+import { PostgresJourneyStoreOptions } from "./store/postgres.cjs";
+import { StoreLease } from "./store/index.cjs";
+import postgres from "postgres";
+//#region src/postgres-js.d.ts
+/**
+ * `@shware/workflow/postgres-js` — the Postgres store over postgres.js
+ * (`postgres` is an optional peer dependency; import this subpath only when
+ * you use it). On Cloudflare the connection string is Hyperdrive's.
+ */
+/** postgres.js → the store's minimal client. Inside `begin` every statement runs on the transaction client; the store never nests, so an inner `transaction` continues on the same one. */
+export declare function postgresJsClient(sql: postgres.Sql | postgres.TransactionSql, inTransaction?: boolean): SqlClientLike;
+export interface PostgresJsStoreOptions extends PostgresJourneyStoreOptions {
+  /**
+   * postgres.js options. Defaults suit a Worker with Hyperdrive: one
+   * connection per request/run, closed after 2 s idle, no type fetch on
+   * connect, prepared statements (Hyperdrive caches them).
+   */
+  connection?: postgres.Options<Record<string, never>>;
+}
+/**
+ * Open a Postgres-backed store for one request or workflow run. The lease's
+ * `close` ends the client — a Worker cannot share a socket across requests,
+ * and Hyperdrive keeps the real pool next to the database.
+ */
+export declare function postgresJsStore(connectionString: string, options?: PostgresJsStoreOptions): Required<StoreLease>;
+//#endregion
+//# sourceMappingURL=postgres-js.d.cts.map

package/dist/postgres-js.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-js.d.cts","names":[],"sources":["../src/postgres-js.ts"],"mappings":";;;;;;;;;;;wBAegB,iBACd,KAAK,SAAS,MAAM,SAAS,gBAC7B,0BACC;iBAWc,+BAA+B;;;;;;EAM9C,aAAa,SAAS,QAAQ;;;;;;;wBAQhB,gBACd,0BACA,UAAS,yBACR,SAAS"}

package/dist/postgres-js.d.mts

@@ -0,0 +1,28 @@
+import { SqlClientLike } from "./store/sql.mjs";
+import { PostgresJourneyStoreOptions } from "./store/postgres.mjs";
+import { StoreLease } from "./store/index.mjs";
+import postgres from "postgres";
+//#region src/postgres-js.d.ts
+/**
+ * `@shware/workflow/postgres-js` — the Postgres store over postgres.js
+ * (`postgres` is an optional peer dependency; import this subpath only when
+ * you use it). On Cloudflare the connection string is Hyperdrive's.
+ */
+/** postgres.js → the store's minimal client. Inside `begin` every statement runs on the transaction client; the store never nests, so an inner `transaction` continues on the same one. */
+export declare function postgresJsClient(sql: postgres.Sql | postgres.TransactionSql, inTransaction?: boolean): SqlClientLike;
+export interface PostgresJsStoreOptions extends PostgresJourneyStoreOptions {
+  /**
+   * postgres.js options. Defaults suit a Worker with Hyperdrive: one
+   * connection per request/run, closed after 2 s idle, no type fetch on
+   * connect, prepared statements (Hyperdrive caches them).
+   */
+  connection?: postgres.Options<Record<string, never>>;
+}
+/**
+ * Open a Postgres-backed store for one request or workflow run. The lease's
+ * `close` ends the client — a Worker cannot share a socket across requests,
+ * and Hyperdrive keeps the real pool next to the database.
+ */
+export declare function postgresJsStore(connectionString: string, options?: PostgresJsStoreOptions): Required<StoreLease>;
+//#endregion
+//# sourceMappingURL=postgres-js.d.mts.map

package/dist/postgres-js.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-js.d.mts","names":[],"sources":["../src/postgres-js.ts"],"mappings":";;;;;;;;;;;wBAegB,iBACd,KAAK,SAAS,MAAM,SAAS,gBAC7B,0BACC;iBAWc,+BAA+B;;;;;;EAM9C,aAAa,SAAS,QAAQ;;;;;;;wBAQhB,gBACd,0BACA,UAAS,yBACR,SAAS"}

package/dist/postgres-js.mjs

@@ -0,0 +1,38 @@
+import { PostgresJourneyStore } from "./store/postgres.mjs";
+import postgres from "postgres";
+//#region src/postgres-js.ts
+/**
+* `@shware/workflow/postgres-js` — the Postgres store over postgres.js
+* (`postgres` is an optional peer dependency; import this subpath only when
+* you use it). On Cloudflare the connection string is Hyperdrive's.
+*/
+/** postgres.js → the store's minimal client. Inside `begin` every statement runs on the transaction client; the store never nests, so an inner `transaction` continues on the same one. */
+function postgresJsClient(sql, inTransaction = false) {
+	return {
+		query: (text, params = []) => sql.unsafe(text, params),
+		transaction: (fn) => inTransaction ? fn(postgresJsClient(sql, true)) : sql.begin((tx) => fn(postgresJsClient(tx, true)))
+	};
+}
+/**
+* Open a Postgres-backed store for one request or workflow run. The lease's
+* `close` ends the client — a Worker cannot share a socket across requests,
+* and Hyperdrive keeps the real pool next to the database.
+*/
+function postgresJsStore(connectionString, options = {}) {
+	const { connection, ...storeOptions } = options;
+	const sql = postgres(connectionString, {
+		max: 1,
+		idle_timeout: 2,
+		fetch_types: false,
+		prepare: true,
+		...connection
+	});
+	return {
+		store: new PostgresJourneyStore(postgresJsClient(sql), storeOptions),
+		close: () => sql.end({ timeout: 5 })
+	};
+}
+//#endregion
+export { postgresJsClient, postgresJsStore };
+
+//# sourceMappingURL=postgres-js.mjs.map

package/dist/postgres-js.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-js.mjs","names":[],"sources":["../src/postgres-js.ts"],"sourcesContent":["import postgres from 'postgres';\nimport type { StoreLease } from './store/index';\nimport {\n  PostgresJourneyStore,\n  type PostgresJourneyStoreOptions,\n  type SqlClientLike,\n} from './store/postgres';\n\n/**\n * `@shware/workflow/postgres-js` — the Postgres store over postgres.js\n * (`postgres` is an optional peer dependency; import this subpath only when\n * you use it). On Cloudflare the connection string is Hyperdrive's.\n */\n\n/** postgres.js → the store's minimal client. Inside `begin` every statement runs on the transaction client; the store never nests, so an inner `transaction` continues on the same one. */\nexport function postgresJsClient(\n  sql: postgres.Sql | postgres.TransactionSql,\n  inTransaction = false\n): SqlClientLike {\n  return {\n    query: <T>(text: string, params: readonly unknown[] = []) =>\n      sql.unsafe(text, params as never) as unknown as Promise<T[]>,\n    transaction: <T>(fn: (tx: SqlClientLike) => Promise<T>) =>\n      inTransaction\n        ? fn(postgresJsClient(sql, true))\n        : ((sql as postgres.Sql).begin((tx) => fn(postgresJsClient(tx, true))) as Promise<T>),\n  };\n}\n\nexport interface PostgresJsStoreOptions extends PostgresJourneyStoreOptions {\n  /**\n   * postgres.js options. Defaults suit a Worker with Hyperdrive: one\n   * connection per request/run, closed after 2 s idle, no type fetch on\n   * connect, prepared statements (Hyperdrive caches them).\n   */\n  connection?: postgres.Options<Record<string, never>>;\n}\n\n/**\n * Open a Postgres-backed store for one request or workflow run. The lease's\n * `close` ends the client — a Worker cannot share a socket across requests,\n * and Hyperdrive keeps the real pool next to the database.\n */\nexport function postgresJsStore(\n  connectionString: string,\n  options: PostgresJsStoreOptions = {}\n): Required<StoreLease> {\n  const { connection, ...storeOptions } = options;\n  const sql = postgres(connectionString, {\n    max: 1,\n    // A journey run lives for days: between steps it sleeps or waits, and a run holding its\n    // connection through that holds one per sleeping instance — hundreds of them exhaust the\n    // database. Idle connections close and the next query opens a fresh one.\n    idle_timeout: 2,\n    fetch_types: false,\n    prepare: true,\n    ...connection,\n  });\n  return {\n    store: new PostgresJourneyStore(postgresJsClient(sql), storeOptions),\n    close: () => sql.end({ timeout: 5 }),\n  };\n}\n"],"mappings":";;;;;;;;;AAeA,SAAgB,iBACd,KACA,gBAAgB,OACD;CACf,OAAO;EACL,QAAW,MAAc,SAA6B,CAAC,MACrD,IAAI,OAAO,MAAM,MAAe;EAClC,cAAiB,OACf,gBACI,GAAG,iBAAiB,KAAK,IAAI,CAAC,IAC5B,IAAqB,OAAO,OAAO,GAAG,iBAAiB,IAAI,IAAI,CAAC,CAAC;CAC3E;AACF;;;;;;AAgBA,SAAgB,gBACd,kBACA,UAAkC,CAAC,GACb;CACtB,MAAM,EAAE,YAAY,GAAG,iBAAiB;CACxC,MAAM,MAAM,SAAS,kBAAkB;EACrC,KAAK;EAIL,cAAc;EACd,aAAa;EACb,SAAS;EACT,GAAG;CACL,CAAC;CACD,OAAO;EACL,OAAO,IAAI,qBAAqB,iBAAiB,GAAG,GAAG,YAAY;EACnE,aAAa,IAAI,IAAI,EAAE,SAAS,EAAE,CAAC;CACrC;AACF"}

package/dist/provenance.cjs

@@ -0,0 +1,67 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/provenance.ts
+/**
+* V8-style frame: `at fn (file:line:col)` / `at file:line:col`, where file may
+* be an absolute path, a file:// URL (Node ESM) or an http(s) URL (Vite dev).
+*/
+const FRAME = /at (?:.*? \()?(.+?):(\d+):(\d+)\)?$/;
+/**
+* Capture the source location of the call to `boundary` — pass the public
+* builder method itself; everything at and below it is excluded from the stack.
+*/
+function captureLoc(boundary) {
+	const capture = Error.captureStackTrace;
+	if (typeof capture !== "function") return void 0;
+	const holder = /* @__PURE__ */ new Error("provenance capture");
+	capture(holder, boundary);
+	const frame = holder.stack?.split("\n")[1];
+	const match = frame === void 0 ? null : FRAME.exec(frame);
+	if (!match) return void 0;
+	const [, rawFile, line, column] = match;
+	return {
+		file: normalizeFile(rawFile, globalThis.process?.cwd?.()),
+		line: Number(line),
+		column: Number(column)
+	};
+}
+/**
+* file:// URLs become plain paths; paths under `cwd` become cwd-relative so the
+* IR stays portable across machines and never leaks a home directory. Browser
+* (Vite dev) URLs pass through untouched.
+*
+* Windows is where this used to give up. An ESM frame there reads
+* 'file:///C:/Users/alice/proj/src/wf.ts' — a URL, with a slash in front of the
+* drive letter — while process.cwd() reads 'C:\\Users\\alice\\proj'. Neither
+* the separators nor that slash lined up, the prefix test failed, and the
+* author's home directory shipped inside every deploy's IR.
+*
+* @internal exported for the tests: this is the compiler's only platform-aware
+* line, and the platform it gets wrong is not the one the suite runs on.
+*/
+function normalizeFile(rawFile, cwd) {
+	let file = rawFile;
+	if (file.startsWith("file://")) {
+		file = decodeURIComponent(file.slice(7));
+		if (/^\/[A-Za-z]:/.test(file)) file = file.slice(1);
+	}
+	file = toPosix(file);
+	if (cwd !== void 0) {
+		const root = toPosix(cwd);
+		if (file.startsWith(`${root}/`)) file = file.slice(root.length + 1);
+	}
+	return file;
+}
+/**
+* One spelling per path so the two can be compared: '/' separators, and an
+* upper-case drive letter — Windows reports the same drive in either case
+* depending on who was asked (the loader's URL, an env var, the shell).
+*/
+function toPosix(path) {
+	const slashed = path.replaceAll("\\", "/");
+	return /^[a-z]:/.test(slashed) ? slashed[0].toUpperCase() + slashed.slice(1) : slashed;
+}
+//#endregion
+exports.captureLoc = captureLoc;
+exports.normalizeFile = normalizeFile;
+
+//# sourceMappingURL=provenance.cjs.map

package/dist/provenance.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.cjs","names":[],"sources":["../src/provenance.ts"],"sourcesContent":["import type { SourceLocIR } from './ir';\n\n/**\n * Provenance — where in source code a definition came from.\n *\n * Every builder call records its callsite into `meta.loc`. This is the\n * compiler's source map: the IR knows which file:line:column produced each\n * node, so the UI can jump from a canvas node to the editor, and a UI edit can\n * later be written back as an in-place patch of the exact literal that\n * produced the value. `meta` is excluded from contentHash (see hash.ts), so\n * provenance never affects execution identity, version pinning, or plan.\n *\n * Capture is best-effort by design: it relies on `Error.captureStackTrace`\n * (V8, JavaScriptCore 16.4+, SpiderMonkey 132+) to start the stack at the\n * caller of the public builder method — no frame-skipping heuristics over\n * bundled/unbundled layouts. Where the API or a parsable frame is missing,\n * `loc` is simply absent and every consumer degrades gracefully.\n */\n\ntype AnyFunction = (...args: never[]) => unknown;\n\n/**\n * V8-style frame: `at fn (file:line:col)` / `at file:line:col`, where file may\n * be an absolute path, a file:// URL (Node ESM) or an http(s) URL (Vite dev).\n */\nconst FRAME = /at (?:.*? \\()?(.+?):(\\d+):(\\d+)\\)?$/;\n\n/**\n * Capture the source location of the call to `boundary` — pass the public\n * builder method itself; everything at and below it is excluded from the stack.\n */\nexport function captureLoc(boundary: AnyFunction): SourceLocIR | undefined {\n  // Read off the constructor untyped: the API is V8-first, and this module must\n  // typecheck in DOM-less / Node-less environments (workerd, browsers) alike.\n  const capture = (Error as { captureStackTrace?: (target: object, boundary: AnyFunction) => void })\n    .captureStackTrace;\n  if (typeof capture !== 'function') return undefined;\n\n  const holder = new Error('provenance capture');\n  capture(holder, boundary);\n  // [0] is the message header; [1] is the first frame past the boundary — the callsite.\n  const frame = holder.stack?.split('\\n')[1];\n  const match = frame === undefined ? null : FRAME.exec(frame);\n  if (!match) return undefined;\n\n  const [, rawFile, line, column] = match;\n  return {\n    // globalThis lookup instead of a bare `process` reference: same portability\n    // requirement as above — no Node types in workerd / browser consumers.\n    file: normalizeFile(\n      rawFile,\n      (globalThis as { process?: { cwd?: () => string } }).process?.cwd?.()\n    ),\n    line: Number(line),\n    column: Number(column),\n  };\n}\n\n/**\n * file:// URLs become plain paths; paths under `cwd` become cwd-relative so the\n * IR stays portable across machines and never leaks a home directory. Browser\n * (Vite dev) URLs pass through untouched.\n *\n * Windows is where this used to give up. An ESM frame there reads\n * 'file:///C:/Users/alice/proj/src/wf.ts' — a URL, with a slash in front of the\n * drive letter — while process.cwd() reads 'C:\\\\Users\\\\alice\\\\proj'. Neither\n * the separators nor that slash lined up, the prefix test failed, and the\n * author's home directory shipped inside every deploy's IR.\n *\n * @internal exported for the tests: this is the compiler's only platform-aware\n * line, and the platform it gets wrong is not the one the suite runs on.\n */\nexport function normalizeFile(rawFile: string, cwd: string | undefined): string {\n  let file = rawFile;\n  if (file.startsWith('file://')) {\n    file = decodeURIComponent(file.slice('file://'.length));\n    // '/C:/…' is URL shape, not path shape\n    if (/^\\/[A-Za-z]:/.test(file)) file = file.slice(1);\n  }\n  file = toPosix(file);\n  if (cwd !== undefined) {\n    const root = toPosix(cwd);\n    if (file.startsWith(`${root}/`)) file = file.slice(root.length + 1);\n  }\n  return file;\n}\n\n/**\n * One spelling per path so the two can be compared: '/' separators, and an\n * upper-case drive letter — Windows reports the same drive in either case\n * depending on who was asked (the loader's URL, an env var, the shell).\n */\nfunction toPosix(path: string): string {\n  const slashed = path.replaceAll('\\\\', '/');\n  return /^[a-z]:/.test(slashed) ? slashed[0].toUpperCase() + slashed.slice(1) : slashed;\n}\n"],"mappings":";;;;;;AAyBA,MAAM,QAAQ;;;;;AAMd,SAAgB,WAAW,UAAgD;CAGzE,MAAM,UAAW,MACd;CACH,IAAI,OAAO,YAAY,YAAY,OAAO,KAAA;CAE1C,MAAM,yBAAS,IAAI,MAAM,oBAAoB;CAC7C,QAAQ,QAAQ,QAAQ;CAExB,MAAM,QAAQ,OAAO,OAAO,MAAM,IAAI,CAAC,CAAC;CACxC,MAAM,QAAQ,UAAU,KAAA,IAAY,OAAO,MAAM,KAAK,KAAK;CAC3D,IAAI,CAAC,OAAO,OAAO,KAAA;CAEnB,MAAM,GAAG,SAAS,MAAM,UAAU;CAClC,OAAO;EAGL,MAAM,cACJ,SACC,WAAoD,SAAS,MAAM,CACtE;EACA,MAAM,OAAO,IAAI;EACjB,QAAQ,OAAO,MAAM;CACvB;AACF;;;;;;;;;;;;;;;AAgBA,SAAgB,cAAc,SAAiB,KAAiC;CAC9E,IAAI,OAAO;CACX,IAAI,KAAK,WAAW,SAAS,GAAG;EAC9B,OAAO,mBAAmB,KAAK,MAAM,CAAgB,CAAC;EAEtD,IAAI,eAAe,KAAK,IAAI,GAAG,OAAO,KAAK,MAAM,CAAC;CACpD;CACA,OAAO,QAAQ,IAAI;CACnB,IAAI,QAAQ,KAAA,GAAW;EACrB,MAAM,OAAO,QAAQ,GAAG;EACxB,IAAI,KAAK,WAAW,GAAG,KAAK,EAAE,GAAG,OAAO,KAAK,MAAM,KAAK,SAAS,CAAC;CACpE;CACA,OAAO;AACT;;;;;;AAOA,SAAS,QAAQ,MAAsB;CACrC,MAAM,UAAU,KAAK,WAAW,MAAM,GAAG;CACzC,OAAO,UAAU,KAAK,OAAO,IAAI,QAAQ,EAAE,CAAC,YAAY,IAAI,QAAQ,MAAM,CAAC,IAAI;AACjF"}

package/dist/provenance.d.cts

@@ -0,0 +1,41 @@
+import { SourceLocIR } from "./ir.cjs";
+//#region src/provenance.d.ts
+/**
+ * Provenance — where in source code a definition came from.
+ *
+ * Every builder call records its callsite into `meta.loc`. This is the
+ * compiler's source map: the IR knows which file:line:column produced each
+ * node, so the UI can jump from a canvas node to the editor, and a UI edit can
+ * later be written back as an in-place patch of the exact literal that
+ * produced the value. `meta` is excluded from contentHash (see hash.ts), so
+ * provenance never affects execution identity, version pinning, or plan.
+ *
+ * Capture is best-effort by design: it relies on `Error.captureStackTrace`
+ * (V8, JavaScriptCore 16.4+, SpiderMonkey 132+) to start the stack at the
+ * caller of the public builder method — no frame-skipping heuristics over
+ * bundled/unbundled layouts. Where the API or a parsable frame is missing,
+ * `loc` is simply absent and every consumer degrades gracefully.
+ */
+type AnyFunction = (...args: never[]) => unknown;
+/**
+ * Capture the source location of the call to `boundary` — pass the public
+ * builder method itself; everything at and below it is excluded from the stack.
+ */
+export declare function captureLoc(boundary: AnyFunction): SourceLocIR | undefined;
+/**
+ * file:// URLs become plain paths; paths under `cwd` become cwd-relative so the
+ * IR stays portable across machines and never leaks a home directory. Browser
+ * (Vite dev) URLs pass through untouched.
+ *
+ * Windows is where this used to give up. An ESM frame there reads
+ * 'file:///C:/Users/alice/proj/src/wf.ts' — a URL, with a slash in front of the
+ * drive letter — while process.cwd() reads 'C:\\Users\\alice\\proj'. Neither
+ * the separators nor that slash lined up, the prefix test failed, and the
+ * author's home directory shipped inside every deploy's IR.
+ *
+ * @internal exported for the tests: this is the compiler's only platform-aware
+ * line, and the platform it gets wrong is not the one the suite runs on.
+ */
+export declare function normalizeFile(rawFile: string, cwd: string | undefined): string;
+//#endregion
+//# sourceMappingURL=provenance.d.cts.map

package/dist/provenance.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.d.cts","names":[],"sources":["../src/provenance.ts"],"mappings":";;;;;;;;;;;;;;;;;;KAmBK,kBAAkB;;;;;wBAYP,WAAW,UAAU,cAAc;;;;;;;;;;;;;;;wBAyCnC,cAAc,iBAAiB"}

package/dist/provenance.d.mts

@@ -0,0 +1,41 @@
+import { SourceLocIR } from "./ir.mjs";
+//#region src/provenance.d.ts
+/**
+ * Provenance — where in source code a definition came from.
+ *
+ * Every builder call records its callsite into `meta.loc`. This is the
+ * compiler's source map: the IR knows which file:line:column produced each
+ * node, so the UI can jump from a canvas node to the editor, and a UI edit can
+ * later be written back as an in-place patch of the exact literal that
+ * produced the value. `meta` is excluded from contentHash (see hash.ts), so
+ * provenance never affects execution identity, version pinning, or plan.
+ *
+ * Capture is best-effort by design: it relies on `Error.captureStackTrace`
+ * (V8, JavaScriptCore 16.4+, SpiderMonkey 132+) to start the stack at the
+ * caller of the public builder method — no frame-skipping heuristics over
+ * bundled/unbundled layouts. Where the API or a parsable frame is missing,
+ * `loc` is simply absent and every consumer degrades gracefully.
+ */
+type AnyFunction = (...args: never[]) => unknown;
+/**
+ * Capture the source location of the call to `boundary` — pass the public
+ * builder method itself; everything at and below it is excluded from the stack.
+ */
+export declare function captureLoc(boundary: AnyFunction): SourceLocIR | undefined;
+/**
+ * file:// URLs become plain paths; paths under `cwd` become cwd-relative so the
+ * IR stays portable across machines and never leaks a home directory. Browser
+ * (Vite dev) URLs pass through untouched.
+ *
+ * Windows is where this used to give up. An ESM frame there reads
+ * 'file:///C:/Users/alice/proj/src/wf.ts' — a URL, with a slash in front of the
+ * drive letter — while process.cwd() reads 'C:\\Users\\alice\\proj'. Neither
+ * the separators nor that slash lined up, the prefix test failed, and the
+ * author's home directory shipped inside every deploy's IR.
+ *
+ * @internal exported for the tests: this is the compiler's only platform-aware
+ * line, and the platform it gets wrong is not the one the suite runs on.
+ */
+export declare function normalizeFile(rawFile: string, cwd: string | undefined): string;
+//#endregion
+//# sourceMappingURL=provenance.d.mts.map

package/dist/provenance.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.d.mts","names":[],"sources":["../src/provenance.ts"],"mappings":";;;;;;;;;;;;;;;;;;KAmBK,kBAAkB;;;;;wBAYP,WAAW,UAAU,cAAc;;;;;;;;;;;;;;;wBAyCnC,cAAc,iBAAiB"}

package/dist/provenance.mjs

@@ -0,0 +1,65 @@
+//#region src/provenance.ts
+/**
+* V8-style frame: `at fn (file:line:col)` / `at file:line:col`, where file may
+* be an absolute path, a file:// URL (Node ESM) or an http(s) URL (Vite dev).
+*/
+const FRAME = /at (?:.*? \()?(.+?):(\d+):(\d+)\)?$/;
+/**
+* Capture the source location of the call to `boundary` — pass the public
+* builder method itself; everything at and below it is excluded from the stack.
+*/
+function captureLoc(boundary) {
+	const capture = Error.captureStackTrace;
+	if (typeof capture !== "function") return void 0;
+	const holder = /* @__PURE__ */ new Error("provenance capture");
+	capture(holder, boundary);
+	const frame = holder.stack?.split("\n")[1];
+	const match = frame === void 0 ? null : FRAME.exec(frame);
+	if (!match) return void 0;
+	const [, rawFile, line, column] = match;
+	return {
+		file: normalizeFile(rawFile, globalThis.process?.cwd?.()),
+		line: Number(line),
+		column: Number(column)
+	};
+}
+/**
+* file:// URLs become plain paths; paths under `cwd` become cwd-relative so the
+* IR stays portable across machines and never leaks a home directory. Browser
+* (Vite dev) URLs pass through untouched.
+*
+* Windows is where this used to give up. An ESM frame there reads
+* 'file:///C:/Users/alice/proj/src/wf.ts' — a URL, with a slash in front of the
+* drive letter — while process.cwd() reads 'C:\\Users\\alice\\proj'. Neither
+* the separators nor that slash lined up, the prefix test failed, and the
+* author's home directory shipped inside every deploy's IR.
+*
+* @internal exported for the tests: this is the compiler's only platform-aware
+* line, and the platform it gets wrong is not the one the suite runs on.
+*/
+function normalizeFile(rawFile, cwd) {
+	let file = rawFile;
+	if (file.startsWith("file://")) {
+		file = decodeURIComponent(file.slice(7));
+		if (/^\/[A-Za-z]:/.test(file)) file = file.slice(1);
+	}
+	file = toPosix(file);
+	if (cwd !== void 0) {
+		const root = toPosix(cwd);
+		if (file.startsWith(`${root}/`)) file = file.slice(root.length + 1);
+	}
+	return file;
+}
+/**
+* One spelling per path so the two can be compared: '/' separators, and an
+* upper-case drive letter — Windows reports the same drive in either case
+* depending on who was asked (the loader's URL, an env var, the shell).
+*/
+function toPosix(path) {
+	const slashed = path.replaceAll("\\", "/");
+	return /^[a-z]:/.test(slashed) ? slashed[0].toUpperCase() + slashed.slice(1) : slashed;
+}
+//#endregion
+export { captureLoc, normalizeFile };
+
+//# sourceMappingURL=provenance.mjs.map

package/dist/provenance.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.mjs","names":[],"sources":["../src/provenance.ts"],"sourcesContent":["import type { SourceLocIR } from './ir';\n\n/**\n * Provenance — where in source code a definition came from.\n *\n * Every builder call records its callsite into `meta.loc`. This is the\n * compiler's source map: the IR knows which file:line:column produced each\n * node, so the UI can jump from a canvas node to the editor, and a UI edit can\n * later be written back as an in-place patch of the exact literal that\n * produced the value. `meta` is excluded from contentHash (see hash.ts), so\n * provenance never affects execution identity, version pinning, or plan.\n *\n * Capture is best-effort by design: it relies on `Error.captureStackTrace`\n * (V8, JavaScriptCore 16.4+, SpiderMonkey 132+) to start the stack at the\n * caller of the public builder method — no frame-skipping heuristics over\n * bundled/unbundled layouts. Where the API or a parsable frame is missing,\n * `loc` is simply absent and every consumer degrades gracefully.\n */\n\ntype AnyFunction = (...args: never[]) => unknown;\n\n/**\n * V8-style frame: `at fn (file:line:col)` / `at file:line:col`, where file may\n * be an absolute path, a file:// URL (Node ESM) or an http(s) URL (Vite dev).\n */\nconst FRAME = /at (?:.*? \\()?(.+?):(\\d+):(\\d+)\\)?$/;\n\n/**\n * Capture the source location of the call to `boundary` — pass the public\n * builder method itself; everything at and below it is excluded from the stack.\n */\nexport function captureLoc(boundary: AnyFunction): SourceLocIR | undefined {\n  // Read off the constructor untyped: the API is V8-first, and this module must\n  // typecheck in DOM-less / Node-less environments (workerd, browsers) alike.\n  const capture = (Error as { captureStackTrace?: (target: object, boundary: AnyFunction) => void })\n    .captureStackTrace;\n  if (typeof capture !== 'function') return undefined;\n\n  const holder = new Error('provenance capture');\n  capture(holder, boundary);\n  // [0] is the message header; [1] is the first frame past the boundary — the callsite.\n  const frame = holder.stack?.split('\\n')[1];\n  const match = frame === undefined ? null : FRAME.exec(frame);\n  if (!match) return undefined;\n\n  const [, rawFile, line, column] = match;\n  return {\n    // globalThis lookup instead of a bare `process` reference: same portability\n    // requirement as above — no Node types in workerd / browser consumers.\n    file: normalizeFile(\n      rawFile,\n      (globalThis as { process?: { cwd?: () => string } }).process?.cwd?.()\n    ),\n    line: Number(line),\n    column: Number(column),\n  };\n}\n\n/**\n * file:// URLs become plain paths; paths under `cwd` become cwd-relative so the\n * IR stays portable across machines and never leaks a home directory. Browser\n * (Vite dev) URLs pass through untouched.\n *\n * Windows is where this used to give up. An ESM frame there reads\n * 'file:///C:/Users/alice/proj/src/wf.ts' — a URL, with a slash in front of the\n * drive letter — while process.cwd() reads 'C:\\\\Users\\\\alice\\\\proj'. Neither\n * the separators nor that slash lined up, the prefix test failed, and the\n * author's home directory shipped inside every deploy's IR.\n *\n * @internal exported for the tests: this is the compiler's only platform-aware\n * line, and the platform it gets wrong is not the one the suite runs on.\n */\nexport function normalizeFile(rawFile: string, cwd: string | undefined): string {\n  let file = rawFile;\n  if (file.startsWith('file://')) {\n    file = decodeURIComponent(file.slice('file://'.length));\n    // '/C:/…' is URL shape, not path shape\n    if (/^\\/[A-Za-z]:/.test(file)) file = file.slice(1);\n  }\n  file = toPosix(file);\n  if (cwd !== undefined) {\n    const root = toPosix(cwd);\n    if (file.startsWith(`${root}/`)) file = file.slice(root.length + 1);\n  }\n  return file;\n}\n\n/**\n * One spelling per path so the two can be compared: '/' separators, and an\n * upper-case drive letter — Windows reports the same drive in either case\n * depending on who was asked (the loader's URL, an env var, the shell).\n */\nfunction toPosix(path: string): string {\n  const slashed = path.replaceAll('\\\\', '/');\n  return /^[a-z]:/.test(slashed) ? slashed[0].toUpperCase() + slashed.slice(1) : slashed;\n}\n"],"mappings":";;;;;AAyBA,MAAM,QAAQ;;;;;AAMd,SAAgB,WAAW,UAAgD;CAGzE,MAAM,UAAW,MACd;CACH,IAAI,OAAO,YAAY,YAAY,OAAO,KAAA;CAE1C,MAAM,yBAAS,IAAI,MAAM,oBAAoB;CAC7C,QAAQ,QAAQ,QAAQ;CAExB,MAAM,QAAQ,OAAO,OAAO,MAAM,IAAI,CAAC,CAAC;CACxC,MAAM,QAAQ,UAAU,KAAA,IAAY,OAAO,MAAM,KAAK,KAAK;CAC3D,IAAI,CAAC,OAAO,OAAO,KAAA;CAEnB,MAAM,GAAG,SAAS,MAAM,UAAU;CAClC,OAAO;EAGL,MAAM,cACJ,SACC,WAAoD,SAAS,MAAM,CACtE;EACA,MAAM,OAAO,IAAI;EACjB,QAAQ,OAAO,MAAM;CACvB;AACF;;;;;;;;;;;;;;;AAgBA,SAAgB,cAAc,SAAiB,KAAiC;CAC9E,IAAI,OAAO;CACX,IAAI,KAAK,WAAW,SAAS,GAAG;EAC9B,OAAO,mBAAmB,KAAK,MAAM,CAAgB,CAAC;EAEtD,IAAI,eAAe,KAAK,IAAI,GAAG,OAAO,KAAK,MAAM,CAAC;CACpD;CACA,OAAO,QAAQ,IAAI;CACnB,IAAI,QAAQ,KAAA,GAAW;EACrB,MAAM,OAAO,QAAQ,GAAG;EACxB,IAAI,KAAK,WAAW,GAAG,KAAK,EAAE,GAAG,OAAO,KAAK,MAAM,KAAK,SAAS,CAAC;CACpE;CACA,OAAO;AACT;;;;;;AAOA,SAAS,QAAQ,MAAsB;CACrC,MAAM,UAAU,KAAK,WAAW,MAAM,GAAG;CACzC,OAAO,UAAU,KAAK,OAAO,IAAI,QAAQ,EAAE,CAAC,YAAY,IAAI,QAAQ,MAAM,CAAC,IAAI;AACjF"}

package/dist/push.cjs

@@ -0,0 +1,14 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_templates = require("./templates.cjs");
+//#region src/push.ts
+/** A renderer over the registry; a TemplateValidationError means nothing may be sent. */
+function registryPushRenderer(pushes) {
+	return async (key, props) => {
+		if (!Object.hasOwn(pushes, key)) throw new Error(`unknown push template: ${key}`);
+		return require_templates.renderPushContent(pushes[key], key, props);
+	};
+}
+//#endregion
+exports.registryPushRenderer = registryPushRenderer;
+
+//# sourceMappingURL=push.cjs.map

package/dist/push.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.cjs","names":["renderPushContent"],"sources":["../src/push.ts"],"sourcesContent":["import type { ScalarIR } from './ir';\nimport { type PushContent, type PushTemplate, renderPushContent } from './templates';\n\n/**\n * `@shware/workflow/push` — push-notification content. A push is data, not a\n * component: a title and a body the OS renders in its own chrome, built by a\n * `pushTemplate`'s `content(parsedProps)` — final text, never placeholder-\n * expanded, so braces in user data survive. Transport is a separate concern\n * (`@shware/workflow/apns`, `@shware/workflow/fcm`).\n */\n\nexport type RenderedPush = PushContent;\n\nexport type PushRenderer = (\n  template: string,\n  props: Record<string, ScalarIR | undefined>\n) => Promise<RenderedPush>;\n\n/** A renderer over the registry; a TemplateValidationError means nothing may be sent. */\nexport function registryPushRenderer(pushes: Record<string, PushTemplate>): PushRenderer {\n  return async (key, props) => {\n    if (!Object.hasOwn(pushes, key)) throw new Error(`unknown push template: ${key}`);\n    return renderPushContent(pushes[key], key, props);\n  };\n}\n"],"mappings":";;;;AAmBA,SAAgB,qBAAqB,QAAoD;CACvF,OAAO,OAAO,KAAK,UAAU;EAC3B,IAAI,CAAC,OAAO,OAAO,QAAQ,GAAG,GAAG,MAAM,IAAI,MAAM,0BAA0B,KAAK;EAChF,OAAOA,kBAAAA,kBAAkB,OAAO,MAAM,KAAK,KAAK;CAClD;AACF"}

package/dist/push.d.cts

@@ -0,0 +1,16 @@
+import { ScalarIR } from "./ir.cjs";
+import { PushContent, PushTemplate } from "./templates.cjs";
+//#region src/push.d.ts
+/**
+ * `@shware/workflow/push` — push-notification content. A push is data, not a
+ * component: a title and a body the OS renders in its own chrome, built by a
+ * `pushTemplate`'s `content(parsedProps)` — final text, never placeholder-
+ * expanded, so braces in user data survive. Transport is a separate concern
+ * (`@shware/workflow/apns`, `@shware/workflow/fcm`).
+ */
+export type RenderedPush = PushContent;
+export type PushRenderer = (template: string, props: Record<string, ScalarIR | undefined>) => Promise<RenderedPush>;
+/** A renderer over the registry; a TemplateValidationError means nothing may be sent. */
+export declare function registryPushRenderer(pushes: Record<string, PushTemplate>): PushRenderer;
+//#endregion
+//# sourceMappingURL=push.d.cts.map

package/dist/push.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.d.cts","names":[],"sources":["../src/push.ts"],"mappings":";;;;;;;;;;YAWY,eAAe;YAEf,gBACV,kBACA,OAAO,eAAe,0BACnB,QAAQ;;wBAGG,qBAAqB,QAAQ,eAAe,gBAAgB"}

package/dist/push.d.mts

@@ -0,0 +1,16 @@
+import { ScalarIR } from "./ir.mjs";
+import { PushContent, PushTemplate } from "./templates.mjs";
+//#region src/push.d.ts
+/**
+ * `@shware/workflow/push` — push-notification content. A push is data, not a
+ * component: a title and a body the OS renders in its own chrome, built by a
+ * `pushTemplate`'s `content(parsedProps)` — final text, never placeholder-
+ * expanded, so braces in user data survive. Transport is a separate concern
+ * (`@shware/workflow/apns`, `@shware/workflow/fcm`).
+ */
+export type RenderedPush = PushContent;
+export type PushRenderer = (template: string, props: Record<string, ScalarIR | undefined>) => Promise<RenderedPush>;
+/** A renderer over the registry; a TemplateValidationError means nothing may be sent. */
+export declare function registryPushRenderer(pushes: Record<string, PushTemplate>): PushRenderer;
+//#endregion
+//# sourceMappingURL=push.d.mts.map

package/dist/push.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.d.mts","names":[],"sources":["../src/push.ts"],"mappings":";;;;;;;;;;YAWY,eAAe;YAEf,gBACV,kBACA,OAAO,eAAe,0BACnB,QAAQ;;wBAGG,qBAAqB,QAAQ,eAAe,gBAAgB"}

package/dist/push.mjs

@@ -0,0 +1,13 @@
+import { renderPushContent } from "./templates.mjs";
+//#region src/push.ts
+/** A renderer over the registry; a TemplateValidationError means nothing may be sent. */
+function registryPushRenderer(pushes) {
+	return async (key, props) => {
+		if (!Object.hasOwn(pushes, key)) throw new Error(`unknown push template: ${key}`);
+		return renderPushContent(pushes[key], key, props);
+	};
+}
+//#endregion
+export { registryPushRenderer };
+
+//# sourceMappingURL=push.mjs.map

package/dist/push.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.mjs","names":[],"sources":["../src/push.ts"],"sourcesContent":["import type { ScalarIR } from './ir';\nimport { type PushContent, type PushTemplate, renderPushContent } from './templates';\n\n/**\n * `@shware/workflow/push` — push-notification content. A push is data, not a\n * component: a title and a body the OS renders in its own chrome, built by a\n * `pushTemplate`'s `content(parsedProps)` — final text, never placeholder-\n * expanded, so braces in user data survive. Transport is a separate concern\n * (`@shware/workflow/apns`, `@shware/workflow/fcm`).\n */\n\nexport type RenderedPush = PushContent;\n\nexport type PushRenderer = (\n  template: string,\n  props: Record<string, ScalarIR | undefined>\n) => Promise<RenderedPush>;\n\n/** A renderer over the registry; a TemplateValidationError means nothing may be sent. */\nexport function registryPushRenderer(pushes: Record<string, PushTemplate>): PushRenderer {\n  return async (key, props) => {\n    if (!Object.hasOwn(pushes, key)) throw new Error(`unknown push template: ${key}`);\n    return renderPushContent(pushes[key], key, props);\n  };\n}\n"],"mappings":";;;AAmBA,SAAgB,qBAAqB,QAAoD;CACvF,OAAO,OAAO,KAAK,UAAU;EAC3B,IAAI,CAAC,OAAO,OAAO,QAAQ,GAAG,GAAG,MAAM,IAAI,MAAM,0BAA0B,KAAK;EAChF,OAAO,kBAAkB,OAAO,MAAM,KAAK,KAAK;CAClD;AACF"}

package/dist/react-email.cjs

@@ -0,0 +1,48 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_templates = require("./templates.cjs");
+let react = require("react");
+let react_dom_server = require("react-dom/server");
+//#region src/react-email.ts
+/**
+* `@shware/workflow/react-email` — an EmailRenderer over the project's email
+* registry (`react-dom` is an optional peer dependency; import this subpath
+* only when you use it).
+*
+* The registry maps keys to `emailTemplate({...})` definitions. Props are
+* parsed against the template's schema before the component renders — a
+* failure throws TemplateValidationError and nothing renders — and the
+* component renders as an element, so hooks and context work. Rendering
+* streams and waits for every Suspense boundary (`allReady`) — react-email's
+* `<Tailwind>` suspends while it compiles the classes, which synchronous
+* static markup cannot wait for — then prepends the XHTML doctype react-email
+* uses. @react-email/render itself is avoided because its Workers build
+* statically imports prettier and html-to-text for options never used here.
+*/
+const DOCTYPE = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">";
+function registryRenderer(emails) {
+	return async (key, props) => {
+		if (!Object.hasOwn(emails, key)) throw new Error(`unknown email template: ${key}`);
+		const template = emails[key];
+		const parsed = require_templates.parseTemplateProps(template, key, props);
+		const element = (0, react.createElement)(template.component, parsed);
+		return {
+			subject: template.subject,
+			html: DOCTYPE + await renderToHtml(element)
+		};
+	};
+}
+/** Render to a string once every Suspense boundary has resolved; a rendering error rejects. */
+async function renderToHtml(element) {
+	let failure;
+	const stream = await (0, react_dom_server.renderToReadableStream)(element, { onError: (error) => {
+		failure = error;
+	} });
+	await stream.allReady;
+	const html = await new Response(stream).text();
+	if (failure !== void 0) throw failure instanceof Error ? failure : new Error("email render failed", { cause: failure });
+	return html.replace(/^<!DOCTYPE html>/i, "").replace(/<link rel="preload" as="image"[^>]*\/>/g, "");
+}
+//#endregion
+exports.registryRenderer = registryRenderer;
+
+//# sourceMappingURL=react-email.cjs.map

package/dist/react-email.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-email.cjs","names":["parseTemplateProps","createElement","renderToReadableStream"],"sources":["../src/react-email.ts"],"sourcesContent":["import { type ComponentType, type ReactElement, createElement } from 'react';\nimport { renderToReadableStream } from 'react-dom/server';\nimport type { EmailRenderer } from './cloudflare';\nimport { type EmailTemplate, parseTemplateProps } from './templates';\n\n/**\n * `@shware/workflow/react-email` — an EmailRenderer over the project's email\n * registry (`react-dom` is an optional peer dependency; import this subpath\n * only when you use it).\n *\n * The registry maps keys to `emailTemplate({...})` definitions. Props are\n * parsed against the template's schema before the component renders — a\n * failure throws TemplateValidationError and nothing renders — and the\n * component renders as an element, so hooks and context work. Rendering\n * streams and waits for every Suspense boundary (`allReady`) — react-email's\n * `<Tailwind>` suspends while it compiles the classes, which synchronous\n * static markup cannot wait for — then prepends the XHTML doctype react-email\n * uses. @react-email/render itself is avoided because its Workers build\n * statically imports prettier and html-to-text for options never used here.\n */\n\nconst DOCTYPE =\n  '<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">';\n\nexport function registryRenderer(emails: Record<string, EmailTemplate>): EmailRenderer {\n  return async (key, props) => {\n    if (!Object.hasOwn(emails, key)) throw new Error(`unknown email template: ${key}`);\n    const template = emails[key];\n    const parsed = parseTemplateProps(template, key, props);\n    const element = createElement(template.component as ComponentType<object>, parsed);\n    return { subject: template.subject, html: DOCTYPE + (await renderToHtml(element)) };\n  };\n}\n\n/** Render to a string once every Suspense boundary has resolved; a rendering error rejects. */\nasync function renderToHtml(element: ReactElement): Promise<string> {\n  let failure: unknown;\n  const stream = await renderToReadableStream(element, {\n    onError: (error) => {\n      failure = error;\n    },\n  });\n  await stream.allReady;\n  const html = await new Response(stream).text();\n  if (failure !== undefined) {\n    throw failure instanceof Error ? failure : new Error('email render failed', { cause: failure });\n  }\n  // Streaming a document adds what static markup did not: an HTML5 doctype (the caller prepends\n  // the XHTML one email clients expect) and React 19's image preload hints, which mean nothing in\n  // an email. Both are dropped, as @react-email/render does.\n  return html\n    .replace(/^<!DOCTYPE html>/i, '')\n    .replace(/<link rel=\"preload\" as=\"image\"[^>]*\\/>/g, '');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,UACJ;AAEF,SAAgB,iBAAiB,QAAsD;CACrF,OAAO,OAAO,KAAK,UAAU;EAC3B,IAAI,CAAC,OAAO,OAAO,QAAQ,GAAG,GAAG,MAAM,IAAI,MAAM,2BAA2B,KAAK;EACjF,MAAM,WAAW,OAAO;EACxB,MAAM,SAASA,kBAAAA,mBAAmB,UAAU,KAAK,KAAK;EACtD,MAAM,WAAA,GAAUC,MAAAA,cAAAA,CAAc,SAAS,WAAoC,MAAM;EACjF,OAAO;GAAE,SAAS,SAAS;GAAS,MAAM,UAAW,MAAM,aAAa,OAAO;EAAG;CACpF;AACF;;AAGA,eAAe,aAAa,SAAwC;CAClE,IAAI;CACJ,MAAM,SAAS,OAAA,GAAMC,iBAAAA,uBAAAA,CAAuB,SAAS,EACnD,UAAU,UAAU;EAClB,UAAU;CACZ,EACF,CAAC;CACD,MAAM,OAAO;CACb,MAAM,OAAO,MAAM,IAAI,SAAS,MAAM,CAAC,CAAC,KAAK;CAC7C,IAAI,YAAY,KAAA,GACd,MAAM,mBAAmB,QAAQ,UAAU,IAAI,MAAM,uBAAuB,EAAE,OAAO,QAAQ,CAAC;CAKhG,OAAO,KACJ,QAAQ,qBAAqB,EAAE,CAAC,CAChC,QAAQ,2CAA2C,EAAE;AAC1D"}

package/dist/react-email.d.cts

@@ -0,0 +1,7 @@
+import { EmailTemplate } from "./templates.cjs";
+import { EmailRenderer } from "./cloudflare/senders.cjs";
+import "./cloudflare/index.cjs";
+//#region src/react-email.d.ts
+export declare function registryRenderer(emails: Record<string, EmailTemplate>): EmailRenderer;
+//#endregion
+//# sourceMappingURL=react-email.d.cts.map

package/dist/react-email.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-email.d.cts","names":[],"sources":["../src/react-email.ts"],"mappings":";;;;wBAwBgB,iBAAiB,QAAQ,eAAe,iBAAiB"}

package/dist/react-email.d.mts

@@ -0,0 +1,7 @@
+import { EmailTemplate } from "./templates.mjs";
+import { EmailRenderer } from "./cloudflare/senders.mjs";
+import "./cloudflare/index.mjs";
+//#region src/react-email.d.ts
+export declare function registryRenderer(emails: Record<string, EmailTemplate>): EmailRenderer;
+//#endregion
+//# sourceMappingURL=react-email.d.mts.map

package/dist/react-email.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-email.d.mts","names":[],"sources":["../src/react-email.ts"],"mappings":";;;;wBAwBgB,iBAAiB,QAAQ,eAAe,iBAAiB"}