@pithy-sh/support 0.1.2 → 0.1.3

package/dist/version.generated.js

@@ -0,0 +1,7 @@
+//#region src/version.generated.ts
+/** This package's npm name — the join key against a release feed. */
+const PACKAGE_NAME = "@pithy-sh/support";
+/** This package's version, stamped from its own package.json at generation time. */
+const PACKAGE_VERSION = "0.1.3";
+//#endregion
+export { PACKAGE_NAME, PACKAGE_VERSION };

package/dist/workflows/classify.d.ts

@@ -0,0 +1,63 @@
+import type { SupportAi } from "../ai/classify";
+import type { SupportAiConfig } from "../config/config";
+import type { SupportCategories } from "../data/categories";
+import { type SupportDatabase } from "../data/tables";
+/**
+ * The classification orchestration — the pure, testable core the Workflow step runs.
+ *
+ * Reads a message, asks the model about it, **appends** a classification row, and denormalizes the
+ * answer onto its thread. The two writes are deliberate and asymmetric: the history is append-only
+ * so a model upgrade is visible in the data rather than a silent rewrite, and the thread carries only
+ * the current answer because that is what the inbox query reads.
+ *
+ * Idempotent by construction. Re-running over the same message appends a second row and overwrites
+ * the same three thread columns with a fresh judgment — which is what makes a Workflow retry, a
+ * manual reclassify, and a post-upgrade backfill the same operation.
+ */
+/** Everything classification needs, all injectable. */
+export interface ClassifyDeps {
+    /** The support tables. */
+    db: SupportDatabase;
+    /** The Workers AI binding. */
+    ai: SupportAi;
+    /** The effective taxonomy — the defaults plus the adopter's. */
+    categories: SupportCategories;
+    /** Model, bounds, and temperature. */
+    ai_config: SupportAiConfig;
+    /**
+     * Archive a thread the classifier calls `spam`, so it never reaches the open inbox.
+     *
+     * **Archived, never deleted.** The classifier is wrong sometimes, and a pass that destroyed mail
+     * would be untrustworthy the first time it was — whereas an archived thread is still readable under
+     * the archived filter and one click from being back. That is what makes `spam` a filter rather than
+     * a bin, and it is why this is safe to have on by default.
+     */
+    archiveSpam: boolean;
+    /** Generate a row id. */
+    newId: () => string;
+    /** Now. */
+    now: () => Date;
+}
+/** What one classification run did. `null` when the message no longer exists. */
+export interface ClassifyOutcome {
+    /** The thread the classification landed on. */
+    threadId: string;
+    /** The category chosen. */
+    category: string;
+    /** The model's confidence. */
+    confidence: number;
+    /** The model that produced it. */
+    model: string;
+    /** Whether this run archived the thread because it classified as spam. */
+    archivedAsSpam: boolean;
+}
+/** Classify one stored message and write the result. Returns null when the message is gone. */
+export declare function runClassification(deps: ClassifyDeps, messageId: string): Promise<ClassifyOutcome | null>;
+/**
+ * The message a manual reclassify runs against: a thread's most recent **inbound** message.
+ *
+ * Inbound, not latest — a thread whose last message is our own reply would otherwise be reclassified
+ * on the text the adopter wrote, which says nothing about what the customer wanted.
+ */
+export declare function latestInboundMessageId(db: SupportDatabase, threadId: string): Promise<string | undefined>;
+//# sourceMappingURL=classify.d.ts.map

package/dist/workflows/classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../../src/workflows/classify.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAG5D,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,gBAAgB,CAAC;AAExB;;;;;;;;;;;GAWG;AAEH,uDAAuD;AACvD,MAAM,WAAW,YAAY;IAC3B,0BAA0B;IAC1B,EAAE,EAAE,eAAe,CAAC;IACpB,8BAA8B;IAC9B,EAAE,EAAE,SAAS,CAAC;IACd,gEAAgE;IAChE,UAAU,EAAE,iBAAiB,CAAC;IAC9B,sCAAsC;IACtC,SAAS,EAAE,eAAe,CAAC;IAC3B;;;;;;;OAOG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB,yBAAyB;IACzB,KAAK,EAAE,MAAM,MAAM,CAAC;IACpB,WAAW;IACX,GAAG,EAAE,MAAM,IAAI,CAAC;CACjB;AAED,iFAAiF;AACjF,MAAM,WAAW,eAAe;IAC9B,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,2BAA2B;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,8BAA8B;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,0EAA0E;IAC1E,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,+FAA+F;AAC/F,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAwE9G;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,EAAE,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAc/G"}

