astroidjs 0.1.1 → 0.2.0

package/dist/workflow/advance.d.ts

@@ -0,0 +1,102 @@
+/** The D1 surface this needs. Structural, so a real `D1Database` fits and a
+ *  test can pass a stub. */
+export interface WorkflowDatabase {
+    prepare(query: string): {
+        bind(...values: unknown[]): {
+            run(): Promise<{
+                meta?: {
+                    changes?: number;
+                };
+            }>;
+            first<T = Record<string, unknown>>(): Promise<T | null>;
+        };
+    };
+}
+/** Who is advancing the item. */
+export interface WorkflowActor {
+    /** Short initials shown in the audit trail. Trimmed, upper-cased, capped. */
+    initials: string;
+    /** Optional account id, when the pipeline runs behind a portal. */
+    userId?: string;
+}
+export type AdvanceResult = {
+    ok: true;
+    /** The stage now in progress. Equals `stageCount` when the item is done. */
+    stage: number;
+    complete: boolean;
+} | {
+    ok: false;
+    /** Maps straight onto an HTTP status, so a route is a one-liner. */
+    status: 404 | 409 | 422;
+    error: string;
+};
+export interface AdvanceOptions {
+    db: WorkflowDatabase;
+    /** Table holding the `stage` column. */
+    table: string;
+    /** Audit table — one row per completed stage. */
+    auditTable: string;
+    /** Primary key column on `table`. Default `"id"`. */
+    idColumn?: string;
+    /** Foreign key column on the audit table. Default `"<table singular>_id"`,
+     *  which is why it's explicit here rather than guessed. */
+    auditIdColumn: string;
+    /** The item being advanced. */
+    id: string | number;
+    /**
+     * The stage the caller believes is in progress. This is the whole guard: it
+     * comes from the page the operator was looking at, so a stale page fails
+     * instead of advancing something that already moved.
+     */
+    expectedStage: number;
+    /** Total number of stages. Signing the last one completes the item. */
+    stageCount: number;
+    actor: WorkflowActor;
+    /** Free-form recorded values for this stage, stored as JSON on the audit row. */
+    specs?: {
+        k: string;
+        v: string;
+    }[];
+}
+/** Trim/normalize operator initials, or null when there aren't any. */
+export declare function normalizeInitials(value: unknown): string | null;
+/** Drop anything malformed from a caller-supplied spec list and bound it. An
+ *  operator's notes are untrusted input like any other request body. */
+export declare function normalizeSpecs(value: unknown): {
+    k: string;
+    v: string;
+}[];
+/**
+ * Advance one item by one stage, recording who did it.
+ *
+ * ```ts
+ * const result = await advanceWorkflowStage({
+ *   db: env.DB, table: "orders", auditTable: "orders_signoffs",
+ *   auditIdColumn: "order_id", id, expectedStage, stageCount: 4,
+ *   actor: { initials: "BB" }, specs,
+ * });
+ * return json(result, result.ok ? 200 : result.status);
+ * ```
+ *
+ * Every failure is a status, never a throw: a conflict is an ordinary outcome
+ * of two people working at once, not an exception.
+ */
+export declare function advanceWorkflowStage(options: AdvanceOptions): Promise<AdvanceResult>;
+export type OverrideAction = "back" | "skip";
+export interface OverrideOptions extends Omit<AdvanceOptions, "specs" | "expectedStage"> {
+    action: OverrideAction;
+    /** Override log table. */
+    overrideTable: string;
+    /** Where the item is now, from the operator's page — the same staleness guard. */
+    expectedStage: number;
+    /** Optional station/context label recorded with the override. */
+    station?: string;
+}
+/**
+ * Move an item out of band — back a stage, or skip one — and log it.
+ *
+ * Sending an item BACK deletes the audit row for the stage being reopened, so
+ * "a sign-off exists" keeps meaning "that stage is genuinely done". Leaving it
+ * would make the audit trail claim work that was undone.
+ */
+export declare function overrideWorkflowStage(options: OverrideOptions): Promise<AdvanceResult>;

package/dist/workflow/advance.js

