@pithy-sh/support 0.1.2 → 0.1.4

package/dist/workflows/specs.js

@@ -0,0 +1,48 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+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,50 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+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,39 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+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.4",
   "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 && bun ../../tooling/build/src/stampDeclarations.ts",
     "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.5",
+    "@pithy-sh/email": "^0.1.4",
+    "@pithy-sh/secrets": "^0.1.4",
+    "@pithy-sh/storage": "^0.1.4",
     "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.4",
+    "@pithy-sh/payments": "^0.1.5",
+    "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/http/handlers.ts

@@ -359,7 +359,7 @@ export async function submitFeedbackRequest(
       context: input.context,
       // Decoded here, at the transport boundary, so `submitFeedback` takes bytes and stays testable
       // without a request — the same split `ingest.ts` has from the `email()` handler. The decode is
-      // bounded before it allocates: `atob` materialises the whole result, so a size check afterwards
+      // bounded before it allocates: `atob` materializes the whole result, so a size check afterwards
       // has already paid for the attack it was meant to refuse.
       attachments: input.attachments.map((attachment) => ({
         filename: attachment.filename,

package/src/submission/encoding.ts

@@ -19,7 +19,7 @@ const BASE64_EXPANSION = 4 / 3;
 /**
  * The largest base64 string worth decoding, derived from a decoded-byte bound.
  *
- * Checked **before** decoding, not after. `atob` materialises the whole result, so a client that sends
+ * Checked **before** decoding, not after. `atob` materializes the whole result, so a client that sends
  * fifty megabytes of base64 has already been allocated fifty megabytes of Worker memory by the time a
  * post-hoc size check could refuse it — and the request that does that is the one an attacker sends.
  * A little slack for padding and any whitespace a client's encoder inserted.

package/src/submission/submit.ts

@@ -50,7 +50,7 @@ import { checkAccountRate, checkAttachment } from "./guard";
  * The mail path's rule, applied to a different shape: **refuse on the cheapest true reason first.**
  * The two shape bounds a client controls the cost of — how many files, and how large each encoded one
  * is — are applied at the transport boundary in `http/handlers.ts` *before* anything is decoded,
- * because `atob` materialises its whole result and a size check after it has already been handed the
+ * because `atob` materializes its whole result and a size check after it has already been handed the
  * allocation it meant to refuse. What is left arrives here as bytes:
  *
  * 0. **The declared category**, which needs no I/O at all — it is a comparison against a taxonomy this

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.4";