package/dist/workflows/classify.js

@@ -0,0 +1,68 @@
+import "../data/enums.js";
+import { SupportClassification } from "../data/classification.js";
+import { SUPPORT_CLASSIFICATIONS_TABLE, SUPPORT_MESSAGES_TABLE, SUPPORT_THREADS_TABLE } from "../data/tables.js";
+import { classifyMessage } from "../ai/classify.js";
+//#region src/workflows/classify.ts
+/** Classify one stored message and write the result. Returns null when the message is gone. */
+async function runClassification(deps, messageId) {
+	const message = await deps.db.selectFrom(SUPPORT_MESSAGES_TABLE).select([
+		"id",
+		"threadId",
+		"subject",
+		"textBody"
+	]).where("id", "=", messageId).executeTakeFirst();
+	if (!message) return null;
+	const result = await classifyMessage(deps.ai, {
+		categories: deps.categories,
+		subject: message.subject,
+		body: message.textBody,
+		model: deps.ai_config.model,
+		maxChars: deps.ai_config.maxChars,
+		temperature: deps.ai_config.temperature
+	});
+	const now = deps.now();
+	await deps.db.insertInto(SUPPORT_CLASSIFICATIONS_TABLE).values(SupportClassification.encode({
+		id: deps.newId(),
+		threadId: message.threadId,
+		messageId: message.id,
+		category: result.category,
+		priority: result.priority,
+		sentiment: result.sentiment,
+		confidence: result.confidence,
+		model: result.model,
+		createdAt: now
+	})).execute();
+	const archivedAsSpam = deps.archiveSpam && result.category === "spam";
+	await deps.db.updateTable(SUPPORT_THREADS_TABLE).set({
+		category: result.category,
+		priority: result.priority,
+		sentiment: result.sentiment,
+		confidence: result.confidence,
+		model: result.model,
+		classifiedAt: now.getTime(),
+		updatedAt: now.getTime(),
+		...archivedAsSpam ? {
+			archived: 1,
+			archivedAt: now.getTime(),
+			archivedBy: result.model
+		} : {}
+	}).where("id", "=", message.threadId).execute();
+	return {
+		threadId: message.threadId,
+		category: result.category,
+		confidence: result.confidence,
+		model: result.model,
+		archivedAsSpam
+	};
+}
+/**
+* The message a manual reclassify runs against: a thread's most recent **inbound** message.
+*
+* Inbound, not latest — a thread whose last message is our own reply would otherwise be reclassified
+* on the text the adopter wrote, which says nothing about what the customer wanted.
+*/
+async function latestInboundMessageId(db, threadId) {
+	return (await db.selectFrom(SUPPORT_MESSAGES_TABLE).select(["id"]).where("threadId", "=", threadId).where("direction", "=", "inbound").orderBy("receivedAt", "desc").orderBy("id", "desc").limit(1).executeTakeFirst())?.id;
+}
+//#endregion
+export { latestInboundMessageId, runClassification };

package/dist/workflows/retryPolicy.d.ts

@@ -0,0 +1,39 @@
+import type { WorkflowRetryPolicy } from "@pithy-sh/core/src/workflow/faults";
+/**
+ * **What a classification retries, and what it refuses to.**
+ *
+ * `ai/classify.ts` already drew this line and drew it correctly: a model that returns prose, an invented
+ * label, or an envelope nobody documented yields `uncategorized` at zero confidence and never throws,
+ * because throwing would burn a retry budget on a model that is going to say the same thing next time.
+ * The one case it deliberately does not swallow is a binding that is *unavailable*. This is that
+ * sentence in the form the durable step reads (pithy-sh/pithy#348).
+ *
+ * ## Retryable, and why
+ *
+ * - **`core/upstream_failed`** — Workers AI rejected the call. Raised at exactly one place, the wrap
+ *   around `ai.run` in `classifyMessage`, and it means the model did not answer at all. That is the
+ *   whole population of transient faults in a classification, and the code is what lets the step tell
+ *   it from a bad answer — a raw throw would be `unclassified`, and unclassified is terminal.
+ * - **A transient D1 fault** — the message read, the appended history row, the thread denormalization.
+ *   Classified in core by `withD1Retry`, never restated here.
+ *
+ * ## Terminal, and why
+ *
+ * - **`support/not_found`** — a thread or message that is gone. `runClassification` does not even raise
+ *   it for the message it was started for: a missing row returns `null`, because an instance outliving
+ *   the row that started it is the ordinary way a rollback looks.
+ * - **`support/classification_failed`** — the AI binding is absent from the env. A binding does not
+ *   appear on the fourth attempt; this wants `pithy support provision`.
+ * - **`support/invalid_category`** — the adopter's taxonomy will not validate. Config, and identical
+ *   next time.
+ * - **`support/unparseable_message`, `support/rejected`, `support/reply_failed`** — all inbound-path and
+ *   reply-path refusals. None runs inside the classify step.
+ * - **`validation/invalid_input`** — a payload the schema refuses.
+ *
+ * **Re-running is free, which is what makes the retryable entry safe.** Classification is idempotent by
+ * construction: a second pass appends a second history row and overwrites the same three thread columns
+ * with a fresh judgment, which is why a Workflow retry, a manual reclassify, and a post-upgrade
+ * backfill are the same operation.
+ */
+export declare const supportWorkflowRetry: WorkflowRetryPolicy;
+//# sourceMappingURL=retryPolicy.d.ts.map