@@ -0,0 +1,145 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// The guarded advance — the one piece of a staged pipeline that is genuinely
+// hard to get right.
+//
+// Two operators standing at two stations both press "sign off" on the same job.
+// A read-then-write advance runs the item forward two stages and writes two
+// audit rows, and nobody notices until the numbers stop adding up. The fix is
+// optimistic concurrency: make the write itself assert the stage it expected —
+// `UPDATE … SET stage = ? WHERE id = ? AND stage = ?` — and treat "0 rows
+// changed" as the conflict signal rather than checking first and hoping.
+//
+// ORDERING MATTERS, and the reference gets it wrong. ghostfire's floor route
+// inserts the sign-off row and THEN runs the guarded update, so a double submit
+// writes two audit rows even though only one advance lands. Here the guarded
+// update goes first and the audit row is written only if it actually moved the
+// item — so the audit table can't record work that didn't happen. The unique
+// index the schema generator emits on `(entity_id, stage)` is the belt to that
+// braces.
+/** Longest initials we store. Three is what a floor actually writes. */
+const MAX_INITIALS = 3;
+/** Caps on recorded specs, so one request can't write an unbounded blob. */
+const MAX_SPECS = 24;
+const MAX_SPEC_KEY = 60;
+const MAX_SPEC_VALUE = 200;
+/** Trim/normalize operator initials, or null when there aren't any. */
+export function normalizeInitials(value) {
+    const initials = String(value ?? "")
+        .trim()
+        .toUpperCase()
+        .slice(0, MAX_INITIALS);
+    return initials || null;
+}
+/** Drop anything malformed from a caller-supplied spec list and bound it. An
+ *  operator's notes are untrusted input like any other request body. */
+export function normalizeSpecs(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((s) => !!s && typeof s === "object" && typeof s.k === "string" && typeof s.v === "string")
+        .map((s) => ({ k: s.k.slice(0, MAX_SPEC_KEY), v: s.v.slice(0, MAX_SPEC_VALUE) }))
+        .slice(0, MAX_SPECS);
+}
+/**
+ * Advance one item by one stage, recording who did it.
+ *
+ * ```ts
+ * const result = await advanceWorkflowStage({
+ *   db: env.DB, table: "orders", auditTable: "orders_signoffs",
+ *   auditIdColumn: "order_id", id, expectedStage, stageCount: 4,
+ *   actor: { initials: "BB" }, specs,
+ * });
+ * return json(result, result.ok ? 200 : result.status);
+ * ```
+ *
+ * Every failure is a status, never a throw: a conflict is an ordinary outcome
+ * of two people working at once, not an exception.
+ */
+export async function advanceWorkflowStage(options) {
+    const { db, table, auditTable, idColumn = "id", auditIdColumn, id, expectedStage, stageCount, actor, } = options;
+    const initials = normalizeInitials(actor.initials);
+    if (!initials)
+        return { ok: false, status: 422, error: "Initials are required to sign off." };
+    if (!Number.isInteger(expectedStage) || expectedStage < 0 || expectedStage >= stageCount) {
+        return { ok: false, status: 422, error: "That stage doesn't exist in this workflow." };
+    }
+    const next = expectedStage + 1;
+    // The guard. `changes === 0` means the row is gone or someone else already
+    // moved it — the two cases are told apart below, but only after the write,
+    // so there is no window between the check and the update.
+    const advanced = await db
+        .prepare(`UPDATE ${table} SET stage = ? WHERE ${idColumn} = ? AND stage = ?`)
+        .bind(next, id, expectedStage)
+        .run();
+    if ((advanced.meta?.changes ?? 0) === 0) {
+        const current = await db
+            .prepare(`SELECT stage FROM ${table} WHERE ${idColumn} = ?`)
+            .bind(id)
+            .first();
+        if (!current)
+            return { ok: false, status: 404, error: "That item no longer exists." };
+        return {
+            ok: false,
+            status: 409,
+            // Naming the actual stage is what makes this recoverable: the operator
+            // refreshes and sees where the job really is, rather than pressing again.
+            error: `Someone else already moved this to stage ${current.stage} — refresh and try again.`,
+        };
+    }
+    // Only now, with the advance committed, is the work real enough to record.
+    const specs = normalizeSpecs(options.specs);
+    await db
+        .prepare(`INSERT INTO ${auditTable} (${auditIdColumn}, stage, specs, initials, actor_id, signed_at)` +
+        ` VALUES (?, ?, ?, ?, ?, ?)`)
+        .bind(id, expectedStage, specs.length > 0 ? JSON.stringify(specs) : null, initials, actor.userId ?? null, Math.floor(Date.now() / 1000))
+        .run();
+    return { ok: true, stage: next, complete: next >= stageCount };
+}
+/**
+ * Move an item out of band — back a stage, or skip one — and log it.
+ *
+ * Sending an item BACK deletes the audit row for the stage being reopened, so
+ * "a sign-off exists" keeps meaning "that stage is genuinely done". Leaving it
+ * would make the audit trail claim work that was undone.
+ */
+export async function overrideWorkflowStage(options) {
+    const { db, table, auditTable, overrideTable, idColumn = "id", auditIdColumn, id, action, expectedStage, stageCount, actor, station, } = options;
+    const initials = normalizeInitials(actor.initials);
+    if (!initials)
+        return { ok: false, status: 422, error: "Initials are required to override." };
+    const target = action === "back" ? expectedStage - 1 : expectedStage + 1;
+    if (target < 0)
+        return { ok: false, status: 422, error: "This is already the first stage." };
+    if (target > stageCount)
+        return { ok: false, status: 422, error: "This is already complete." };
+    const moved = await db
+        .prepare(`UPDATE ${table} SET stage = ? WHERE ${idColumn} = ? AND stage = ?`)
+        .bind(target, id, expectedStage)
+        .run();
+    if ((moved.meta?.changes ?? 0) === 0) {
+        const current = await db
+            .prepare(`SELECT stage FROM ${table} WHERE ${idColumn} = ?`)
+            .bind(id)
+            .first();
+        if (!current)
+            return { ok: false, status: 404, error: "That item no longer exists." };
+        return {
+            ok: false,
+            status: 409,
+            error: `Someone else already moved this to stage ${current.stage} — refresh and try again.`,
+        };
+    }
+    if (action === "back") {
+        await db
+            .prepare(`DELETE FROM ${auditTable} WHERE ${auditIdColumn} = ? AND stage = ?`)
+            .bind(id, target)
+            .run();
+    }
+    await db
+        .prepare(`INSERT INTO ${overrideTable} (${auditIdColumn}, action, initials, station, at)` +
+        ` VALUES (?, ?, ?, ?, ?)`)
+        .bind(id, action, initials, station ?? null, Math.floor(Date.now() / 1000))
+        .run();
+    return { ok: true, stage: target, complete: target >= stageCount };
+}

