wizards 0.1.9

package/node_modules/@engenty-wizards/shared/dist/projects.d.ts

@@ -0,0 +1,74 @@
+export declare const FACT_TYPES: readonly ["text", "longtext", "number", "date", "url", "email", "phone", "boolean"];
+export type FactType = (typeof FACT_TYPES)[number];
+export interface ProjectFact {
+    /** How templates name it: `{{facts.<key>}}`. Made from the label, stable afterwards. */
+    key: string;
+    label: string;
+    value: string;
+    /** Only when chosen by hand; otherwise the type is read off the value. */
+    type?: FactType;
+}
+/** The type a value looks like. A value that looks like nothing in particular is text. */
+export declare function detectFactType(value: string): FactType;
+export declare function factType(fact: Pick<ProjectFact, "value" | "type">): FactType;
+/** A fact's key from its label: lower case, a-z 0-9 and _, unique among `taken`. */
+export declare function factKey(label: string, taken?: string[]): string;
+/** Facts most projects have; offered as empty rows to fill in. */
+export declare const BASIC_FACTS: {
+    key: string;
+    de: string;
+    en: string;
+}[];
+export interface BrandColor {
+    /** What the colour is for and how to use it, in the admin's words: "Primär – Buttons und Überschriften". */
+    name: string;
+    /** #rrggbb */
+    value: string;
+}
+export declare const PROJECT_FILE_KINDS: readonly ["logo", "asset", "document"];
+export type ProjectFileKind = (typeof PROJECT_FILE_KINDS)[number];
+/** `pending`: being read, described and indexed. */
+export type ProjectFileStatus = "pending" | "ready" | "failed";
+export interface ProjectFileView {
+    id: string;
+    kind: ProjectFileKind;
+    name: string;
+    mime: string;
+    size: number;
+    description: string;
+    /** A web address the file was fetched from, when it was not uploaded. */
+    source: string | null;
+    status: ProjectFileStatus;
+    error: string | null;
+    /** Documents: what the index holds of it. `embeddings` includes the keywords. */
+    indexed: "embeddings" | "keywords" | null;
+    pages: number | null;
+    chars: number | null;
+    createdAt: string;
+}
+export declare const PROJECT_LIMITS: {
+    readonly facts: 100;
+    readonly colors: 12;
+    readonly files: {
+        readonly logo: 8;
+        readonly asset: 100;
+        readonly document: 50;
+    };
+    readonly bytes: {
+        readonly logo: 5000000;
+        readonly asset: 15000000;
+        readonly video: 80000000;
+        readonly document: 30000000;
+    };
+};
+/** The largest file of a kind and type a project takes. */
+export declare function projectFileLimit(kind: ProjectFileKind, mime: string): number;
+/** One passage the document index found for a question. */
+export interface ProjectSearchHit {
+    fileId: string;
+    name: string;
+    /** The passage's place in its document, from 0. */
+    index: number;
+    text: string;
+    score: number;
+}

package/node_modules/@engenty-wizards/shared/dist/projects.js