package/dist/workflows/retryPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retryPolicy.d.ts","sourceRoot":"","sources":["../../src/workflows/retryPolicy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,oBAAoB,EAAE,mBAMlC,CAAC"}

package/dist/workflows/retryPolicy.js

@@ -0,0 +1,43 @@
+//#region src/workflows/retryPolicy.ts
+/**
+* **What a classification retries, and what it refuses to.**
+*
+* `ai/classify.ts` already drew this line and drew it correctly: a model that returns prose, an invented
+* label, or an envelope nobody documented yields `uncategorized` at zero confidence and never throws,
+* because throwing would burn a retry budget on a model that is going to say the same thing next time.
+* The one case it deliberately does not swallow is a binding that is *unavailable*. This is that
+* sentence in the form the durable step reads (pithy-sh/pithy#348).
+*
+* ## Retryable, and why
+*
+* - **`core/upstream_failed`** — Workers AI rejected the call. Raised at exactly one place, the wrap
+*   around `ai.run` in `classifyMessage`, and it means the model did not answer at all. That is the
+*   whole population of transient faults in a classification, and the code is what lets the step tell
+*   it from a bad answer — a raw throw would be `unclassified`, and unclassified is terminal.
+* - **A transient D1 fault** — the message read, the appended history row, the thread denormalization.
+*   Classified in core by `withD1Retry`, never restated here.
+*
+* ## Terminal, and why
+*
+* - **`support/not_found`** — a thread or message that is gone. `runClassification` does not even raise
+*   it for the message it was started for: a missing row returns `null`, because an instance outliving
+*   the row that started it is the ordinary way a rollback looks.
+* - **`support/classification_failed`** — the AI binding is absent from the env. A binding does not
+*   appear on the fourth attempt; this wants `pithy support provision`.
+* - **`support/invalid_category`** — the adopter's taxonomy will not validate. Config, and identical
+*   next time.
+* - **`support/unparseable_message`, `support/rejected`, `support/reply_failed`** — all inbound-path and
+*   reply-path refusals. None runs inside the classify step.
+* - **`validation/invalid_input`** — a payload the schema refuses.
+*
+* **Re-running is free, which is what makes the retryable entry safe.** Classification is idempotent by
+* construction: a second pass appends a second history row and overwrites the same three thread columns
+* with a fresh judgment, which is why a Workflow retry, a manual reclassify, and a post-upgrade
+* backfill are the same operation.
+*/
+const supportWorkflowRetry = {
+	capability: "support",
+	retryable: { "core/upstream_failed": "The model did not answer at all; classification is idempotent, so asking again costs one call." }
+};
+//#endregion
+export { supportWorkflowRetry };

package/dist/workflows/specs.d.ts