package/dist/workflow/config.d.ts

@@ -0,0 +1,60 @@
+/** One stage in the pipeline. */
+export interface WorkflowStage {
+    /** Stable key, used in generated code and audit rows. */
+    key: string;
+    /** What an operator reads. */
+    label: string;
+}
+/** One field an operator fills in when signing off a stage. */
+export interface WorkflowField {
+    key: string;
+    label: string;
+    placeholder?: string;
+}
+export interface WorkflowConfig {
+    /**
+     * Base name for the generated tables and routes — `"orders"` gives an
+     * `orders.stage` column, an `orders_signoffs` audit table, and
+     * `/api/orders/advance`.
+     */
+    key: string;
+    /** The stages, in order. A bare string is shorthand for `{ key, label }`. */
+    stages: readonly (string | WorkflowStage)[];
+    /**
+     * Per-stage fields recorded on sign-off, keyed by stage key. A stage with no
+     * entry records only actor + timestamp.
+     *
+     * These are the "specs" in the reference — brew ratio, water activity. They
+     * are stored as a JSON blob on the audit row rather than as columns, because
+     * they are documentation of what happened, not something the pipeline
+     * branches on, and every stage wants a different set.
+     */
+    stationFields?: Record<string, WorkflowField[]>;
+    /**
+     * Emit an override log table. Every out-of-band move — sending an item back a
+     * stage, skipping one — is recorded with the actor's initials. Default true:
+     * a pipeline you can override without a trace is one nobody trusts.
+     */
+    overrides?: boolean;
+}
+/** Normalized stage list. */
+export declare function workflowStages(config: WorkflowConfig): WorkflowStage[];
+/** The audit table's name for a workflow. */
+export declare const workflowAuditTable: (config: WorkflowConfig) => string;
+/** The override log's name, or null when overrides are off. */
+export declare const workflowOverrideTable: (config: WorkflowConfig) => string | null;
+/**
+ * Define a staged workflow.
+ *
+ * ```ts
+ * export const fulfillment = defineWorkflow({
+ *   key: "orders",
+ *   stages: ["received", "picked", "packed", "shipped"],
+ *   stationFields: { packed: [{ key: "weight", label: "Package weight" }] },
+ * });
+ * ```
+ *
+ * Validated here rather than at generation, so a malformed pipeline fails at
+ * config load with a message naming the problem.
+ */
+export declare function defineWorkflow(config: WorkflowConfig): WorkflowConfig;