@@ -0,0 +1,96 @@
+// --- facts ---------------------------------------------------------------------
+// What a project knows about itself as label and value: an address, a VAT id, anything. Every
+// step of the project's wizards can read them.
+export const FACT_TYPES = [
+    "text",
+    "longtext",
+    "number",
+    "date",
+    "url",
+    "email",
+    "phone",
+    "boolean",
+];
+const DATE_RE = /^(\d{4}-\d{2}-\d{2}|\d{1,2}\.\s?\d{1,2}\.\s?\d{4})$/;
+const NUMBER_RE = /^[+-]?\d{1,3}([.,\s']?\d{3})*([.,]\d+)?$/;
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/;
+const URL_RE = /^(https?:\/\/|www\.)\S+$/i;
+const PHONE_RE = /^\+?[\d\s()/.-]{7,20}$/;
+const BOOLEAN_RE = /^(ja|nein|yes|no|true|false)$/i;
+/** The type a value looks like. A value that looks like nothing in particular is text. */
+export function detectFactType(value) {
+    const v = value.trim();
+    if (!v) {
+        return "text";
+    }
+    if (v.includes("\n") || v.length > 140) {
+        return "longtext";
+    }
+    if (BOOLEAN_RE.test(v)) {
+        return "boolean";
+    }
+    if (EMAIL_RE.test(v)) {
+        return "email";
+    }
+    if (URL_RE.test(v)) {
+        return "url";
+    }
+    if (DATE_RE.test(v)) {
+        return "date";
+    }
+    // A postcode or a count is a number; a phone number starts with + or 0 and is longer.
+    if (NUMBER_RE.test(v) && !/^(\+|0\d)/.test(v)) {
+        return "number";
+    }
+    if (PHONE_RE.test(v) && v.replace(/\D/g, "").length >= 7) {
+        return "phone";
+    }
+    return "text";
+}
+export function factType(fact) {
+    return fact.type ?? detectFactType(fact.value);
+}
+/** A fact's key from its label: lower case, a-z 0-9 and _, unique among `taken`. */
+export function factKey(label, taken = []) {
+    const base = label
+        .toLowerCase()
+        .replace(/ä/g, "ae")
+        .replace(/ö/g, "oe")
+        .replace(/ü/g, "ue")
+        .replace(/ß/g, "ss")
+        .normalize("NFD")
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .slice(0, 40) || "fakt";
+    let key = base;
+    for (let i = 2; taken.includes(key); i++) {
+        key = `${base}_${i}`;
+    }
+    return key;
+}
+/** Facts most projects have; offered as empty rows to fill in. */
+export const BASIC_FACTS = [
+    { key: "adresse", de: "Adresse", en: "Address" },
+    { key: "plz", de: "PLZ", en: "Postcode" },
+    { key: "ort", de: "Ort", en: "City" },
+    { key: "uid", de: "UID", en: "VAT id" },
+    { key: "telefon", de: "Telefon", en: "Phone" },
+    { key: "e_mail", de: "E-Mail", en: "Email" },
+    { key: "website", de: "Website", en: "Website" },
+    { key: "iban", de: "IBAN", en: "IBAN" },
+];
+// --- files -----------------------------------------------------------------------
+export const PROJECT_FILE_KINDS = ["logo", "asset", "document"];
+export const PROJECT_LIMITS = {
+    facts: 100,
+    colors: 12,
+    files: { logo: 8, asset: 100, document: 50 },
+    bytes: { logo: 5_000_000, asset: 15_000_000, video: 80_000_000, document: 30_000_000 },
+};
+/** The largest file of a kind and type a project takes. */
+export function projectFileLimit(kind, mime) {
+    if (kind === "asset" && mime.startsWith("video/")) {
+        return PROJECT_LIMITS.bytes.video;
+    }
+    return PROJECT_LIMITS.bytes[kind];
+}

package/node_modules/@engenty-wizards/shared/dist/run.d.ts

@@ -0,0 +1,219 @@
+import type { Format, ModelClass, Step, WizardDefinition } from "./definition.js";
+import type { ConnectionView, ListDef, ListRow } from "./store.js";
+export type RunStatus = "waiting_input" | "running" | "done" | "failed" | "cancelled";
+export interface AssetRef {
+    id: string;
+    /** image | video | html | text | json */
+    kind: string;
+    mime: string;
+    name: string;
+    /**
+     * Media a model made ("generated") or changed ("edited"). Shown with a label wherever it is
+     * displayed; the file itself carries the marking in its metadata (EU AI Act, Art. 50).
+     */
+    ai?: "generated" | "edited";
+}
+export interface StepOutput {
+    text?: string;
+    json?: unknown;
+    assets?: AssetRef[];
+    /** Widgets: what loading it with this run's data showed. */
+    widget?: {
+        /** Seconds of animation the widget registered for video export; null = a still widget. */
+        duration: number | null;
+        errors: string[];
+    };
+    at: string;
+}
+export interface RunState {
+    values: Record<string, unknown>;
+    outputs: Record<string, StepOutput>;
+    /** Interactive steps answered, oldest first — "back" pops this. */
+    history: string[];
+    /** Regenerate notes per step. */
+    notes: Record<string, string>;
+    /** Steps that make several results: the entries (from 0) to make again; the others stay. */
+    redo?: Record<string, number[]>;
+}
+interface AskBase {
+    id: string;
+    stepId: string;
+    /** Why the wizard asks, in the person's language. */
+    reason: string;
+    at: string;
+}
+/**
+ * A running step asks the person to sign in on a page the wizard's browser has open. What the
+ * person types goes into that page; the model never sees it.
+ */
+export interface LoginAsk extends AskBase {
+    kind: "login";
+    site: {
+        host: string;
+        title: string;
+    };
+    /** Inputs found on the page, to fill here instead of clicking into the picture. */
+    fields: {
+        id: string;
+        label: string;
+        secret: boolean;
+    }[];
+}
+/** A running step wants to change something in one of the person's accounts and asks first. */
+export interface ConfirmAsk extends AskBase {
+    kind: "confirm";
+    /** The connected service, e.g. "Notion". */
+    service: string;
+    action: {
+        id: string;
+        summary: string;
+        destructive: boolean;
+    };
+    /** What would be sent, as readable JSON. */
+    input: string;
+}
+/** What a running step asks the person; the step waits for the answer. */
+export type RunAsk = LoginAsk | ConfirmAsk;
+/** A question as a step puts it; the runner adds id, step and time. */
+export type AskInput = Omit<LoginAsk, "id" | "stepId" | "at"> | Omit<ConfirmAsk, "id" | "stepId" | "at">;
+/**
+ * `fill` and `done` answer a sign-in (remember = keep the sign-in); `done` also allows a change
+ * (remember = allow that action for the rest of the run); `skip` declines either.
+ */
+export type AskAnswer = {
+    type: "fill";
+    values: Record<string, string>;
+    remember?: boolean;
+} | {
+    type: "done";
+    remember?: boolean;
+} | {
+    type: "skip";
+};
+/** One thing the person does in the wizard's browser while it waits for them. */
+export type BrowserAct = {
+    type: "click";
+    x: number;
+    y: number;
+} | {
+    type: "type";
+    text: string;
+} | {
+    type: "key";
+    key: "Enter" | "Tab" | "Backspace" | "Escape";
+} | {
+    type: "scroll";
+    dy: number;
+};
+/** A stored list the current step shows. */
+export interface ShownList {
+    def: ListDef;
+    rows: ListRow[];
+    formats: Format[];
+    label: string | null;
+}
+export interface RunEvent {
+    id: number;
+    at: string;
+    stepId: string | null;
+    type: "step_started" | "step_done" | "tool" | "info" | "error";
+    message: string;
+    /** A picture of the run this is about (a photo being looked at, an image just made). */
+    asset?: string | null;
+}
+export interface RunView {
+    id: string;
+    status: RunStatus;
+    mode: "test" | "live";
+    wizard: Pick<WizardDefinition, "title" | "description" | "avatar" | "intro">;
+    /** The step the person is on (interactive) or the one running. */
+    step: Step | null;
+    values: Record<string, unknown>;
+    /** What fields of the current page start with, from earlier steps (`prefill`). */
+    prefill: Record<string, unknown>;
+    outputs: Record<string, StepOutput>;
+    /** Steps whose outputs the current step shows, with their definitions. */
+    shown: {
+        step: Step;
+        output: StepOutput | null;
+        formats: Format[];
+        label: string | null;
+    }[];
+    progress: {
+        done: number;
+        total: number;
+    };
+    canBack: boolean;
+    error: string | null;
+    events: RunEvent[];
+    brand: BrandView;
+    /** What the running step asks the person right now. */
+    ask: RunAsk | null;
+    /** Stored lists the current step shows (a page's list fields, a review, the result). */
+    lists: ShownList[];
+    /** The wizard's connections with what the person has connected. */
+    connections: ConnectionView[];
+    /** The wizard keeps things for the person between runs (lists, files, accounts). */
+    keeps: boolean;
+    /** Set once the result is shared. */
+    shareUrl: string | null;
+    /** When the run and its shared link are deleted; null = kept. */
+    expiresAt: string | null;
+}
+/** A shared result: what `/s/<token>` shows. Never the person's answers. */
+export interface ShareView {
+    token: string;
+    title: string;
+    message: string | null;
+    wizard: Pick<WizardDefinition, "title" | "description" | "avatar">;
+    brand: BrandView;
+    shown: RunView["shown"];
+    createdAt: string;
+    expiresAt: string | null;
+    /** The wizard's public link, to make your own — when it is published and open. */
+    wizardUrl: string | null;
+}
+export interface BrandView {
+    name: string;
+    accent: string | null;
+    logoUrl: string | null;
+}
+export interface PublicWizard {
+    token: string;
+    title: string;
+    description: string;
+    avatar: string;
+    intro: string | null;
+    brand: BrandView;
+    turnstileSiteKey: string | null;
+    available: boolean;
+    unavailableReason: string | null;
+}
+/** What a step is expected to cost, in credits. `high` is the 90th percentile once measured. */
+export interface StepEstimate {
+    credits: number;
+    high: number;
+    /** From at least five runs of this version; otherwise from a formula. */
+    measured: boolean;
+}
+/** What a run is expected to cost. `available` is false where no credits are involved. */
+/** A model class a wizard needs that this runtime cannot serve, with the steps that call it. */
+export interface MissingModel {
+    cls: ModelClass;
+    /** Why the class cannot run, as the person reads it. */
+    problem: string;
+    steps: {
+        id: string;
+        title: string;
+    }[];
+    /** A step that needs it lies on every path: the run cannot start. */
+    blocking: boolean;
+}
+export interface RunEstimate {
+    available: boolean;
+    credits: number;
+    /** Credits held when a run starts. */
+    reserve: number;
+    steps: Record<string, StepEstimate>;
+}
+export {};

package/node_modules/@engenty-wizards/shared/dist/run.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@engenty-wizards/shared/dist/store.d.ts

@@ -0,0 +1,100 @@
+import { type TableColumn } from "./engenty/data-tables/index.js";
+/**
+ * What a wizard keeps between runs for one person: lists (tabular data), files and connected
+ * accounts. The wizard definition says which lists and connections exist; the content belongs
+ * to the person who ran it.
+ */
+/** A list is an engenty data table: typed columns, rows of cells keyed by column id. */
+export interface ListDef {
+    id: string;
+    title: string;
+    description?: string;
+    columns: TableColumn[];
+    /** Column whose value identifies a row: saving a row with a known key updates it. */
+    key?: string;
+    /**
+     * The rows are gone through one by one in a review: `file` holds the path of a kept file
+     * shown beside the row, `status` is a select whose options are the answers (first = open).
+     */
+    check?: {
+        file?: string;
+        status?: string;
+    };
+}
+export interface ListRow {
+    id: string;
+    cells: Record<string, unknown>;
+    updatedAt: string;
+}
+export interface StoreFile {
+    path: string;
+    mime: string;
+    size: number;
+    /** Where the file came from, in words: "E-Mail von billing@notion.so, 3.9.2026". */
+    source: string | null;
+    updatedAt: string;
+}
+export declare const STORE_LIMITS: {
+    fileBytes: number;
+    totalBytes: number;
+    files: number;
+    rowsPerList: number;
+};
+/** Kinds of accounts a wizard can ask the person to connect. */
+export declare const CONNECTION_KINDS: readonly ["mail"];
+export type ConnectionKind = (typeof CONNECTION_KINDS)[number];
+/** An account the person connects: a built-in kind, or one of the project's imported connectors. */
+export interface ConnectionDef {
+    id: string;
+    kind?: ConnectionKind;
+    /** Id of an imported connector of the project. */
+    connector?: string;
+    /** Imported connectors: the actions steps may call. Default: every action that only reads. */
+    actions?: string[];
+    /**
+     * Imported connectors: per action, run it without asking ("allow") or ask the person first
+     * ("ask"). Default: reading is allowed, changing asks; deleting always asks.
+     */
+    policy?: Record<string, "allow" | "ask">;
+    title?: string;
+    description?: string;
+}
+/** A connector the person can pick for a connection: an OAuth sign-in or a credentials form. */
+export interface ConnectorOption {
+    id: string;
+    name: string;
+    auth: "oauth2" | "api_key";
+    /** `api_key` connectors: the form, in order. */
+    fields?: {
+        key: string;
+        label: string;
+        secret?: boolean;
+        placeholder?: string;
+        required?: boolean;
+    }[];
+    /** Shown under the form: where to get the values. */
+    hint?: string;
+}
+export interface ConnectionView {
+    id: string;
+    kind: ConnectionKind | null;
+    /** The imported connector behind the connection, if it is one. */
+    connector: string | null;
+    title: string | null;
+    description: string | null;
+    /** Set when the person has connected an account. */
+    account: {
+        connector: string;
+        label: string;
+        connectedAt: string;
+    } | null;
+    connectors: ConnectorOption[];
+}
+/** One list as a Markdown table of raw cell values — what a model reads. */
+export declare function listAsMarkdown(def: ListDef, rows: ListRow[], limit?: number): string;
+/** The key a row is matched on: trimmed and lower-cased, so "Notion " and "notion" are one row. */
+export declare function rowKey(def: ListDef, cells: Record<string, unknown>): string | null;
+/** A new row's cells, typed by the list's columns. Throws `TableColumnValueError` on a bad value. */
+export declare function newCells(def: ListDef, input: Record<string, unknown>): Record<string, unknown>;
+/** An existing row's cells with some columns changed; cells of columns the list no longer has are dropped. */
+export declare function patchCells(def: ListDef, current: Record<string, unknown>, patch: Record<string, unknown>): Record<string, unknown>;

package/node_modules/@engenty-wizards/shared/dist/store.js

@@ -0,0 +1,44 @@
+import { coerceRowValues, mergeRowValues } from "./engenty/data-tables/index.js";
+export const STORE_LIMITS = {
+    fileBytes: 15_000_000,
+    totalBytes: 200_000_000,
+    files: 2000,
+    rowsPerList: 5000,
+};
+/** Kinds of accounts a wizard can ask the person to connect. */
+export const CONNECTION_KINDS = ["mail"];
+/** One list as a Markdown table of raw cell values — what a model reads. */
+export function listAsMarkdown(def, rows, limit = 200) {
+    if (!rows.length) {
+        return "(empty)";
+    }
+    const cols = def.columns;
+    const cell = (v) => v === null || v === undefined
+        ? ""
+        : (Array.isArray(v) ? v.join(", ") : String(v)).replace(/\|/g, "\\|").replace(/\s+/g, " ");
+    const head = `| ${cols.map((c) => c.id).join(" | ")} |\n|${cols.map(() => " --- ").join("|")}|`;
+    const body = rows
+        .slice(0, limit)
+        .map((r) => `| ${cols.map((c) => cell(r.cells[c.id])).join(" | ")} |`);
+    const more = rows.length > limit ? [`… ${rows.length - limit} more rows`] : [];
+    return [head, ...body, ...more].join("\n");
+}
+/** The key a row is matched on: trimmed and lower-cased, so "Notion " and "notion" are one row. */
+export function rowKey(def, cells) {
+    if (!def.key) {
+        return null;
+    }
+    const raw = cells[def.key];
+    const key = raw === null || raw === undefined ? "" : String(raw).trim().toLowerCase();
+    return key || null;
+}
+/** A new row's cells, typed by the list's columns. Throws `TableColumnValueError` on a bad value. */
+export function newCells(def, input) {
+    return coerceRowValues(def.columns, input);
+}
+/** An existing row's cells with some columns changed; cells of columns the list no longer has are dropped. */
+export function patchCells(def, current, patch) {
+    const known = new Set(def.columns.map((c) => c.id));
+    const kept = Object.fromEntries(Object.entries(current).filter(([id]) => known.has(id)));
+    return mergeRowValues(def.columns, kept, patch);
+}

package/node_modules/@engenty-wizards/shared/dist/workspace.d.ts

@@ -0,0 +1,16 @@
+/** A file in a wizard's workspace. The content lives in the blob store under its hash. */
+export interface WorkspaceFile {
+    path: string;
+    hash: string;
+    mime: string;
+    size: number;
+}
+export declare const WORKSPACE_LIMITS: {
+    fileBytes: number;
+    totalBytes: number;
+    files: number;
+};
+/** Relative, forward slashes, no `..`, no hidden files. Returns the normalised path or null. */
+export declare function cleanPath(raw: string): string | null;
+export declare function mimeForPath(path: string): string;
+export declare function isTextMime(mime: string): boolean;

package/node_modules/@engenty-wizards/shared/dist/workspace.js

@@ -0,0 +1,51 @@
+export const WORKSPACE_LIMITS = {
+    fileBytes: 5_000_000,
+    totalBytes: 25_000_000,
+    files: 200,
+};
+const PATH_RE = /^[A-Za-z0-9_-][A-Za-z0-9_.-]*(\/[A-Za-z0-9_-][A-Za-z0-9_.-]*)*$/;
+/** Relative, forward slashes, no `..`, no hidden files. Returns the normalised path or null. */
+export function cleanPath(raw) {
+    const path = raw.trim().replace(/^\.?\/+/, "");
+    if (path.length > 200 || !PATH_RE.test(path) || path.split("/").some((p) => p === "..")) {
+        return null;
+    }
+    return path;
+}
+const MIME_BY_EXT = {
+    html: "text/html",
+    htm: "text/html",
+    js: "text/javascript",
+    mjs: "text/javascript",
+    css: "text/css",
+    json: "application/json",
+    geojson: "application/geo+json",
+    csv: "text/csv",
+    txt: "text/plain",
+    md: "text/markdown",
+    svg: "image/svg+xml",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+    gif: "image/gif",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    ttf: "font/ttf",
+    otf: "font/otf",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    pdf: "application/pdf",
+};
+export function mimeForPath(path) {
+    const ext = path.split(".").pop()?.toLowerCase() ?? "";
+    return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+export function isTextMime(mime) {
+    return (mime.startsWith("text/") ||
+        mime === "application/json" ||
+        mime === "application/geo+json" ||
+        mime === "image/svg+xml");
+}

package/node_modules/@engenty-wizards/shared/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@engenty-wizards/shared",
+  "version": "0.1.0",
+  "license": "FSL-1.1-MIT",
+  "type": "module",
+  "exports": {
+    "./engenty/data-tables": "./dist/engenty/data-tables/index.js",
+    "./*": "./dist/*.js"
+  }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "wizards",
+  "version": "0.1.9",
+  "description": "Make a wish. Get your wizard. It guides you step by step. Let AI do the work. Runs on your machine, on the AI subscription you already have.",
+  "license": "FSL-1.1-MIT",
+  "homepage": "https://engenty.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/engenty/engenty-wizards.git"
+  },
+  "type": "module",
+  "bin": {
+    "wizards": "bin/wizards.mjs"
+  },
+  "engines": {
+    "node": ">=24.11"
+  },
+  "files": [
+    "apps",
+    "bin",
+    "plugin"
+  ],
+  "dependencies": {
+    "@ai-sdk/anthropic": "4.0.54",
+    "@ai-sdk/gateway": "4.0.82",
+    "@ai-sdk/openai": "4.0.67",
+    "@clack/prompts": "1.8.1",
+    "@engenty-wizards/shared": "0.1.0",
+    "@executor-js/plugin-openapi": "1.6.8",
+    "@hono/node-server": "2.1.3",
+    "@libsql/client": "0.18.0",
+    "@mastra/core": "1.74.0",
+    "@mastra/docker": "0.8.0",
+    "@mastra/mcp": "2.1.2",
+    "@modelcontextprotocol/client": "2.2.0",
+    "@modelcontextprotocol/server": "2.2.0",
+    "@turbodocx/html-to-docx": "1.23.1",
+    "ai": "7.0.102",
+    "aws4fetch": "1.0.20",
+    "drizzle-orm": "0.45.3",
+    "effect": "4.0.0-beta.59",
+    "exceljs": "4.4.0",
+    "fast-xml-parser": "5.11.2",
+    "fflate": "0.8.3",
+    "hono": "4.13.12",
+    "imapflow": "2.2.1",
+    "jose": "6.2.12",
+    "mammoth": "1.13.0",
+    "marked": "18.0.14",
+    "nanoid": "5.1.16",
+    "node-pty": "1.1.0",
+    "pdf-parse": "2.4.5",
+    "playwright-core": "1.63.0",
+    "postal-mime": "4.0.2",
+    "rfc6902": "5.3.0",
+    "turndown": "7.2.4",
+    "zod": "4.6.5"
+  },
+  "bundleDependencies": [
+    "@engenty-wizards/shared"
+  ]
+}