@@ -0,0 +1,43 @@
+import type { WorkflowRegistry } from "@pithy-sh/core/src/workflow/spec";
+import { z } from "zod";
+/**
+ * The one durable job support owns, declared once.
+ *
+ * **Classification is a Workflow, not part of the `email()` handler**, and that is a hard constraint
+ * rather than a preference. An inbound handler runs under a tight CPU budget; a model call is
+ * hundreds of milliseconds of wall time it cannot spend, and a model that is slow or briefly
+ * unavailable would take the *persistence* of the message down with it. So the handler does the
+ * cheap, must-not-fail half — parse, bound, store — and hands off. A classification that fails
+ * retries against a message that is already safely in D1.
+ *
+ * `optional: true`: the Workflow lives in the prebuilt support worker that `pithy support provision`
+ * deploys, so a project that has not provisioned must still boot and still receive mail. An absent
+ * binding degrades to a logged skip and a thread that stays `uncategorized` — which is exactly the
+ * state a classification is allowed to be in.
+ */
+/** The capability name — the first segment of the dispatch key and of every deployed workflow name. */
+export declare const SUPPORT_CAPABILITY = "support";
+/** Which message to classify. */
+export declare const SupportClassifyParams: z.ZodObject<{
+    messageId: z.ZodString;
+}, z.core.$strip>;
+export type SupportClassifyParams = z.infer<typeof SupportClassifyParams>;
+/** Support's durable jobs, keyed by job name. The key is the second segment of the `support/<job>` dispatch key. */
+export declare const supportWorkflows: {
+    readonly classify: {
+        readonly binding: "SUPPORT_CLASSIFY";
+        readonly className: "SupportClassifyWorkflow";
+        readonly params: z.ZodObject<{
+            messageId: z.ZodString;
+        }, z.core.$strip>;
+        readonly optional: true;
+    };
+};
+/**
+ * Support's jobs as a dispatch registry, keyed `support/<job>`. Built here rather than through
+ * `composeWorkflows` because the inbound handler dispatches from inside the capability, before any
+ * project-wide registry exists — and the key format comes from core's {@link workflowKey} either
+ * way, so the two cannot drift.
+ */
+export declare const supportWorkflowRegistry: WorkflowRegistry;
+//# sourceMappingURL=specs.d.ts.map

package/dist/workflows/specs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"specs.d.ts","sourceRoot":"","sources":["../../src/workflows/specs.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,kCAAkC,CAAC;AAC1F,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;GAcG;AAEH,uGAAuG;AACvG,eAAO,MAAM,kBAAkB,YAAY,CAAC;AAE5C,iCAAiC;AACjC,eAAO,MAAM,qBAAqB;;iBASsE,CAAC;AACzG,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E,oHAAoH;AACpH,eAAO,MAAM,gBAAgB;;iBAEzB,OAAO,EAAE,kBAAkB;iBAC3B,SAAS,EAAE,yBAAyB;iBACpC,MAAM;;;iBACN,QAAQ;;CAEwB,CAAC;AAErC;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,gBAKrC,CAAC"}

package/dist/workflows/specs.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { workflowKey } from "@pithy-sh/core/src/workflow/naming";
+//#region src/workflows/specs.ts
+/**
+* The one durable job support owns, declared once.
+*
+* **Classification is a Workflow, not part of the `email()` handler**, and that is a hard constraint
+* rather than a preference. An inbound handler runs under a tight CPU budget; a model call is
+* hundreds of milliseconds of wall time it cannot spend, and a model that is slow or briefly
+* unavailable would take the *persistence* of the message down with it. So the handler does the
+* cheap, must-not-fail half — parse, bound, store — and hands off. A classification that fails
+* retries against a message that is already safely in D1.
+*
+* `optional: true`: the Workflow lives in the prebuilt support worker that `pithy support provision`
+* deploys, so a project that has not provisioned must still boot and still receive mail. An absent
+* binding degrades to a logged skip and a thread that stays `uncategorized` — which is exactly the
+* state a classification is allowed to be in.
+*/
+/** The capability name — the first segment of the dispatch key and of every deployed workflow name. */
+const SUPPORT_CAPABILITY = "support";
+/** Which message to classify. */
+const SupportClassifyParams = z.object({ messageId: z.string().min(1).describe("The `pithy_support_messages.id` to classify. The Workflow reads that message, asks the model about it, appends a classification row, and denormalizes the answer onto its thread.") }).describe("The instance parameters of the classification Workflow — the one message it runs against.");
+/** Support's durable jobs, keyed by job name. The key is the second segment of the `support/<job>` dispatch key. */
+const supportWorkflows = { classify: {
+	binding: "SUPPORT_CLASSIFY",
+	className: "SupportClassifyWorkflow",
+	params: SupportClassifyParams,
+	optional: true
+} };
+/**
+* Support's jobs as a dispatch registry, keyed `support/<job>`. Built here rather than through
+* `composeWorkflows` because the inbound handler dispatches from inside the capability, before any
+* project-wide registry exists — and the key format comes from core's {@link workflowKey} either
+* way, so the two cannot drift.
+*/
+const supportWorkflowRegistry = Object.fromEntries(Object.entries(supportWorkflows).map(([job, spec]) => {
+	const key = workflowKey(SUPPORT_CAPABILITY, job);
+	return [key, {
+		key,
+		capability: SUPPORT_CAPABILITY,
+		job,
+		spec
+	}];
+}));
+//#endregion
+export { SUPPORT_CAPABILITY, SupportClassifyParams, supportWorkflowRegistry, supportWorkflows };