package/dist/workflow/config.js

@@ -0,0 +1,73 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// `defineWorkflow` — staged, audited pipelines.
+//
+// The shape this generalizes is ghostfire.coffee's production floor, and the
+// framing correction in #256 is the important part: despite the name "order
+// tracker", it is NOT queue- or Durable-Object-driven. It is a synchronous SSR
+// + D1 state machine — an integer `stage` column advanced by sign-off rows,
+// where "liveness" is an email plus a page reload. That maps to a workflow
+// module, distinct from the queues module and from #71's realtime DO. If live
+// push is wanted later it layers on top; it is not required for the pattern.
+//
+// The domain (coffee production) is site-specific; the mechanism is not.
+// Fulfillment, onboarding, approval chains, and support-ticket flows are all
+// the same four things:
+//
+//   1. an ordered list of stages, and one integer saying which is in progress;
+//   2. exactly one audit row per completed stage — who, when, and what they
+//      recorded;
+//   3. an advance that is safe when two operators press the button at once;
+//   4. a per-stage side-effect hook (issue the invoice on packaging).
+import { AstroidConfigError } from "../errors.js";
+/** Normalized stage list. */
+export function workflowStages(config) {
+    return config.stages.map((stage) => typeof stage === "string" ? { key: stage, label: stage } : stage);
+}
+/** The audit table's name for a workflow. */
+export const workflowAuditTable = (config) => `${config.key}_signoffs`;
+/** The override log's name, or null when overrides are off. */
+export const workflowOverrideTable = (config) => config.overrides === false ? null : `${config.key}_override_log`;
+/**
+ * Define a staged workflow.
+ *
+ * ```ts
+ * export const fulfillment = defineWorkflow({
+ *   key: "orders",
+ *   stages: ["received", "picked", "packed", "shipped"],
+ *   stationFields: { packed: [{ key: "weight", label: "Package weight" }] },
+ * });
+ * ```
+ *
+ * Validated here rather than at generation, so a malformed pipeline fails at
+ * config load with a message naming the problem.
+ */
+export function defineWorkflow(config) {
+    if (!config.key || !/^[a-z][a-z0-9_]*$/.test(config.key)) {
+        throw new AstroidConfigError(`Workflow \`key\` must be a lowercase identifier (it names generated tables and routes); got ${JSON.stringify(config.key)}`);
+    }
+    const stages = workflowStages(config);
+    // Two stages is the floor: with one there is nothing to advance to, and the
+    // whole module is an integer that only ever holds 0.
+    if (stages.length < 2) {
+        throw new AstroidConfigError(`Workflow ${JSON.stringify(config.key)} needs at least 2 stages; got ${stages.length}`);
+    }
+    const seen = new Set();
+    for (const stage of stages) {
+        if (!stage.key || !/^[a-z][a-z0-9_]*$/.test(stage.key)) {
+            throw new AstroidConfigError(`Workflow stage keys must be lowercase identifiers; got ${JSON.stringify(stage.key)}`);
+        }
+        // Duplicates would make `stationFields` ambiguous and an audit row's stage
+        // key non-unique — both silent, both awful to debug later.
+        if (seen.has(stage.key)) {
+            throw new AstroidConfigError(`Workflow ${JSON.stringify(config.key)} has a duplicate stage ${JSON.stringify(stage.key)}`);
+        }
+        seen.add(stage.key);
+    }
+    for (const stageKey of Object.keys(config.stationFields ?? {})) {
+        if (!seen.has(stageKey)) {
+            throw new AstroidConfigError(`Workflow ${JSON.stringify(config.key)} declares stationFields for an unknown stage ${JSON.stringify(stageKey)} (stages: ${[...seen].join(", ")})`);
+        }
+    }
+    return config;
+}

package/dist/workflow/generate.d.ts

@@ -0,0 +1,22 @@
+import { type WorkflowConfig } from "./config.js";
+/**
+ * The Drizzle table sources a workflow adds: the audit table, and the override
+ * log when enabled.
+ *
+ * The `stage` column itself is NOT emitted here — it belongs to the project's
+ * own entity table (orders, applications, tickets), which Astroid doesn't own.
+ * The returned `stageColumn` is the line to paste into it, which keeps the
+ * ownership boundary honest rather than generating a table the project already has.
+ */
+export declare function generateWorkflowSchema(config: WorkflowConfig): {
+    source: string;
+    stageColumn: string;
+};
+/**
+ * `src/pages/api/<key>/advance.ts` — the guarded advance route.
+ *
+ * Thin by design: `advanceWorkflowStage` owns the concurrency guard and the
+ * status contract, so what's left here is authentication and the per-stage side
+ * effects, which are the project's own business.
+ */
+export declare function generateWorkflowRoute(config: WorkflowConfig): string;

package/dist/workflow/generate.js

@@ -0,0 +1,138 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+//
+// Workflow → Drizzle schema + the advance route.
+//
+// The schema half is a pure function of the config (regenerate freely); the
+// route is SCAFFOLD-ONCE, because per-stage side effects — issue the invoice
+// when packaging is signed, email the customer on every move — are the whole
+// reason a project reaches for this module, and regenerating would erase them.
+import { workflowAuditTable, workflowOverrideTable, workflowStages, } from "./config.js";
+/**
+ * The Drizzle table sources a workflow adds: the audit table, and the override
+ * log when enabled.
+ *
+ * The `stage` column itself is NOT emitted here — it belongs to the project's
+ * own entity table (orders, applications, tickets), which Astroid doesn't own.
+ * The returned `stageColumn` is the line to paste into it, which keeps the
+ * ownership boundary honest rather than generating a table the project already has.
+ */
+export function generateWorkflowSchema(config) {
+    const stages = workflowStages(config);
+    const audit = workflowAuditTable(config);
+    const override = workflowOverrideTable(config);
+    // `orders` → `order_id`. Naive de-pluralisation on purpose: it covers the
+    // real cases and a project that needs otherwise passes `auditIdColumn`.
+    const fk = `${config.key.replace(/s$/, "")}_id`;
+    const camel = (s) => s.replace(/_(\w)/g, (_, c) => c.toUpperCase());
+    const lines = [
+        "// Workflow tables — generated by Astroid from defineWorkflow().",
+        "//",
+        `// Stage model: \`${config.key}.stage\` is the stage currently IN PROGRESS`,
+        `// (0–${stages.length - 1}); ${stages.length} means complete. A stage is done once its`,
+        `// \`${audit}\` row exists.`,
+        "//",
+        `// Add this column to your \`${config.key}\` table:`,
+        `//   stage: integer("stage").notNull().default(0),`,
+        'import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";',
+        "",
+        `/** One row per COMPLETED stage — who signed it off, when, and what they recorded. */`,
+        `export const ${camel(audit)} = sqliteTable(`,
+        `  ${JSON.stringify(audit)},`,
+        "  {",
+        '    id: integer("id").primaryKey({ autoIncrement: true }),',
+        `    ${camel(fk)}: text(${JSON.stringify(fk)}).notNull(),`,
+        '    /** The stage this row completes (0-based). */',
+        '    stage: integer("stage").notNull(),',
+        "    /** Recorded values for the stage, [{ k, v }] JSON. */",
+        '    specs: text("specs", { mode: "json" }).$type<{ k: string; v: string }[]>(),',
+        '    initials: text("initials").notNull(),',
+        '    /** Account id when the pipeline runs behind a portal. */',
+        '    actorId: text("actor_id"),',
+        '    signedAt: integer("signed_at", { mode: "timestamp" })',
+        "      .notNull()",
+        "      .$defaultFn(() => new Date()),",
+        "  },",
+        "  (t) => [",
+        `    index(${JSON.stringify(`${audit}_entity_idx`)}).on(t.${camel(fk)}),`,
+        "    // One sign-off per stage per item. The guarded advance already prevents",
+        "    // a double move, and this makes a duplicate audit row impossible even if",
+        "    // a future caller writes one directly.",
+        `    uniqueIndex(${JSON.stringify(`${audit}_entity_stage_key`)}).on(t.${camel(fk)}, t.stage),`,
+        "  ],",
+        ");",
+    ];
+    if (override) {
+        lines.push("", "/** Out-of-band moves — sending an item back a stage, or skipping one.", " *  A pipeline you can override without a trace is one nobody trusts. */", `export const ${camel(override)} = sqliteTable(`, `  ${JSON.stringify(override)},`, "  {", '    id: integer("id").primaryKey({ autoIncrement: true }),', `    ${camel(fk)}: text(${JSON.stringify(fk)}).notNull(),`, '    /** "back" | "skip". */', '    action: text("action").notNull(),', '    initials: text("initials").notNull(),', '    station: text("station"),', '    at: integer("at", { mode: "timestamp" })', "      .notNull()", "      .$defaultFn(() => new Date()),", "  },", `  (t) => [index(${JSON.stringify(`${override}_entity_idx`)}).on(t.${camel(fk)})],`, ");");
+    }
+    lines.push("", "/** Stage labels, index === stage number. */", `export const ${config.key.toUpperCase()}_STAGES = ${JSON.stringify(stages.map((s) => s.label))} as const;`, "");
+    return { source: lines.join("\n"), stageColumn: 'stage: integer("stage").notNull().default(0),' };
+}
+/**
+ * `src/pages/api/<key>/advance.ts` — the guarded advance route.
+ *
+ * Thin by design: `advanceWorkflowStage` owns the concurrency guard and the
+ * status contract, so what's left here is authentication and the per-stage side
+ * effects, which are the project's own business.
+ */
+export function generateWorkflowRoute(config) {
+    const stages = workflowStages(config);
+    const audit = workflowAuditTable(config);
+    const fk = `${config.key.replace(/s$/, "")}_id`;
+    return [
+        `// Advance one ${config.key} item by a stage.`,
+        "//",
+        "// Scaffolded once; yours to edit. `advanceWorkflowStage` owns the part that",
+        "// is easy to get wrong — the optimistic-concurrency guard, so two operators",
+        "// pressing sign-off at the same moment can't run an item forward twice — and",
+        "// returns a status rather than throwing, because a conflict is an ordinary",
+        "// outcome of two people working at once.",
+        "//",
+        "// What belongs to you is below the call: the per-stage side effects. The",
+        "// reference this generalizes issues the balance invoice when packaging is",
+        "// signed and emails the customer on every other move.",
+        'import type { APIRoute } from "astro";',
+        'import { advanceWorkflowStage } from "astroidjs";',
+        'import { env } from "cloudflare:workers";',
+        "",
+        "export const prerender = false;",
+        "",
+        `const STAGE_COUNT = ${stages.length};`,
+        "",
+        "export const POST: APIRoute = async ({ request, locals }) => {",
+        "  // TODO: gate this. A pipeline advance is a privileged action — check the",
+        "  // portal session/role here before anything else.",
+        "  void locals;",
+        "",
+        "  const body = (await request.json().catch(() => null)) as {",
+        "    id?: string;",
+        "    stage?: number;",
+        "    initials?: string;",
+        "    specs?: { k: string; v: string }[];",
+        "  } | null;",
+        "",
+        "  if (!body?.id || typeof body.stage !== \"number\") {",
+        '    return Response.json({ ok: false, error: "Bad request" }, { status: 400 });',
+        "  }",
+        "",
+        "  const result = await advanceWorkflowStage({",
+        "    db: env.DB,",
+        `    table: ${JSON.stringify(config.key)},`,
+        `    auditTable: ${JSON.stringify(audit)},`,
+        `    auditIdColumn: ${JSON.stringify(fk)},`,
+        "    id: body.id,",
+        "    expectedStage: body.stage,",
+        "    stageCount: STAGE_COUNT,",
+        '    actor: { initials: body.initials ?? "" },',
+        "    specs: body.specs,",
+        "  });",
+        "",
+        "  if (!result.ok) return Response.json(result, { status: result.status });",
+        "",
+        "  // TODO: per-stage side effects go here — `result.stage` is the stage now in",
+        "  // progress, and `result.complete` is true once the last one is signed.",
+        "",
+        "  return Response.json(result);",
+        "};",
+        "",
+    ].join("\n");
+}