package/dist/workflows/worker.d.ts

@@ -0,0 +1,48 @@
+import { WorkflowEntrypoint, type WorkflowEvent, type WorkflowStep } from "cloudflare:workers";
+import type { D1Database } from "@cloudflare/workers-types";
+import type { SupportAi } from "../ai/classify";
+/**
+ * The prebuilt support worker. `pithy support provision` deploys one per environment; the adopter
+ * authors no code for it. It hosts the classification Workflow — a thin durable shell around the
+ * tested orchestration in `classify.ts`. The app worker receives the mail, stores it, and starts an
+ * instance.
+ *
+ * This module imports `cloudflare:workers`, so it runs only in the Workers runtime and is excluded
+ * from the node `.describe()` meta-test.
+ *
+ * **The effective taxonomy arrives as config, not as code.** `SUPPORT_CONFIG` carries the adopter's
+ * own categories, so their `tournament_dispute` reaches the prompt without this worker importing
+ * anything of theirs — which it could not do anyway, since it is deployed from this package.
+ *
+ * **The default export is what makes this an ES module** (#426). It exports one Workflow class and has
+ * no cron, so until now it exported no default — and wrangler infers a worker's module format from
+ * exactly that, so the build read it as a service worker and refused `cloudflare:workers` outright.
+ * The host did not build, `pithy dev` carried on past it, and classification silently never ran. The
+ * refusal it exports is the honest body for a host with no request surface; see
+ * `@pithy-sh/core/src/workflow/hostEntry`.
+ */
+/** The support worker's env: the app database, the AI binding, and the serialized config. */
+export interface SupportWorkerEnv {
+    /** The app database the support tables live in. */
+    DB: D1Database;
+    /** The Workers AI binding. */
+    AI: SupportAi;
+    /** The resolved support config as a JSON string, filled at provision. */
+    SUPPORT_CONFIG?: string;
+}
+/** Classify one stored message and write the result. */
+export declare class SupportClassifyWorkflow extends WorkflowEntrypoint<SupportWorkerEnv, {
+    messageId: string;
+}> {
+    run(event: WorkflowEvent<{
+        messageId: string;
+    }>, step: WorkflowStep): Promise<void>;
+}
+/**
+ * The module's default export, and therefore its format. See `hostEntry` for why a Workflow host needs
+ * one at all, and why this one refuses rather than being empty: nothing reaches this worker over HTTP —
+ * the app worker stores the message and starts an instance on the `SUPPORT_CLASSIFY` binding.
+ */
+declare const _default: import("@pithy-sh/core/src/workflow/hostEntry").WorkflowHostEntry;
+export default _default;
+//# sourceMappingURL=worker.d.ts.map

package/dist/workflows/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/workflows/worker.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAE/F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAG5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAQhD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,6FAA6F;AAC7F,MAAM,WAAW,gBAAgB;IAC/B,mDAAmD;IACnD,EAAE,EAAE,UAAU,CAAC;IACf,8BAA8B;IAC9B,EAAE,EAAE,SAAS,CAAC;IACd,yEAAyE;IACzE,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wDAAwD;AACxD,qBAAa,uBAAwB,SAAQ,kBAAkB,CAAC,gBAAgB,EAAE;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;IACvF,GAAG,CAAC,KAAK,EAAE,aAAa,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAwBjG;CACF;AAED;;;;GAIG"}

package/dist/workflows/worker.js