package/dist/workflow/index.d.ts

@@ -0,0 +1,3 @@
+export { type AdvanceOptions, type AdvanceResult, advanceWorkflowStage, normalizeInitials, normalizeSpecs, type OverrideAction, type OverrideOptions, overrideWorkflowStage, type WorkflowActor, type WorkflowDatabase, } from "./advance.js";
+export { defineWorkflow, type WorkflowConfig, type WorkflowField, type WorkflowStage, workflowAuditTable, workflowOverrideTable, workflowStages, } from "./config.js";
+export { generateWorkflowRoute, generateWorkflowSchema } from "./generate.js";

package/dist/workflow/index.js

@@ -0,0 +1,4 @@
+// Copyright (c) 2026 BowenLabs. Astroid is MIT licensed.
+export { advanceWorkflowStage, normalizeInitials, normalizeSpecs, overrideWorkflowStage, } from "./advance.js";
+export { defineWorkflow, workflowAuditTable, workflowOverrideTable, workflowStages, } from "./config.js";
+export { generateWorkflowRoute, generateWorkflowSchema } from "./generate.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astroidjs",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Astroid — an opinionated meta-framework over Louise Toolkit and Astro for building editable, multi-editor sites on Cloudflare Workers.",
   "keywords": [
     "astro",
@@ -27,6 +27,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./astro": {
+      "types": "./dist/astro/index.d.ts",
+      "import": "./dist/astro/index.js",
+      "default": "./dist/astro/index.js"
+    },
     "./components/*.astro": "./src/components/*.astro",
     "./components/Collection": {
       "types": "./src/components/Collection.tsx",
@@ -35,7 +40,16 @@
     "./components/sections": {
       "types": "./src/components/sections.ts",
       "default": "./src/components/sections.ts"
-    }
+    },
+    "./components/justify": {
+      "types": "./src/components/justify.ts",
+      "default": "./src/components/justify.ts"
+    },
+    "./components/media-meta": {
+      "types": "./src/components/media-meta.ts",
+      "default": "./src/components/media-meta.ts"
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",
@@ -46,8 +60,7 @@
     "access": "public"
   },
   "dependencies": {
-    "drizzle-orm": "^0.45.0",
-    "louise-toolkit": "0.14.0"
+    "louise-toolkit": "0.16.0"
   },
   "peerDependencies": {
     "solid-js": "^1.9.0"
@@ -58,15 +71,18 @@
     }
   },
   "devDependencies": {
+    "@types/node": "^24.13.3",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "solid-js": "^1.9.14",
-    "typescript": "^5.8.0"
+    "typescript": "^5.8.0",
+    "vitest": "^4.1.10"
   },
   "engines": {
     "node": ">=24.0.0"
   },
   "scripts": {
     "build": "tsgo -p tsconfig.build.json",
+    "test": "vp test",
     "typecheck": "tsgo --noEmit"
   }
 }