@@ -0,0 +1,37 @@
+import { SupportConfig } from "../config/config.js";
+import { resolveCategories } from "../data/categories.js";
+import { supportDatabase } from "../data/tables.js";
+import { SUPPORT_CAPABILITY } from "./specs.js";
+import { runClassification } from "./classify.js";
+import { supportWorkflowRetry } from "./retryPolicy.js";
+import { WorkflowEntrypoint } from "cloudflare:workers";
+import { NonRetryableError } from "cloudflare:workflows";
+import { classifiedSteps } from "@pithy-sh/core/src/workflow/faults";
+import { workflowHostEntry } from "@pithy-sh/core/src/workflow/hostEntry";
+//#region src/workflows/worker.ts
+/** Classify one stored message and write the result. */
+var SupportClassifyWorkflow = class extends WorkflowEntrypoint {
+	async run(event, step) {
+		const config = SupportConfig.parse(this.env.SUPPORT_CONFIG ? JSON.parse(this.env.SUPPORT_CONFIG) : {});
+		const deps = {
+			db: supportDatabase(this.env.DB),
+			ai: this.env.AI,
+			categories: resolveCategories(config.categories),
+			ai_config: config.ai,
+			archiveSpam: config.guard.archiveSpam,
+			newId: () => crypto.randomUUID(),
+			now: () => /* @__PURE__ */ new Date()
+		};
+		await classifiedSteps(step, supportWorkflowRetry, NonRetryableError).do(`classify-${event.payload.messageId}`, async () => {
+			await runClassification(deps, event.payload.messageId);
+		});
+	}
+};
+/**
+* The module's default export, and therefore its format. See `hostEntry` for why a Workflow host needs
+* one at all, and why this one refuses rather than being empty: nothing reaches this worker over HTTP —
+* the app worker stores the message and starts an instance on the `SUPPORT_CLASSIFY` binding.
+*/
+var worker_default = workflowHostEntry(SUPPORT_CAPABILITY);
+//#endregion
+export { SupportClassifyWorkflow, worker_default as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pithy-sh/support",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -8,19 +8,24 @@
     "directory": "packages/support"
   },
   "files": [
+    "dist",
     "src",
     "pithy.manifest.json",
-    "!src/**/*.test.*"
+    "!src/**/*.test.*",
+    "!dist/**/*.test.*"
   ],
   "type": "module",
   "engines": {
     "node": ">=22"
   },
   "exports": {
-    "./src/*": "./src/*.ts"
+    "./src/*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json --noEmit false --outDir dist",
+    "build": "tsdown && tsc -p tsconfig.build.json",
     "typecheck": "tsc -p tsconfig.json",
     "test": "vitest run",
     "test:node": "vitest run --project=node",
@@ -31,19 +36,19 @@
   "dependencies": {
     "@cloudflare/workers-types": "^5.20260729.1",
     "@hono/zod-validator": "^0.9.0",
-    "@pithy-sh/core": "^0.1.2",
-    "@pithy-sh/email": "^0.1.2",
-    "@pithy-sh/secrets": "^0.1.2",
-    "@pithy-sh/storage": "^0.1.2",
-    "hono": "^4.13.2",
-    "kysely": "^0.29.0",
+    "@pithy-sh/core": "^0.1.3",
+    "@pithy-sh/email": "^0.1.3",
+    "@pithy-sh/secrets": "^0.1.3",
+    "@pithy-sh/storage": "^0.1.3",
     "postal-mime": "^3.0.0",
-    "tldts": "^7.4.10",
-    "zod": "^4.0.0"
+    "tldts": "^7.4.10"
   },
   "peerDependencies": {
-    "@pithy-sh/auth": "^0.1.2",
-    "@pithy-sh/payments": "^0.1.2"
+    "@pithy-sh/auth": "^0.1.3",
+    "@pithy-sh/payments": "^0.1.3",
+    "hono": "^4.13.2",
+    "kysely": "^0.29.0",
+    "zod": "^4.4.0"
   },
   "peerDependenciesMeta": {
     "@pithy-sh/auth": {
@@ -60,9 +65,13 @@
     "@pithy-sh/tsconfig": "workspace:*",
     "@types/node": "^22.15.0",
     "@vitest/coverage-v8": "^4.1.0",
+    "hono": "^4.13.2",
+    "kysely": "^0.29.0",
     "kysely-d1": "^0.4.0",
+    "tsdown": "^0.23.0",
     "typescript": "^7.0.2",
     "vitest": "^4.1.0",
-    "wrangler": "^4.115.0"
+    "wrangler": "^4.115.0",
+    "zod": "^4.4.0"
   }
 }

package/src/version.generated.ts

@@ -13,4 +13,4 @@
 export const PACKAGE_NAME = "@pithy-sh/support";
 
 /** This package's version, stamped from its own package.json at generation time. */
-export const PACKAGE_VERSION = "0.1.2";
+export const PACKAGE_VERSION = "0.1.3";