From 911139eb7eb3447918f95b906c58c9f668994667 Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 17:37:03 +0200 Subject: [PATCH 01/21] docs(workflow-world): add design spec and implementation plan Spec: dual-engine workflows (legacy in-memory + Vercel SDK 'world' backed by self-hosted Postgres/MongoDB) behind a thin WorkflowKit facade. Plan: TDD, optional @ai_kit/workflow-world package, blocking spike on directive-in-arrow detection, mocked unit tests + opt-in docker-compose integration tests. Co-Authored-By: Claude Opus 4.8 (1M context) --- .../plans/2026-06-02-workflow-world-engine.md | 1481 +++++++++++++++++ ...2026-06-02-workflow-world-engine-design.md | 565 +++++++ 2 files changed, 2046 insertions(+) create mode 100644 docs/superpowers/plans/2026-06-02-workflow-world-engine.md create mode 100644 docs/superpowers/specs/2026-06-02-workflow-world-engine-design.md diff --git a/docs/superpowers/plans/2026-06-02-workflow-world-engine.md b/docs/superpowers/plans/2026-06-02-workflow-world-engine.md new file mode 100644 index 0000000..261e3c4 --- /dev/null +++ b/docs/superpowers/plans/2026-06-02-workflow-world-engine.md @@ -0,0 +1,1481 @@ +# Plan d'implémentation — Moteur de workflow "world" (SDK Vercel) pour ai-kit + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Ajouter un second moteur d'exécution de workflows ("world", basé sur le Vercel Workflow SDK, persisté en Postgres/MongoDB) à côté du moteur legacy en mémoire, exposé via une façade ai-kit unifiée `WorkflowKit` (défaut : legacy). + +**Architecture:** Un nouveau package optionnel `@ai_kit/workflow-world` isole les dépendances lourdes du SDK Vercel (`workflow`, `@workflow/world-postgres`, `@workflow-worlds/mongodb`). `@ai_kit/core` reçoit une façade `WorkflowKit` qui détient la config (moteur + world), expose `start/stop/run`, et charge le package world en `import()` **dynamique** uniquement si `engine: 'world'`. Aucune dépendance Vercel n'est tirée par un utilisateur legacy. La couture est un contrat `WorldEngineAdapter` défini dans core et implémenté par le package world. + +**Tech Stack:** TypeScript (NodeNext, ESM), pnpm workspaces, vitest, `tsc -p tsconfig.build.json`. SDK Vercel `workflow` + worlds. Spec de référence : `docs/superpowers/specs/2026-06-02-workflow-world-engine-design.md`. + +--- + +## Notes transverses (à lire avant de commencer) + +- **Branche** : travailler sur une branche dédiée `feat/workflow-world-engine` (on est sur `dev`). Ne pas commit sur `dev` directement. +- **Commits** : terminer chaque message de commit par la ligne : + `Co-Authored-By: Claude Opus 4.8 (1M context) ` +- **Commandes par package** : + - build : `pnpm --filter build` + - test : `pnpm --filter test` +- **Incertitudes SDK** : certaines signatures exactes du SDK Vercel ne sont confirmées que par lecture de la doc embarquée (`node_modules/workflow/docs/` via la commande `/workflow`). Les tâches concernées contiennent une **étape de vérification** explicite. Le code fourni reflète le meilleur état connu (confirmé en partie par d'anciens tests, cf. spec §4). +- **Gate bloquant** : la **Phase 1 (spike)** conditionne l'API d'écriture de la Phase 5. Ne pas figer les helpers d'écriture avant le verdict du spike. + +--- + +## File Structure + +**Nouveau package `@ai_kit/workflow-world`** (`packages/workflow-world/`) +- `package.json` — métadonnées, deps SDK Vercel, peer deps build, peer type-only sur core. +- `tsconfig.json`, `tsconfig.build.json` — calqués sur `packages/rag/`. +- `src/worlds.ts` — table `type → { target, applyEnv, load }` ; résolution + validation de config + application des env. +- `src/adapter.ts` — `createWorldAdapter(cfg)` : implémente `WorldEngineAdapter` (start/stop/run) ; loaders de modules injectables pour les tests. +- `src/authoring.ts` — `defineWorldStep` / `defineWorldWorkflow` + types `WorldStep` (forme finale décidée par le spike Phase 1). +- `src/index.ts` — ré-exports publics. +- `src/worlds.test.ts`, `src/adapter.test.ts`, `src/authoring.test.ts` — tests unitaires (mockés, sans DB). +- `src/integration.postgres.test.ts`, `src/integration.mongo.test.ts` — tests d'intégration (opt-in, DB réelle). +- `docker-compose.test.yml` — Postgres + MongoDB pour les tests d'intégration. + +**Modifications `@ai_kit/core`** (`packages/core/`) +- `src/workflows/kit/types.ts` — `WorkflowEngine`, `WorldConfig`, `WorkflowKitOptions`, `WorldRunHandle`, `WorldEngineAdapter` (contrat). +- `src/workflows/kit/WorkflowKit.ts` — la façade. +- `src/workflows/kit/index.ts` — ré-exports. +- `src/workflows/index.ts` — `export * from "./kit/index.js";` (MODIF). +- `src/workflows/kit/WorkflowKit.test.ts` — tests unitaires de la façade. +- `package.json` — ajoute `@ai_kit/workflow-world` en `peerDependencies` (optionnel) + `devDependencies` (`workspace:*`) (MODIF). + +**Racine** +- `pnpm-workspace.yaml` — ajoute `packages/workflow-world` (MODIF). +- `packages/core/tests/workflows/vercelWorld.test.ts`, `vercelAutoRegister.test.ts` — **SUPPRESSION** (tests orphelins, module jamais implémenté). + +**Spike (jetable)** : `scratch/world-spike/` (hors workspace, supprimé en fin de Phase 1). + +--- + +## Phase 0 — Préparation + +### Task 0.1: Branche de travail + +**Files:** aucun (git) + +- [ ] **Step 1: Créer la branche** + +Run: +```bash +cd /home/killian/Documents/dev/ai-kit +git checkout -b feat/workflow-world-engine +``` +Expected: `Switched to a new branch 'feat/workflow-world-engine'` + +### Task 0.2: Confirmer les signatures du SDK Vercel (lève §12.1, §12.3, §12.4 du spec) + +**Files:** +- Create: `docs/superpowers/notes/2026-06-02-vercel-sdk-signatures.md` + +- [ ] **Step 1: Installer le SDK dans un scratch isolé** + +Run: +```bash +mkdir -p /home/killian/Documents/dev/ai-kit/scratch/world-spike +cd /home/killian/Documents/dev/ai-kit/scratch/world-spike +pnpm init +pnpm add workflow @workflow/world-postgres @workflow-worlds/mongodb nitro rollup +``` +Expected: installation OK, `node_modules/workflow/docs/` présent. + +- [ ] **Step 2: Lire la doc embarquée et noter les signatures exactes** + +Lire (Read tool) : +- `scratch/world-spike/node_modules/workflow/docs/` (index + pages api-reference) +- README de `node_modules/@workflow/world-postgres` et `node_modules/@workflow-worlds/mongodb` + +Consigner dans `docs/superpowers/notes/2026-06-02-vercel-sdk-signatures.md` les réponses confirmées à : +1. Import + signature exacte de `start` (déclenchement d'un run) — `workflow/api` ou autre ? +2. Type retourné par `start` (forme du `WorldRunHandle` : `runId` ? autre ?). +3. Postgres : signature de `createWorld(...)` (confirmer `{ connectionString, jobPrefix, queueConcurrency, maxPoolSize }`) et méthodes du world retourné (`start/stop/close/shutdown`). +4. MongoDB : nom du package, signature de son `createWorld`/équivalent, et **noms exacts des variables d'env** (le spec utilise `WORKFLOW_MONGO_URL` à titre provisoire). +5. Sélection du world : `WORKFLOW_TARGET_WORLD` (env) suffit-il, ou faut-il passer l'instance `createWorld(...)` au runtime ? `getWorld()` existe-t-il dans `workflow/runtime` ? + +- [ ] **Step 3: Commit des notes** + +```bash +cd /home/killian/Documents/dev/ai-kit +git add docs/superpowers/notes/2026-06-02-vercel-sdk-signatures.md +git commit -m "docs(workflow-world): confirm Vercel SDK signatures from bundled docs + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +> **Si une signature diffère du code de ce plan** : adapter le code des tâches suivantes en conséquence, en gardant la même structure. Les notes font foi sur les signatures. + +--- + +## Phase 1 — SPIKE BLOQUANT : détection de directive dans une arrow (spec §12.0) + +> Verdict requis avant la Phase 5. Détermine la forme finale de `defineWorldStep`/`defineWorldWorkflow`. + +### Task 1.1: Monter un mini-workflow et tester la détection + +**Files:** +- Create (jetable) : `scratch/world-spike/nitro.config.ts`, `scratch/world-spike/src/workflows.ts`, `scratch/world-spike/src/index.ts` + +- [ ] **Step 1: Config Nitro** + +`scratch/world-spike/nitro.config.ts` : +```ts +import { defineNitroConfig } from 'nitro/config'; + +export default defineNitroConfig({ + modules: ['workflow/nitro'], + routes: { '/**': { handler: './src/index.ts', format: 'node' } }, +}); +``` + +- [ ] **Step 2: Deux écritures à comparer** + +`scratch/world-spike/src/workflows.ts` : +```ts +// CONTRÔLE : fonction nommée (forme officielle documentée) +export async function controlWorkflow(x: number) { + "use workflow"; + return await controlStep(x); +} +async function controlStep(x: number) { + "use step"; + return x + 1; +} + +// CANDIDAT : arrow passée à un wrapper identité (forme défaite à valider) +const identity = (_id: string, fn: T): T => fn; + +export const candidateWorkflow = identity('cand-wf', async (x: number) => { + "use workflow"; + return await candidateStep(x); +}); +const candidateStep = identity('cand-step', async (x: number) => { + "use step"; + return x + 1; +}); +``` + +- [ ] **Step 3: Route de déclenchement** + +`scratch/world-spike/src/index.ts` : +```ts +import { start } from 'workflow/api'; +import { controlWorkflow, candidateWorkflow } from './workflows.js'; + +export default async function handler() { + const a = await start(controlWorkflow, [1]); + const b = await start(candidateWorkflow, [1]); + return new Response(JSON.stringify({ control: a, candidate: b })); +} +``` +> Adapter les imports si la Task 0.2 a révélé d'autres chemins. + +- [ ] **Step 4: Builder et déclencher** + +Run: +```bash +cd /home/killian/Documents/dev/ai-kit/scratch/world-spike +# .env local (postgres jetable via docker, ou world-local si dispo) +npx nitro dev & +sleep 4 +curl -s http://localhost:3000/ +npx workflow inspect runs || npx workflow web +``` +Expected (à observer) : pour CHAQUE workflow, les **steps apparaissent comme steps durables** dans l'inspecteur, et le build n'émet pas d'erreur de directive ignorée sur le candidat. + +- [ ] **Step 5: Verdict (decision gate)** + +Consigner dans `docs/superpowers/notes/2026-06-02-vercel-sdk-signatures.md` (section "Spike directive-in-arrow") l'un de : +- **A — OK** : le candidat est compilé comme le contrôle → Phase 5 livre `defineWorldStep`/`defineWorldWorkflow` en wrappers identité (forme du spec §7.1). +- **2 — Fonctions nommées seulement** : le candidat n'est PAS durable → Phase 5 livre des **types** (`WorldStep`) + doc imposant `export async function name() { "use step" }` (pas de wrapper runtime). +- **3 — Échec** : fallback option B (directives brutes, pas de helper). La Task 5.x "authoring" devient une simple page de doc. + +- [ ] **Step 6: Nettoyer le scratch et commit du verdict** + +```bash +cd /home/killian/Documents/dev/ai-kit +rm -rf scratch/world-spike +git add docs/superpowers/notes/2026-06-02-vercel-sdk-signatures.md +git commit -m "spike(workflow-world): record directive-in-arrow detection verdict + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +--- + +## Phase 2 — Scaffold du package `@ai_kit/workflow-world` + +### Task 2.1: Créer le squelette du package + +**Files:** +- Create: `packages/workflow-world/package.json` +- Create: `packages/workflow-world/tsconfig.json` +- Create: `packages/workflow-world/tsconfig.build.json` +- Create: `packages/workflow-world/src/index.ts` +- Modify: `pnpm-workspace.yaml` + +- [ ] **Step 1: `package.json`** + +`packages/workflow-world/package.json` : +```json +{ + "name": "@ai_kit/workflow-world", + "version": "0.1.0", + "description": "Vercel Workflow SDK world engine adapter for AI Kit (self-hosted Postgres/MongoDB).", + "type": "module", + "main": "./dist/index.js", + "types": "./dist/index.d.ts", + "exports": { + ".": { + "import": "./dist/index.js", + "types": "./dist/index.d.ts" + } + }, + "files": ["dist"], + "scripts": { + "clean": "rm -rf dist tsconfig.build.tsbuildinfo", + "build": "pnpm run clean && tsc -p tsconfig.build.json", + "prepare": "pnpm run build", + "test": "vitest run" + }, + "keywords": ["ai", "workflow", "vercel", "world", "postgres", "mongodb"], + "license": "MIT", + "packageManager": "pnpm@10.15.0", + "publishConfig": { "access": "public" }, + "dependencies": { + "workflow": "latest", + "@workflow/world-postgres": "latest", + "@workflow-worlds/mongodb": "latest" + }, + "peerDependencies": { + "@ai_kit/core": ">=1.3.0 <2" + }, + "devDependencies": { + "@ai_kit/core": "workspace:*", + "typescript": "^5.9.2", + "vitest": "^4.1.8" + } +} +``` +> Remplacer `"latest"` par les versions exactes installées au spike (Task 0.1) — lire `scratch`/le lockfile avant suppression, ou refaire `pnpm view version`. + +- [ ] **Step 2: `tsconfig.json`** (calqué sur `packages/rag/tsconfig.json`) + +`packages/workflow-world/tsconfig.json` : +```json +{ + "compilerOptions": { + "module": "NodeNext", + "moduleResolution": "NodeNext", + "target": "es2022", + "types": ["node", "vitest/globals"], + "strict": true, + "esModuleInterop": true, + "skipLibCheck": true + }, + "include": ["src"] +} +``` + +- [ ] **Step 3: `tsconfig.build.json`** (calqué sur `packages/rag/tsconfig.build.json`) + +`packages/workflow-world/tsconfig.build.json` : +```json +{ + "extends": "./tsconfig.json", + "compilerOptions": { + "composite": true, + "outDir": "./dist", + "rootDir": "./src", + "declaration": true, + "declarationMap": true, + "sourceMap": true, + "stripInternal": true + }, + "include": ["src"], + "exclude": ["tests", "dist", "**/*.test.ts"] +} +``` + +- [ ] **Step 4: `src/index.ts` (vide pour l'instant)** + +`packages/workflow-world/src/index.ts` : +```ts +export {}; +``` + +- [ ] **Step 5: Enregistrer dans le workspace** + +Modifier `pnpm-workspace.yaml` : ajouter ` - packages/workflow-world` dans la liste `packages:` (après ` - packages/core`). + +- [ ] **Step 6: Installer + build à blanc** + +Run: +```bash +cd /home/killian/Documents/dev/ai-kit +pnpm install +pnpm --filter @ai_kit/workflow-world build +``` +Expected: build OK (dist/index.js généré, vide). + +- [ ] **Step 7: Commit** + +```bash +git add packages/workflow-world pnpm-workspace.yaml pnpm-lock.yaml +git commit -m "feat(workflow-world): scaffold optional package + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +--- + +## Phase 3 — Contrat d'adapter dans `@ai_kit/core` + +### Task 3.1: Définir les types du kit (sans logique) + +**Files:** +- Create: `packages/core/src/workflows/kit/types.ts` + +- [ ] **Step 1: Écrire les types** + +`packages/core/src/workflows/kit/types.ts` : +```ts +import type { Workflow } from "../workflow.js"; +import type { WorkflowRunOptions, WorkflowRunResult } from "../types.js"; + +export type WorkflowEngine = "legacy" | "world"; + +export interface WorldConfig { + type: "postgres" | "mongodb"; + /** Connection string (postgres:// ou mongodb://). */ + url: string; + /** Postgres : namespacing des jobs si DB partagée. */ + jobPrefix?: string; + /** Postgres : nombre de workers concurrents. */ + workerConcurrency?: number; + /** Postgres : taille du pool de connexions. */ + maxPoolSize?: number; +} + +export interface WorkflowKitOptions { + /** Moteur par défaut. Défaut : "legacy". */ + engine?: WorkflowEngine; + /** Config du world. Requis si engine === "world". */ + world?: WorldConfig; +} + +/** Handle opaque renvoyé par le moteur world (pass-through du SDK Vercel). */ +export interface WorldRunHandle { + runId?: string; + [key: string]: unknown; +} + +/** Contrat implémenté par @ai_kit/workflow-world. Défini ici pour découpler core du SDK. */ +export interface WorldEngineAdapter { + start(): Promise; + stop(): Promise; + run(workflow: (...args: any[]) => unknown, args: unknown[]): Promise; +} + +/** Forme du module @ai_kit/workflow-world chargé dynamiquement. */ +export interface WorkflowWorldModule { + createWorldAdapter(config: WorldConfig): WorldEngineAdapter; +} + +/** Options par appel de WorkflowKit.run. */ +export interface WorkflowRunDispatchOptions { + engine?: WorkflowEngine; +} + +// Ré-export pratique pour les overloads de run() +export type { Workflow, WorkflowRunOptions, WorkflowRunResult }; +``` +> `Workflow`, `WorkflowRunOptions`, `WorkflowRunResult` proviennent de l'existant (`workflow.ts`, `types.ts`). Vérifier les chemins/types exacts à l'écriture (cf. spec §3 et l'exploration). + +- [ ] **Step 2: Compiler les types** + +Run: +```bash +cd /home/killian/Documents/dev/ai-kit +pnpm --filter @ai_kit/core exec tsc -p tsconfig.build.json --noEmit +``` +Expected: pas d'erreur de type. + +- [ ] **Step 3: Commit** + +```bash +git add packages/core/src/workflows/kit/types.ts +git commit -m "feat(core): add WorkflowKit contract types + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +### Task 3.2: Exporter les types depuis l'API publique de core (AVANT Phase 4) + +> Indispensable : `@ai_kit/workflow-world` (Phase 4) fait `import type { WorldConfig } from "@ai_kit/core"`, qui résout vers le `dist/index.d.ts` de core. Les types doivent donc être exportés **et core rebuildé** avant la Phase 4. La classe `WorkflowKit` viendra plus tard (Phase 5). + +**Files:** +- Create: `packages/core/src/workflows/kit/index.ts` +- Modify: `packages/core/src/workflows/index.ts` + +- [ ] **Step 1: `kit/index.ts` — types uniquement (pas encore la classe)** + +`packages/core/src/workflows/kit/index.ts` : +```ts +export type { + WorkflowEngine, + WorldConfig, + WorkflowKitOptions, + WorldRunHandle, + WorldEngineAdapter, + WorkflowWorldModule, + WorkflowRunDispatchOptions, +} from "./types.js"; +``` + +- [ ] **Step 2: Ré-exporter depuis `workflows/index.ts`** + +Ajouter en fin de `packages/core/src/workflows/index.ts` : +```ts +export * from "./kit/index.js"; +``` + +- [ ] **Step 3: Build de core (publie les types dans dist)** + +Run: `pnpm --filter @ai_kit/core build` +Expected: build OK ; `dist/index.d.ts` exporte `WorldConfig`, `WorldEngineAdapter`, etc. + +- [ ] **Step 4: Commit** + +```bash +git add packages/core/src/workflows/kit/index.ts packages/core/src/workflows/index.ts +git commit -m "feat(core): export WorkflowKit contract types from public API + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +--- + +## Phase 4 — Package world : `worlds.ts` puis `adapter.ts` (TDD) + +> Pré-requis : Task 3.2 terminée (types exportés + core buildé), sinon les `import type ... from "@ai_kit/core"` ne résolvent pas. + +### Task 4.1: `worlds.ts` — résolution + env (TDD) + +**Files:** +- Create: `packages/workflow-world/src/worlds.ts` +- Test: `packages/workflow-world/src/worlds.test.ts` + +- [ ] **Step 1: Test qui échoue** + +`packages/workflow-world/src/worlds.test.ts` : +```ts +import { describe, expect, it } from "vitest"; +import { resolveWorld, WORLD_TARGETS } from "./worlds.js"; + +describe("resolveWorld", () => { + it("mappe postgres vers le bon target et applique les env", () => { + const env: Record = {}; + const w = resolveWorld( + { type: "postgres", url: "postgres://u:p@h:5432/db", jobPrefix: "wf__", workerConcurrency: 5 }, + env, + ); + expect(w.target).toBe(WORLD_TARGETS.postgres); + expect(env.WORKFLOW_TARGET_WORLD).toBe(WORLD_TARGETS.postgres); + expect(env.WORKFLOW_POSTGRES_URL).toBe("postgres://u:p@h:5432/db"); + expect(env.WORKFLOW_POSTGRES_JOB_PREFIX).toBe("wf__"); + expect(env.WORKFLOW_POSTGRES_WORKER_CONCURRENCY).toBe("5"); + }); + + it("mappe mongodb vers le bon target", () => { + const env: Record = {}; + const w = resolveWorld({ type: "mongodb", url: "mongodb://h:27017/db" }, env); + expect(w.target).toBe(WORLD_TARGETS.mongodb); + expect(env.WORKFLOW_TARGET_WORLD).toBe(WORLD_TARGETS.mongodb); + }); + + it("rejette une url manquante", () => { + expect(() => resolveWorld({ type: "postgres", url: "" }, {})).toThrow(/url/i); + }); + + it("rejette un type inconnu", () => { + // @ts-expect-error test runtime + expect(() => resolveWorld({ type: "redis", url: "x" }, {})).toThrow(/unsupported|inconnu/i); + }); +}); +``` + +- [ ] **Step 2: Lancer → échec** + +Run: `pnpm --filter @ai_kit/workflow-world test` +Expected: FAIL (`Cannot find module './worlds.js'`). + +- [ ] **Step 3: Implémenter `worlds.ts`** + +`packages/workflow-world/src/worlds.ts` : +```ts +import type { WorldConfig } from "@ai_kit/core"; + +export const WORLD_TARGETS = { + postgres: "@workflow/world-postgres", + mongodb: "@workflow-worlds/mongodb", +} as const; + +export interface ResolvedWorld { + target: string; + type: WorldConfig["type"]; +} + +/** Valide la config, pose les variables d'env dans `env`, et renvoie le target résolu. */ +export function resolveWorld( + config: WorldConfig, + env: Record = process.env, +): ResolvedWorld { + if (!config.url) { + throw new Error("workflow-world: 'url' is required in WorldConfig"); + } + const target = WORLD_TARGETS[config.type]; + if (!target) { + throw new Error(`workflow-world: unsupported world type '${config.type}'`); + } + + env.WORKFLOW_TARGET_WORLD = target; + + if (config.type === "postgres") { + env.WORKFLOW_POSTGRES_URL = config.url; + if (config.jobPrefix) env.WORKFLOW_POSTGRES_JOB_PREFIX = config.jobPrefix; + if (config.workerConcurrency != null) + env.WORKFLOW_POSTGRES_WORKER_CONCURRENCY = String(config.workerConcurrency); + if (config.maxPoolSize != null) + env.WORKFLOW_POSTGRES_MAX_POOL_SIZE = String(config.maxPoolSize); + } else { + // mongodb — confirmer les noms d'env via les notes Task 0.2 + env.WORKFLOW_MONGO_URL = config.url; + } + + return { target, type: config.type }; +} +``` + +- [ ] **Step 4: Lancer → succès** + +Run: `pnpm --filter @ai_kit/workflow-world test` +Expected: PASS (4 tests). + +- [ ] **Step 5: Commit** + +```bash +git add packages/workflow-world/src/worlds.ts packages/workflow-world/src/worlds.test.ts +git commit -m "feat(workflow-world): world type resolution and env mapping + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +### Task 4.2: `adapter.ts` — createWorldAdapter (TDD avec loaders injectables) + +**Files:** +- Create: `packages/workflow-world/src/adapter.ts` +- Test: `packages/workflow-world/src/adapter.test.ts` + +- [ ] **Step 1: Test qui échoue** + +`packages/workflow-world/src/adapter.test.ts` : +```ts +import { afterEach, describe, expect, it, vi } from "vitest"; +import { createWorldAdapter, __setWorldModuleLoaders } from "./adapter.js"; + +afterEach(() => __setWorldModuleLoaders()); + +function mockPostgres() { + const start = vi.fn().mockResolvedValue(undefined); + const stop = vi.fn().mockResolvedValue(undefined); + const close = vi.fn().mockResolvedValue(undefined); + const shutdown = vi.fn().mockResolvedValue(undefined); + const createWorld = vi.fn(() => ({ start, stop, close, shutdown })); + const startRun = vi.fn().mockResolvedValue({ runId: "r_1" }); + __setWorldModuleLoaders({ + postgres: async () => ({ createWorld }), + api: async () => ({ start: startRun }), + }); + return { createWorld, start, stop, close, shutdown, startRun }; +} + +describe("createWorldAdapter (postgres)", () => { + it("démarre le world avec la config mappée", async () => { + const m = mockPostgres(); + const env: Record = {}; + const adapter = createWorldAdapter( + { type: "postgres", url: "postgres://u:p@h:5432/db", jobPrefix: "wf__", workerConcurrency: 5 }, + env, + ); + await adapter.start(); + expect(m.createWorld).toHaveBeenCalledWith({ + connectionString: "postgres://u:p@h:5432/db", + jobPrefix: "wf__", + queueConcurrency: 5, + }); + expect(m.start).toHaveBeenCalledTimes(1); + expect(env.WORKFLOW_TARGET_WORLD).toBe("@workflow/world-postgres"); + }); + + it("run délègue à start() du SDK", async () => { + const m = mockPostgres(); + const adapter = createWorldAdapter({ type: "postgres", url: "postgres://x" }, {}); + const fn = async () => 1; + const handle = await adapter.run(fn, ["a"]); + expect(m.startRun).toHaveBeenCalledWith(fn, ["a"]); + expect(handle).toEqual({ runId: "r_1" }); + }); + + it("stop appelle stop/close/shutdown du world", async () => { + const m = mockPostgres(); + const adapter = createWorldAdapter({ type: "postgres", url: "postgres://x" }, {}); + await adapter.start(); + await adapter.stop(); + expect(m.stop).toHaveBeenCalledTimes(1); + expect(m.close).toHaveBeenCalledTimes(1); + expect(m.shutdown).toHaveBeenCalledTimes(1); + }); + + it("erreur claire si le package world manque", async () => { + __setWorldModuleLoaders({ + postgres: async () => { + const e = new Error("not found") as Error & { code?: string }; + e.code = "ERR_MODULE_NOT_FOUND"; + throw e; + }, + }); + const adapter = createWorldAdapter({ type: "postgres", url: "postgres://x" }, {}); + await expect(adapter.start()).rejects.toThrow("@workflow/world-postgres"); + }); +}); +``` + +- [ ] **Step 2: Lancer → échec** + +Run: `pnpm --filter @ai_kit/workflow-world test` +Expected: FAIL (`Cannot find module './adapter.js'`). + +- [ ] **Step 3: Implémenter `adapter.ts`** + +`packages/workflow-world/src/adapter.ts` : +```ts +import type { WorldConfig, WorldEngineAdapter, WorldRunHandle } from "@ai_kit/core"; +import { resolveWorld, WORLD_TARGETS } from "./worlds.js"; + +interface PostgresWorld { + start?(): Promise; + stop?(): Promise; + close?(): Promise; + shutdown?(): Promise; +} +interface WorldModuleLoaders { + postgres: () => Promise<{ createWorld: (opts: Record) => PostgresWorld }>; + mongodb: () => Promise<{ createWorld: (opts: Record) => PostgresWorld }>; + api: () => Promise<{ start: (fn: (...a: any[]) => unknown, args: unknown[]) => Promise }>; +} + +function defaultLoaders(): WorldModuleLoaders { + return { + postgres: () => import(WORLD_TARGETS.postgres) as Promise, + mongodb: () => import(WORLD_TARGETS.mongodb) as Promise, + api: () => import("workflow/api") as Promise, + }; +} + +let loaders: WorldModuleLoaders = defaultLoaders(); +/** @internal — test seam. Sans argument : reset. */ +export function __setWorldModuleLoaders(custom?: Partial): void { + loaders = { ...defaultLoaders(), ...custom }; +} + +async function loadWorldModule(type: WorldConfig["type"]) { + try { + return type === "postgres" ? await loaders.postgres() : await loaders.mongodb(); + } catch (err) { + const code = (err as { code?: string }).code; + if (code === "ERR_MODULE_NOT_FOUND") { + throw new Error( + `workflow-world: the optional dependency '${WORLD_TARGETS[type]}' is not installed. ` + + `Install it: pnpm add ${WORLD_TARGETS[type]}`, + ); + } + throw err; + } +} + +export function createWorldAdapter( + config: WorldConfig, + env: Record = process.env, +): WorldEngineAdapter { + let world: PostgresWorld | undefined; + + return { + async start() { + resolveWorld(config, env); + const mod = await loadWorldModule(config.type); + world = mod.createWorld(buildWorldOptions(config)); + await world.start?.(); + }, + async stop() { + if (!world) return; + await world.stop?.(); + await world.close?.(); + await world.shutdown?.(); + world = undefined; + }, + async run(fn, args) { + const { start } = await loaders.api(); + return start(fn, args); + }, + }; +} + +function buildWorldOptions(config: WorldConfig): Record { + if (config.type === "postgres") { + const opts: Record = { connectionString: config.url }; + if (config.jobPrefix) opts.jobPrefix = config.jobPrefix; + if (config.workerConcurrency != null) opts.queueConcurrency = config.workerConcurrency; + if (config.maxPoolSize != null) opts.maxPoolSize = config.maxPoolSize; + return opts; + } + // mongodb — confirmer la forme via les notes Task 0.2 + return { connectionString: config.url }; +} +``` + +- [ ] **Step 4: Lancer → succès** + +Run: `pnpm --filter @ai_kit/workflow-world test` +Expected: PASS (toute la suite, dont les 4 nouveaux tests adapter). + +- [ ] **Step 5: Commit** + +```bash +git add packages/workflow-world/src/adapter.ts packages/workflow-world/src/adapter.test.ts +git commit -m "feat(workflow-world): createWorldAdapter with injectable loaders + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +### Task 4.3: `authoring.ts` — helpers d'écriture (forme = verdict Phase 1) + +**Files:** +- Create: `packages/workflow-world/src/authoring.ts` +- Test: `packages/workflow-world/src/authoring.test.ts` + +> **Branche selon le verdict du spike (Task 1.1 Step 5).** + +- [ ] **Step 1 (verdict A) : test qui échoue** + +`packages/workflow-world/src/authoring.test.ts` : +```ts +import { describe, expect, it } from "vitest"; +import { defineWorldStep, defineWorldWorkflow } from "./authoring.js"; + +describe("authoring helpers (identity wrappers)", () => { + it("defineWorldStep renvoie la même fonction (identité)", () => { + const fn = async (x: number) => x + 1; + const step = defineWorldStep("inc", fn); + expect(step).toBe(fn); + }); + it("defineWorldWorkflow renvoie la même fonction (identité)", () => { + const fn = async (x: number) => x; + const wf = defineWorldWorkflow("id", fn); + expect(wf).toBe(fn); + }); +}); +``` + +- [ ] **Step 2: Lancer → échec** + +Run: `pnpm --filter @ai_kit/workflow-world test` +Expected: FAIL (`Cannot find module './authoring.js'`). + +- [ ] **Step 3 (verdict A) : implémenter en wrappers identité** + +`packages/workflow-world/src/authoring.ts` : +```ts +/** + * Helper d'écriture pour un step world. NB : la directive "use step" DOIT + * rester la première instruction du corps de `fn` — le helper ne peut pas + * l'injecter (détection au build par le compilo). Voir spec §7.1. + */ +export function defineWorldStep unknown>( + _id: string, + fn: Fn, +): Fn { + return fn; +} + +/** Idem pour un workflow world. La directive "use workflow" reste obligatoire dans `fn`. */ +export function defineWorldWorkflow unknown>( + _id: string, + fn: Fn, +): Fn { + return fn; +} + +export type WorldStep = (...args: Args) => Promise; +``` + +> **Si verdict = 2 (fonctions nommées seulement)** : ne pas exporter `defineWorldStep/defineWorldWorkflow` runtime ; n'exporter que les **types** (`WorldStep`) et documenter la forme `export async function name() { "use step" }`. Adapter le test pour ne valider que les types (`expectTypeOf`). +> **Si verdict = 3 (échec)** : ne pas créer `authoring.ts` ; sauter à la Task 4.4, et la doc (Phase 7) montrera uniquement les directives brutes. + +- [ ] **Step 4: Lancer → succès** + +Run: `pnpm --filter @ai_kit/workflow-world test` +Expected: PASS. + +- [ ] **Step 5: Commit** + +```bash +git add packages/workflow-world/src/authoring.ts packages/workflow-world/src/authoring.test.ts +git commit -m "feat(workflow-world): defineWorldStep/defineWorldWorkflow authoring helpers + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +### Task 4.4: Exports publics du package + +**Files:** +- Modify: `packages/workflow-world/src/index.ts` + +- [ ] **Step 1: Écrire les ré-exports** + +`packages/workflow-world/src/index.ts` (verdict A) : +```ts +export { createWorldAdapter } from "./adapter.js"; +export { resolveWorld, WORLD_TARGETS } from "./worlds.js"; +export { defineWorldStep, defineWorldWorkflow } from "./authoring.js"; +export type { WorldStep } from "./authoring.js"; +``` +> Verdict 2 : retirer la ligne `createWorldAdapter`? Non — `createWorldAdapter` reste (c'est le runtime). Retirer seulement les helpers runtime absents. Verdict 3 : retirer la ligne `authoring`. + +- [ ] **Step 2: Build du package** + +Run: `pnpm --filter @ai_kit/workflow-world build` +Expected: build OK, `dist/index.d.ts` exporte `createWorldAdapter`. + +- [ ] **Step 3: Commit** + +```bash +git add packages/workflow-world/src/index.ts +git commit -m "feat(workflow-world): public exports + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +--- + +## Phase 5 — Façade `WorkflowKit` dans `@ai_kit/core` (TDD) + +### Task 5.1: Dépendance optionnelle vers le package world + +**Files:** +- Modify: `packages/core/package.json` + +- [ ] **Step 1: Ajouter peer optionnelle + devDep workspace** + +Dans `packages/core/package.json` : +- Sous `peerDependencies`, ajouter : `"@ai_kit/workflow-world": ">=0.1.0 <1"` +- Sous `peerDependenciesMeta`, ajouter : `"@ai_kit/workflow-world": { "optional": true }` +- Sous `devDependencies`, ajouter : `"@ai_kit/workflow-world": "workspace:*"` + +- [ ] **Step 2: Installer** + +Run: +```bash +cd /home/killian/Documents/dev/ai-kit +pnpm install +``` +Expected: lien workspace OK. + +- [ ] **Step 3: Commit** + +```bash +git add packages/core/package.json pnpm-lock.yaml +git commit -m "chore(core): add @ai_kit/workflow-world as optional peer dependency + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +### Task 5.2: `WorkflowKit` — validation de config (TDD) + +**Files:** +- Create: `packages/core/src/workflows/kit/WorkflowKit.ts` +- Test: `packages/core/src/workflows/kit/WorkflowKit.test.ts` + +- [ ] **Step 1: Test qui échoue** + +`packages/core/src/workflows/kit/WorkflowKit.test.ts` : +```ts +import { describe, expect, it } from "vitest"; +import { WorkflowKit } from "./WorkflowKit.js"; + +describe("WorkflowKit — config", () => { + it("défaut = engine legacy", () => { + expect(new WorkflowKit().engine).toBe("legacy"); + }); + + it("engine 'world' sans config world → throw", () => { + expect(() => new WorkflowKit({ engine: "world" })).toThrow(/world/i); + }); + + it("type de world inconnu → throw", () => { + // @ts-expect-error test runtime + expect(() => new WorkflowKit({ engine: "world", world: { type: "redis", url: "x" } })).toThrow(); + }); + + it("start/stop sont no-op en legacy", async () => { + const kit = new WorkflowKit(); + await expect(kit.start()).resolves.toBeUndefined(); + await expect(kit.stop()).resolves.toBeUndefined(); + }); +}); +``` + +- [ ] **Step 2: Lancer → échec** + +Run: `pnpm --filter @ai_kit/core test WorkflowKit` +Expected: FAIL (`Cannot find module './WorkflowKit.js'`). + +- [ ] **Step 3: Implémenter `WorkflowKit.ts` (config + lifecycle)** + +`packages/core/src/workflows/kit/WorkflowKit.ts` : +```ts +import type { Workflow } from "../workflow.js"; +import type { WorkflowRunOptions, WorkflowRunResult } from "../types.js"; +import type { + WorkflowEngine, + WorkflowKitOptions, + WorldConfig, + WorldEngineAdapter, + WorkflowWorldModule, + WorldRunHandle, + WorkflowRunDispatchOptions, +} from "./types.js"; + +const VALID_WORLD_TYPES = ["postgres", "mongodb"] as const; + +export class WorkflowKit { + readonly engine: WorkflowEngine; + readonly world?: WorldConfig; + #adapter?: WorldEngineAdapter; + + constructor(options: WorkflowKitOptions = {}) { + this.engine = options.engine ?? "legacy"; + this.world = options.world; + + if (this.engine === "world" && !this.world) { + throw new Error("WorkflowKit: engine 'world' requires a 'world' config"); + } + if (this.world && !VALID_WORLD_TYPES.includes(this.world.type)) { + throw new Error(`WorkflowKit: unsupported world type '${this.world.type}'`); + } + } + + async start(): Promise { + if (this.engine !== "world") return; + const adapter = await this.#ensureAdapter(); + await adapter.start(); + } + + async stop(): Promise { + if (this.engine !== "world" || !this.#adapter) return; + await this.#adapter.stop(); + } + + // Overload legacy + run( + workflow: Workflow, + options: WorkflowRunOptions, + dispatch?: WorkflowRunDispatchOptions, + ): Promise>; + // Overload world + run( + workflow: (...args: any[]) => unknown, + args: unknown[], + dispatch?: WorkflowRunDispatchOptions, + ): Promise; + // Implémentation + async run( + workflow: any, + input: any, + dispatch?: WorkflowRunDispatchOptions, + ): Promise { + const engine = dispatch?.engine ?? this.engine; + if (engine === "legacy") { + return (workflow as Workflow).run(input); + } + const adapter = await this.#ensureAdapter(); + return adapter.run(workflow, input as unknown[]); + } + + async #ensureAdapter(): Promise { + if (this.#adapter) return this.#adapter; + if (!this.world) { + throw new Error("WorkflowKit: engine 'world' requires a 'world' config"); + } + let mod: WorkflowWorldModule; + try { + mod = (await import("@ai_kit/workflow-world")) as unknown as WorkflowWorldModule; + } catch { + throw new Error( + "WorkflowKit: engine 'world' requires the '@ai_kit/workflow-world' package. " + + "Install it: pnpm add @ai_kit/workflow-world", + ); + } + this.#adapter = mod.createWorldAdapter(this.world); + return this.#adapter; + } +} +``` +> Vérifier la signature exacte de `Workflow.run(options)` dans `workflow.ts` (spec §2 indique `run(options: WorkflowRunOptions)` → `WorkflowRunResult`). Ajuster les génériques si nécessaire. + +- [ ] **Step 4: Lancer → succès** + +Run: `pnpm --filter @ai_kit/core test WorkflowKit` +Expected: PASS (4 tests). + +- [ ] **Step 5: Commit** + +```bash +git add packages/core/src/workflows/kit/WorkflowKit.ts packages/core/src/workflows/kit/WorkflowKit.test.ts +git commit -m "feat(core): WorkflowKit facade with config validation and lifecycle + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +### Task 5.3: Dispatch `run` — délégation legacy & world (TDD) + +**Files:** +- Modify: `packages/core/src/workflows/kit/WorkflowKit.test.ts` + +- [ ] **Step 1: Ajouter les tests de dispatch (échec)** + +Ajouter à `WorkflowKit.test.ts` : +```ts +import { vi } from "vitest"; + +describe("WorkflowKit — dispatch run", () => { + it("legacy : délègue à Workflow.run", async () => { + const fakeWorkflow = { run: vi.fn().mockResolvedValue({ status: "success" }) }; + const kit = new WorkflowKit(); // legacy + const res = await kit.run(fakeWorkflow as any, { inputData: { id: 1 } }); + expect(fakeWorkflow.run).toHaveBeenCalledWith({ inputData: { id: 1 } }); + expect(res).toEqual({ status: "success" }); + }); + + it("world : délègue à adapter.run via @ai_kit/workflow-world", async () => { + const adapterRun = vi.fn().mockResolvedValue({ runId: "r_9" }); + vi.doMock("@ai_kit/workflow-world", () => ({ + createWorldAdapter: () => ({ + start: vi.fn(), stop: vi.fn(), run: adapterRun, + }), + })); + const { WorkflowKit: Kit } = await import("./WorkflowKit.js"); + const kit = new Kit({ engine: "world", world: { type: "postgres", url: "postgres://x" } }); + const fn = async () => 1; + const handle = await kit.run(fn, ["a"]); + expect(adapterRun).toHaveBeenCalledWith(fn, ["a"]); + expect(handle).toEqual({ runId: "r_9" }); + vi.doUnmock("@ai_kit/workflow-world"); + }); +}); +``` +> `vi.doMock` doit précéder l'`import()` dynamique du module testé (déjà le cas ici). Ajouter `vi.resetModules()` en `beforeEach` du nouveau describe si nécessaire. + +- [ ] **Step 2: Lancer → succès** (l'implémentation de 5.2 couvre déjà ces cas) + +Run: `pnpm --filter @ai_kit/core test WorkflowKit` +Expected: PASS (tous les tests, dont les 2 nouveaux). Si le mock world échoue, ajuster `vi.resetModules()`/ordre des imports — ne PAS modifier la logique de `WorkflowKit`. + +- [ ] **Step 3: Commit** + +```bash +git add packages/core/src/workflows/kit/WorkflowKit.test.ts +git commit -m "test(core): WorkflowKit run dispatch (legacy + world) + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +### Task 5.4: Exporter la classe `WorkflowKit` depuis core + +> Les **types** sont déjà exportés (Task 3.2). Ici on ajoute uniquement la **classe**. + +**Files:** +- Modify: `packages/core/src/workflows/kit/index.ts` + +- [ ] **Step 1: Ajouter l'export de la classe** + +Ajouter en tête de `packages/core/src/workflows/kit/index.ts` (au-dessus de l'`export type` existant) : +```ts +export { WorkflowKit } from "./WorkflowKit.js"; +``` + +- [ ] **Step 2: Build de core** + +Run: `pnpm --filter @ai_kit/core build` +Expected: build OK ; `dist/index.d.ts` exporte `WorkflowKit`. + +- [ ] **Step 3: Vérifier l'import public** + +Run: +```bash +cd /home/killian/Documents/dev/ai-kit +node -e "import('@ai_kit/core').then(m => console.log(typeof m.WorkflowKit))" +``` +Expected: `function` + +- [ ] **Step 4: Commit** + +```bash +git add packages/core/src/workflows/kit/index.ts +git commit -m "feat(core): export WorkflowKit class from public API + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +--- + +## Phase 6 — Nettoyage des tests obsolètes + +### Task 6.1: Supprimer les tests vercel orphelins + +**Files:** +- Delete: `packages/core/tests/workflows/vercelWorld.test.ts` +- Delete: `packages/core/tests/workflows/vercelAutoRegister.test.ts` + +- [ ] **Step 1: Confirmer qu'ils ciblent un module non créé** + +Run: +```bash +cd /home/killian/Documents/dev/ai-kit +ls packages/core/src/workflows/vercel/ 2>&1 # doit être vide +``` +Expected: dossier vide → ces tests ne peuvent pas passer (module absent), et on a décidé de mettre le world dans `@ai_kit/workflow-world`, pas dans core. + +- [ ] **Step 2: Supprimer** + +Run: +```bash +git rm packages/core/tests/workflows/vercelWorld.test.ts packages/core/tests/workflows/vercelAutoRegister.test.ts +rmdir packages/core/src/workflows/vercel 2>/dev/null || true +``` + +- [ ] **Step 3: Lancer la suite core** + +Run: `pnpm --filter @ai_kit/core test` +Expected: la suite tourne ; les échecs liés à `vercelWorld`/`vercelAutoRegister` ont disparu. (Les autres échecs pré-existants connus ne sont pas du ressort de ce plan.) + +- [ ] **Step 4: Commit** + +```bash +git commit -m "chore(core): remove orphaned vercel world test stubs + +Module src/workflows/vercel was never implemented; the world engine now +lives in the optional @ai_kit/workflow-world package. + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +--- + +## Phase 7 — Tests d'intégration (opt-in) & documentation + +> **Stratégie tests à deux niveaux :** +> - **Unitaire (toujours, sans DB)** : Phases 4–5. Les modules SDK/world sont **mockés** via les loaders injectables (`__setWorldModuleLoaders`) et `vi.doMock`. Aucune base requise → tournent partout, y compris CI. +> - **Intégration (opt-in, DB réelle)** : tâches ci-dessous. Postgres + MongoDB réels lancés via **`docker-compose.test.yml`**. Skip automatique si les URLs d'env ne sont pas posées → jamais bloquant en CI. + +### Task 7.1: `docker-compose.test.yml` (postgres + mongo) + +**Files:** +- Create: `packages/workflow-world/docker-compose.test.yml` +- Modify: `packages/workflow-world/package.json` (scripts) + +- [ ] **Step 1: Écrire le compose** + +`packages/workflow-world/docker-compose.test.yml` : +```yaml +services: + postgres: + image: postgres:16 + environment: + POSTGRES_USER: world + POSTGRES_PASSWORD: world + POSTGRES_DB: world + ports: + - "5432:5432" + healthcheck: + test: ["CMD-SHELL", "pg_isready -U world -d world"] + interval: 2s + timeout: 3s + retries: 30 + mongo: + image: mongo:7 + ports: + - "27017:27017" + healthcheck: + test: ["CMD", "mongosh", "--quiet", "--eval", "db.adminCommand('ping')"] + interval: 2s + timeout: 3s + retries: 30 +``` + +- [ ] **Step 2: Scripts package.json** + +Ajouter dans `scripts` de `packages/workflow-world/package.json` : +```json + "db:up": "docker compose -f docker-compose.test.yml up -d --wait", + "db:down": "docker compose -f docker-compose.test.yml down -v", + "test:integration": "WORKFLOW_WORLD_PG_URL=postgres://world:world@localhost:5432/world WORKFLOW_WORLD_MONGO_URL=mongodb://localhost:27017/world vitest run integration" +``` +> `--wait` (Compose v2) bloque jusqu'à ce que les healthchecks passent → les DB sont prêtes avant les tests. + +- [ ] **Step 3: Vérifier que le compose démarre** + +Run: +```bash +cd /home/killian/Documents/dev/ai-kit/packages/workflow-world +pnpm run db:up +docker compose -f docker-compose.test.yml ps +pnpm run db:down +``` +Expected: les 2 services passent `healthy` puis sont supprimés proprement. + +- [ ] **Step 4: Commit** + +```bash +cd /home/killian/Documents/dev/ai-kit +git add packages/workflow-world/docker-compose.test.yml packages/workflow-world/package.json +git commit -m "test(workflow-world): docker-compose for postgres+mongo integration + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +### Task 7.2: Test d'intégration Postgres (opt-in) + +**Files:** +- Create: `packages/workflow-world/src/integration.postgres.test.ts` + +- [ ] **Step 1: Test gardé par variable d'env** + +`packages/workflow-world/src/integration.postgres.test.ts` : +```ts +import { describe, expect, it } from "vitest"; +import { createWorldAdapter } from "./adapter.js"; + +const RUN_IT = process.env.WORKFLOW_WORLD_PG_URL ? describe : describe.skip; + +RUN_IT("integration: postgres world", () => { + it("démarre et arrête un world Postgres réel", async () => { + const adapter = createWorldAdapter({ + type: "postgres", + url: process.env.WORKFLOW_WORLD_PG_URL!, + }); + await adapter.start(); + await adapter.stop(); + expect(true).toBe(true); + }, 60_000); +}); +``` + +- [ ] **Step 2: Vérifier le skip par défaut** + +Run: `pnpm --filter @ai_kit/workflow-world test` +Expected: le bloc integration est **skipped** (pas de `WORKFLOW_WORLD_PG_URL`). + +- [ ] **Step 3 (optionnel local) : lancer les DB et exécuter l'intégration** + +Run: +```bash +cd /home/killian/Documents/dev/ai-kit/packages/workflow-world +pnpm run db:up +pnpm run test:integration +pnpm run db:down +``` +Expected: test Postgres PASS (ou consigner l'échec/ajustement de signature dans les notes Task 0.2). + +- [ ] **Step 4: Commit** + +```bash +cd /home/killian/Documents/dev/ai-kit +git add packages/workflow-world/src/integration.postgres.test.ts +git commit -m "test(workflow-world): opt-in postgres integration test + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +### Task 7.3: Test d'intégration MongoDB (opt-in) + +**Files:** +- Create: `packages/workflow-world/src/integration.mongo.test.ts` + +- [ ] **Step 1: Test gardé par variable d'env** + +`packages/workflow-world/src/integration.mongo.test.ts` : +```ts +import { describe, expect, it } from "vitest"; +import { createWorldAdapter } from "./adapter.js"; + +const RUN_IT = process.env.WORKFLOW_WORLD_MONGO_URL ? describe : describe.skip; + +RUN_IT("integration: mongodb world (expérimental)", () => { + it("démarre et arrête un world MongoDB réel", async () => { + const adapter = createWorldAdapter({ + type: "mongodb", + url: process.env.WORKFLOW_WORLD_MONGO_URL!, + }); + await adapter.start(); + await adapter.stop(); + expect(true).toBe(true); + }, 60_000); +}); +``` +> World Mongo = communautaire/expérimental (cf. spec §1, §7.2). Si la signature/les env diffèrent (notes Task 0.2), ajuster ce test et `buildWorldOptions`/`resolveWorld` en conséquence. Si le world ne démarre pas du tout dans la version installée, marquer le test `describe.skip` avec un commentaire « expérimental — non supporté en l'état » plutôt que de le laisser rouge. + +- [ ] **Step 2: Vérifier le skip par défaut** + +Run: `pnpm --filter @ai_kit/workflow-world test` +Expected: le bloc Mongo est **skipped** (pas de `WORKFLOW_WORLD_MONGO_URL`). + +- [ ] **Step 3 (optionnel local) : exécuter contre le compose** + +Run: +```bash +cd /home/killian/Documents/dev/ai-kit/packages/workflow-world +pnpm run db:up +pnpm run test:integration # exécute postgres + mongo +pnpm run db:down +``` +Expected: test Mongo PASS, ou skip documenté si expérimental non supporté. + +- [ ] **Step 4: Commit** + +```bash +cd /home/killian/Documents/dev/ai-kit +git add packages/workflow-world/src/integration.mongo.test.ts +git commit -m "test(workflow-world): opt-in mongodb integration test + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +### Task 7.4: README du package + lien vers le spec + +**Files:** +- Create: `packages/workflow-world/README.md` + +- [ ] **Step 1: Écrire le README** + +`packages/workflow-world/README.md` — contenu : +```markdown +# @ai_kit/workflow-world + +Moteur de workflow "world" pour AI Kit : adapte le Vercel Workflow SDK +(persistance durable Postgres/MongoDB) derrière la façade `WorkflowKit` de +`@ai_kit/core`. Optionnel : non requis pour le moteur legacy. + +## Installation + +\`\`\`bash +pnpm add @ai_kit/core @ai_kit/workflow-world workflow @workflow/world-postgres +pnpm add -D nitro rollup +\`\`\` + +## Contrainte + +Le SDK Vercel exige une étape de build (Nitro) et un worker long-vivant. +Voir le guide complet et les exemples end-to-end : +`docs/superpowers/specs/2026-06-02-workflow-world-engine-design.md` (§5, §6). + +## Usage + +\`\`\`ts +import { WorkflowKit } from '@ai_kit/core'; +import { defineWorldWorkflow, defineWorldStep } from '@ai_kit/workflow-world'; + +const kit = new WorkflowKit({ + engine: 'world', + world: { type: 'postgres', url: process.env.WORKFLOW_POSTGRES_URL! }, +}); +await kit.start(); +\`\`\` + +> La directive `"use step"` / `"use workflow"` reste obligatoire dans le corps +> des fonctions, même avec `defineWorldStep` (détection au build). Voir spec §7.1. + +## Tests + +- Unitaires (sans DB, mockés) : `pnpm test` +- Intégration (opt-in, DB réelle) : + `pnpm run db:up && pnpm run test:integration && pnpm run db:down` + (lance Postgres + MongoDB via `docker-compose.test.yml`). +``` +> Si le verdict du spike est 2 ou 3, retirer la mention `defineWorldStep`/`defineWorldWorkflow` et montrer la forme retenue. + +- [ ] **Step 2: Commit** + +```bash +git add packages/workflow-world/README.md +git commit -m "docs(workflow-world): package README + +Co-Authored-By: Claude Opus 4.8 (1M context) " +``` + +### Task 7.5: Vérification finale globale + +**Files:** aucun + +- [ ] **Step 1: Build des deux packages** + +Run: +```bash +cd /home/killian/Documents/dev/ai-kit +pnpm --filter @ai_kit/workflow-world build && pnpm --filter @ai_kit/core build +``` +Expected: les deux builds OK. + +- [ ] **Step 2: Tests des deux packages** + +Run: +```bash +pnpm --filter @ai_kit/workflow-world test && pnpm --filter @ai_kit/core test +``` +Expected: workflow-world 100% vert ; core sans nouvel échec (les échecs pré-existants connus mis à part — cf. mémoire projet ; la CI ne gate que server + client-kit). + +- [ ] **Step 3: Vérifier la non-régression server** + +Run: `pnpm --filter @ai_kit/server build && pnpm --filter @ai_kit/server test` +Expected: server OK (il dépend de core). + +- [ ] **Step 4: Commit final si des artefacts de lock ont changé** + +```bash +git add -A && git commit -m "chore(workflow-world): final build/lock sync + +Co-Authored-By: Claude Opus 4.8 (1M context) " || echo "rien à committer" +``` + +--- + +## Récap de couverture (spec → tâches) + +| Section du spec | Tâche(s) | +|---|---| +| §2 Architecture / packaging | Phase 2 (scaffold) + Task 5.1 (peer dep) | +| §3 Façade WorkflowKit (config, lifecycle, run, env) | Phase 3 (types) + Phase 5 (impl) | +| §4 Contrat d'adapter + mapping world | Task 3.1 + Task 4.1 + Task 4.2 | +| §5 Frontières app hôte (Nitro) | README 7.2 + doc spec (référencée) | +| §6 Exemples d'usage | README 7.2 (renvoi au spec §6) | +| §7.1 Helpers d'écriture (option A) | Phase 1 (spike) + Task 4.3 | +| §7.2 Couverture fonctionnelle | héritée du SDK (rien à coder) | +| §9 Erreurs/retries (dep manquante) | Task 4.2 (erreur claire) + Task 5.2 (#ensureAdapter) | +| §10 Tests (unit + intégration opt-in) | Phases 4–5 (unit, mockés, sans DB) + Task 7.1 (docker-compose PG+Mongo) + Tasks 7.2/7.3 (intégration PG/Mongo) | +| §12.0 Spike bloquant | Phase 1 | +| §12.1/.3/.4 signatures SDK | Task 0.2 | +| §12.2 env Mongo | Task 0.2 (Step 2.4) | +| Nettoyage tests obsolètes | Phase 6 | diff --git a/docs/superpowers/specs/2026-06-02-workflow-world-engine-design.md b/docs/superpowers/specs/2026-06-02-workflow-world-engine-design.md new file mode 100644 index 0000000..0591b22 --- /dev/null +++ b/docs/superpowers/specs/2026-06-02-workflow-world-engine-design.md @@ -0,0 +1,565 @@ +# Design — Moteur de workflow "world" (SDK Vercel) pour ai-kit + +- **Date** : 2026-06-02 +- **Statut** : design validé (sections 1–3), en attente de relecture finale +- **Auteur** : Killian + Claude +- **Scope** : ajouter un second moteur d'exécution de workflows ("world", basé sur le Vercel Workflow SDK) à côté du moteur legacy en mémoire, via une façade ai-kit unifiée. Par défaut : legacy. + +--- + +## 1. Contexte & décisions + +### Deux moteurs distincts + +- **`legacy`** (défaut) : le moteur maison actuel dans `packages/core/src/workflows/` (`createWorkflow` → `WorkflowBuilder` → `Workflow.run()` / `WorkflowRun`). 100 % en mémoire, aucune persistance. +- **`world`** : le **Vercel Workflow SDK** (package `workflow`) avec un backend "world" durable : **Postgres** (`@workflow/world-postgres`, officiel) ou **MongoDB** (`@workflow-worlds/mongodb`, communautaire — **expérimental**). + +### Décisions actées (brainstorming) + +| Décision | Choix | Raison | +|---|---|---| +| Qui exécute le moteur world | Embarquer le **vrai SDK Vercel** | Durabilité production gratuite (runs/events/steps persistés, file de jobs, replay) | +| Bases supportées en v1 | **Postgres + MongoDB** | Couvre self-hosted SQL et NoSQL ; Mongo marqué expérimental | +| Où vivent les deps lourdes | **Nouveau package optionnel** `@ai_kit/workflow-world` | `@ai_kit/core` reste léger ; aucun user legacy ne tire les deps Vercel | +| Portée de la façade | **Façade fine unifiée** (config + `start/stop` + `run` qui délègue) | Faible couplage ; l'écriture des workflows reste native par moteur | +| Moteur par défaut | **`legacy`** | Aucune rupture pour l'existant | +| Écriture des steps world | **Helper typé fin** `defineWorldStep` / `defineWorldWorkflow` (option A) | Shape proche de `createStep` + typage, **sans** posséder de compilateur. La directive `"use step"` reste obligatoire dans le corps (cf. §7.1) | + +### Contrainte dure à connaître + +Le SDK Vercel **exige une étape de build** (Nitro + rollup, module `workflow/nitro`) pour compiler les fonctions `"use workflow"` / `"use step"`, **et** un **worker long-vivant** qui poll la base (incompatible serverless pur). ai-kit peut **lisser la configuration runtime** (sélection du world, démarrage du worker, délégation du `start`), mais **ne peut pas masquer l'étape de build Nitro** : l'app hôte qui veut le moteur world doit l'adopter. Voir §5. + +--- + +## 2. Architecture & dépendances + +``` +packages/ + core/ @ai_kit/core — inchangé pour les users legacy + src/workflows/ moteur legacy (en mémoire) — INTACT + src/workflows/kit/ + WorkflowKit.ts NOUVEAU : la façade + types.ts NOUVEAU : WorkflowKitOptions, WorldConfig, WorldEngineAdapter, WorldRunHandle + index.ts NOUVEAU : ré-exports + workflow-world/ @ai_kit/workflow-world — NOUVEAU package optionnel + src/ + adapter.ts createWorldAdapter(cfg) : implémente WorldEngineAdapter + worlds.ts mapping type → package/env (postgres | mongodb) + authoring.ts NOUVEAU : defineWorldStep / defineWorldWorkflow (helpers typés, cf. §7.1) + index.ts +``` + +### Sens des dépendances (aucun cycle runtime) + +``` +@ai_kit/core + └─ optionalDependencies + peerDependencies → @ai_kit/workflow-world (chargé par import() dynamique uniquement si engine:'world') + +@ai_kit/workflow-world + ├─ dependencies → workflow, @workflow/world-postgres, @workflow-worlds/mongodb + ├─ peerDependencies → nitro, rollup (build : fournis par l'app hôte) + └─ peerDependencies → @ai_kit/core (import type uniquement → effacé au build) +``` + +- Un user legacy `pnpm add @ai_kit/core` → **zéro** dépendance Vercel installée. +- Un user world ajoute `pnpm add @ai_kit/workflow-world`. +- La façade référence le contrat d'adapter par `import type` (effacé au build) et charge l'implémentation par `await import('@ai_kit/workflow-world')` à l'exécution → pas de cycle, pas de coût pour legacy. + +--- + +## 3. La façade `WorkflowKit` (classe ai-kit générale) + +Vit dans `@ai_kit/core`, exportée depuis l'index public. Nom calqué sur la convention `XxxKit` (`ServerKit`, `client-kit`). + +### Types + +```ts +export type WorkflowEngine = 'legacy' | 'world'; + +export interface WorldConfig { + type: 'postgres' | 'mongodb'; + url: string; // connection string + jobPrefix?: string; // postgres : namespacing des jobs si DB partagée + workerConcurrency?: number; // postgres : workers concurrents (défaut SDK : 50) + maxPoolSize?: number; // postgres : taille du pool (défaut SDK : 10) +} + +export interface WorkflowKitOptions { + engine?: WorkflowEngine; // défaut : 'legacy' + world?: WorldConfig; // requis si engine === 'world' +} + +// handle opaque renvoyé par le moteur world (pass-through du SDK Vercel) +export interface WorldRunHandle { /* shape du SDK, typée au plus près à l'implémentation */ } + +// contrat implémenté par @ai_kit/workflow-world +export interface WorldEngineAdapter { + start(): Promise; + stop(): Promise; + run(workflow: (...args: any[]) => unknown, args: unknown[]): Promise; +} +``` + +### API + +```ts +import { WorkflowKit } from '@ai_kit/core'; + +const kit = new WorkflowKit({ + engine: 'legacy', // défaut — peut être omis + world: { type: 'postgres', url: process.env.WORKFLOW_DB_URL! }, +}); + +await kit.start(); // legacy : no-op | world : set env → getWorld() → world.start() (démarre le worker) + +// --- engine 'legacy' : wf = Workflow ai-kit (createWorkflow().commit()) --- +const result = await kit.run(myLegacyWorkflow, { inputData }); // → Workflow.run(options) + +// --- engine 'world' : wf = fonction "use workflow", input = tableau d'args --- +const handle = await kit.run(myWorldWorkflow, [orderId]); // → start(fn, args) de workflow/api + +await kit.stop(); // legacy : no-op | world : arrêt propre du worker +``` + +### Comportement + +- **Dispatch par overloads typés** sur le moteur configuré. Override possible par appel : `kit.run(wf, input, { engine: 'world' })`. + - `legacy` → `Workflow.run(options)` existant ; renvoie `WorkflowRunResult`. + - `world` → charge `@ai_kit/workflow-world` en lazy, appelle `createWorldAdapter(world).run(fn, args)` qui délègue à `start()` de `workflow/api` ; renvoie le `WorldRunHandle` (pass-through léger). +- **Lifecycle unifié** : `start()` / `stop()` sont des no-op en legacy → même code des deux côtés. En world, ils pilotent le worker long-vivant. +- **Validation de config** (constructeur) : + - `engine: 'world'` sans `world` → throw explicite. + - `world.type` inconnu → throw. + - `engine: 'legacy'` avec un `world` fourni → autorisé (permet de basculer par env sans réécrire la config). + +### Gotcha d'ordre des variables d'environnement + +Le runtime Vercel résout le world depuis les env (`WORKFLOW_TARGET_WORLD`, `WORKFLOW_POSTGRES_URL`, …) **au premier import** de `workflow/runtime`. Conséquence : + +- La sélection du world (`WORKFLOW_TARGET_WORLD`) doit idéalement venir du **`.env` / env du process** posé au démarrage, **avant** tout import de `workflow`. +- `WorkflowKit.start()` pose aussi ces variables **défensivement** depuis la config avant d'importer le runtime, mais l'app hôte importe `sleep`/`start` depuis `workflow` dans ses fichiers de workflow (chargés tôt). Recommandation : **env file canonique pour la sélection du world**, façade pour le tuning programmatique. Documenté dans le guide d'usage. + +--- + +## 4. Le contrat d'adapter + +`@ai_kit/core` définit l'interface `WorldEngineAdapter` (types) ; `@ai_kit/workflow-world` l'implémente. C'est la couture qui garde core découplé du SDK Vercel. + +```ts +// @ai_kit/workflow-world +import type { WorldConfig, WorldEngineAdapter } from '@ai_kit/core'; + +export function createWorldAdapter(cfg: WorldConfig): WorldEngineAdapter { + return { + async start() { + applyWorldEnv(cfg); // pose WORKFLOW_TARGET_WORLD + URL/tuning + const { getWorld } = await import('workflow/runtime'); + const world = await getWorld(); + await world.start?.(); + }, + async stop() { /* world.stop?.() si dispo */ }, + async run(fn, args) { + const { start } = await import('workflow/api'); + return start(fn, args); + }, + }; +} +``` + +### Mapping `type` → package / env (table interne `worlds.ts`) + +| `type` | Package | `WORKFLOW_TARGET_WORLD` | Connexion | Maturité | +|---|---|---|---|---| +| `postgres` | `@workflow/world-postgres` | `@workflow/world-postgres` | `WORKFLOW_POSTGRES_URL` (+ `WORKFLOW_POSTGRES_JOB_PREFIX`, `WORKFLOW_POSTGRES_WORKER_CONCURRENCY`, `WORKFLOW_POSTGRES_MAX_POOL_SIZE`) | ✅ officiel | +| `mongodb` | `@workflow-worlds/mongodb` | `@workflow-worlds/mongodb` | env Mongo (driver natif) | ⚠️ communautaire / expérimental | + +> ⚠️ Les chemins d'import exacts (`workflow/runtime`, `workflow/api`, `getWorld`, signature de `start`, API `world.start/stop`) et les env Mongo doivent être **confirmés contre la doc embarquée de la version installée** (`node_modules/workflow/docs/` via la commande `/workflow`) au moment de l'implémentation. Ce design fige l'architecture, pas les signatures exactes. + +--- + +## 5. Responsabilités & frontières (ai-kit vs app hôte) + +| Responsabilité | Qui | +|---|---| +| Choisir le moteur (`legacy`/`world`), tenir la config | `WorkflowKit` (ai-kit) | +| Sélectionner + démarrer/arrêter le world (worker) | `WorkflowKit.start/stop` + adapter (ai-kit) | +| Déléguer le lancement d'un run | `WorkflowKit.run` (ai-kit) | +| **Étape de build Nitro/rollup** (compiler `"use workflow"`) | **App hôte** (ai-kit ne peut pas la masquer) | +| Définir les fonctions `"use workflow"` / `"use step"` | App hôte (écriture native) | +| Exposer les routes/handlers qui appellent `kit.run` | App hôte | +| Faire tourner un process long-vivant | App hôte (infra) | + +ai-kit fournit en plus : **doc + snippets** de la config Nitro à coller dans l'app hôte (cf. guide getting-started Vercel par framework). + +--- + +## 6. Façons d'utiliser (exemples de code complets) + +Tous les exemples sont end-to-end (fichiers réels, imports inclus). Les imports `workflow` / `workflow/api` sont conformes à la doc Vercel vérifiée ; les signatures exactes restent à confirmer (§12). + +### A. Legacy seul (défaut, zéro nouvelle dépendance) + +`workflows/order.legacy.ts` — définition + lancement, comme aujourd'hui mais via la façade : + +```ts +import { WorkflowKit, createWorkflow, createStep } from '@ai_kit/core'; + +const fetchOrder = createStep({ + id: 'fetchOrder', + handler: async ({ inputData }) => ({ id: inputData.id, total: 4200 }), +}); +const charge = createStep({ + id: 'charge', + handler: async ({ inputData }) => ({ ...inputData, chargeId: 'ch_1' }), +}); + +export const orderWorkflow = createWorkflow({ id: 'order' }) + .then(fetchOrder) + .then(charge) + .commit(); + +// --- lancement --- +const kit = new WorkflowKit(); // engine: 'legacy' (défaut) +const result = await kit.run(orderWorkflow, { inputData: { id: 'o_123' } }); +console.log(result.status, result.result); // 'success' { id, total, chargeId } +``` + +> En legacy, `kit.start()` / `kit.stop()` sont des no-op : on peut les appeler pour garder le même code que le mode world, ou les omettre. + +### B. World Postgres (self-hosted) — exemple end-to-end + +**1. Installation** (dans l'app hôte) : + +```bash +pnpm add @ai_kit/core @ai_kit/workflow-world workflow @workflow/world-postgres +pnpm add -D nitro rollup +``` + +**2. `.env`** — sélection du world (canonique, posée avant tout import `workflow`) : + +```bash +WORKFLOW_ENGINE=world +WORKFLOW_TARGET_WORLD=@workflow/world-postgres +WORKFLOW_POSTGRES_URL=postgres://world:world@localhost:5432/world +WORKFLOW_POSTGRES_WORKER_CONCURRENCY=50 +``` + +**3. `nitro.config.ts`** — l'étape de build qui compile les `"use workflow"` (à la charge de l'app hôte, cf. §5) : + +```ts +import { defineNitroConfig } from 'nitro/config'; + +export default defineNitroConfig({ + modules: ['workflow/nitro'], + routes: { '/**': { handler: './src/index.ts', format: 'node' } }, +}); +``` + +**4. `src/workflows/signup.ts`** — workflow + steps en style Vercel : + +```ts +import { sleep, FatalError } from 'workflow'; + +export async function handleUserSignup(email: string) { + "use workflow"; // corps déterministe + const user = await createUser(email); // chaque await = point durable + await sendWelcomeEmail(user); + await sleep('5s'); + return { userId: user.id }; +} + +async function createUser(email: string) { + "use step"; // runtime Node complet, retry auto + if (!email.includes('@')) throw new FatalError('email invalide'); + return { id: crypto.randomUUID(), email }; +} + +async function sendWelcomeEmail(user: { id: string; email: string }) { + "use step"; + // appel SMTP/API réel ici + return { sent: true }; +} +``` + +**5. `src/index.ts`** — démarrage du world + serveur Hono (stack ai-kit) + arrêt propre : + +```ts +import { serve } from '@hono/node-server'; +import { Hono } from 'hono'; +import { WorkflowKit } from '@ai_kit/core'; +import { handleUserSignup } from './workflows/signup.js'; + +const kit = new WorkflowKit({ + engine: 'world', + world: { type: 'postgres', url: process.env.WORKFLOW_POSTGRES_URL!, workerConcurrency: 50 }, +}); + +await kit.start(); // démarre le worker graphile (poll Postgres) + +const app = new Hono(); +app.post('/api/signup', async (c) => { + const { email } = await c.req.json(); + const handle = await kit.run(handleUserSignup, [email]); // → start(fn, args) + return c.json({ message: 'signup workflow started', runId: handle.runId }); +}); + +const server = serve({ fetch: app.fetch, port: 3000 }); +process.on('SIGTERM', async () => { await kit.stop(); server.close(); }); // arrêt propre du worker +``` + +**6. Lancer & vérifier** : + +```bash +nitro dev +curl -X POST --json '{"email":"hello@example.com"}' http://localhost:3000/api/signup +npx workflow web # dashboard d'observabilité des runs +``` + +### C. World MongoDB (expérimental) — seule la config change + +Aucune autre ligne de code applicatif ne bouge par rapport à B : + +```bash +# .env +WORKFLOW_TARGET_WORLD=@workflow-worlds/mongodb +WORKFLOW_MONGO_URL=mongodb://localhost:27017/world +``` + +```ts +const kit = new WorkflowKit({ + engine: 'world', + world: { type: 'mongodb', url: process.env.WORKFLOW_MONGO_URL! }, +}); +await kit.start(); +``` + +### D. Basculer de moteur par configuration (un seul code) + +```ts +import { WorkflowKit } from '@ai_kit/core'; + +export const kit = new WorkflowKit({ + engine: (process.env.WORKFLOW_ENGINE as 'legacy' | 'world') ?? 'legacy', + world: { type: 'postgres', url: process.env.WORKFLOW_POSTGRES_URL ?? '' }, +}); +await kit.start(); // no-op en legacy, démarre le worker en world +``` + +→ dev local en `legacy` (rapide, sans infra), prod en `world` (durable) en changeant **une seule** variable d'env. + +### E. Même logique métier, deux moteurs (factorisation) + +Le SDK Vercel ne sait pas exécuter un `Workflow` ai-kit : on garde deux écritures, mais on **factorise la logique métier** dans des fonctions pures réutilisées des deux côtés. La façade unifie le **lancement**, pas l'écriture. + +`domain/payment.ts` — logique pure, sans dépendance moteur : + +```ts +export async function chargePayment(order: { id: string; total: number }) { + // appel Stripe réel, déterminé par les args — réutilisable partout + return { chargeId: `ch_${order.id}`, amount: order.total }; +} +``` + +Côté **world**, via les helpers `defineWorldWorkflow` / `defineWorldStep` (option A — shape proche de `createStep`, la directive reste dans le corps) : + +```ts +import { defineWorldWorkflow, defineWorldStep } from '@ai_kit/workflow-world'; +import { chargePayment } from '../domain/payment.js'; +import type { Order } from '../domain/payment.js'; + +const chargeStep = defineWorldStep('charge', async (order: Order) => { + "use step"; // <- incompressible (compilo build-time) + return chargePayment(order); // <- même logique que le legacy +}); + +export const paymentWorkflow = defineWorldWorkflow('payment', async (order: Order) => { + "use workflow"; + return await chargeStep(order); +}); +``` + +Côté **legacy** (`handler` qui enrobe la même logique pure) : + +```ts +import { createStep } from '@ai_kit/core'; +import { chargePayment } from '../domain/payment.js'; + +export const chargeStepLegacy = createStep({ + id: 'charge', + handler: async ({ inputData }) => chargePayment(inputData), // <- même logique +}); +``` + +--- + +## 7. Primitives de contrôle de flux : aucun "décorateur" à préparer + +Le moteur legacy expose le contrôle de flux via des **méthodes de builder** (DAG déclaratif). Le SDK Vercel n'a **aucun décorateur** : un workflow est une **fonction async** et le contrôle de flux est du **JavaScript natif** (vérifié dans le cookbook). + +| Besoin | Legacy (builder) | Vercel SDK (dans `"use workflow"`) | Prêt ? | +|---|---|---|---| +| Séquentiel | `.then(step)` | `await stepA(); await stepB();` | ✅ natif | +| Boucle | `.while({ condition })` | `while (cond) { ... }` / `for (...)` | ✅ natif | +| Itérer une collection | step `forEach` | `for (const x of list) { await step(x) }` | ✅ natif | +| Parallèle / fan-out | `.branchParallel()` | `await Promise.all(list.map(step))` | ✅ natif | +| Batch + isolation d'échec | (manuel) | `for(...) { await Promise.allSettled(batch.map(step)) }` | ✅ natif | +| Race / timeout | — | `await Promise.race([hook, sleep('24h')])` | ✅ natif | +| Condition / branche | `.conditions().then(branches)` | `if (...) {} else {}` / `switch` | ✅ natif | +| Human-in-the-loop | `.human()` + `resumeWithHumanInput` | `createWebhook()` **ou** `defineHook()` + `hook.create()` / `hook.resume()` | ✅ natif | +| Délai durable | — | `await sleep('30d')` | ✅ natif | +| Retry | (manuel dans le handler) | **auto** (max 3 essais par défaut) + `FatalError` (stop) / `RetryableError` (transitoire) | ✅ natif | + +**Conséquence** : ai-kit n'a **pas** à fournir/porter des décorateurs de boucle/parallèle pour le moteur world. La boucle, c'est `for`/`while`. Le travail réel est : (1) la façade + adapter, (2) la **documentation de migration** (déclaratif → impératif). + +### Règles de déterminisme (à respecter à l'écriture world) + +- Le **corps `"use workflow"` doit être déterministe** : pas de `Date.now()`, `Math.random()`, `fetch`, I/O directs → ces effets vont dans des fonctions `"use step"`. (Le compilo *seede* `Date`/`Math.random`/`crypto` dans ce contexte.) +- Les **steps** ont le runtime Node complet, sont retried, et leurs résultats sont persistés pour le replay. Args **passés par valeur**. + +### 7.1 Helpers d'écriture `defineWorldStep` / `defineWorldWorkflow` (décision : option A) + +**Pourquoi pas un décorateur.** Les directives `"use step"` / `"use workflow"` sont traitées **au build** par le compilateur `workflow/nitro` (rollup), qui **scanne statiquement** le source pour le littéral en première instruction du corps, puis transforme la fonction (seed des globals, bornes durables de replay, persistance). Un **décorateur est runtime** : il enrobe la fonction dans une closure et s'exécute trop tard → le compilo ne le voit pas et **ne transforme pas** la fonction (= pas de durabilité). Le package `workflow` n'expose d'ailleurs **aucune** API programmatique de step (`defineStep`/`@step` n'existent pas) — les directives sont l'unique mécanisme. La compatibilité d'écriture « méthode » totale exigerait un **codegen** (le traducteur écarté, cf. §11). + +**Ce que fournit le helper.** `defineWorldStep(id, fn)` et `defineWorldWorkflow(id, fn)` sont des **wrappers quasi-identité** : ils renvoient la fonction (pour que le compilo la voie telle quelle) et ajoutent du **typage I/O** + des **métadonnées ai-kit** (id pour logs/observabilité). La directive `"use step"` **reste une ligne du corps** — c'est incompressible. + +```ts +export const charge = defineWorldStep('charge', async (order: Order): Promise => { + "use step"; // obligatoire — le helper ne peut pas l'injecter + return chargePayment(order); +}); +``` + +**⚠️ Spike bloquant (cf. §12).** Tout repose sur le fait que le compilo Vercel **détecte la directive dans une arrow passée en argument** au helper. Les exemples officiels n'utilisent que des `export async function name()`. Trois issues possibles à valider **avant** de figer l'API : +1. **OK** → on livre `defineWorldStep`/`defineWorldWorkflow` comme ci-dessus. +2. **Le compilo n'accepte que les fonctions nommées top-level** → dégradation en **ergonomie type-only** : l'utilisateur écrit `export async function charge(...) { "use step"; ... }` et annote avec les **types** ai-kit (`WorldStep`), sans wrapper runtime. +3. **Échec total des helpers** → fallback **option B** (directives brutes + factorisation de la logique métier), déjà documenté. + +### 7.2 Couverture fonctionnelle (parité avec le SDK Vercel) + +Parce qu'on **embarque le vrai SDK** (option 1), le moteur `world` hérite de **100 % des fonctionnalités Vercel** — on ne réimplémente ni ne masque rien. + +| Domaine | Fonctionnalités | World | +|---|---|---| +| Exécution durable | replay après crash, persistance runs/steps/events | ✅ | +| Suspension | `sleep('30d')`, délais durables, timeouts | ✅ | +| Human-in-the-loop | `createWebhook`, `defineHook` + `resume`, hooks | ✅ | +| Parallèle / boucles | JS natif (`Promise.all/allSettled/race`, `for`) | ✅ | +| Erreurs / retries | retry auto, `FatalError`, `RetryableError` | ✅ | +| Streaming | `getWritable`, resumable streams, updates depuis tools | ✅ | +| AI / agents | `DurableAgent`, chat transport, message queueing, tools | ✅ | +| Observabilité | dashboard `npx workflow web`, `workflow inspect runs` | ✅ | + +**Nuances (à connaître) :** +1. **Façade fine ≠ moins de features.** Les API avancées (observer/streamer un run, reprendre un hook) ne transitent **pas** par `WorkflowKit` : on les utilise **directement** via `import { ... } from 'workflow'`. Décision « façade fine » — la pleine puissance est à un import près, pas masquée. +2. **La parité dépend du world.** Vrai sur **Postgres** (référence officielle). Sur **MongoDB** (communautaire, « no E2E test data »), certaines capacités (ex. streaming temps réel via NOTIFY/LISTEN) peuvent être moins complètes → **expérimental**. +3. **`legacy` ne gagne pas ces features** : la parité n'existe que sous `engine: 'world'`. +4. **Contraintes intrinsèques Vercel** persistent : build Nitro, worker long-vivant, déterminisme. Ce sont celles du SDK, pas d'ai-kit. + +--- + +## 8. Guide de migration : legacy → world + +La migration est une **réécriture déclaratif → impératif**, pas un remplacement de décorateurs. + +### Avant — moteur legacy (builder) + +```ts +import { createWorkflow, createStep } from '@ai_kit/core'; + +const fetchOrder = createStep({ id: 'fetchOrder', handler: async ({ inputData }) => getOrder(inputData.id) }); +const charge = createStep({ id: 'charge', handler: async ({ inputData }) => chargePayment(inputData) }); +const notify = createStep({ id: 'notify', handler: async ({ inputData }) => sendEmail(inputData) }); + +export const orderWorkflow = createWorkflow({ id: 'order' }) + .then(fetchOrder) + .then(charge) + .then(notify) + .commit(); + +// lancement +await orderWorkflow.run({ inputData: { id: 'o_123' } }); +``` + +### Après — moteur world (fonction + directives) + +```ts +import { FatalError } from 'workflow'; + +export async function orderWorkflow(orderId: string) { + "use workflow"; // corps déterministe + const order = await fetchOrder(orderId); // chaque await = point durable + const charged = await charge(order); + await notify(charged); + return { orderId, status: 'completed' }; +} + +async function fetchOrder(id: string) { "use step"; return getOrder(id); } +async function charge(order: Order) { "use step"; return chargePayment(order); } +async function notify(o: Charged) { "use step"; return sendEmail(o); } + +// lancement (via la façade, inchangé côté appelant) +await kit.run(orderWorkflow, ['o_123']); +``` + +### Table de correspondance des cas réels + +| Cas legacy | Réécriture world | +|---|---| +| `.while({ condition, step })` | `while (await condition()) { await step() }` | +| `forEach` (séquentiel) | `for (const x of items) { await step(x) }` | +| `forEach` (parallèle) | `await Promise.all(items.map(x => step(x)))` | +| `.branchParallel(id, cfg)` | `const [a, b] = await Promise.all([stepA(), stepB()])` | +| `.conditions(...).then({ a, b })` | `if (cond) return await branchA(); else return await branchB();` | +| `.human({ id, schema })` + `resumeWithHumanInput` | `const hook = approvalHook.create({ token }); const r = await Promise.race([hook, sleep('24h')])` + route `approvalHook.resume(token, payload)` | +| `handler({ inputData, ctx, store })` | step `"use step"` (args par valeur) + état via valeurs de retour / closures du workflow | +| retry maison | retry auto (max 3) ; `throw new FatalError()` pour stopper | + +### Checklist de migration (par workflow) + +1. Identifier les effets non déterministes → les isoler dans des `"use step"`. +2. Transformer le DAG builder en flux impératif (table ci-dessus). +3. Remplacer les steps human par `createWebhook` / `defineHook` + route de reprise. +4. Ajouter la config Nitro (§5) à l'app hôte. +5. Pointer `kit` sur `engine: 'world'` ; lancer via `kit.run`. +6. Vérifier replay/durabilité (kill du worker à mi-run → reprise). + +--- + +## 9. Gestion d'erreurs & retries + +- **World** : steps retried automatiquement (max 3 par défaut). `FatalError` → arrêt immédiat sans retry ; `RetryableError` → backoff sur erreurs transitoires (429, etc.). Réf : `/docs/foundations/errors-and-retries`. +- **Façade** : si `engine: 'world'` et `@ai_kit/workflow-world` non installé → erreur claire (« installez `@ai_kit/workflow-world` ») au `import()` dynamique. +- **Config** : erreurs de validation au constructeur (cf. §3). +- **Legacy** : comportement actuel inchangé. + +--- + +## 10. Stratégie de tests + +| Niveau | Quoi | Infra | +|---|---|---| +| Unit (core) | Validation de config `WorkflowKit`, dispatch d'overloads, no-op start/stop en legacy, lazy-import déclenché en world (mock de l'adapter) | aucune | +| Unit (workflow-world) | `worlds.ts` : mapping `type` → package/env correct | aucune | +| Intégration (workflow-world) | smoke d'un run réel : Postgres via Docker/testcontainers ; Mongo idem | Docker (opt-in via flag/env) | +| Non-régression | la suite legacy existante reste verte | aucune | + +- Les tests d'intégration world sont **opt-in** (skip si Docker absent) → pas de dépendance infra dans la CI standard. +- **CI** : la CI ne gate que `server` + `client-kit` (cf. mémoire projet). Garder les changements de `core` non régressifs ; le nouveau package n'entre pas dans le gate tant que ses tests d'intégration sont opt-in. + +--- + +## 11. Hors-scope / YAGNI + +- ❌ Façade riche (handles/events unifiés, human-in-the-loop normalisé entre moteurs) — explicitement écarté en brainstorming. +- ❌ Traducteur builder ai-kit → SDK Vercel — écarté (complexe, lossy). +- ❌ Masquer/automatiser le build Nitro de l'app hôte — impossible. +- ❌ World managé Vercel (`@workflow/world-vercel`) — hors besoin self-hosted (ajout trivial plus tard via le mapping). +- ❌ Mongo en "stable" — livré expérimental. + +## 12. Questions ouvertes (à confirmer à l'implémentation) + +0. **🔴 SPIKE BLOQUANT (à faire en tout premier)** : le compilo `workflow/nitro` détecte-t-il la directive `"use step"` / `"use workflow"` dans une **arrow function passée en argument** à `defineWorldStep`/`defineWorldWorkflow` ? Si non → dégrader en ergonomie type-only ou fallback option B (cf. §7.1). **Aucune autre tâche d'écriture world ne se fige avant ce verdict.** +1. Chemins/signatures exacts : `workflow/runtime#getWorld`, `workflow/api#start`, API `world.start/stop` (confirmer via `node_modules/workflow/docs/` / `/workflow`). +2. Variables d'env du world Mongo (`@workflow-worlds/mongodb`) — lire le README GitHub du projet. +3. Type précis du `WorldRunHandle` renvoyé par `start()` (pour typer le pass-through). +4. Le runtime accepte-t-il une **injection programmatique** d'instance world (`createWorld(...)`) en plus de la sélection par env ? Si oui, préférable à la manip d'env (§3 gotcha). From 5d1bd14cb2034228b2fd54754cec97962e0650e2 Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 17:45:57 +0200 Subject: [PATCH 02/21] docs(workflow-world): confirm Vercel SDK signatures from bundled docs Co-Authored-By: Claude Opus 4.8 (1M context) --- .../notes/2026-06-02-vercel-sdk-signatures.md | 275 ++++++++++++++++++ 1 file changed, 275 insertions(+) create mode 100644 docs/superpowers/notes/2026-06-02-vercel-sdk-signatures.md diff --git a/docs/superpowers/notes/2026-06-02-vercel-sdk-signatures.md b/docs/superpowers/notes/2026-06-02-vercel-sdk-signatures.md new file mode 100644 index 0000000..4d9eefa --- /dev/null +++ b/docs/superpowers/notes/2026-06-02-vercel-sdk-signatures.md @@ -0,0 +1,275 @@ +# Vercel Workflow SDK — Confirmed Signatures + +Spike project: `/tmp/world-spike` +Date: 2026-06-02 +Branch: `feat/workflow-world-engine` + +--- + +## Versions + +| Package | Installed version | +|---|---| +| `workflow` | 4.3.1 | +| `@workflow/world-postgres` | 4.1.4 | +| `@workflow-worlds/mongodb` | 0.2.1 | +| `nitro` | 3.0.260522-beta | +| `rollup` | 4.61.0 | + +Transitive packages confirmed relevant: +- `@workflow/core` 4.3.1 (re-exported by `workflow`) +- `@workflow/world` 4.1.0-beta.2 (base `World` interface) + +--- + +## Q1 — Import path and exact signature of `start` + +**Confirmed.** + +```typescript +import { start } from 'workflow/api'; +``` + +The `start` function is exported from `workflow/api`, which re-exports from +`@workflow/core/runtime`. Four overloads are declared +(`node_modules/.pnpm/@workflow+core@4.3.1/node_modules/@workflow/core/dist/runtime/start.d.ts`): + +```typescript +// Overload 1: with args + deploymentId +declare function start( + workflow: WorkflowFunction | WorkflowMetadata, + args: unknown[], + options: StartOptionsWithDeploymentId +): Promise>; + +// Overload 2: no args + deploymentId +declare function start( + workflow: WorkflowFunction<[], TResult> | WorkflowMetadata, + options: StartOptionsWithDeploymentId +): Promise>; + +// Overload 3: with args, no deploymentId (primary non-Vercel overload) +declare function start( + workflow: WorkflowFunction | WorkflowMetadata, + args: TArgs, + options?: StartOptionsWithoutDeploymentId +): Promise>; + +// Overload 4: no args, no deploymentId +declare function start( + workflow: WorkflowFunction<[], TResult> | WorkflowMetadata, + options?: StartOptionsWithoutDeploymentId +): Promise>; +``` + +Supporting types: + +```typescript +interface StartOptionsBase { + world?: World; // inject a specific world instance; if omitted, inferred from env + specVersion?: number; +} +interface StartOptionsWithDeploymentId extends StartOptionsBase { + deploymentId: 'latest' | (string & {}); +} +interface StartOptionsWithoutDeploymentId extends StartOptionsBase { + deploymentId?: undefined; +} +type StartOptions = StartOptionsWithDeploymentId | StartOptionsWithoutDeploymentId; + +type WorkflowFunction = (...args: TArgs) => Promise; +type WorkflowMetadata = { workflowId: string }; +``` + +--- + +## Q2 — Exact type returned by `start` (the "run handle") + +**Confirmed.** + +`start` returns `Promise>`. `Run` is a class defined in +`@workflow/core/dist/runtime/run.d.ts`: + +```typescript +class Run { + runId: string; // ← confirmed: property is 'runId' + + // Lifecycle + wakeUp(options?: StopSleepOptions): Promise; + cancel(): Promise; + + // Getters (lazy-resolved promises) + get exists(): Promise; + get status(): Promise; + get returnValue(): Promise; + get workflowName(): Promise; + get createdAt(): Promise; + get startedAt(): Promise; + get completedAt(): Promise; + get readable(): WorkflowReadableStream; + + // Explicit streaming + getReadable(options?: WorkflowReadableStreamOptions): WorkflowReadableStream; +} +``` + +`WorkflowRunStatus` is `'pending' | 'running' | 'completed' | 'failed' | 'cancelled'`. + +Key notes: +- The handle property is `runId` (string), not `id` or `run_id`. +- `Run` is also exported from `workflow/api` (re-exported from `@workflow/core/runtime`). +- `getRun(runId: string): Run` is available in both `workflow/api` + and `workflow/runtime` to reconstitute a handle from a stored ID. + +--- + +## Q3 — Postgres world: `createWorld` signature and lifecycle methods + +**Confirmed.** + +```typescript +import { createWorld } from '@workflow/world-postgres'; +``` + +Source: `@workflow/world-postgres/dist/index.d.ts` and `config.d.ts`. + +```typescript +function createWorld(config?: PostgresWorldConfig): World & { + start(): Promise; +}; + +type PostgresWorldConfig = + | { + connectionString: string; // reads WORKFLOW_POSTGRES_URL if omitted; default 'postgres://world:world@localhost:5432/world' + maxPoolSize?: number; // reads WORKFLOW_POSTGRES_MAX_POOL_SIZE; default 10 + pool?: undefined; + } + | { + pool: Pool; // pass an existing pg.Pool; close() will NOT end it + connectionString?: undefined; + maxPoolSize?: undefined; + } + & { + jobPrefix?: string; // reads WORKFLOW_POSTGRES_JOB_PREFIX + queueConcurrency?: number; // default 10; reads WORKFLOW_POSTGRES_WORKER_CONCURRENCY + streamFlushIntervalMs?: number; // default 10ms; set to 0 for immediate flushing + }; +``` + +**Lifecycle methods on the returned object:** + +- `start(): Promise` — CONFIRMED (on the return type of `createWorld`; starts the graphile-worker queue). +- `close(): Promise` — CONFIRMED as optional on the `World` interface (per `building-a-world.mdx` doc and `queue.d.ts`). NOT on the top-level `createWorld` return type declaration, but the internal `PostgresQueue` type (used by the queue sub-object) does expose `close()`. +- `stop()` — NOT PRESENT. No `stop` method exists anywhere in the postgres world types. +- `shutdown()` — NOT PRESENT. No `shutdown` method exists anywhere in the postgres world types. + +Summary of lifecycle: call `world.start()` once at server startup. To gracefully shut down, call `world.close?.()` (optional, not on the public declared return type but present at runtime via the base `World` interface optional method). + +**Design assumption correction:** The assumed shape `{ connectionString, jobPrefix, queueConcurrency, maxPoolSize }` is correct but incomplete — `pool` (mutually exclusive with `connectionString`) and `streamFlushIntervalMs` also exist. + +--- + +## Q4 — MongoDB world: package name, `createWorld` signature, environment variables + +**Confirmed.** + +Package name: `@workflow-worlds/mongodb` (note: scope is `@workflow-worlds`, not `@workflow`). + +```typescript +import { createWorld } from '@workflow-worlds/mongodb'; +// or +import createWorld from '@workflow-worlds/mongodb'; // default export also available +``` + +Signature: + +```typescript +function createWorld(config?: MongoDBWorldConfig): World; + +interface MongoDBWorldConfig { + mongoUrl?: string; // env: WORKFLOW_MONGODB_URI; default 'mongodb://localhost:27017' + databaseName?: string; // env: WORKFLOW_MONGODB_DATABASE_NAME; default 'workflow' + baseUrl?: string; // env: WORKFLOW_SERVICE_URL; base URL for HTTP callbacks (queue) + concurrency?: number; // env: WORKFLOW_CONCURRENCY; max concurrent processing; default 20 + useChangeStreams?: boolean; // env: WORKFLOW_MONGODB_CHANGE_STREAMS ('true'/'false'); default true + // MongoClient can also be injected directly (confirmed in streamer.d.ts: `client?: MongoClient`) +} +``` + +**CORRECTION vs design assumption:** The design provisionally uses `WORKFLOW_MONGO_URL` but the actual env var name is `WORKFLOW_MONGODB_URI`. This must be updated in the adapter env mapping. + +Full list of confirmed MongoDB environment variables: + +| Env var | Purpose | Default | +|---|---|---| +| `WORKFLOW_MONGODB_URI` | MongoDB connection string | `mongodb://localhost:27017` | +| `WORKFLOW_MONGODB_DATABASE_NAME` | Database name | `workflow` | +| `WORKFLOW_MONGODB_CHANGE_STREAMS` | Enable change streams (`'true'`/`'false'`) | `'true'` | +| `WORKFLOW_SERVICE_URL` | Base URL for HTTP callbacks | `http://localhost:{PORT}` | +| `WORKFLOW_CONCURRENCY` | Max concurrent message processing | `20` | + +Unlike the postgres world, the MongoDB `createWorld` returns a plain `World` (not `World & { start() }`). No explicit `start()` on the declared return type — the world connects lazily on first use. + +--- + +## Q5 — World selection: env-var-only vs explicit instance injection + +**Confirmed.** + +### Env-var-only approach (works, documented as primary path) + +Setting `WORKFLOW_TARGET_WORLD` to the package name is sufficient for `start()` and +`getWorld()` to use the correct world. The runtime's `createWorld()` (no-arg, from +`workflow/runtime`) reads `WORKFLOW_TARGET_WORLD` and auto-imports the package. + +For Postgres: +```bash +WORKFLOW_TARGET_WORLD="@workflow/world-postgres" +WORKFLOW_POSTGRES_URL="postgres://user:pass@host:5432/db" +``` + +For MongoDB: +```bash +WORKFLOW_TARGET_WORLD="@workflow-worlds/mongodb" +WORKFLOW_MONGODB_URI="mongodb://localhost:27017" +``` + +### Programmatic instance injection (also supported) + +You may also create a world instance yourself and inject it via `setWorld()`: + +```typescript +import { setWorld } from 'workflow/runtime'; +import { createWorld } from '@workflow/world-postgres'; + +const world = createWorld({ connectionString: process.env.WORKFLOW_POSTGRES_URL }); +setWorld(world); +``` + +Alternatively, pass `world` as an option directly to `start()`: + +```typescript +import { start } from 'workflow/api'; +const run = await start(myWorkflow, [arg1], { world }); +``` + +### `getWorld()` — CONFIRMED + +```typescript +import { getWorld } from 'workflow/runtime'; +// signature: () => World +const world = getWorld(); +``` + +No parameters; returns the singleton `World` (auto-created from env if not yet set). +Also re-exported from `@workflow/core/runtime`. + +`setWorld(world: World | undefined): void` resets the cached singleton (useful when env vars change). + +`getWorldHandlers()` also exists on `workflow/runtime` — returns only `Pick` for build-time use without env bindings. + +--- + +## Spike Directive-in-Arrow Placeholder + +_(Task 1.1 will fill this section with the `"use workflow"` directive placement findings.)_ From fb632af5c2e195a5e5bff66aa6413fc1f4bbc265 Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 17:51:16 +0200 Subject: [PATCH 03/21] spike(workflow-world): record directive-in-arrow detection verdict Co-Authored-By: Claude Opus 4.8 (1M context) --- .../notes/2026-06-02-vercel-sdk-signatures.md | 105 +++++++++++++++++- 1 file changed, 103 insertions(+), 2 deletions(-) diff --git a/docs/superpowers/notes/2026-06-02-vercel-sdk-signatures.md b/docs/superpowers/notes/2026-06-02-vercel-sdk-signatures.md index 4d9eefa..f8a1e44 100644 --- a/docs/superpowers/notes/2026-06-02-vercel-sdk-signatures.md +++ b/docs/superpowers/notes/2026-06-02-vercel-sdk-signatures.md @@ -270,6 +270,107 @@ Also re-exported from `@workflow/core/runtime`. --- -## Spike Directive-in-Arrow Placeholder +## Spike Directive-in-Arrow (Task 1.1) -_(Task 1.1 will fill this section with the `"use workflow"` directive placement findings.)_ +**VERDICT 2 — Named-only (more precisely: "top-level binding only").** + +An arrow function passed as an **argument to a call expression** (the `defineWorldStep('id', async () => { "use step" })` +"candidate" form) is **NOT** detected or transformed by the `workflow` compiler. The directive is silently left in the +function body and no durable primitive is emitted — meaning the step/workflow would run as **plain non-durable code**. + +We therefore **cannot** ship `defineWorldStep` / `defineWorldWorkflow` as runtime identity wrappers. +Ship **type-only ergonomics** instead (a `WorldStep` / `WorldWorkflow` type) and require users to write a +**top-level binding** with the directive inside the body, e.g.: + +```ts +// OK — top-level named function (canonical, all docs use this) +export async function charge(order: Order) { + "use step"; + return chargePayment(order); +} + +// ALSO OK — arrow/fn-expression bound DIRECTLY to a const (no wrapping call) +export const charge: WorldStep = async (order) => { + "use step"; + return chargePayment(order); +}; +``` + +### Where the transform actually lives + +- File-selection gate (`@workflow/builders/dist/transform-utils.js`) is a **pure source-text regex** on the directive + string (`useWorkflowPattern = /^\s*(['"])use workflow\1;?\s*$/m`) and is form-agnostic — so the file *is* picked up + for transformation regardless of function form. That gate is **not** what decides durability. +- The real AST transform is a compiled-Rust SWC plugin: `@workflow/swc-plugin/swc_plugin_workflow.wasm` (v4.1.1), + invoked by `@workflow/builders/dist/apply-swc-transform.js` via `@swc/core`'s `transform` with + `jsc.experimental.plugins = [[swcPluginPath, { mode, moduleSpecifier }]]` where `mode` is `'workflow'` or `'step'`. + This wasm decides what gets a durable boundary. + +### Method used: empirical run of the **real production transform** + +I invoked `applySwcTransform()` (the exact function the Nitro/rollup builders call) on control vs candidate forms and +inspected the emitted code + `workflowManifest`. A transformed step gets: the `"use step"` directive **stripped**, an +injected `import { registerStepFunction } from "workflow/internal/private"`, a `/**__internal_workflows{...}*/` manifest +comment, and a trailing `registerStepFunction("step//…", fn)` registration. A transformed workflow gets a +`fn.workflowId = "workflow//…"` assignment + `globalThis.__private_workflows.set(...)`. Untransformed code keeps the raw +directive and produces an empty `{}` manifest. + +Results (mode in parens): + +| Form | Transformed? | Evidence | +|---|---|---| +| `export async function f(){ "use step" }` (CONTROL) | **YES** | directive stripped, `registerStepFunction("step//./test//chargeControl", chargeControl)` emitted, manifest `{"steps":{...}}` | +| `export const f = async () => { "use step" }` (arrow bound directly to const) | **YES** | manifest `{"steps":{...}}`, `registerStepFunction("step//./test//chargeVar", chargeVar)` emitted | +| `const f = async () => { "use step" }; export { f }` (local then re-export) | **YES** | manifest populated, registration emitted | +| `obj = { async charge(){ "use step" } }` (object method) | **YES** | hoisted to `obj$charge`, `registerStepFunction("step//./t//obj/charge", obj$charge)` | +| **`export const f = defineWorldStep('id', async () => { "use step" })`** (CANDIDATE — arrow in wrapper call) | **NO** | directive left intact in body, **no** `registerStepFunction`, manifest `{}` | +| `export const a = wrap(async () => { "use step" })` (wrapper, single arg) | **NO** | directive intact, manifest `{}` | +| `register(async () => { "use step" })` (bare inline call arg) | **NO** | directive intact, manifest `{}` | +| `export const wf = defineWorldWorkflow('wf', async () => { "use workflow" })` (CANDIDATE workflow) | **NO** | no `.workflowId`, no `__private_workflows.set`, manifest `{}` | +| `export async function wf(){ "use workflow" }` (CONTROL workflow) | **YES** | `wf.workflowId = "workflow//…"`, `globalThis.__private_workflows.set(...)`, manifest populated | + +Verbatim CONTROL output (transformed): +```js +import { registerStepFunction } from "workflow/internal/private"; +/**__internal_workflows{"steps":{"test.ts":{"chargeControl":{"stepId":"step//./test//chargeControl"}}}}*/; +export async function chargeControl(order) { return order.amount; } +registerStepFunction("step//./test//chargeControl", chargeControl); +``` + +Verbatim CANDIDATE output (NOT transformed — directive survives, undurable): +```js +const defineWorldStep = (_id, fn)=>fn; +export const chargeCandidate = defineWorldStep('charge', async (order)=>{ + "use step"; // ← left in place, never stripped, never registered + return order.amount; +}); +// workflowManifest: {} +``` + +### Corroborating source/string evidence + +`strings` on `swc_plugin_workflow.wasm` shows the transform validates the **container form** of a directive and +enumerates the supported containers — none of which is "arrow inside a call argument": + +- `Class instance methods cannot be marked with "use workflow". Only static methods, functions, and object methods are supported.` +- `Functions marked with "use step" must be async functions` +- ` must be at the top of the <…>` / `"…" is not a supported directive` +- registration symbols: `registerStepFunction`, `workflow/internal/private`, `WORKFLOW_USE_STEP`, `__private_workflows`. + +(Note: `@workflow/builders/dist/workflows-extractor.js` *does* walk `ArrowFunctionExpression` in `buildFunctionMap`, but +that is only the **inspector graph** extractor — not the durability transform — so it is not evidence of durability.) + +### Why this is the safe verdict + +A runtime identity wrapper would compile cleanly, pass types, and *look* correct, but the step/workflow body would +execute as ordinary code with **zero durability / no replay boundary** — a silent correctness failure for users. The +deciding factor is purely syntactic: the directive-bearing function must be the initializer of a **top-level +declaration** (named `function`, or arrow/fn-expr bound directly to a `const`/`let`), an object method, or a static +method. Putting it inside a **call expression** (a wrapper) breaks detection. + +**Ship plan:** type-only ergonomics — export `WorldStep` / `WorldWorkflow` function types so users get +inference + a documented requirement to write the directive inside a top-level binding. No `defineWorldStep` runtime +wrapper. + +(Scratch project `/tmp/world-spike` used `workflow` 4.3.1 → `@workflow/swc-plugin` 4.1.1 / `@workflow/builders` 4.0.9, +`@swc/core` 1.15.3; cleaned up after the spike.) From ead848b93534f500dedf261e2c6d86132f96db20 Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 17:54:19 +0200 Subject: [PATCH 04/21] feat(workflow-world): scaffold optional package Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/workflow-world/package.json | 39 + packages/workflow-world/src/index.ts | 1 + packages/workflow-world/tsconfig.build.json | 20 + packages/workflow-world/tsconfig.json | 17 + pnpm-lock.yaml | 3763 ++++++++++++++++++- pnpm-workspace.yaml | 1 + 6 files changed, 3790 insertions(+), 51 deletions(-) create mode 100644 packages/workflow-world/package.json create mode 100644 packages/workflow-world/src/index.ts create mode 100644 packages/workflow-world/tsconfig.build.json create mode 100644 packages/workflow-world/tsconfig.json diff --git a/packages/workflow-world/package.json b/packages/workflow-world/package.json new file mode 100644 index 0000000..d66daa5 --- /dev/null +++ b/packages/workflow-world/package.json @@ -0,0 +1,39 @@ +{ + "name": "@ai_kit/workflow-world", + "version": "0.1.0", + "description": "Vercel Workflow SDK world engine adapter for AI Kit (self-hosted Postgres/MongoDB).", + "type": "module", + "main": "./dist/index.js", + "types": "./dist/index.d.ts", + "exports": { + ".": { + "import": "./dist/index.js", + "types": "./dist/index.d.ts" + } + }, + "files": ["dist"], + "scripts": { + "clean": "rm -rf dist tsconfig.build.tsbuildinfo", + "build": "pnpm run clean && tsc -p tsconfig.build.json", + "prepare": "pnpm run build", + "test": "vitest run" + }, + "keywords": ["ai", "workflow", "vercel", "world", "postgres", "mongodb"], + "license": "MIT", + "packageManager": "pnpm@10.15.0", + "publishConfig": { "access": "public" }, + "dependencies": { + "workflow": "^4.3.1", + "@workflow/world-postgres": "^4.1.4", + "@workflow-worlds/mongodb": "^0.2.1" + }, + "peerDependencies": { + "@ai_kit/core": ">=1.3.0 <2" + }, + "devDependencies": { + "@ai_kit/core": "workspace:*", + "@types/node": "^24.7.0", + "typescript": "^5.9.2", + "vitest": "^4.1.8" + } +} diff --git a/packages/workflow-world/src/index.ts b/packages/workflow-world/src/index.ts new file mode 100644 index 0000000..cb0ff5c --- /dev/null +++ b/packages/workflow-world/src/index.ts @@ -0,0 +1 @@ +export {}; diff --git a/packages/workflow-world/tsconfig.build.json b/packages/workflow-world/tsconfig.build.json new file mode 100644 index 0000000..daf719a --- /dev/null +++ b/packages/workflow-world/tsconfig.build.json @@ -0,0 +1,20 @@ +{ + "extends": "./tsconfig.json", + "compilerOptions": { + "composite": true, + "outDir": "./dist", + "rootDir": "./src", + "declaration": true, + "declarationMap": true, + "sourceMap": true, + "stripInternal": true + }, + "include": [ + "src" + ], + "exclude": [ + "tests", + "dist", + "**/*.test.ts" + ] +} diff --git a/packages/workflow-world/tsconfig.json b/packages/workflow-world/tsconfig.json new file mode 100644 index 0000000..9e820b8 --- /dev/null +++ b/packages/workflow-world/tsconfig.json @@ -0,0 +1,17 @@ +{ + "compilerOptions": { + "module": "NodeNext", + "moduleResolution": "NodeNext", + "target": "es2022", + "types": [ + "node", + "vitest/globals" + ], + "strict": true, + "esModuleInterop": true, + "skipLibCheck": true + }, + "include": [ + "src" + ] +} diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index c656e51..fa30c06 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -25,10 +25,10 @@ importers: version: 5.9.3 vite: specifier: ^7.3.5 - version: 7.3.5(@types/node@24.7.0)(tsx@4.20.6) + version: 7.3.5(@types/node@24.7.0)(jiti@2.7.0)(tsx@4.20.6) vitest: specifier: ^4.1.8 - version: 4.1.8(@opentelemetry/api@1.9.0)(@types/node@24.7.0)(vite@7.3.5(@types/node@24.7.0)(tsx@4.20.6)) + version: 4.1.8(@opentelemetry/api@1.9.0)(@types/node@24.7.0)(vite@7.3.5(@types/node@24.7.0)(jiti@2.7.0)(tsx@4.20.6)) packages/core: dependencies: @@ -89,10 +89,10 @@ importers: version: 5.9.3 vite: specifier: ^7.3.5 - version: 7.3.5(@types/node@24.7.0)(tsx@4.20.6) + version: 7.3.5(@types/node@24.7.0)(jiti@2.7.0)(tsx@4.20.6) vitest: specifier: ^4.1.8 - version: 4.1.8(@opentelemetry/api@1.9.0)(@types/node@24.7.0)(vite@7.3.5(@types/node@24.7.0)(tsx@4.20.6)) + version: 4.1.8(@opentelemetry/api@1.9.0)(@types/node@24.7.0)(vite@7.3.5(@types/node@24.7.0)(jiti@2.7.0)(tsx@4.20.6)) packages/create-ai-kit: dependencies: @@ -120,7 +120,7 @@ importers: version: 2.4.9 tsup: specifier: ^8.0.1 - version: 8.5.0(postcss@8.5.15)(tsx@4.20.6)(typescript@5.9.3) + version: 8.5.0(@swc/core@1.15.3)(jiti@2.7.0)(postcss@8.5.15)(tsx@4.20.6)(typescript@5.9.3) typescript: specifier: ^5.3.3 version: 5.9.3 @@ -176,10 +176,10 @@ importers: version: 5.9.3 vite: specifier: ^7.3.5 - version: 7.3.5(@types/node@24.7.0)(tsx@4.20.6) + version: 7.3.5(@types/node@24.7.0)(jiti@2.7.0)(tsx@4.20.6) vitest: specifier: ^4.1.8 - version: 4.1.8(@opentelemetry/api@1.9.0)(@types/node@24.7.0)(vite@7.3.5(@types/node@24.7.0)(tsx@4.20.6)) + version: 4.1.8(@opentelemetry/api@1.9.0)(@types/node@24.7.0)(vite@7.3.5(@types/node@24.7.0)(jiti@2.7.0)(tsx@4.20.6)) packages/server: dependencies: @@ -219,13 +219,38 @@ importers: version: 5.9.3 vite: specifier: ^7.3.5 - version: 7.3.5(@types/node@24.7.0)(tsx@4.20.6) + version: 7.3.5(@types/node@24.7.0)(jiti@2.7.0)(tsx@4.20.6) vitest: specifier: ^4.1.8 - version: 4.1.8(@opentelemetry/api@1.9.0)(@types/node@24.7.0)(vite@7.3.5(@types/node@24.7.0)(tsx@4.20.6)) + version: 4.1.8(@opentelemetry/api@1.9.0)(@types/node@24.7.0)(vite@7.3.5(@types/node@24.7.0)(jiti@2.7.0)(tsx@4.20.6)) packages/types: {} + packages/workflow-world: + dependencies: + '@workflow-worlds/mongodb': + specifier: ^0.2.1 + version: 0.2.1(socks@2.8.7) + '@workflow/world-postgres': + specifier: ^4.1.4 + version: 4.1.4(@cloudflare/workers-types@4.20251118.0)(@opentelemetry/api@1.9.0)(@types/pg@8.15.6)(better-sqlite3@12.10.0)(typescript@5.9.3) + workflow: + specifier: ^4.3.1 + version: 4.3.1(@nestjs/common@11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24(@nestjs/common@11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2))(reflect-metadata@0.2.2)(rxjs@7.8.2))(@opentelemetry/api@1.9.0)(@swc/cli@0.8.1(@swc/core@1.15.3)(chokidar@5.0.0))(@swc/core@1.15.3)(typescript@5.9.3) + devDependencies: + '@ai_kit/core': + specifier: workspace:* + version: link:../core + '@types/node': + specifier: ^24.7.0 + version: 24.12.4 + typescript: + specifier: ^5.9.2 + version: 5.9.3 + vitest: + specifier: ^4.1.8 + version: 4.1.8(@opentelemetry/api@1.9.0)(@types/node@24.12.4)(vite@7.3.5(@types/node@24.12.4)(jiti@2.7.0)(tsx@4.20.6)) + packages: '@ai-sdk/gateway@3.0.91': @@ -259,6 +284,55 @@ packages: '@anthropic-ai/sdk@0.40.1': resolution: {integrity: sha512-DJMWm8lTEM9Lk/MSFL+V+ugF7jKOn0M2Ujvb5fN8r2nY14aHbGPZ1k6sgjL+tpJ3VuOGJNG+4R83jEpOuYPv8w==} + '@aws-crypto/crc32@5.2.0': + resolution: {integrity: sha512-nLbCWqQNgUiwwtFsen1AdzAtvuLRsQS8rYgMuxCrdKf9kOssamGLuPwyTY9wyYblNr9+1XM8v6zoDTPPSIeANg==} + engines: {node: '>=16.0.0'} + + '@aws-crypto/sha256-browser@5.2.0': + resolution: {integrity: sha512-AXfN/lGotSQwu6HNcEsIASo7kWXZ5HYWvfOmSNKDsEqC4OashTp8alTmaz+F7TC2L083SFv5RdB+qU3Vs1kZqw==} + + '@aws-crypto/sha256-js@5.2.0': + resolution: {integrity: sha512-FFQQyu7edu4ufvIZ+OadFpHHOt+eSTBaYaki44c+akjg7qZg9oOQeLlk77F6tSYqjDAFClrHJk9tMf0HdVyOvA==} + engines: {node: '>=16.0.0'} + + '@aws-crypto/supports-web-crypto@5.2.0': + resolution: {integrity: sha512-iAvUotm021kM33eCdNfwIN//F77/IADDSs58i+MDaOqFrVjZo9bAal0NK7HurRuWLLpF1iLX7gbWrjHjeo+YFg==} + + '@aws-crypto/util@5.2.0': + resolution: {integrity: sha512-4RkU9EsI6ZpBve5fseQlGNUWKMa1RLPQ1dnjnQoe07ldfIzcsGb5hC5W0Dm7u423KWzawlrpbjXBrXCEv9zazQ==} + + '@aws-sdk/core@3.974.15': + resolution: {integrity: sha512-UpA0rTGW/tHGITcCqHisbuuEPraYg9GG+mWmXjY5+RxZBMLGe6aL9oe0ix50LztwAcPIkGZLH0yWdMIkCM10hw==} + engines: {node: '>=20.0.0'} + + '@aws-sdk/credential-provider-web-identity@3.972.13': + resolution: {integrity: sha512-a6iFMh1pgUH0TdcouBppLJUfPM7Yd3R9S1xFodPtCRoLqCz2RQFA3qjA8x4112PVYXEd4/pHX2eihapq39w0rA==} + engines: {node: '>=20.0.0'} + + '@aws-sdk/nested-clients@3.997.13': + resolution: {integrity: sha512-2pA6eyb5nSo/ZD2cayhOTEMoGQYgspq0RI05GDLkzQ3ajZ6isS6waV6E92Am/hz4LIlLUTrbwPLurJ/fuiHvkg==} + engines: {node: '>=20.0.0'} + + '@aws-sdk/signature-v4-multi-region@3.996.30': + resolution: {integrity: sha512-HULDLMVzkmTSEv6//7kx2kRevp/VYUpm8hJNNFbmhxDn0fUiGTxVcM9yg31TukvTq8nyOBDUN2gH0o5IRbKjdw==} + engines: {node: '>=20.0.0'} + + '@aws-sdk/types@3.973.9': + resolution: {integrity: sha512-kuBfgQVdcz5Bmapc4A13YbpVw/pXkesfhetcFYwbntqas8sF41OHyd4o28+/TG2ZQdHBsv90Lsu5y6oitvYCdg==} + engines: {node: '>=20.0.0'} + + '@aws-sdk/util-locate-window@3.965.5': + resolution: {integrity: sha512-WhlJNNINQB+9qtLtZJcpQdgZw3SCDCpXdUJP7cToGwHbCWCnRckGlc6Bx/OhWwIYFNAn+FIydY8SZ0QmVu3xTQ==} + engines: {node: '>=20.0.0'} + + '@aws-sdk/xml-builder@3.972.26': + resolution: {integrity: sha512-cDbrqvDS73whl6YAPSPq0U6whzG6UWI9PuWh0wrUuGoZexhWEqhdunbukV7iBoaWnFV1AODutM5hOD6rtn439g==} + engines: {node: '>=20.0.0'} + + '@aws/lambda-invoke-store@0.2.4': + resolution: {integrity: sha512-iY8yvjE0y651BixKNPgmv1WrQc+GZ142sb0z4gYnChDDY2YqI4P/jsSopBWrKfAt7LOJAkOXt7rC/hms+WclQQ==} + engines: {node: '>=18.0.0'} + '@azure/abort-controller@2.1.2': resolution: {integrity: sha512-nBrLsEWm4J2u5LpAPjxADTlq3trDgVZZXHNKabeXZtpq3d3AbN/KGO82R87rdDz5/lYB024rtEf10/q0urNgsA==} engines: {node: '>=18.0.0'} @@ -326,6 +400,39 @@ packages: resolution: {integrity: sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==} engines: {node: '>=6.9.0'} + '@borewit/text-codec@0.2.2': + resolution: {integrity: sha512-DDaRehssg1aNrH4+2hnj1B7vnUGEjU6OIlyRdkMd0aUdIUvKXrJfXsy8LVtXAy7DRvYVluWbMspsRhz2lcW0mQ==} + + '@cbor-extract/cbor-extract-darwin-arm64@2.2.2': + resolution: {integrity: sha512-ZKZ/F8US7JR92J4DMct6cLW/Y66o2K576+zjlEN/MevH70bFIsB10wkZEQPLzl2oNh2SMGy55xpJ9JoBRl5DOA==} + cpu: [arm64] + os: [darwin] + + '@cbor-extract/cbor-extract-darwin-x64@2.2.2': + resolution: {integrity: sha512-32b1mgc+P61Js+KW9VZv/c+xRw5EfmOcPx990JbCBSkYJFY0l25VinvyyWfl+3KjibQmAcYwmyzKF9J4DyKP/Q==} + cpu: [x64] + os: [darwin] + + '@cbor-extract/cbor-extract-linux-arm64@2.2.2': + resolution: {integrity: sha512-wfqgzqCAy/Vn8i6WVIh7qZd0DdBFaWBjPdB6ma+Wihcjv0gHqD/mw3ouVv7kbbUNrab6dKEx/w3xQZEdeXIlzg==} + cpu: [arm64] + os: [linux] + + '@cbor-extract/cbor-extract-linux-arm@2.2.2': + resolution: {integrity: sha512-tNg0za41TpQfkhWjptD+0gSD2fggMiDCSacuIeELyb2xZhr7PrhPe5h66Jc67B/5dmpIhI2QOUtv4SBsricyYQ==} + cpu: [arm] + os: [linux] + + '@cbor-extract/cbor-extract-linux-x64@2.2.2': + resolution: {integrity: sha512-rpiLnVEsqtPJ+mXTdx1rfz4RtUGYIUg2rUAZgd1KjiC1SehYUSkJN7Yh+aVfSjvCGtVP0/bfkQkXpPXKbmSUaA==} + cpu: [x64] + os: [linux] + + '@cbor-extract/cbor-extract-win32-x64@2.2.2': + resolution: {integrity: sha512-dI+9P7cfWxkTQ+oE+7Aa6onEn92PHgfWXZivjNheCRmTBDBf2fx6RyTi0cmgpYLnD1KLZK9ZYrMxaPZ4oiXhGA==} + cpu: [x64] + os: [win32] + '@cfworker/json-schema@4.1.1': resolution: {integrity: sha512-gAmrUZSGtKc3AiBL71iNWxDsyUC5uMaKKGdvzYsBoTW/xi42JQHl7eKV2OYzCUqvc+D2RCcf7EXY2iCyFIk6og==} @@ -653,6 +760,9 @@ packages: '@modelcontextprotocol/sdk': optional: true + '@graphile/logger@0.2.0': + resolution: {integrity: sha512-jjcWBokl9eb1gVJ85QmoaQ73CQ52xAaOCF29ukRbYNl6lY+ts0ErTaDYOBlejcbUs2OpaiqYLO5uDhyLFzWw4w==} + '@hono/node-server@1.19.14': resolution: {integrity: sha512-GwtvgtXxnWsucXvbQXkRgqksiH2Qed37H9xHZocE5sA3N8O8O8/8FA3uclQXxXVzc9XBZuEOMK7+r02FmSpHtw==} engines: {node: '>=18.14.1'} @@ -683,6 +793,9 @@ packages: '@jridgewell/gen-mapping@0.3.13': resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==} + '@jridgewell/remapping@2.3.5': + resolution: {integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==} + '@jridgewell/resolve-uri@3.1.2': resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} engines: {node: '>=6.0.0'} @@ -693,6 +806,9 @@ packages: '@jridgewell/trace-mapping@0.3.31': resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==} + '@keyv/serialize@1.1.1': + resolution: {integrity: sha512-dXn3FZhPv0US+7dtJsIi2R+c7qWYiReoEh5zUntWCf4oSpMNib8FDhSoed6m3QyZdx5hK7iLFkYk3rNxwt8vTA==} + '@langchain/core@1.1.48': resolution: {integrity: sha512-fQU6Guyb1pwc2fEplmA8FPbKfOMAofjnyJzExevro0FxEiuGHE18Ov/ZHmT9trWCDTZRI9eW1VIc6aChxV8pAQ==} engines: {node: '>=20'} @@ -711,6 +827,10 @@ packages: '@opentelemetry/exporter-trace-otlp-http': '>=0.202.0 <1.0.0' '@opentelemetry/sdk-trace-base': ^2.0.1 + '@lukeed/csprng@1.1.0': + resolution: {integrity: sha512-Z7C/xXCiGWsg0KuKsHTKJxbWhpI3Vs5GwLfOean7MGyVFGqdRgBbAjOCh6u4bbjPc/8MJ2pZmK/0DLdCbivLDA==} + engines: {node: '>=8'} + '@mistralai/mistralai@1.10.0': resolution: {integrity: sha512-tdIgWs4Le8vpvPiUEWne6tK0qbVc+jMenujnvTqOjogrJUsCSQhus0tHTU1avDDh5//Rq2dFgP9mWRAdIEoBqg==} @@ -727,6 +847,163 @@ packages: '@mongodb-js/saslprep@1.4.11': resolution: {integrity: sha512-o9rAHc0IpIjuPSxRutWpE1F62x7n+4mVS4rCNHkzhIUMQcc18bb6xEq5wd2NdN0WjepIyXIppRshYI2kQDOZVA==} + '@napi-rs/nice-android-arm-eabi@1.1.1': + resolution: {integrity: sha512-kjirL3N6TnRPv5iuHw36wnucNqXAO46dzK9oPb0wj076R5Xm8PfUVA9nAFB5ZNMmfJQJVKACAPd/Z2KYMppthw==} + engines: {node: '>= 10'} + cpu: [arm] + os: [android] + + '@napi-rs/nice-android-arm64@1.1.1': + resolution: {integrity: sha512-blG0i7dXgbInN5urONoUCNf+DUEAavRffrO7fZSeoRMJc5qD+BJeNcpr54msPF6qfDD6kzs9AQJogZvT2KD5nw==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [android] + + '@napi-rs/nice-darwin-arm64@1.1.1': + resolution: {integrity: sha512-s/E7w45NaLqTGuOjC2p96pct4jRfo61xb9bU1unM/MJ/RFkKlJyJDx7OJI/O0ll/hrfpqKopuAFDV8yo0hfT7A==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [darwin] + + '@napi-rs/nice-darwin-x64@1.1.1': + resolution: {integrity: sha512-dGoEBnVpsdcC+oHHmW1LRK5eiyzLwdgNQq3BmZIav+9/5WTZwBYX7r5ZkQC07Nxd3KHOCkgbHSh4wPkH1N1LiQ==} + engines: {node: '>= 10'} + cpu: [x64] + os: [darwin] + + '@napi-rs/nice-freebsd-x64@1.1.1': + resolution: {integrity: sha512-kHv4kEHAylMYmlNwcQcDtXjklYp4FCf0b05E+0h6nDHsZ+F0bDe04U/tXNOqrx5CmIAth4vwfkjjUmp4c4JktQ==} + engines: {node: '>= 10'} + cpu: [x64] + os: [freebsd] + + '@napi-rs/nice-linux-arm-gnueabihf@1.1.1': + resolution: {integrity: sha512-E1t7K0efyKXZDoZg1LzCOLxgolxV58HCkaEkEvIYQx12ht2pa8hoBo+4OB3qh7e+QiBlp1SRf+voWUZFxyhyqg==} + engines: {node: '>= 10'} + cpu: [arm] + os: [linux] + + '@napi-rs/nice-linux-arm64-gnu@1.1.1': + resolution: {integrity: sha512-CIKLA12DTIZlmTaaKhQP88R3Xao+gyJxNWEn04wZwC2wmRapNnxCUZkVwggInMJvtVElA+D4ZzOU5sX4jV+SmQ==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [linux] + + '@napi-rs/nice-linux-arm64-musl@1.1.1': + resolution: {integrity: sha512-+2Rzdb3nTIYZ0YJF43qf2twhqOCkiSrHx2Pg6DJaCPYhhaxbLcdlV8hCRMHghQ+EtZQWGNcS2xF4KxBhSGeutg==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [linux] + + '@napi-rs/nice-linux-ppc64-gnu@1.1.1': + resolution: {integrity: sha512-4FS8oc0GeHpwvv4tKciKkw3Y4jKsL7FRhaOeiPei0X9T4Jd619wHNe4xCLmN2EMgZoeGg+Q7GY7BsvwKpL22Tg==} + engines: {node: '>= 10'} + cpu: [ppc64] + os: [linux] + + '@napi-rs/nice-linux-riscv64-gnu@1.1.1': + resolution: {integrity: sha512-HU0nw9uD4FO/oGCCk409tCi5IzIZpH2agE6nN4fqpwVlCn5BOq0MS1dXGjXaG17JaAvrlpV5ZeyZwSon10XOXw==} + engines: {node: '>= 10'} + cpu: [riscv64] + os: [linux] + + '@napi-rs/nice-linux-s390x-gnu@1.1.1': + resolution: {integrity: sha512-2YqKJWWl24EwrX0DzCQgPLKQBxYDdBxOHot1KWEq7aY2uYeX+Uvtv4I8xFVVygJDgf6/92h9N3Y43WPx8+PAgQ==} + engines: {node: '>= 10'} + cpu: [s390x] + os: [linux] + + '@napi-rs/nice-linux-x64-gnu@1.1.1': + resolution: {integrity: sha512-/gaNz3R92t+dcrfCw/96pDopcmec7oCcAQ3l/M+Zxr82KT4DljD37CpgrnXV+pJC263JkW572pdbP3hP+KjcIg==} + engines: {node: '>= 10'} + cpu: [x64] + os: [linux] + + '@napi-rs/nice-linux-x64-musl@1.1.1': + resolution: {integrity: sha512-xScCGnyj/oppsNPMnevsBe3pvNaoK7FGvMjT35riz9YdhB2WtTG47ZlbxtOLpjeO9SqqQ2J2igCmz6IJOD5JYw==} + engines: {node: '>= 10'} + cpu: [x64] + os: [linux] + + '@napi-rs/nice-openharmony-arm64@1.1.1': + resolution: {integrity: sha512-6uJPRVwVCLDeoOaNyeiW0gp2kFIM4r7PL2MczdZQHkFi9gVlgm+Vn+V6nTWRcu856mJ2WjYJiumEajfSm7arPQ==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [openharmony] + + '@napi-rs/nice-win32-arm64-msvc@1.1.1': + resolution: {integrity: sha512-uoTb4eAvM5B2aj/z8j+Nv8OttPf2m+HVx3UjA5jcFxASvNhQriyCQF1OB1lHL43ZhW+VwZlgvjmP5qF3+59atA==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [win32] + + '@napi-rs/nice-win32-ia32-msvc@1.1.1': + resolution: {integrity: sha512-CNQqlQT9MwuCsg1Vd/oKXiuH+TcsSPJmlAFc5frFyX/KkOh0UpBLEj7aoY656d5UKZQMQFP7vJNa1DNUNORvug==} + engines: {node: '>= 10'} + cpu: [ia32] + os: [win32] + + '@napi-rs/nice-win32-x64-msvc@1.1.1': + resolution: {integrity: sha512-vB+4G/jBQCAh0jelMTY3+kgFy00Hlx2f2/1zjMoH821IbplbWZOkLiTYXQkygNTzQJTq5cvwBDgn2ppHD+bglQ==} + engines: {node: '>= 10'} + cpu: [x64] + os: [win32] + + '@napi-rs/nice@1.1.1': + resolution: {integrity: sha512-xJIPs+bYuc9ASBl+cvGsKbGrJmS6fAKaSZCnT0lhahT5rhA2VVy9/EcIgd2JhtEuFOJNx7UHNn/qiTPTY4nrQw==} + engines: {node: '>= 10'} + + '@nestjs/common@11.1.24': + resolution: {integrity: sha512-9zHxaDDM+oXW9As6UsP5yYB+UqczBmpeSCIFWdPEtEukMnZhxODG1BBjaUcdBB8Sc1uzojSJSJlp3yFp853t1g==} + peerDependencies: + class-transformer: '>=0.4.1' + class-validator: '>=0.13.2' + reflect-metadata: ^0.1.12 || ^0.2.0 + rxjs: ^7.1.0 + peerDependenciesMeta: + class-transformer: + optional: true + class-validator: + optional: true + + '@nestjs/core@11.1.24': + resolution: {integrity: sha512-K4bzT+lEdd0Hhcsw3jtk56QAW6s6skK3ViN7hIROSN0kUf4ROwWEAKopJID6yhPQxB45kDtP2wEcjzE8171J3g==} + engines: {node: '>= 20'} + peerDependencies: + '@nestjs/common': ^11.0.0 + '@nestjs/microservices': ^11.0.0 + '@nestjs/platform-express': ^11.0.0 + '@nestjs/websockets': ^11.0.0 + reflect-metadata: ^0.1.12 || ^0.2.0 + rxjs: ^7.1.0 + peerDependenciesMeta: + '@nestjs/microservices': + optional: true + '@nestjs/platform-express': + optional: true + '@nestjs/websockets': + optional: true + + '@nodable/entities@2.1.1': + resolution: {integrity: sha512-Pig3HxDIoMgjdEH8OCf/dkcTmLFjJRjWuq8jSnklu284/TKOPibSRERmOykiwmyXTtv61mP+44f3GMx0tLAyjg==} + + '@nuxt/kit@4.4.2': + resolution: {integrity: sha512-5+IPRNX2CjkBhuWUwz0hBuLqiaJPRoKzQ+SvcdrQDbAyE+VDeFt74VpSFr5/R0ujrK4b+XnSHUJWdS72w6hsog==} + engines: {node: '>=18.12.0'} + + '@nuxt/opencollective@0.4.1': + resolution: {integrity: sha512-GXD3wy50qYbxCJ652bDrDzgMr3NFEkIS374+IgFQKkCvk9yiYcLvX2XDYr7UyQxf4wK0e+yqDYRubZ0DtOxnmQ==} + engines: {node: ^14.18.0 || >=16.10.0, npm: '>=5.10.0'} + hasBin: true + + '@oclif/core@4.8.1': + resolution: {integrity: sha512-07mq0vKCWNsB85ZHeBMlTAiO0KLFqHyAeRK3bD2K8CI1tX3tiwkWw1lZQZkiw8MUBrhxdROhMkYMY4Q0l7JHqA==} + engines: {node: '>=18.0.0'} + + '@oclif/plugin-help@6.2.37': + resolution: {integrity: sha512-5N/X/FzlJaYfpaHwDC0YHzOzKDWa41s9t+4FpCDu4f9OMReds4JeNBaaWk9rlIzdKjh2M6AC5Q18ORfECRkHGA==} + engines: {node: '>=18.0.0'} + '@opentelemetry/api-logs@0.207.0': resolution: {integrity: sha512-lAb0jQRVyleQQGiuuvCOTDVspc14nx6XJjP4FspJ1sNARo3Regq4ZZbrc3rN4b1TYSuUCvgH+UXUPug4SLOqEQ==} engines: {node: '>=8.0.0'} @@ -1004,9 +1281,63 @@ packages: cpu: [x64] os: [win32] + '@sec-ant/readable-stream@0.4.1': + resolution: {integrity: sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==} + '@sinclair/typebox@0.27.10': resolution: {integrity: sha512-MTBk/3jGLNB2tVxv6uLlFh1iu64iYOQ2PbdOSK3NW8JZsmlaOh2q6sdtKowBhfw8QFLmYNzTW4/oK4uATIi6ZA==} + '@sindresorhus/is@7.2.0': + resolution: {integrity: sha512-P1Cz1dWaFfR4IR+U13mqqiGsLFf1KbayybWwdd2vfctdV6hDpUkgCY0nKOLLTMSoRd/jJNjtbqzf13K8DCCXQw==} + engines: {node: '>=18'} + + '@sindresorhus/merge-streams@4.0.0': + resolution: {integrity: sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ==} + engines: {node: '>=18'} + + '@smithy/core@3.24.6': + resolution: {integrity: sha512-wBXDRup6UU97VKyaiRo8AssnfStPtG0oAAfpq/bC0a1YYau8pM86YB4kM6ccoVi1mS8l/UHbn9oDM+7uozr/ug==} + engines: {node: '>=18.0.0'} + + '@smithy/fetch-http-handler@5.4.6': + resolution: {integrity: sha512-FEwEYJ1jlBKdhe9TPzfghEi1bP55ZeEImlDkEa62bBBYzUcnB6RUCyuiS2mqKt6ZVjUbBgcNhzfIctH+Hevx9g==} + engines: {node: '>=18.0.0'} + + '@smithy/is-array-buffer@2.2.0': + resolution: {integrity: sha512-GGP3O9QFD24uGeAXYUjwSTXARoqpZykHadOmA8G5vfJPK0/DC67qa//0qvqrJzL1xc8WQWX7/yc7fwudjPHPhA==} + engines: {node: '>=14.0.0'} + + '@smithy/node-http-handler@4.7.6': + resolution: {integrity: sha512-3fya8i7GrJilQouk4cZJKdy5k8MWQBpjfXrRNaXDedH8r779tr0jcxyH3+yoTmsluc2+vF4S343yFbnvu8ExDQ==} + engines: {node: '>=18.0.0'} + + '@smithy/property-provider@4.3.6': + resolution: {integrity: sha512-0rhHv1Ww27kajF6qewme2aRtJmKFtSwE6EZ2dj5KxdX/R3ANsUugqTnH0tvpZwGiQ3MOMhetuCGFAeKVv3/Onw==} + engines: {node: '>=18.0.0'} + + '@smithy/shared-ini-file-loader@4.5.6': + resolution: {integrity: sha512-In8gYD2R66EKlGAq9QrNKVrMOGaGBD7LUNp2kUjeQ4V9zNktFIXBPmrCySr4YYo+jVeVL6CnWj26sOamcF0qIg==} + engines: {node: '>=18.0.0'} + + '@smithy/signature-v4@5.4.6': + resolution: {integrity: sha512-Ojg4B6oIDlIr1R86xCDJt1zJWnYa0VINmqdjfe9qxWjdRivHalZ3iSlQgVqYbW0MdpFOC5XfHEWsnbmdnpIILQ==} + engines: {node: '>=18.0.0'} + + '@smithy/types@4.14.3': + resolution: {integrity: sha512-YupL0ZWmFtJexUN2cHzkvvF/b9pKrtAIfT1o7/oY/Ppu8IYeZ+lDPM5vZdQJaSeA132dJCqojjGC9NhXeF71VQ==} + engines: {node: '>=18.0.0'} + + '@smithy/util-buffer-from@2.2.0': + resolution: {integrity: sha512-IJdWBbTcMQ6DA0gdNhh/BwrLkDR+ADW5Kr1aZmd4k3DIF6ezMV4R2NIAmT08wQJ3yUK82thHWmC/TnK/wpMMIA==} + engines: {node: '>=14.0.0'} + + '@smithy/util-utf8@2.3.0': + resolution: {integrity: sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A==} + engines: {node: '>=14.0.0'} + + '@standard-schema/spec@1.0.0': + resolution: {integrity: sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA==} + '@standard-schema/spec@1.1.0': resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==} @@ -1034,12 +1365,108 @@ packages: resolution: {integrity: sha512-X0OOgJQfD9BDNhxfslozuq/26fPyBt+TsMX+YkI2T6Hc4M2bkCDho/D4LC8nV9gNtviuejWdhit8YzHwnKOQoQ==} engines: {node: '>=20.0.0'} + '@swc/cli@0.8.1': + resolution: {integrity: sha512-L+ACCGHCiS0VqHVep/INLVnvRvJ2XooQFLZq4L8snhxw1jsqz+XRcY313UsyPVturPPE1shW3jic7rt3qEQTSQ==} + engines: {node: '>= 20.19.0'} + hasBin: true + peerDependencies: + '@swc/core': ^1.2.66 + chokidar: ^5.0.0 + peerDependenciesMeta: + chokidar: + optional: true + + '@swc/core-darwin-arm64@1.15.3': + resolution: {integrity: sha512-AXfeQn0CvcQ4cndlIshETx6jrAM45oeUrK8YeEY6oUZU/qzz0Id0CyvlEywxkWVC81Ajpd8TQQ1fW5yx6zQWkQ==} + engines: {node: '>=10'} + cpu: [arm64] + os: [darwin] + + '@swc/core-darwin-x64@1.15.3': + resolution: {integrity: sha512-p68OeCz1ui+MZYG4wmfJGvcsAcFYb6Sl25H9TxWl+GkBgmNimIiRdnypK9nBGlqMZAcxngNPtnG3kEMNnvoJ2A==} + engines: {node: '>=10'} + cpu: [x64] + os: [darwin] + + '@swc/core-linux-arm-gnueabihf@1.15.3': + resolution: {integrity: sha512-Nuj5iF4JteFgwrai97mUX+xUOl+rQRHqTvnvHMATL/l9xE6/TJfPBpd3hk/PVpClMXG3Uvk1MxUFOEzM1JrMYg==} + engines: {node: '>=10'} + cpu: [arm] + os: [linux] + + '@swc/core-linux-arm64-gnu@1.15.3': + resolution: {integrity: sha512-2Nc/s8jE6mW2EjXWxO/lyQuLKShcmTrym2LRf5Ayp3ICEMX6HwFqB1EzDhwoMa2DcUgmnZIalesq2lG3krrUNw==} + engines: {node: '>=10'} + cpu: [arm64] + os: [linux] + + '@swc/core-linux-arm64-musl@1.15.3': + resolution: {integrity: sha512-j4SJniZ/qaZ5g8op+p1G9K1z22s/EYGg1UXIb3+Cg4nsxEpF5uSIGEE4mHUfA70L0BR9wKT2QF/zv3vkhfpX4g==} + engines: {node: '>=10'} + cpu: [arm64] + os: [linux] + + '@swc/core-linux-x64-gnu@1.15.3': + resolution: {integrity: sha512-aKttAZnz8YB1VJwPQZtyU8Uk0BfMP63iDMkvjhJzRZVgySmqt/apWSdnoIcZlUoGheBrcqbMC17GGUmur7OT5A==} + engines: {node: '>=10'} + cpu: [x64] + os: [linux] + + '@swc/core-linux-x64-musl@1.15.3': + resolution: {integrity: sha512-oe8FctPu1gnUsdtGJRO2rvOUIkkIIaHqsO9xxN0bTR7dFTlPTGi2Fhk1tnvXeyAvCPxLIcwD8phzKg6wLv9yug==} + engines: {node: '>=10'} + cpu: [x64] + os: [linux] + + '@swc/core-win32-arm64-msvc@1.15.3': + resolution: {integrity: sha512-L9AjzP2ZQ/Xh58e0lTRMLvEDrcJpR7GwZqAtIeNLcTK7JVE+QineSyHp0kLkO1rttCHyCy0U74kDTj0dRz6raA==} + engines: {node: '>=10'} + cpu: [arm64] + os: [win32] + + '@swc/core-win32-ia32-msvc@1.15.3': + resolution: {integrity: sha512-B8UtogMzErUPDWUoKONSVBdsgKYd58rRyv2sHJWKOIMCHfZ22FVXICR4O/VwIYtlnZ7ahERcjayBHDlBZpR0aw==} + engines: {node: '>=10'} + cpu: [ia32] + os: [win32] + + '@swc/core-win32-x64-msvc@1.15.3': + resolution: {integrity: sha512-SpZKMR9QBTecHeqpzJdYEfgw30Oo8b/Xl6rjSzBt1g0ZsXyy60KLXrp6IagQyfTYqNYE/caDvwtF2FPn7pomog==} + engines: {node: '>=10'} + cpu: [x64] + os: [win32] + + '@swc/core@1.15.3': + resolution: {integrity: sha512-Qd8eBPkUFL4eAONgGjycZXj1jFCBW8Fd+xF0PzdTlBCWQIV1xnUT7B93wUANtW3KGjl3TRcOyxwSx/u/jyKw/Q==} + engines: {node: '>=10'} + peerDependencies: + '@swc/helpers': '>=0.5.17' + peerDependenciesMeta: + '@swc/helpers': + optional: true + + '@swc/counter@0.1.3': + resolution: {integrity: sha512-e2BR4lsJkkRlKZ/qCHPw9ZaSxc0MVUd7gtbtaB7aMvHeJVYe8sOB8DBZkP2DtISHGSku9sCK6T6cnY0CtXrOCQ==} + + '@swc/types@0.1.26': + resolution: {integrity: sha512-lyMwd7WGgG79RS7EERZV3T8wMdmPq3xwyg+1nmAM64kIhx5yl+juO2PYIHb7vTiPgPCj8LYjsNV2T5wiQHUEaw==} + + '@tokenizer/inflate@0.4.1': + resolution: {integrity: sha512-2mAv+8pkG6GIZiF1kNg1jAjh27IDxEPKwdGul3snfztFerfPGI1LjDezZp3i7BElXompqEtPmoPx6c2wgtWsOA==} + engines: {node: '>=18'} + + '@tokenizer/token@0.3.0': + resolution: {integrity: sha512-OvjF+z51L3ov0OyAU0duzsYuvO01PH7x4t6DJx+guahgTnBHkhJdG7soQeTSFLWN3efnHyibZ4Z8l2EuWwJN3A==} + '@toon-format/toon@0.9.0': resolution: {integrity: sha512-BaMhGh1+/z8ceDrF2xL9Drd42hijbUJlivm/1goPR26RgCYsqlMkHbg48hx9a5UjZC7oZqxWPJ6ju5qvALi6Ag==} '@types/chai@5.2.3': resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==} + '@types/debug@4.1.13': + resolution: {integrity: sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==} + '@types/deep-eql@4.0.2': resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==} @@ -1052,6 +1479,12 @@ packages: '@types/fs-extra@11.0.4': resolution: {integrity: sha512-yTbItCNreRooED33qjunPthRcSjERP1r4MqCZc7wv0u2sUkzTFp45tgUfS5+r7FrZPdmCCNflLhVSP/o+SemsQ==} + '@types/http-cache-semantics@4.2.0': + resolution: {integrity: sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==} + + '@types/interpret@1.1.4': + resolution: {integrity: sha512-r+tPKWHYqaxJOYA3Eik0mMi+SEREqOXLmsooRFmc6GHv7nWUDixFtKN+cegvsPlDcEZd9wxsdp041v2imQuvag==} + '@types/istanbul-lib-coverage@2.0.6': resolution: {integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==} @@ -1067,12 +1500,18 @@ packages: '@types/jsonfile@6.1.4': resolution: {integrity: sha512-D5qGUYwjvnNNextdU59/+fI+spnwtTFmyQP0h+PfIOSkNfpU6AOICUOkm4i0OnSk+NyjdPJrxCDro0sJsWlRpQ==} + '@types/ms@2.1.0': + resolution: {integrity: sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==} + '@types/node-fetch@2.6.13': resolution: {integrity: sha512-QGpRVpzSaUs30JBSGPjOg4Uveu384erbHBoT1zeONvyCfwQxIkUshLAOqN/k9EjGviPRmWTTe6aH2qySWKTVSw==} '@types/node@18.19.130': resolution: {integrity: sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg==} + '@types/node@22.19.19': + resolution: {integrity: sha512-dyh/xO2Fh5bYrfWaaqGrRQQGkNdmYw6AmaAUvYeUMNTWQtvb796ikLdmTchRmOlOiIJ1TDXfWgVx1QkUlQ6Hew==} + '@types/node@24.12.4': resolution: {integrity: sha512-GUUEShf+PBCGW2KaXwcIt3Yk+e3pkKwWKb9GSyM9WQVE+ep2jzmHdGsHzu4wgcZy5fN9FBdVzjpBQsYlpfpgLA==} @@ -1088,12 +1527,18 @@ packages: '@types/prompts@2.4.9': resolution: {integrity: sha512-qTxFi6Buiu8+50/+3DGIWLHM6QuWsEKugJnnP6iv2Mc4ncxE4A/OJkjuVOA+5X0X1S/nq5VJRa8Lu+nwcvbrKA==} + '@types/semver@7.7.1': + resolution: {integrity: sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA==} + '@types/stack-utils@2.0.3': resolution: {integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==} '@types/webidl-conversions@7.0.3': resolution: {integrity: sha512-CiJJvcRtIgzadHCYXw7dqEnMNRjhGZlYK05Mj9OyktqV8uVT8fD2BFOB7S1uwBE3Kj2Z+4UyPmFw/Ixgw/LAlA==} + '@types/whatwg-url@11.0.5': + resolution: {integrity: sha512-coYR071JRaHa+xoEvvYqvnIHaVqaYrLPbsufM9BF63HkwI5Lgmy2QR8Q5K/lYDYo5AK82wOvSOS0UsLTpTG7uQ==} + '@types/whatwg-url@13.0.0': resolution: {integrity: sha512-N8WXpbE6Wgri7KUSvrmQcqrMllKZ9uxkYWMt+mCSGwNc0Hsw9VQTW7ApqI4XNrx6/SaM2QQJCzMPDEXE058s+Q==} @@ -1110,10 +1555,38 @@ packages: resolution: {integrity: sha512-yURCknZhvywvQItHMMmFSo+fq5arCUIyz/CVk7jD89MSai7dkaX8ufjCWp3NttLojoTVbcE72ri+be/TnEbMHw==} engines: {node: '>=20.0.0'} + '@vercel/cli-auth@0.0.1': + resolution: {integrity: sha512-CnqiuMlZ4pjs2LCPYiR6aLKPPd3Xb8SBI1Y7eotXKgpx6qgrGNY+E7EIyUt5ErGHJGIrCZyGG5WEo4bHtVmz2Q==} + + '@vercel/functions@3.6.1': + resolution: {integrity: sha512-xz+zZvj/XE6KDHZ8kYNO25Axpjng/kTJd/87SwONa6hzlq94K69OdqH1ZC/CehbtwWknpeyHqUHmpnfoaCbLZQ==} + engines: {node: '>= 20'} + peerDependencies: + '@aws-sdk/credential-provider-web-identity': '*' + peerDependenciesMeta: + '@aws-sdk/credential-provider-web-identity': + optional: true + '@vercel/oidc@3.1.0': resolution: {integrity: sha512-Fw28YZpRnA3cAHHDlkt7xQHiJ0fcL+NRcIqsocZQUSmbzeIKRpwttJjik5ZGanXP+vlA4SbTg+AbA3bP363l+w==} engines: {node: '>= 20'} + '@vercel/oidc@3.2.0': + resolution: {integrity: sha512-UycprH3T6n3jH0k44NHMa7pnFHGu/N05MjojYr+Mc6I7obkoLIJujSWwin1pCvdy/eOxrI/l3uDLQsmcrOb4ug==} + engines: {node: '>= 20'} + + '@vercel/oidc@3.5.0': + resolution: {integrity: sha512-jo7GgeJx2YMkjg9A28pFM5p88n5SnSHvDeNlf9898bRWiG9jPxwedj/gn/2XTw4UOTyQ50uHlrTGSlf/XU5tgw==} + engines: {node: '>= 20'} + + '@vercel/queue@0.0.0-alpha.40': + resolution: {integrity: sha512-57FD3amfL+SR+p1G9izqvEPcqXhJTel3qSOHdBRS4x+ByC5YkWcGP8xgFoB4Gwe8+SZv1twOqfBofHB2tXmJKw==} + engines: {node: '>=20.0.0'} + + '@vercel/queue@0.1.7': + resolution: {integrity: sha512-4Uk9LOvDPVYqBJGrNDk4fdLte4CmFERXCUJI2y7SRYX1d//dI96Ww7sgKZF4+YDj/YaBXoCZ11AU0HYkVwW9Eg==} + engines: {node: '>=20.0.0'} + '@vitest/expect@4.1.8': resolution: {integrity: sha512-h3nDO677RDLEGlBxyQ5CW8RlMThSKSRLUePLOx09gNIWRL40edgA1GCZSZgf1W55MFAG6/Sw14KeaAnqv0NKdQ==} @@ -1143,32 +1616,192 @@ packages: '@vitest/utils@4.1.8': resolution: {integrity: sha512-uOJamYALNhfJ6iolExyQM40yIQwDqYnkKtQ5VCiSe17E33H0aQ/u+1GlRuz4LZBk6Mm3sg90G9hEbmEt37C1Zg==} - abort-controller@3.0.0: - resolution: {integrity: sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==} - engines: {node: '>=6.5'} + '@workflow-worlds/mongodb@0.2.1': + resolution: {integrity: sha512-GFQH/zjJcW9hBYNONIPRLgYO9oB3y12cIeXYCh97g3GMg9yfY5Cf836D7nDlI0M82TiP5BziSy+REDA77o2NtA==} - accepts@2.0.0: - resolution: {integrity: sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==} - engines: {node: '>= 0.6'} + '@workflow/astro@4.0.8': + resolution: {integrity: sha512-y+m9tJ3BqpwJiXGJCVF2vvBDiQ0EJnidh4RgyrX/txR3/IGQtMYo1LI65ZcBjsNj+8rzsSkDRR0eQM+6ztGmkw==} - acorn@8.15.0: - resolution: {integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==} - engines: {node: '>=0.4.0'} + '@workflow/builders@4.0.9': + resolution: {integrity: sha512-SqMt+AXWwoTZqAic5GWt7J8KyhwkmXiEEjM49uq4ISmHK/zrKBynzrBl+BHEJZS6KSnlTICKZUvjtfDknYRu4Q==} + + '@workflow/cli@4.2.8': + resolution: {integrity: sha512-/pfOMeKzXoRXJDoGZwSSj7eHuHlJH0P4jmNJ42Vd4XchnxgS/a8asVx+ym2QMM03yLy3drhKsBs3S4saQjTcPw==} hasBin: true - afinn-165-financialmarketnews@3.0.0: - resolution: {integrity: sha512-0g9A1S3ZomFIGDTzZ0t6xmv4AuokBvBmpes8htiyHpH7N4xDmvSQL6UxL/Zcs2ypRb3VwgCscaD8Q3zEawKYhw==} + '@workflow/core@4.3.1': + resolution: {integrity: sha512-TUNRYHCDXHYDg/Q+m9rHc0WOzZBQHK8j6OUZalaAWruTQB4e93jXtH/Kh9sIqODthvgV9i5lROmVWzXfILhkmw==} + peerDependencies: + '@opentelemetry/api': '1' + peerDependenciesMeta: + '@opentelemetry/api': + optional: true - afinn-165@2.0.2: - resolution: {integrity: sha512-mJ/RLUfpXfQA6bzugv+bBsc/QYkVrKaLYeS8fWBpKbTCsonv4iuV9ET0fgReEunm9vKLkaNgnekuSNlTC3WQ1Q==} + '@workflow/errors@4.1.0-beta.14': + resolution: {integrity: sha512-vc01pVxxhRZt9lpGkTuW2X+/KHYMOP4Gc42BiIrf/x6bz9oWPInTbfFW+YAPvstE4SF1gpyxMpb5r4yjg6LznA==} - agent-base@6.0.2: - resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==} - engines: {node: '>= 6.0.0'} + '@workflow/errors@4.1.3': + resolution: {integrity: sha512-0QaAZPqxTg38zeTEXxgVhTOyX5ANFNsEKg4Esk/Kl2xWzFK54U+YE4vcqTyZn7raKLz3wnEh6f0oA9kzIZiTNA==} - agent-base@7.1.4: - resolution: {integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==} - engines: {node: '>= 14'} + '@workflow/nest@0.0.8': + resolution: {integrity: sha512-3F7qb5KA7pm9tWiCqaBCY0Z736AvPq+t/8vhwrtg7VQ57M/6JPQdo21PBacQfUXpf6N36I0TPKH/tFrPYefHxA==} + hasBin: true + peerDependencies: + '@nestjs/common': '>=10.0.0' + '@nestjs/core': '>=10.0.0' + '@swc/cli': '>=0.4.0' + '@swc/core': '>=1.5.0' + + '@workflow/next@4.0.9': + resolution: {integrity: sha512-uTGF/xJStgN/nPdMYX0m6zk34p3VhwGrNSW3GkuGTKWavKdG6OfNFBSG6WakpkSOltdoeKpNeQPTcrdSC4CSuw==} + peerDependencies: + next: '>13' + peerDependenciesMeta: + next: + optional: true + + '@workflow/nitro@4.0.9': + resolution: {integrity: sha512-JSJWH6RVB01hgNezx2H3mnlF9XUQEC0PuSW3BKICarXxWC3XjIxy6Bg8bVOqFWRyC1+NYxwhqMEHtHMde+Ni9w==} + + '@workflow/nuxt@4.0.9': + resolution: {integrity: sha512-SW6sXphFk33H5Vtz7oyG4hP5vTY7oAJYCVoeREy6m/FNdY+z8DEly5C5bqEfIUeQzE3BjtPTFqbG7aUD2L28Yg==} + + '@workflow/rollup@4.0.8': + resolution: {integrity: sha512-Wn3xqYNcq8ZktHzh37PnP0MWzk8pXT5KKBflmzz/eHIOBEePnjRhlZUjIAQ+ryQt2wGoZA+gnI+Pgf5UTUhgdA==} + + '@workflow/serde@4.1.1': + resolution: {integrity: sha512-191/N2w3WlrapuAvtAT1knONuqJ9auOqM8c7yMMM7c6rqXAZQKkNJrOuuj/j0vp7x43rg0+fy90bqT/xQ5ki4w==} + + '@workflow/sveltekit@4.0.8': + resolution: {integrity: sha512-Vl/tqNE/j7+/LdYMeDM+WeZPY9XiOlGRBIF1UsRHquzyKYBz6x+wqByCNB6m4EHMLCpT+YcFkgDmZfOPdFprtA==} + + '@workflow/swc-plugin@4.1.1': + resolution: {integrity: sha512-Bi1K/z7Fjxzf5DY9BCBZHMd6Y4SvuCPOAyslydcDD9m38Suz3xCcfrEDvXo8R5mnEnTuLIB4GEJyB54CkMuuiQ==} + peerDependencies: + '@swc/core': 1.15.3 + + '@workflow/typescript-plugin@4.0.2': + resolution: {integrity: sha512-7bw6aEl+QMZWWZmhJS5bydrSgmxQrG8Kyo5Zhdb7klu+/pBUyNMVTUZmnfe1xRjWborqvOevqYbSDh0a0gwnAw==} + peerDependencies: + typescript: '>=5.0.0' + + '@workflow/utils@4.1.0-beta.11': + resolution: {integrity: sha512-4fIstKn3jSN7pyJzp8RZ4Rbrohpxa+mc3sKji7wDGnqzD9GnSbm3+WOhGAduvYZubsAHN7HmXrfZ96EPLXtu6g==} + + '@workflow/utils@4.1.2': + resolution: {integrity: sha512-Q9KNjROGO/YjRvgbigobODGWtbOunNWhnyVU3EmfstrD8hBgwUyzN9cvi61Cnu/2C9g9Y1YW3Qr0/XSQTUJQIA==} + + '@workflow/vite@4.0.8': + resolution: {integrity: sha512-WXvNL3IPB4eLSjJBvxxK1+MYkrQDpv7OtaqkCtUyFeTr0IzsKlcgp91cqIH7L4UcLZ3TA0AQy6Phucb54hadTQ==} + + '@workflow/web@4.1.9': + resolution: {integrity: sha512-LHmxH/WNLluI8ZnJtGMyCgvf4qsHlI22Om7/RYnFBbgCjB8rGXjyv0giEC8WFFU2hkz4bloBxmH+SCCmNruYSw==} + + '@workflow/world-local@4.1.4': + resolution: {integrity: sha512-vQsQFZF8Wifd1Sm8plo45CXAtKQBQ0dBOus7IGkDPabrp7hfJRbfN5YG4CiiyoiXfmJCBQgW9utv6XneY+YTbg==} + peerDependencies: + '@opentelemetry/api': '1' + peerDependenciesMeta: + '@opentelemetry/api': + optional: true + + '@workflow/world-postgres@4.1.4': + resolution: {integrity: sha512-RcK29jyD3IpCTfIk4ndUWgsdTcwvubL18UyUMm7iT1k6axxozOnH1slS3JT2bu7iuIwtIzwScDeLmfMDyfrZNA==} + hasBin: true + + '@workflow/world-vercel@4.3.2': + resolution: {integrity: sha512-uVUQaoP7ojqWPQjTJGFMASBXXjlL9yuCGaF6IZ51rNoyb9MiKS/t668p23tzrQrY3kqgh4PNu1jYc/5R4j+UPg==} + peerDependencies: + '@opentelemetry/api': '1' + peerDependenciesMeta: + '@opentelemetry/api': + optional: true + + '@workflow/world@4.1.0-beta.2': + resolution: {integrity: sha512-fGFQu/J/HKOnSXj0jB8kCiIt/6fdPCqsMg2IRdUhfLyRev/ZTgcb1Ecd0o3+lAJxn7RAprJccGpDNanalctOIQ==} + peerDependencies: + zod: 4.1.11 + + '@workflow/world@4.1.4': + resolution: {integrity: sha512-XJYkyLewLI23JtYDGAq0WGSjXBYPeieOjOQyrR8COe8SFECqQym45NcMoJw34OsEdc7R7KA1IQnBnNdV97/4Pg==} + peerDependencies: + zod: 4.3.6 + + '@xhmikosr/archive-type@8.0.1': + resolution: {integrity: sha512-toXuiWChyfOpEiCPsIw6HGHaNji5LVkvB6EREL548vGWr+hGaehwxG4LzN20vm9aGFXwnA/Jty8yW2/SmV+1zQ==} + engines: {node: '>=20'} + + '@xhmikosr/bin-check@8.2.1': + resolution: {integrity: sha512-DNruLq+kalxcE7JeDxtqrN9kyWjLW8VqsQPLRTwD1t9ck/1rF4qBL0mX5Fe2/xLOMjo5wPb67BNX2kSAhzfLjA==} + engines: {node: '>=20'} + + '@xhmikosr/bin-wrapper@14.2.5': + resolution: {integrity: sha512-MXfD5mNdc9xQM4/I4O7uWSdQqeZPTYRQSfddUtfH9oUeVkDUTnX4HI2udTsvDEs7ptv2ywHE9UfxlMUs+79wFw==} + engines: {node: '>=20'} + + '@xhmikosr/decompress-tar@9.0.1': + resolution: {integrity: sha512-4AkVR1SoqTxYY22IRRYKDeLirPIDGqMqYsqgjKYuwhgRcBb+yDP4t5Xph33UCzL/nahK/aADmlMEjTNstbX7kw==} + engines: {node: '>=20'} + + '@xhmikosr/decompress-tarbz2@9.0.1': + resolution: {integrity: sha512-aFONnsbqEOuXudvK7V7wB8dcEAKR389oUYQfZhrQZA8OtogJpDjrUAvEH3Qlc9yFqTU6r5/svTEcRwtXhoIJbQ==} + engines: {node: '>=20'} + + '@xhmikosr/decompress-targz@9.0.1': + resolution: {integrity: sha512-1JXu2b6yrpm5EuBoOzMU57B4qrHXJKWQQ7LlMynNEiz85mEjDciO3ayf//GXaTLLCEKiHjWlU3q3THjgf7uODA==} + engines: {node: '>=20'} + + '@xhmikosr/decompress-unzip@8.1.1': + resolution: {integrity: sha512-/B+Z0qJflGn5UEtmMZ2qeKeXwexOycxaibYhMOyLcRPJriXs4IkoSngVUVZXLYViu9TdHyFWynC6NB4EWBg8cg==} + engines: {node: '>=20'} + + '@xhmikosr/decompress@11.1.3': + resolution: {integrity: sha512-NiyhJq6z7ERsYghcnXZUI6ooDXgZtoB+G9eUsYhfSM4VLp2rKx9UxhKI1NEf1PqosrNPxG3bnSsr2UBVbNurlg==} + engines: {node: '>=20'} + + '@xhmikosr/downloader@16.1.3': + resolution: {integrity: sha512-jtQZZbO3xsRmDDeEz7m23ydgbW9YpVnOALNygmKNvjjuTuQwtcXGVJ9xWv4x7niElvziJrak+WUBmWYcFosolA==} + engines: {node: '>=20'} + + '@xhmikosr/os-filter-obj@4.1.0': + resolution: {integrity: sha512-y5ArHvQ7BVule/+L9yE2nYMhceiJhgsqo58lOfnisQ7bg+Kjfmkgr7JBuVFiTkl+ErdShpp829QstZQyLugl8g==} + engines: {node: '>=20'} + + abort-controller@3.0.0: + resolution: {integrity: sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==} + engines: {node: '>=6.5'} + + accepts@1.3.8: + resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==} + engines: {node: '>= 0.6'} + + accepts@2.0.0: + resolution: {integrity: sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==} + engines: {node: '>= 0.6'} + + acorn@8.15.0: + resolution: {integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==} + engines: {node: '>=0.4.0'} + hasBin: true + + acorn@8.16.0: + resolution: {integrity: sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==} + engines: {node: '>=0.4.0'} + hasBin: true + + afinn-165-financialmarketnews@3.0.0: + resolution: {integrity: sha512-0g9A1S3ZomFIGDTzZ0t6xmv4AuokBvBmpes8htiyHpH7N4xDmvSQL6UxL/Zcs2ypRb3VwgCscaD8Q3zEawKYhw==} + + afinn-165@2.0.2: + resolution: {integrity: sha512-mJ/RLUfpXfQA6bzugv+bBsc/QYkVrKaLYeS8fWBpKbTCsonv4iuV9ET0fgReEunm9vKLkaNgnekuSNlTC3WQ1Q==} + + agent-base@6.0.2: + resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==} + engines: {node: '>= 6.0.0'} + + agent-base@7.1.4: + resolution: {integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==} + engines: {node: '>= 14'} agentkeepalive@4.6.0: resolution: {integrity: sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ==} @@ -1191,6 +1824,17 @@ packages: ajv@8.20.0: resolution: {integrity: sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==} + ansi-align@3.0.1: + resolution: {integrity: sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==} + + ansi-escapes@4.3.2: + resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==} + engines: {node: '>=8'} + + ansi-escapes@7.3.0: + resolution: {integrity: sha512-BvU8nYgGQBxcmMuEeUEmNTvrMVjJNSH7RgW24vXexN4Ven6qCvy4TntnvlnwnMLTVlcRQQdbRY8NKnaIoeWDNg==} + engines: {node: '>=18'} + ansi-regex@5.0.1: resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} engines: {node: '>=8'} @@ -1211,6 +1855,10 @@ packages: resolution: {integrity: sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==} engines: {node: '>=12'} + ansis@3.17.0: + resolution: {integrity: sha512-0qWUglt9JEqLFr3w1I1pbrChn1grhaiAR2ocX1PP/flRmxgtwTzPFFFnfIlD6aMOLQZgSuCRlidD70lvx8yhzg==} + engines: {node: '>=14'} + any-promise@1.3.0: resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==} @@ -1218,19 +1866,55 @@ packages: resolution: {integrity: sha512-KLy/ugo33KZA7nugtQ7O0E1c8kQ52N3IvD/XgIh4w/Nr28ypfkwDfA67F1ev4N1m5D+BOk1+b2dEJDfpj/VvZg==} engines: {node: '>=0.2.6'} + argparse@2.0.1: + resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} + + array-flatten@1.1.1: + resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==} + assertion-error@2.0.1: resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==} engines: {node: '>=12'} + async-listen@3.0.0: + resolution: {integrity: sha512-V+SsTpDqkrWTimiotsyl33ePSjA5/KrithwupuvJ6ztsqPvGv6ge4OredFhPffVXiLN/QUWvE0XcqJaYgt6fOg==} + engines: {node: '>= 14'} + + async-sema@3.1.1: + resolution: {integrity: sha512-tLRNUXati5MFePdAk8dw7Qt7DpxPB60ofAgn8WRhW6a2rcimZnYBP9oxHiv0OHy+Wz7kPMG+t4LGdt31+4EmGg==} + + async@3.2.6: + resolution: {integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==} + asynckit@0.4.0: resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} axios@1.16.1: resolution: {integrity: sha512-caYkukvroVPO8KrzuJEb50Hm07KwfBZPEC3VeFHTsqWHvKTsy54hjJz9BS/cdaypROE2rH6xvm9mHX4fgWkr3A==} + b4a@1.8.1: + resolution: {integrity: sha512-aiqre1Nr0B/6DgE2N5vwTc+2/oQZ4Wh1t4NznYY4E00y8LCt6NqdRv81so00oo27D8MVKTpUa/MwUUtBLXCoDw==} + peerDependencies: + react-native-b4a: '*' + peerDependenciesMeta: + react-native-b4a: + optional: true + balanced-match@1.0.2: resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} + balanced-match@4.0.4: + resolution: {integrity: sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==} + engines: {node: 18 || 20 || >=22} + + bare-events@2.9.1: + resolution: {integrity: sha512-Z0oHEHAFDZkffN8Qc39zNZjQlMDkPJRyyyZieU1VH7u8c5S+qHZ2S8ixdKIAxEjfHO7FJxXmJWgteOghVanIsg==} + peerDependencies: + bare-abort-controller: '*' + peerDependenciesMeta: + bare-abort-controller: + optional: true + base-64@0.1.0: resolution: {integrity: sha512-Y5gU45svrR5tI2Vt/X9GPd3L0HNIKzGu202EjxrXMpuc2V2CiKgemAbUUsqYmZJvPtCXoUKjNZwBJzsNScUbXA==} @@ -1244,23 +1928,50 @@ packages: bignumber.js@9.3.1: resolution: {integrity: sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ==} + binary-version-check@6.1.0: + resolution: {integrity: sha512-REKdLKmuViV2WrtWXvNSiPX04KbIjfUV3Cy8batUeOg+FtmowavzJorfFhWq95cVJzINnL/44ixP26TrdJZACA==} + engines: {node: '>=18'} + + binary-version@7.1.0: + resolution: {integrity: sha512-Iy//vPc3ANPNlIWd242Npqc8MK0a/i4kVcHDlDA6HNMv5zMxz4ulIFhOSYJVKw/8AbHdHy0CnGYEt1QqSXxPsw==} + engines: {node: '>=18'} + bindings@1.5.0: resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==} bl@4.1.0: resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==} + body-parser@1.20.5: + resolution: {integrity: sha512-3grm+/2tUOvu2cjJkvsIxrv/wVpfXQW4PsQHYm7yk4vfpu7Ekl6nEsYBoJUL6qDwZUx8wUhQ8tR2qz+ad9c9OA==} + engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} + body-parser@2.2.2: resolution: {integrity: sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA==} engines: {node: '>=18'} + bowser@2.14.1: + resolution: {integrity: sha512-tzPjzCxygAKWFOJP011oxFHs57HzIhOEracIgAePE4pqB3LikALKnSzUyU4MGs9/iCEUuHlAJTjTc5M+u7YEGg==} + + boxen@8.0.1: + resolution: {integrity: sha512-F3PH5k5juxom4xktynS7MoFY+NUWH5LC4CnH11YB8NPew+HLpmBLCybSAEyb2F+4pRXhuhWqFesoQd6DAyc2hw==} + engines: {node: '>=18'} + brace-expansion@2.1.1: resolution: {integrity: sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA==} + brace-expansion@5.0.6: + resolution: {integrity: sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==} + engines: {node: 18 || 20 || >=22} + braces@3.0.3: resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==} engines: {node: '>=8'} + bson@6.10.4: + resolution: {integrity: sha512-WIsKqkSC0ABoBJuT1LEX+2HEvNmNKKgnTAyd0fL8qzK4SH2i9NXg+t08YtdZp/V9IZ33cxe3iV4yM0qg8lMQng==} + engines: {node: '>=16.20.1'} + bson@7.2.0: resolution: {integrity: sha512-YCEo7KjMlbNlyHhz7zAZNDpIpQbd+wOEHJYezv0nMYTn4x31eIUM2yomNNubclAt63dObUzKHWsBLJ9QcZNSnQ==} engines: {node: '>=20.19.0'} @@ -1271,6 +1982,10 @@ packages: buffer@5.7.1: resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==} + builtin-modules@5.0.0: + resolution: {integrity: sha512-bkXY9WsVpY7CvMhKSR6pZilZu9Ln5WDrKVBUXf2S443etkmEO4V58heTecXcUIsNsi4Rx8JUO4NfX1IcQl4deg==} + engines: {node: '>=18.20'} + bundle-name@4.1.0: resolution: {integrity: sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==} engines: {node: '>=18'} @@ -1281,14 +1996,34 @@ packages: peerDependencies: esbuild: '>=0.18' + byte-counter@0.1.0: + resolution: {integrity: sha512-jheRLVMeUKrDBjVw2O5+k4EvR4t9wtxHL+bo/LxfkxsVeuGMy3a5SEGgXdAFA4FSzTrU8rQXQIrsZ3oBq5a0pQ==} + engines: {node: '>=20'} + bytes@3.1.2: resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==} engines: {node: '>= 0.8'} + c12@3.3.4: + resolution: {integrity: sha512-cM0ApFQSBXuourJejzwv/AuPRvAxordTyParRVcHjjtXirtkzM0uK2L9TTn9s0cXZbG7E55jCivRQzoxYmRAlA==} + peerDependencies: + magicast: '*' + peerDependenciesMeta: + magicast: + optional: true + cac@6.7.14: resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==} engines: {node: '>=8'} + cacheable-lookup@7.0.0: + resolution: {integrity: sha512-+qJyx4xiKra8mZrcwhjMRMUhD5NR1R8esPkzIYxX96JiecFoxAXFuz/GpR3+ev4PE1WamHip78wV0vcmPQtp8w==} + engines: {node: '>=14.16'} + + cacheable-request@13.0.19: + resolution: {integrity: sha512-SVXGH037+Mo1aIMO5B2UcleR43FGjFdN+M8JObSyEoQ2Mn4CODRWx28gN5jiTF0n5ItsgtIZfyargMNs8GX4kg==} + engines: {node: '>=18'} + call-bind-apply-helpers@1.0.2: resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==} engines: {node: '>= 0.4'} @@ -1297,6 +2032,21 @@ packages: resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==} engines: {node: '>= 0.4'} + callsites@3.1.0: + resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} + engines: {node: '>=6'} + + camelcase@8.0.0: + resolution: {integrity: sha512-8WB3Jcas3swSvjIeA2yvCJ+Miyz5l1ZmB6HFb9R1317dt9LCQoswg/BGrmAmkWVEszSrrg4RwmO46qIm2OEnSA==} + engines: {node: '>=16'} + + cbor-extract@2.2.2: + resolution: {integrity: sha512-hlSxxI9XO2yQfe9g6msd3g4xCfDqK5T5P0fRMLuaLHhxn4ViPrm+a+MUfhrvH2W962RGxcBwEGzLQyjbDG1gng==} + hasBin: true + + cbor-x@1.6.0: + resolution: {integrity: sha512-0kareyRwHSkL6ws5VXHEf8uY1liitysCVJjlmhaLG+IXLqhSaOO+t63coaso7yjwEzWZzLy8fJo06gZDVQM9Qg==} + chai@6.2.2: resolution: {integrity: sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==} engines: {node: '>=18'} @@ -1316,6 +2066,10 @@ packages: resolution: {integrity: sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==} engines: {node: '>= 14.16.0'} + chokidar@5.0.0: + resolution: {integrity: sha512-TQMmc3w+5AxjpL8iIiwebF73dRDF4fBIieAqGn9RGCWaEVwQ6Fb2cGe31Yns0RRIzii5goJ1Y7xbMwo1TxMplw==} + engines: {node: '>= 20.19.0'} + chownr@1.1.4: resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==} @@ -1323,6 +2077,17 @@ packages: resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==} engines: {node: '>=8'} + citty@0.1.6: + resolution: {integrity: sha512-tskPPKEs8D2KPafUypv2gxwJP8h/OaJmC82QQGGDQcHvXX43xF2VDACcJVmZ0EuSxkpO9Kc4MlrA3q0+FG58AQ==} + + clean-stack@3.0.1: + resolution: {integrity: sha512-lR9wNiMRcVQjSB3a7xXGLuz4cr4wJuuXlaAEbRutGowQTmlp7R72/DOgN21e8jdwblMWl9UOJMJXarX94pzKdg==} + engines: {node: '>=10'} + + cli-boxes@3.0.0: + resolution: {integrity: sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==} + engines: {node: '>=10'} + cli-cursor@5.0.0: resolution: {integrity: sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==} engines: {node: '>=18'} @@ -1331,6 +2096,14 @@ packages: resolution: {integrity: sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==} engines: {node: '>=6'} + cliui@8.0.1: + resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==} + engines: {node: '>=12'} + + clone@1.0.4: + resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==} + engines: {node: '>=0.8'} + cloudflare@4.5.0: resolution: {integrity: sha512-fPcbPKx4zF45jBvQ0z7PCdgejVAPBBCZxwqk1k7krQNfpM07Cfj97/Q6wBzvYqlWXx/zt1S9+m8vnfCe06umbQ==} @@ -1357,6 +2130,14 @@ packages: resolution: {integrity: sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==} engines: {node: '>= 6'} + commander@6.2.1: + resolution: {integrity: sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==} + engines: {node: '>= 6'} + + commander@8.3.0: + resolution: {integrity: sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==} + engines: {node: '>= 12'} + compromise@14.15.1: resolution: {integrity: sha512-9F3UkUaEU1PPz2fgStkE/TI4tk++0wHxS8xfWq9PQWL/v28dy8bEcPVVSLh3dISIRD7PEhJ8YTzHRKF8y9tnLA==} engines: {node: '>=12.0.0'} @@ -1364,21 +2145,39 @@ packages: confbox@0.1.8: resolution: {integrity: sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==} + confbox@0.2.4: + resolution: {integrity: sha512-ysOGlgTFbN2/Y6Cg3Iye8YKulHw+R2fNXHrgSmXISQdMnomY6eNDprVdW9R5xBguEqI954+S6709UyiO7B+6OQ==} + consola@3.4.2: resolution: {integrity: sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==} engines: {node: ^14.18.0 || >=16.10.0} + content-disposition@0.5.4: + resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==} + engines: {node: '>= 0.6'} + content-disposition@1.0.0: resolution: {integrity: sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==} engines: {node: '>= 0.6'} + content-disposition@2.0.1: + resolution: {integrity: sha512-e+H0ZXHSWYrENhQzw1LPuP4oF5MzVKmDU6d3hxlvaPEYLLg62MxtQNPRx4SYSuYJSBUgnQIG4HIN2tEtNv7Dog==} + engines: {node: '>=18'} + content-type@1.0.5: resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==} engines: {node: '>= 0.6'} + convert-hrtime@5.0.0: + resolution: {integrity: sha512-lOETlkIeYSJWcbbcvjRKGxVMXJR+8+OQb/mTPbA4ObPMytYIsUbuOE0Jzy60hjARYszq1id0j8KgVhC+WGZVTg==} + engines: {node: '>=12'} + convert-source-map@2.0.0: resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} + cookie-signature@1.0.7: + resolution: {integrity: sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==} + cookie-signature@1.2.2: resolution: {integrity: sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==} engines: {node: '>=6.6.0'} @@ -1391,6 +2190,15 @@ packages: resolution: {integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==} engines: {node: '>= 0.10'} + cosmiconfig@8.3.6: + resolution: {integrity: sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==} + engines: {node: '>=14'} + peerDependencies: + typescript: '>=4.9.5' + peerDependenciesMeta: + typescript: + optional: true + cross-spawn@7.0.6: resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==} engines: {node: '>= 8'} @@ -1402,6 +2210,17 @@ packages: resolution: {integrity: sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==} engines: {node: '>= 12'} + date-fns@4.1.0: + resolution: {integrity: sha512-Ukq0owbQXxa/U3EGtsdVBkR1w7KOQ5gIBqdH2hkvknzZPYvBxb/aa6E8L7tmjFtkwZBu3UXBbjIgPo/Ez4xaNg==} + + debug@2.6.9: + resolution: {integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + debug@4.4.3: resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==} engines: {node: '>=6.0'} @@ -1411,6 +2230,10 @@ packages: supports-color: optional: true + decompress-response@10.0.0: + resolution: {integrity: sha512-oj7KWToJuuxlPr7VV0vabvxEIiqNMo+q0NueIiL3XhtwC6FVOX7Hr1c0C4eD0bmf7Zr+S/dSf2xvkH3Ad6sU3Q==} + engines: {node: '>=20'} + decompress-response@6.0.0: resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==} engines: {node: '>=10'} @@ -1427,10 +2250,20 @@ packages: resolution: {integrity: sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==} engines: {node: '>=18'} + defaults@1.0.4: + resolution: {integrity: sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==} + + define-lazy-prop@2.0.0: + resolution: {integrity: sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==} + engines: {node: '>=8'} + define-lazy-prop@3.0.0: resolution: {integrity: sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==} engines: {node: '>=12'} + defu@6.1.7: + resolution: {integrity: sha512-7z22QmUWiQ/2d0KkdYmANbRUVABpZ9SNYyH5vx6PZ+nE5bcC0l7uFvEfHlyld/HcGBFTL536ClDt3DEcSlEJAQ==} + delayed-stream@1.0.0: resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} engines: {node: '>=0.4.0'} @@ -1439,10 +2272,20 @@ packages: resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==} engines: {node: '>= 0.8'} + destr@2.0.5: + resolution: {integrity: sha512-ugFTXCtDZunbzasqBxrK93Ik/DRYsO6S/fedkWEMKqt04xZ4csmnmwGDBAb07QWNaGMAmnTIemsYZCksjATwsA==} + + destroy@1.2.0: + resolution: {integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==} + engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} + detect-libc@2.1.2: resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==} engines: {node: '>=8'} + devalue@5.6.3: + resolution: {integrity: sha512-nc7XjUU/2Lb+SvEFVGcWLiKkzfw8+qHI7zn8WYXKkLMgfGSHbgCEaR6bJpev8Cm6Rmrb19Gfd/tZvGqx9is3wg==} + diff-sequences@29.6.3: resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} @@ -1454,10 +2297,106 @@ packages: resolution: {integrity: sha512-JVUnt+DUIzu87TABbhPmNfVdBDt18BLOWjMUFJMSi/Qqg7NTYtabbvSNJGOJ7afbRuv9D/lngizHtP7QyLQ+9w==} engines: {node: '>=12'} + dotenv@17.3.1: + resolution: {integrity: sha512-IO8C/dzEb6O3F9/twg6ZLXz164a2fhTnEWb95H23Dm4OuN+92NmEAlTrupP9VW6Jm3sO26tQlqyvyi4CsnY9GA==} + engines: {node: '>=12'} + dotenv@17.4.2: resolution: {integrity: sha512-nI4U3TottKAcAD9LLud4Cb7b2QztQMUEfHbvhTH09bqXTxnSie8WnjPALV/WMCrJZ6UV/qHJ6L03OqO3LcdYZw==} engines: {node: '>=12'} + drizzle-orm@0.45.1: + resolution: {integrity: sha512-Te0FOdKIistGNPMq2jscdqngBRfBpC8uMFVwqjf6gtTVJHIQ/dosgV/CLBU2N4ZJBsXL5savCba9b0YJskKdcA==} + peerDependencies: + '@aws-sdk/client-rds-data': '>=3' + '@cloudflare/workers-types': '>=4' + '@electric-sql/pglite': '>=0.2.0' + '@libsql/client': '>=0.10.0' + '@libsql/client-wasm': '>=0.10.0' + '@neondatabase/serverless': '>=0.10.0' + '@op-engineering/op-sqlite': '>=2' + '@opentelemetry/api': ^1.4.1 + '@planetscale/database': '>=1.13' + '@prisma/client': '*' + '@tidbcloud/serverless': '*' + '@types/better-sqlite3': '*' + '@types/pg': '*' + '@types/sql.js': '*' + '@upstash/redis': '>=1.34.7' + '@vercel/postgres': '>=0.8.0' + '@xata.io/client': '*' + better-sqlite3: '>=7' + bun-types: '*' + expo-sqlite: '>=14.0.0' + gel: '>=2' + knex: '*' + kysely: '*' + mysql2: '>=2' + pg: '>=8' + postgres: '>=3' + prisma: '*' + sql.js: '>=1' + sqlite3: '>=5' + peerDependenciesMeta: + '@aws-sdk/client-rds-data': + optional: true + '@cloudflare/workers-types': + optional: true + '@electric-sql/pglite': + optional: true + '@libsql/client': + optional: true + '@libsql/client-wasm': + optional: true + '@neondatabase/serverless': + optional: true + '@op-engineering/op-sqlite': + optional: true + '@opentelemetry/api': + optional: true + '@planetscale/database': + optional: true + '@prisma/client': + optional: true + '@tidbcloud/serverless': + optional: true + '@types/better-sqlite3': + optional: true + '@types/pg': + optional: true + '@types/sql.js': + optional: true + '@upstash/redis': + optional: true + '@vercel/postgres': + optional: true + '@xata.io/client': + optional: true + better-sqlite3: + optional: true + bun-types: + optional: true + expo-sqlite: + optional: true + gel: + optional: true + knex: + optional: true + kysely: + optional: true + mysql2: + optional: true + pg: + optional: true + postgres: + optional: true + prisma: + optional: true + sql.js: + optional: true + sqlite3: + optional: true + dunder-proto@1.0.1: resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==} engines: {node: '>= 0.4'} @@ -1465,6 +2404,9 @@ packages: eastasianwidth@0.2.0: resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==} + easy-table@1.2.0: + resolution: {integrity: sha512-OFzVOv03YpvtcWGe5AayU5G2hgybsg3iqA6drU8UaoZyB9jLGMTrz9+asnLp/E+6qPh88yEI1gvyZFZ41dmgww==} + ecdsa-sig-formatter@1.0.11: resolution: {integrity: sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==} @@ -1475,6 +2417,11 @@ packages: resolution: {integrity: sha512-/RInbCy1d4P6Zdfa+TMVsf/ufZVotat5hCw3QXmWtjU+3pFEOvOQ7ibo3aIxyCJw2leIeAMjmPj+1SLJiCpdrQ==} engines: {node: '>=12.0.0'} + ejs@3.1.10: + resolution: {integrity: sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==} + engines: {node: '>=0.10.0'} + hasBin: true + emoji-regex@10.6.0: resolution: {integrity: sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==} @@ -1494,6 +2441,20 @@ packages: end-of-stream@1.4.5: resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==} + enhanced-resolve@5.19.0: + resolution: {integrity: sha512-phv3E1Xl4tQOShqSte26C7Fl84EwUdZsyOuSSk9qtAGyyQs2s3jJzComh+Abf4g187lUUAvH+H26omrqia2aGg==} + engines: {node: '>=10.13.0'} + + environment@1.1.0: + resolution: {integrity: sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==} + engines: {node: '>=18'} + + error-ex@1.3.4: + resolution: {integrity: sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==} + + errx@0.1.0: + resolution: {integrity: sha512-fZmsRiDNv07K6s2KkKFTiD2aIvECa7++PKyD5NC32tpRw46qZA3sOz+aM+/V9V0GDHxVTKLziveV4JhzBHDp9Q==} + es-define-property@1.0.1: resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==} engines: {node: '>= 0.4'} @@ -1523,6 +2484,10 @@ packages: engines: {node: '>=18'} hasBin: true + escalade@3.2.0: + resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==} + engines: {node: '>=6'} + escape-html@1.0.3: resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==} @@ -1530,6 +2495,10 @@ packages: resolution: {integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==} engines: {node: '>=8'} + escape-string-regexp@4.0.0: + resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==} + engines: {node: '>=10'} + estree-walker@3.0.3: resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==} @@ -1544,6 +2513,9 @@ packages: eventemitter3@4.0.7: resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==} + events-universal@1.0.1: + resolution: {integrity: sha512-LUd5euvbMLpwOF8m6ivPCbhQeSiYVNb8Vs0fQ8QjXo0JTkEHpz8pxdQf0gStltaPpw0Cca8b39KxvK9cfKRiAw==} + events@3.3.0: resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==} engines: {node: '>=0.8.x'} @@ -1556,6 +2528,14 @@ packages: resolution: {integrity: sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==} engines: {node: '>=18.0.0'} + execa@8.0.1: + resolution: {integrity: sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==} + engines: {node: '>=16.17'} + + execa@9.6.1: + resolution: {integrity: sha512-9Be3ZoN4LmYR90tUoVu2te2BsbzHfhJyfEiAVfz7N5/zv+jduIfLrV2xdQXOHbaD6KgpGdO9PRPM1Y4Q9QkPkA==} + engines: {node: ^18.19.0 || >=20.5.0} + expand-template@2.0.3: resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==} engines: {node: '>=6'} @@ -1574,19 +2554,50 @@ packages: peerDependencies: express: '>= 4.11' + express@4.22.2: + resolution: {integrity: sha512-IuL+Elrou2ZvCFHs18/CIzy2Nzvo25nZ1/D2eIZlz7c+QUayAcYoiM2BthCjs+EBHVpjYjcuLDAiCWgeIX3X1Q==} + engines: {node: '>= 0.10.0'} + express@5.2.1: resolution: {integrity: sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==} engines: {node: '>= 18'} + exsolve@1.0.7: + resolution: {integrity: sha512-VO5fQUzZtI6C+vx4w/4BWJpg3s/5l+6pRQEHzFRM8WFi4XffSP1Z+4qi7GbjWbvRQEbdIco5mIMq+zX4rPuLrw==} + + exsolve@1.0.8: + resolution: {integrity: sha512-LmDxfWXwcTArk8fUEnOfSZpHOJ6zOMUJKOtFLFqJLoKJetuQG874Uc7/Kki7zFLzYybmZhp1M7+98pfMqeX8yA==} + + ext-list@2.2.2: + resolution: {integrity: sha512-u+SQgsubraE6zItfVA0tBuCBhfU9ogSRnsvygI7wht9TS510oLkBRXBsqopeUG/GBOIQyKZO9wjTqIu/sf5zFA==} + engines: {node: '>=0.10.0'} + + ext-name@5.0.0: + resolution: {integrity: sha512-yblEwXAbGv1VQDmow7s38W77hzAgJAO50ztBLMcUyUBfxv1HC+LGwtiEN+Co6LtlqT/5uwVOxsD4TNIilWhwdQ==} + engines: {node: '>=4'} + extend@3.0.2: resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==} fast-deep-equal@3.1.3: resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} + fast-fifo@1.3.2: + resolution: {integrity: sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==} + + fast-safe-stringify@2.1.1: + resolution: {integrity: sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==} + fast-uri@3.1.2: resolution: {integrity: sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==} + fast-xml-builder@1.2.0: + resolution: {integrity: sha512-00aAWieqff+ZJhsXA4g1g7M8k+7AYoMUUHF+/zFb5U6Uv/P0Vl4QZo84/IcufzYalLuEj9928bXN9PbbFzMF0Q==} + + fast-xml-parser@5.7.3: + resolution: {integrity: sha512-C0AaNuC+mscy6vrAQKAc/rMq+zAPHodfHGZu4sGVehvAQt/JLG1O5zEcYcXSY5zSqr4YVgxsB+pHXTq0i7eDlg==} + hasBin: true + fdir@6.5.0: resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==} engines: {node: '>=12.0.0'} @@ -1600,17 +2611,48 @@ packages: resolution: {integrity: sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==} engines: {node: ^12.20 || >= 14.13} + figures@6.1.0: + resolution: {integrity: sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg==} + engines: {node: '>=18'} + + file-type@21.3.4: + resolution: {integrity: sha512-Ievi/yy8DS3ygGvT47PjSfdFoX+2isQueoYP1cntFW1JLYAuS4GD7NUPGg4zv2iZfV52uDyk5w5Z0TdpRS6Q1g==} + engines: {node: '>=20'} + file-uri-to-path@1.0.0: resolution: {integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==} + filelist@1.0.6: + resolution: {integrity: sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA==} + + filename-reserved-regex@4.0.0: + resolution: {integrity: sha512-9ZT504KxEQDamsOogZImAWGEN24R1uFAxU3ZS4AZqn2ooidmN68Olh7n4/RcA4lLatZztjA0ZSuxeLHVoCc8JA==} + engines: {node: '>=20'} + + filenamify@7.0.1: + resolution: {integrity: sha512-9b4rfnaX2MkJCgp27wypV6DAMvj4WMOSgJ+TdcpJIO84Dql+Cv6iJjdG4XDTLubOWkfNiBv3joO59sau/TXw+Q==} + engines: {node: '>=20'} + fill-range@7.1.1: resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==} engines: {node: '>=8'} - finalhandler@2.1.0: + finalhandler@1.3.2: + resolution: {integrity: sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==} + engines: {node: '>= 0.8'} + + finalhandler@2.1.0: resolution: {integrity: sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==} engines: {node: '>= 0.8'} + find-up@7.0.0: + resolution: {integrity: sha512-YyZM99iHrqLKjmt4LJDj58KI+fYyufRLBSYcqycxf//KpBk9FoewoGX0450m9nB44qrZnovzC2oeP5hUibxc/g==} + engines: {node: '>=18'} + + find-versions@6.0.0: + resolution: {integrity: sha512-2kCCtc+JvcZ86IGAz3Z2Y0A1baIz9fL31pH/0S1IqZr9Iwnjq8izfPtrCyQKO6TLMPELLsQMre7VDqeIKCsHkA==} + engines: {node: '>=18'} + fix-dts-default-cjs-exports@1.0.1: resolution: {integrity: sha512-pVIECanWFC61Hzl2+oOCtoJ3F17kglZC/6N94eRWycFgBH35hHx0Li604ZIzhseh97mf2p0cv7vVrOZGoqhlEg==} @@ -1630,6 +2672,10 @@ packages: form-data-encoder@1.7.2: resolution: {integrity: sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A==} + form-data-encoder@4.1.0: + resolution: {integrity: sha512-G6NsmEW15s0Uw9XnCg+33H3ViYRyiM0hMrMhhqQOR8NFc5GhYrI+6I3u7OTw7b91J2g8rtvMBZJDbcGb2YUniw==} + engines: {node: '>= 18'} + form-data@4.0.5: resolution: {integrity: sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==} engines: {node: '>= 6'} @@ -1646,6 +2692,10 @@ packages: resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==} engines: {node: '>= 0.6'} + fresh@0.5.2: + resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==} + engines: {node: '>= 0.6'} + fresh@2.0.0: resolution: {integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==} engines: {node: '>= 0.8'} @@ -1665,6 +2715,10 @@ packages: function-bind@1.1.2: resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} + function-timeout@1.0.2: + resolution: {integrity: sha512-939eZS4gJ3htTHAldmyyuzlrD58P03fHG49v2JfFXbV6OhvZKRC9j2yAtdHw/zrp2zXHuv05zMIy40F0ge7spA==} + engines: {node: '>=18'} + gaxios@7.1.4: resolution: {integrity: sha512-bTIgTsM2bWn3XklZISBTQX7ZSddGW+IO3bMdGaemHZ3tbqExMENHLx6kKZ/KlejgrMtj8q7wBItt51yegqalrA==} engines: {node: '>=18'} @@ -1673,6 +2727,10 @@ packages: resolution: {integrity: sha512-zV/5HKTfCeKWnxG0Dmrw51hEWFGfcF2xiXqcA3+J90WDuP0SvoiSO5ORvcBsifmx/FoIjgQN3oNOGaQ5PhLFkg==} engines: {node: '>=18'} + get-caller-file@2.0.5: + resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} + engines: {node: 6.* || 8.* || >= 10.*} + get-east-asian-width@1.4.0: resolution: {integrity: sha512-QZjmEOC+IT1uk6Rx0sX22V6uHWVwbdbxf1faPqJ1QhLdGgsRGCZoyaQBm/piRdJy/D2um6hM1UP7ZEeQ4EkP+Q==} engines: {node: '>=18'} @@ -1681,16 +2739,35 @@ packages: resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==} engines: {node: '>= 0.4'} + get-package-type@0.1.0: + resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==} + engines: {node: '>=8.0.0'} + get-proto@1.0.1: resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==} engines: {node: '>= 0.4'} + get-stream@8.0.1: + resolution: {integrity: sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==} + engines: {node: '>=16'} + + get-stream@9.0.1: + resolution: {integrity: sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==} + engines: {node: '>=18'} + get-tsconfig@4.11.0: resolution: {integrity: sha512-sNsqf7XKQ38IawiVGPOoAlqZo1DMrO7TU+ZcZwi7yLl7/7S0JwmoBMKz/IkUPhSoXM0Ng3vT0yB1iCe5XavDeQ==} + giget@3.2.0: + resolution: {integrity: sha512-GvHTWcykIR/fP8cj8dMpuMMkvaeJfPvYnhq0oW+chSeIr+ldX21ifU2Ms6KBoyKZQZmVaUAAhQ2EZ68KJF8a7A==} + hasBin: true + github-from-package@0.0.0: resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==} + glob-to-regexp@0.4.1: + resolution: {integrity: sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==} + glob@10.5.0: resolution: {integrity: sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==} deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me @@ -1708,6 +2785,10 @@ packages: resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==} engines: {node: '>= 0.4'} + got@14.6.6: + resolution: {integrity: sha512-QLV1qeYSo5l13mQzWgP/y0LbMr5Plr5fJilgAIwgnwseproEbtNym8xpLsDzeZ6MWXgNE6kdWGBjdh3zT/Qerg==} + engines: {node: '>=20'} + graceful-fs@4.2.11: resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} @@ -1715,6 +2796,15 @@ packages: resolution: {integrity: sha512-rXunEHF9M9EkMydTBux7+IryYXEZinRk6g8OBOGDBzo/qWJjhTxy86i5q7lQYpCLHN8Sqv1XX3OIOc7ka2gtvQ==} engines: {node: '>=8.0.0'} + graphile-config@0.0.1-beta.18: + resolution: {integrity: sha512-uMdF9Rt8/NwT1wVXNleYgM5ro2hHDodHiKA3efJhgdU8iP+r/hksnghOHreMva0sF5tV73f4TpiELPUR0g7O9w==} + engines: {node: '>=16'} + + graphile-worker@0.16.6: + resolution: {integrity: sha512-e7gGYDmGqzju2l83MpzX8vNG/lOtVJiSzI3eZpAFubSxh/cxs7sRrRGBGjzBP1kNG0H+c95etPpNRNlH65PYhw==} + engines: {node: '>=14.0.0'} + hasBin: true + groq-sdk@0.3.0: resolution: {integrity: sha512-Cdgjh4YoSBE2X4S9sxPGXaAy1dlN4bRtAaDZ3cnq+XsxhhN9WSBeHF64l7LWwuD5ntmw7YC5Vf4Ff1oHCg1LOg==} @@ -1722,6 +2812,10 @@ packages: resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} engines: {node: '>=8'} + has-flag@5.0.1: + resolution: {integrity: sha512-CsNUt5x9LUdx6hnk/E2SZLsDyvfqANZSUq4+D3D8RzDJ2M+HDTIkF60ibS1vHaK55vzgiZw1bEPFG9yH7l33wA==} + engines: {node: '>=12'} + has-symbols@1.1.0: resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==} engines: {node: '>= 0.4'} @@ -1738,14 +2832,25 @@ packages: resolution: {integrity: sha512-eIaZ9qDgu7XV0pxOCrg7/WhnQ6Ivm22UcxhXx/A3dcbqbbYgBEkc6e/J/s7j2tS96zoB0S9VBdLwQNCWwUo4LA==} engines: {node: '>=16.9.0'} + http-cache-semantics@4.2.0: + resolution: {integrity: sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==} + http-errors@2.0.0: resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==} engines: {node: '>= 0.8'} + http-errors@2.0.1: + resolution: {integrity: sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==} + engines: {node: '>= 0.8'} + http-proxy-agent@7.0.2: resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==} engines: {node: '>= 14'} + http2-wrapper@2.2.1: + resolution: {integrity: sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==} + engines: {node: '>=10.19.0'} + https-proxy-agent@5.0.1: resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==} engines: {node: '>= 6'} @@ -1754,9 +2859,21 @@ packages: resolution: {integrity: sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==} engines: {node: '>= 14'} + human-signals@5.0.0: + resolution: {integrity: sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==} + engines: {node: '>=16.17.0'} + + human-signals@8.0.1: + resolution: {integrity: sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==} + engines: {node: '>=18.18.0'} + humanize-ms@1.2.1: resolution: {integrity: sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==} + iconv-lite@0.4.24: + resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==} + engines: {node: '>=0.10.0'} + iconv-lite@0.6.3: resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==} engines: {node: '>=0.10.0'} @@ -1768,12 +2885,31 @@ packages: ieee754@1.2.1: resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==} + ignore@7.0.5: + resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==} + engines: {node: '>= 4'} + + import-fresh@3.3.1: + resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==} + engines: {node: '>=6'} + + indent-string@4.0.0: + resolution: {integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==} + engines: {node: '>=8'} + inherits@2.0.4: resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} ini@1.3.8: resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==} + inspect-with-kind@1.0.5: + resolution: {integrity: sha512-MAQUJuIo7Xqk8EVNP+6d3CKq9c80hi4tjIbIAT6lmGW9W6WzlHiu9PS8uSuUYU+Do+j1baiFp3H25XEVxDIG2g==} + + interpret@3.1.1: + resolution: {integrity: sha512-6xwYfHbajpoF0xLW+iwLkhwgvLoZDfjYfoFNu8ftMoXINzwuymNLd9u/KmwtdT2GbR+/Cz66otEGEVVUHX9QLQ==} + engines: {node: '>=10.13.0'} + ip-address@10.2.0: resolution: {integrity: sha512-/+S6j4E9AHvW9SWMSEY9Xfy66O5PWvVEJ08O0y5JGyEKQpojb0K0GKpz/v5HJ/G0vi3D2sjGK78119oXZeE0qA==} engines: {node: '>= 12'} @@ -1782,9 +2918,17 @@ packages: resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==} engines: {node: '>= 0.10'} + is-arrayish@0.2.1: + resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==} + is-buffer@1.1.6: resolution: {integrity: sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==} + is-docker@2.2.1: + resolution: {integrity: sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==} + engines: {node: '>=8'} + hasBin: true + is-docker@3.0.0: resolution: {integrity: sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} @@ -1807,9 +2951,25 @@ packages: resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} engines: {node: '>=0.12.0'} + is-plain-obj@1.1.0: + resolution: {integrity: sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==} + engines: {node: '>=0.10.0'} + + is-plain-obj@4.1.0: + resolution: {integrity: sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==} + engines: {node: '>=12'} + is-promise@4.0.0: resolution: {integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==} + is-stream@3.0.0: + resolution: {integrity: sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + + is-stream@4.0.1: + resolution: {integrity: sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==} + engines: {node: '>=18'} + is-unicode-supported@1.3.0: resolution: {integrity: sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ==} engines: {node: '>=12'} @@ -1818,6 +2978,10 @@ packages: resolution: {integrity: sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==} engines: {node: '>=18'} + is-wsl@2.2.0: + resolution: {integrity: sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==} + engines: {node: '>=8'} + is-wsl@3.1.1: resolution: {integrity: sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw==} engines: {node: '>=16'} @@ -1825,9 +2989,22 @@ packages: isexe@2.0.0: resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} + isexe@4.0.0: + resolution: {integrity: sha512-FFUtZMpoZ8RqHS3XeXEmHWLA4thH+ZxCv2lOiPIn1Xc7CxrqhWzNSDzD+/chS/zbYezmiwWLdQC09JdQKmthOw==} + engines: {node: '>=20'} + + iterare@1.2.1: + resolution: {integrity: sha512-RKYVTCjAnRthyJes037NX/IiqeidgN1xc3j1RjFfECFp28A1GVwK9nA+i0rJPaHqSZwygLzRnFlzUuHFoWWy+Q==} + engines: {node: '>=6'} + jackspeak@3.4.3: resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==} + jake@10.9.4: + resolution: {integrity: sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==} + engines: {node: '>=10'} + hasBin: true + jest-diff@29.7.0: resolution: {integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} @@ -1848,6 +3025,10 @@ packages: resolution: {integrity: sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + jiti@2.7.0: + resolution: {integrity: sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==} + hasBin: true + jose@6.1.1: resolution: {integrity: sha512-GWSqjfOPf4cWOkBzw5THBjtGPhXKqYnfRBzh4Ni+ArTrQQ9unvmsA3oFLqaYKoKe5sjWmGu5wVKg9Ft1i+LQfg==} @@ -1864,9 +3045,16 @@ packages: js-tokens@4.0.0: resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} + js-yaml@4.2.0: + resolution: {integrity: sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==} + hasBin: true + json-bigint@1.0.0: resolution: {integrity: sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==} + json-parse-even-better-errors@2.3.1: + resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==} + json-schema-traverse@1.0.0: resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} @@ -1876,6 +3064,11 @@ packages: json-schema@0.4.0: resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==} + json5@2.2.3: + resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} + engines: {node: '>=6'} + hasBin: true + jsonfile@6.2.0: resolution: {integrity: sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==} @@ -1893,10 +3086,24 @@ packages: resolution: {integrity: sha512-kpSuLD3/7RenBnjnJdOHXCKC8dTd1JzeOiJhN0necWWci6cC+qX+VuwPnMVgb+a4+KNJSfgqahpnfWaeDXCimw==} engines: {node: '>=18.0.0'} + keyv@5.6.0: + resolution: {integrity: sha512-CYDD3SOtsHtyXeEORYRx2qBtpDJFjRTGXUtmNEMGyzYOKj1TE3tycdlho7kA1Ufx9OYWZzg52QFBGALTirzDSw==} + + kind-of@6.0.3: + resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==} + engines: {node: '>=0.10.0'} + kleur@3.0.3: resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==} engines: {node: '>=6'} + klona@2.0.6: + resolution: {integrity: sha512-dhG34DXATL5hSxJbIexCft8FChFXtmskoZYnoPWjXQuebWYCNkVeV3KkGegCK9CP1oswI/vQibS2GY7Em/sJJA==} + engines: {node: '>= 8'} + + knitwork@1.3.0: + resolution: {integrity: sha512-4LqMNoONzR43B1W0ek0fhXMsDNW/zxa1NdFAVMY+k28pgZLovR4G3PB5MrpTxCy1QaZCqNoiaKPr5w5qZHfSNw==} + langsmith@0.7.3: resolution: {integrity: sha512-Gg+IeRGoF1/aStu80aEnIXJCu+N6+4NoV4tAVFS51ZPRBsRa2KG0LkS7K7/ryZ/yES7O9xdqah5QuuWMIeMjQw==} peerDependencies: @@ -1924,10 +3131,18 @@ packages: lines-and-columns@1.2.4: resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==} + load-esm@1.0.3: + resolution: {integrity: sha512-v5xlu8eHD1+6r8EHTg6hfmO97LN8ugKtiXcy5e6oN72iD2r6u0RPfLl6fxM+7Wnh2ZRq15o0russMst44WauPA==} + engines: {node: '>=13.2.0'} + load-tsconfig@0.2.5: resolution: {integrity: sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + locate-path@7.2.0: + resolution: {integrity: sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + lodash.includes@4.3.0: resolution: {integrity: sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==} @@ -1959,6 +3174,10 @@ packages: long@5.3.2: resolution: {integrity: sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==} + lowercase-keys@3.0.0: + resolution: {integrity: sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + lru-cache@10.4.3: resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==} @@ -1968,6 +3187,10 @@ packages: magic-string@0.30.21: resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==} + make-asynchronous@1.1.0: + resolution: {integrity: sha512-ayF7iT+44LXdxJLTrTd3TLQpFDDvPCBxXxbv+pMUSuHA5Q8zyAfwkRP6aHHwNVFBUFWtxAHqwNJxF8vMZLAbVg==} + engines: {node: '>=18'} + math-intrinsics@1.1.0: resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==} engines: {node: '>= 0.4'} @@ -1975,6 +3198,10 @@ packages: md5@2.3.0: resolution: {integrity: sha512-T1GITYmFaKuO91vxyoQMFETst+O71VUPEU3ze5GNzDm0OWdP8v1ziTaAEPUr/3kLsY3Sftgz242A1SetQiDL7g==} + media-typer@0.3.0: + resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==} + engines: {node: '>= 0.6'} + media-typer@1.1.0: resolution: {integrity: sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==} engines: {node: '>= 0.8'} @@ -2010,10 +3237,20 @@ packages: memory-pager@1.5.0: resolution: {integrity: sha512-ZS4Bp4r/Zoeq6+NLJpP+0Zzm0pR8whtGPf1XExKLJBAczGMnSi3It14OiNCStjQjM6NU1okjQGSxgEZN8eBYKg==} + merge-descriptors@1.0.3: + resolution: {integrity: sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==} + merge-descriptors@2.0.0: resolution: {integrity: sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==} engines: {node: '>=18'} + merge-stream@2.0.0: + resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==} + + methods@1.1.2: + resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==} + engines: {node: '>= 0.6'} + micromatch@4.0.8: resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==} engines: {node: '>=8.6'} @@ -2034,6 +3271,15 @@ packages: resolution: {integrity: sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==} engines: {node: '>= 0.6'} + mime@1.6.0: + resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==} + engines: {node: '>=4'} + hasBin: true + + mimic-fn@4.0.0: + resolution: {integrity: sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==} + engines: {node: '>=12'} + mimic-function@5.0.1: resolution: {integrity: sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==} engines: {node: '>=18'} @@ -2042,6 +3288,18 @@ packages: resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==} engines: {node: '>=10'} + mimic-response@4.0.0: + resolution: {integrity: sha512-e5ISH9xMYU0DzrT+jl8q2ze9D6eWBto+I8CNpe+VI+K2J/F/k3PdkdTdz4wvGVH4NTpo+NRYTVIuMQEMMcsLqg==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + + minimatch@10.2.5: + resolution: {integrity: sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==} + engines: {node: 18 || 20 || >=22} + + minimatch@5.1.9: + resolution: {integrity: sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==} + engines: {node: '>=10'} + minimatch@9.0.9: resolution: {integrity: sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==} engines: {node: '>=16 || 14 >=14.17'} @@ -2053,16 +3311,61 @@ packages: resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==} engines: {node: '>=16 || 14 >=14.17'} + mixpart@0.0.4: + resolution: {integrity: sha512-RAoaOSXnMLrfUfmFbNynRYjeMru/bhgAYRy/GQVI8gmRq7vm9V9c2gGVYnYoQ008X6YTmRIu5b0397U7vb0bIA==} + engines: {node: '>=22.0.0'} + + mixpart@0.0.5-alpha.1: + resolution: {integrity: sha512-2ZfG/NO2SVE9HLk1/W+yOrIOA0d674ljZExLdievZQpYjbJYQjIdye8vNMR63yF7nN/NbO9q8mp16JUEYBCilg==} + engines: {node: '>=20.0.0'} + + mixpart@0.0.6: + resolution: {integrity: sha512-CRdXtgfQH2jARmtNmPR0Q7jL20fiESbaYk1b0KvLD0jCdUuemepREtsbd8nbiY6BHV9OGGddAZITNXklupUPUQ==} + engines: {node: '>=20.0.0'} + mkdirp-classic@0.5.3: resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==} mlly@1.8.0: resolution: {integrity: sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g==} + mlly@1.8.2: + resolution: {integrity: sha512-d+ObxMQFmbt10sretNDytwt85VrbkhhUA/JBGm1MPaWJ65Cl4wOgLaB1NYvJSZ0Ef03MMEU/0xpPMXUIQ29UfA==} + + mongodb-connection-string-url@3.0.2: + resolution: {integrity: sha512-rMO7CGo/9BFwyZABcKAWL8UJwH/Kc2x0g72uhDWzG48URRax5TCIcJ7Rc3RZqffZzO/Gwff/jyKwCU9TN8gehA==} + mongodb-connection-string-url@7.0.1: resolution: {integrity: sha512-h0AZ9A7IDVwwHyMxmdMXKy+9oNlF0zFoahHiX3vQ8e3KFcSP3VmsmfvtRSuLPxmyv2vjIDxqty8smTgie/SNRQ==} engines: {node: '>=20.19.0'} + mongodb@6.21.0: + resolution: {integrity: sha512-URyb/VXMjJ4da46OeSXg+puO39XH9DeQpWCslifrRn9JWugy0D+DvvBvkm2WxmHe61O/H19JM66p1z7RHVkZ6A==} + engines: {node: '>=16.20.1'} + peerDependencies: + '@aws-sdk/credential-providers': ^3.188.0 + '@mongodb-js/zstd': ^1.1.0 || ^2.0.0 + gcp-metadata: ^5.2.0 + kerberos: ^2.0.1 + mongodb-client-encryption: '>=6.0.0 <7' + snappy: ^7.3.2 + socks: ^2.7.1 + peerDependenciesMeta: + '@aws-sdk/credential-providers': + optional: true + '@mongodb-js/zstd': + optional: true + gcp-metadata: + optional: true + kerberos: + optional: true + mongodb-client-encryption: + optional: true + snappy: + optional: true + socks: + optional: true + mongodb@7.2.0: resolution: {integrity: sha512-F/2+BMZtLVhY30ioZp0dAmZ+IRZMBqI+nrv6t5+9/1AIwCa8sMRC3jBf81lpxMhnZgqq8CoUD503Z1oZWq1/sw==} engines: {node: '>=20.19.0'} @@ -2102,6 +3405,9 @@ packages: resolution: {integrity: sha512-b2KQNsmgtkscfeDgkYMcWGn9vZI9YoXh802VDEwE6qc50zxBFQ0Oo8ROkawbPAsXCY1/Z1yp0MagqsZStPWJjw==} engines: {node: '>=20.19.0'} + ms@2.0.0: + resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==} + ms@2.1.3: resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} @@ -2117,6 +3423,11 @@ packages: engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} hasBin: true + nanoid@5.1.6: + resolution: {integrity: sha512-c7+7RQ+dMB5dPwwCp4ee1/iV/q2P6aK1mTZcfr1BTuVlyW9hJYiMPybJCcnBlQtuSmTIWNeazm/zqNoZSSElBg==} + engines: {node: ^18 || >=20} + hasBin: true + napi-build-utils@2.0.0: resolution: {integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==} @@ -2124,6 +3435,10 @@ packages: resolution: {integrity: sha512-Ucb+lsUcGxUqu3rn8cwHjT6gJQosO63nIX/aBQXB3+IDkNbFV7PuviysO+Rzz3aKn7PZhPj3bNF4PS9gDVjYCQ==} engines: {node: '>=0.4.10'} + negotiator@0.6.3: + resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==} + engines: {node: '>= 0.6'} + negotiator@1.0.0: resolution: {integrity: sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==} engines: {node: '>= 0.6'} @@ -2150,6 +3465,22 @@ packages: resolution: {integrity: sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + node-gyp-build-optional-packages@5.1.1: + resolution: {integrity: sha512-+P72GAjVAbTxjjwUmwjVrqrdZROD4nf8KgpBoDxqXXTiYZZt/ud60dE5yvCSr9lRO8e8yv6kgJIC0K0PfZFVQw==} + hasBin: true + + normalize-url@8.1.1: + resolution: {integrity: sha512-JYc0DPlpGWB40kH5g07gGTrYuMqV653k3uBKY6uITPWds3M0ov3GaWGp9lbE3Bzngx8+XkfzgvASb9vk9JDFXQ==} + engines: {node: '>=14.16'} + + npm-run-path@5.3.0: + resolution: {integrity: sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + + npm-run-path@6.0.0: + resolution: {integrity: sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA==} + engines: {node: '>=18'} + object-assign@4.1.1: resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==} engines: {node: '>=0.10.0'} @@ -2161,6 +3492,9 @@ packages: obug@2.1.1: resolution: {integrity: sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==} + ohash@2.0.11: + resolution: {integrity: sha512-RdR9FQrFwNBNXAr4GixM8YaRZRJ5PUWbKYbE5eOsrwAjJW0q2REGcf79oYPsLyskQCZG1PLN+S/K1V00joZAoQ==} + ollama@0.5.18: resolution: {integrity: sha512-lTFqTf9bo7Cd3hpF6CviBe/DEhewjoZYd9N/uCe7O20qYTvGqrNOFOBDj3lbZgFWHUgDv5EeyusYxsZSLS8nvg==} @@ -2171,6 +3505,10 @@ packages: once@1.4.0: resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} + onetime@6.0.0: + resolution: {integrity: sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==} + engines: {node: '>=12'} + onetime@7.0.0: resolution: {integrity: sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==} engines: {node: '>=18'} @@ -2179,6 +3517,10 @@ packages: resolution: {integrity: sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==} engines: {node: '>=18'} + open@8.4.0: + resolution: {integrity: sha512-XgFPPM+B28FtCCgSb9I+s9szOC1vZRSwgWsRUA5ylIxRTgKozqjOCrVOqGsYABPYK5qnfqClxZTFBa8PKt2v6Q==} + engines: {node: '>=12'} + openai@4.104.0: resolution: {integrity: sha512-p99EFNsA/yX6UhVO93f5kJsDRLAg+CTA2RBqdHK4RtK8u5IJw32Hyb2dTGKbnnFmnuoBv5r7Z2CURI9sGZpSuA==} hasBin: true @@ -2198,10 +3540,30 @@ packages: resolution: {integrity: sha512-weP+BZ8MVNnlCm8c0Qdc1WSWq4Qn7I+9CJGm7Qali6g44e/PUzbjNqJX5NJ9ljlNMosfJvg1fKEGILklK9cwnw==} engines: {node: '>=18'} + os-paths@4.4.0: + resolution: {integrity: sha512-wrAwOeXp1RRMFfQY8Sy7VaGVmPocaLwSFOYCGKSyo8qmJ+/yaafCl5BCA1IQZWqFSRBrKDYFeR9d/VyQzfH/jg==} + engines: {node: '>= 6.0'} + + p-cancelable@4.0.1: + resolution: {integrity: sha512-wBowNApzd45EIKdO1LaU+LrMBwAcjfPaYtVzV3lmfM3gf8Z4CHZsiIqlM8TZZ8okYvh5A1cP6gTfCRQtwUpaUg==} + engines: {node: '>=14.16'} + + p-event@6.0.1: + resolution: {integrity: sha512-Q6Bekk5wpzW5qIyUP4gdMEujObYstZl6DMMOSenwBvV0BlE5LkDwkjs5yHbZmdCEq2o4RJx4tE1vwxFVf2FG1w==} + engines: {node: '>=16.17'} + p-finally@1.0.0: resolution: {integrity: sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==} engines: {node: '>=4'} + p-limit@4.0.0: + resolution: {integrity: sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + + p-locate@6.0.0: + resolution: {integrity: sha512-wPrq66Llhl7/4AGC6I+cqxT07LhXvWL08LNXz1fENOw0Ap4sRZZ/gZpTTJ5jpurzzzfS2W/Ge9BY3LgLjCShcw==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + p-queue@6.6.2: resolution: {integrity: sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==} engines: {node: '>=8'} @@ -2210,27 +3572,68 @@ packages: resolution: {integrity: sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==} engines: {node: '>=8'} + p-timeout@6.1.4: + resolution: {integrity: sha512-MyIV3ZA/PmyBN/ud8vV9XzwTrNtR4jFrObymZYnZqMmW0zA8Z17vnT0rBgFE/TlohB+YCHqXMgZzb3Csp49vqg==} + engines: {node: '>=14.16'} + package-json-from-dist@1.0.1: resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==} + parent-module@1.0.1: + resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} + engines: {node: '>=6'} + + parse-json@5.2.0: + resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==} + engines: {node: '>=8'} + + parse-ms@4.0.0: + resolution: {integrity: sha512-TXfryirbmq34y8QBwgqCVLi+8oA3oWx2eAnSn62ITyEhEYaWRlVZ2DvMM9eZbMs/RfxPu/PK/aBLyGj4IrqMHw==} + engines: {node: '>=18'} + parseurl@1.3.3: resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==} engines: {node: '>= 0.8'} + path-exists@5.0.0: + resolution: {integrity: sha512-RjhtfwJOxzcFmNOi6ltcbcu4Iu+FL3zEj83dk4kAS+fVpTxXLO1b38RvJgT/0QwvV/L3aY9TAnyv0EOqW4GoMQ==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + + path-expression-matcher@1.5.0: + resolution: {integrity: sha512-cbrerZV+6rvdQrrD+iGMcZFEiiSrbv9Tfdkvnusy6y0x0GKBXREFg/Y65GhIfm0tnLntThhzCnfKwp1WRjeCyQ==} + engines: {node: '>=14.0.0'} + path-key@3.1.1: resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} engines: {node: '>=8'} + path-key@4.0.0: + resolution: {integrity: sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==} + engines: {node: '>=12'} + path-scurry@1.11.1: resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==} engines: {node: '>=16 || 14 >=14.18'} + path-to-regexp@0.1.13: + resolution: {integrity: sha512-A/AGNMFN3c8bOlvV9RreMdrv7jsmF9XIfDeCd87+I8RNg6s78BhJxMu69NEMHBSJFxKidViTEdruRwEk/WIKqA==} + path-to-regexp@8.4.2: resolution: {integrity: sha512-qRcuIdP69NPm4qbACK+aDogI5CBDMi1jKe0ry5rSQJz8JVLsC7jV8XpiJjGRLLol3N+R5ihGYcrPLTno6pAdBA==} + path-type@4.0.0: + resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==} + engines: {node: '>=8'} + pathe@2.0.3: resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==} + pend@1.2.0: + resolution: {integrity: sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==} + + perfect-debounce@2.1.0: + resolution: {integrity: sha512-LjgdTytVFXeUgtHZr9WYViYSM/g8MkcTPYDlPa3cDqMirHjKiSZPYd6DoL7pK8AJQr+uWkQvCjHNdiMqsrJs+g==} + pg-cloudflare@1.2.7: resolution: {integrity: sha512-YgCtzMH0ptvZJslLM1ffsY4EuGaU0cx4XSdXLRFae8bPP4dS5xL1tNB3k2o/N64cHJpwU7dxKli/nZ2lUa5fLg==} @@ -2276,6 +3679,15 @@ packages: pg-native: optional: true + pg@8.20.0: + resolution: {integrity: sha512-ldhMxz2r8fl/6QkXnBD3CR9/xg694oT6DZQ2s6c/RI28OjtSOpxnPrUCGOBJ46RCUxcWdx3p6kw/xnDHjKvaRA==} + engines: {node: '>= 16.0.0'} + peerDependencies: + pg-native: '>=3.0.1' + peerDependenciesMeta: + pg-native: + optional: true + pg@8.21.0: resolution: {integrity: sha512-AUP1EYJuHraQGsVoCQVIcM7TEJVGtDzxWtGFZd8rds9d+CCXlU5Js1rYgfLNvxy9iJrpHjGrRjoi/3BT9fRyiA==} engines: {node: '>= 16.0.0'} @@ -2307,6 +3719,9 @@ packages: resolution: {integrity: sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==} engines: {node: '>= 6'} + piscina@4.9.2: + resolution: {integrity: sha512-Fq0FERJWFEUpB4eSY59wSNwXD4RYqR+nR/WiEVcZW8IWfVBxJJafcgTEZDQo8k3w0sUarJ8RyVbbUF4GQ2LGbQ==} + pkce-challenge@5.0.0: resolution: {integrity: sha512-ueGLflrrnvwB3xuo/uGob5pd5FN7l0MsLf0Z87o/UQmRtwjvfylfc9MurIxRAWywCYTgrvpXBcqjV4OfCYGCIQ==} engines: {node: '>=16.20.0'} @@ -2314,6 +3729,9 @@ packages: pkg-types@1.3.1: resolution: {integrity: sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==} + pkg-types@2.3.1: + resolution: {integrity: sha512-y+ichcgc2LrADuhLNAx8DFjVfgz91pRxfZdI3UDhxHvcVEZsenLO+7XaU5vOp0u/7V/wZ+plyuQxtrDlZJ+yeg==} + postcss-load-config@6.0.1: resolution: {integrity: sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==} engines: {node: '>= 18'} @@ -2362,6 +3780,10 @@ packages: resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==} engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + pretty-ms@9.3.0: + resolution: {integrity: sha512-gjVS5hOP+M3wMm5nmNOucbIrqudzs9v/57bWRHQWLYklXqoXKrVfYW2W9+glfGsqtPgpiz5WwyEEB+ksXIx3gQ==} + engines: {node: '>=18'} + prompts@2.4.2: resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==} engines: {node: '>= 6'} @@ -2389,14 +3811,25 @@ packages: resolution: {integrity: sha512-Rzq0KEyX/w/tEybncDgdkZrJgVUsUMk3xjh3t5bv3S1HTAtg+uOYt72+ZfwiQwKdysThkTBdL/rTi6HDmX9Ddw==} engines: {node: '>=0.6'} + quick-lru@5.1.1: + resolution: {integrity: sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==} + engines: {node: '>=10'} + range-parser@1.2.1: resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==} engines: {node: '>= 0.6'} + raw-body@2.5.3: + resolution: {integrity: sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==} + engines: {node: '>= 0.8'} + raw-body@3.0.1: resolution: {integrity: sha512-9G8cA+tuMS75+6G/TzW8OtLzmBDMo8p1JRxN5AZ+LAp8uxGA8V8GZm4GQ4/N5QNQEnLmg6SS7wyuSmbKepiKqA==} engines: {node: '>= 0.10'} + rc9@3.0.1: + resolution: {integrity: sha512-gMDyleLWVE+i6Sgtc0QbbY6pEKqYs97NGi6isHQPqYlLemPoO8dxQ3uGi0f4NiP98c+jMW6cG1Kx9dDwfvqARQ==} + rc@1.2.8: resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==} hasBin: true @@ -2412,14 +3845,32 @@ packages: resolution: {integrity: sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==} engines: {node: '>= 14.18.0'} + readdirp@5.0.0: + resolution: {integrity: sha512-9u/XQ1pvrQtYyMpZe7DXKv2p5CNvyVwzUB6uhLAnQwHMSgKMBR62lc7AHljaeteeHXn11XTAaLLUVZYVZyuRBQ==} + engines: {node: '>= 20.19.0'} + redis@5.12.1: resolution: {integrity: sha512-LDsoVvb/CpoV9EN3FXvgvSHNJWuCIzl9MiO3ppOevuGLpSGJhwfQjpEwfFJcQvNSddHADDdZaWx0HnmMxRXG7g==} engines: {node: '>= 18.19.0'} + reflect-metadata@0.2.2: + resolution: {integrity: sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==} + + require-directory@2.1.1: + resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==} + engines: {node: '>=0.10.0'} + require-from-string@2.0.2: resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==} engines: {node: '>=0.10.0'} + resolve-alpn@1.2.1: + resolution: {integrity: sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==} + + resolve-from@4.0.0: + resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==} + engines: {node: '>=4'} + resolve-from@5.0.0: resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==} engines: {node: '>=8'} @@ -2427,6 +3878,10 @@ packages: resolve-pkg-maps@1.0.0: resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==} + responselike@4.0.2: + resolution: {integrity: sha512-cGk8IbWEAnaCpdAt1BHzJ3Ahz5ewDJa0KseTsE3qIRMJ3C698W8psM7byCeWVpd/Ha7FUYzuRVzXoKoM6nRUbA==} + engines: {node: '>=20'} + restore-cursor@5.1.0: resolution: {integrity: sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==} engines: {node: '>=18'} @@ -2444,6 +3899,9 @@ packages: resolution: {integrity: sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==} engines: {node: '>=18'} + rxjs@7.8.2: + resolution: {integrity: sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==} + safe-buffer@5.2.1: resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==} @@ -2454,15 +3912,46 @@ packages: safer-buffer@2.1.2: resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==} + scule@1.3.0: + resolution: {integrity: sha512-6FtHJEvt+pVMIB9IBY+IcCJ6Z5f1iQnytgyfKMhDKgmzYG+TeH/wx1y3l27rshSbLiSanrR9ffZDrEsmjlQF2g==} + + seedrandom@3.0.5: + resolution: {integrity: sha512-8OwmbklUNzwezjGInmZ+2clQmExQPvomqjL7LFqOYqtmuxRgQYqOD3mHaU+MvZn5FLUeVxVfQjwLZW/n/JFuqg==} + + seek-bzip@2.0.0: + resolution: {integrity: sha512-SMguiTnYrhpLdk3PwfzHeotrcwi8bNV4iemL9tx9poR/yeaMYwB9VzR1w7b57DuWpuqR8n6oZboi0hj3AxZxQg==} + hasBin: true + + semver-regex@4.0.5: + resolution: {integrity: sha512-hunMQrEy1T6Jr2uEVjrAIqjwWcQTgOAcIM52C8MY1EZSD3DDNft04XzvYKPqjED65bNVVko0YI38nYeEHCX3yw==} + engines: {node: '>=12'} + + semver-truncate@3.0.0: + resolution: {integrity: sha512-LJWA9kSvMolR51oDE6PN3kALBNaUdkxzAGcexw8gjMA8xr5zUqK0JiR3CgARSqanYF3Z1YHvsErb1KDgh+v7Rg==} + engines: {node: '>=12'} + + semver@7.7.4: + resolution: {integrity: sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==} + engines: {node: '>=10'} + hasBin: true + semver@7.8.1: resolution: {integrity: sha512-rkVq3IXh+4FDGch+KwzX3aV9W3kO54GyEgpvBzSyctDA6Xtd7RJQV1xmXbeQp5v7+VzLOfVqiutSE6GICgPFvg==} engines: {node: '>=10'} hasBin: true + send@0.19.2: + resolution: {integrity: sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==} + engines: {node: '>= 0.8.0'} + send@1.2.0: resolution: {integrity: sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==} engines: {node: '>= 18'} + serve-static@1.16.3: + resolution: {integrity: sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==} + engines: {node: '>= 0.8.0'} + serve-static@2.2.0: resolution: {integrity: sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==} engines: {node: '>= 18'} @@ -2525,10 +4014,22 @@ packages: resolution: {integrity: sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==} engines: {node: '>= 10.0.0', npm: '>= 3.0.0'} + sort-keys-length@1.0.1: + resolution: {integrity: sha512-GRbEOUqCxemTAk/b32F2xa8wDTs+Z1QHOkbhJDQTvv/6G3ZkbJ+frYWsTcc7cBB3Fu4wy4XlLCuNtJuMn7Gsvw==} + engines: {node: '>=0.10.0'} + + sort-keys@1.1.2: + resolution: {integrity: sha512-vzn8aSqKgytVik0iwdBEi+zevbTYZogewTUM6dtpmGwEcdzbub/TX4bCzRhebDCRC3QzXgJsLRKB2V/Oof7HXg==} + engines: {node: '>=0.10.0'} + source-map-js@1.2.1: resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==} engines: {node: '>=0.10.0'} + source-map@0.7.6: + resolution: {integrity: sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==} + engines: {node: '>= 12'} + source-map@0.8.0-beta.0: resolution: {integrity: sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==} engines: {node: '>= 8'} @@ -2567,6 +4068,9 @@ packages: resolution: {integrity: sha512-I6GPS/E0zyieHehMRPQcqkiBMJKGgLta+1hREixhoLPqEA0AlVFiC43dl8uPpmkkeRdDMzYRWFWk5/l9x7nmNg==} engines: {node: '>=0.10.0'} + streamx@2.26.0: + resolution: {integrity: sha512-VvNG1K72Po/xwJzxZFnZ++Tbrv4lwSptsbkFuzXCJAYZvCK5nnxsvXU6ajqkv7chyiI1Y0YXq2Jh8Iy8Y7NF/A==} + string-width@4.2.3: resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} engines: {node: '>=8'} @@ -2590,10 +4094,28 @@ packages: resolution: {integrity: sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==} engines: {node: '>=12'} + strip-dirs@3.0.0: + resolution: {integrity: sha512-I0sdgcFTfKQlUPZyAqPJmSG3HLO9rWDFnxonnIbskYNM3DwFOeTNB5KzVq3dA1GdRAc/25b5Y7UO2TQfKWw4aQ==} + + strip-final-newline@3.0.0: + resolution: {integrity: sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==} + engines: {node: '>=12'} + + strip-final-newline@4.0.0: + resolution: {integrity: sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==} + engines: {node: '>=18'} + strip-json-comments@2.0.1: resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==} engines: {node: '>=0.10.0'} + strnum@2.3.0: + resolution: {integrity: sha512-ums3KNd42PGyx5xaoVTO1mjU1bH3NpY4vsrVlnv9PNGqQj8wd7rJ6nEypLrJ7z5vxK5RP0yMLo6J/Gsm62DI5Q==} + + strtok3@10.3.5: + resolution: {integrity: sha512-ki4hZQfh5rX0QDLLkOCj+h+CVNkqmp/CMf8v8kZpkNVK6jGQooMytqzLZYUVYIZcFZ6yDB70EfD8POcFXiF5oA==} + engines: {node: '>=18'} + sucrase@3.35.0: resolution: {integrity: sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==} engines: {node: '>=16 || 14 >=14.17'} @@ -2602,14 +4124,38 @@ packages: suffix-thumb@5.0.2: resolution: {integrity: sha512-I5PWXAFKx3FYnI9a+dQMWNqTxoRt6vdBdb0O+BJ1sxXCWtSoQCusc13E58f+9p4MYx/qCnEMkD5jac6K2j3dgA==} + super-regex@1.1.0: + resolution: {integrity: sha512-WHkws2ZflZe41zj6AolvvmaTrWds/VuyeYr9iPVv/oQeaIoVxMKaushfFWpOGDT+GuBrM/sVqF8KUCYQlSSTdQ==} + engines: {node: '>=18'} + + supports-color@10.2.2: + resolution: {integrity: sha512-SS+jx45GF1QjgEXQx4NJZV9ImqmO2NPz5FNsIHrsDjh2YsHnawpan7SNQ1o8NuhrbHZy9AZhIoCUiCeaW/C80g==} + engines: {node: '>=18'} + supports-color@7.2.0: resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} engines: {node: '>=8'} + supports-color@8.1.1: + resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==} + engines: {node: '>=10'} + + supports-hyperlinks@4.4.0: + resolution: {integrity: sha512-UKbpT93hN5Nr9go5UY7bopIB9YQlMz9nm/ct4IXt/irb5YRkn9WaqrOBJGZ5Pwvsd5FQzSVeYlGdXoCAPQZrPg==} + engines: {node: '>=20'} + sylvester@0.0.21: resolution: {integrity: sha512-yUT0ukFkFEt4nb+NY+n2ag51aS/u9UHXoZw+A4jgD77/jzZsBoSDHuqysrVCBC4CYR4TYvUJq54ONpXgDBH8tA==} engines: {node: '>=0.2.6'} + system-architecture@1.0.0: + resolution: {integrity: sha512-0OJWD12D7XX3KUg1DYkMaTTjSTo2k/mhIYI3HlBlceXSMcJhW/1qO735fPKS5prcyjvn57Ub151vvASYXpQrEw==} + engines: {node: '>=18'} + + tapable@2.3.3: + resolution: {integrity: sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==} + engines: {node: '>=6'} + tar-fs@2.1.4: resolution: {integrity: sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==} @@ -2617,6 +4163,16 @@ packages: resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==} engines: {node: '>=6'} + tar-stream@3.1.7: + resolution: {integrity: sha512-qJj60CXt7IU1Ffyc3NJMjh6EkuCFej46zUqJ4J7pqYlThyd9bO0XBTmcOIhSzZJVWfsLks0+nle/j538YAW9RQ==} + + terminal-link@5.0.0: + resolution: {integrity: sha512-qFAy10MTMwjzjU8U16YS4YoZD+NQLHzLssFMNqgravjbvIPNiqkGFR4yjhJfmY9R5OFU7+yHxc6y+uGHkKwLRA==} + engines: {node: '>=20'} + + text-decoder@1.2.7: + resolution: {integrity: sha512-vlLytXkeP4xvEq2otHeJfSQIRyWxo/oZGEbXrtEEF9Hnmrdly59sUbzZ/QgyWuLYHctCHxFF4tRQZNQ9k60ExQ==} + thenify-all@1.6.0: resolution: {integrity: sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==} engines: {node: '>=0.8'} @@ -2624,6 +4180,13 @@ packages: thenify@3.3.1: resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==} + through@2.3.8: + resolution: {integrity: sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==} + + time-span@5.1.0: + resolution: {integrity: sha512-75voc/9G4rDIJleOo4jPvN4/YC4GRZrY8yy1uU4lwrB3XEQbWve8zXoO5No4eFrGcTAMYyoY67p8jRQdtA1HbA==} + engines: {node: '>=12'} + tinybench@2.9.0: resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==} @@ -2650,6 +4213,10 @@ packages: resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==} engines: {node: '>=0.6'} + token-types@6.1.2: + resolution: {integrity: sha512-dRXchy+C0IgK8WPC6xvCHFRIWYUbqqdEIKPaKo/AcTUNzwLTK6AH7RjdLWsEZcAN/TBdtfUw3PYEgPr5VPr6ww==} + engines: {node: '>=14.16'} + tr46@0.0.3: resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==} @@ -2697,6 +4264,18 @@ packages: tunnel-agent@0.6.0: resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==} + type-fest@0.21.3: + resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==} + engines: {node: '>=10'} + + type-fest@4.41.0: + resolution: {integrity: sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==} + engines: {node: '>=16'} + + type-is@1.6.18: + resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==} + engines: {node: '>= 0.6'} + type-is@2.0.1: resolution: {integrity: sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==} engines: {node: '>= 0.6'} @@ -2709,12 +4288,40 @@ packages: ufo@1.6.1: resolution: {integrity: sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==} + ufo@1.6.4: + resolution: {integrity: sha512-JFNbkD1Svwe0KvGi8GOeLcP4kAWQ609twvCdcHxq1oSL8svv39ZuSvajcD8B+5D0eL4+s1Is2D/O6KN3qcTeRA==} + + uid@2.0.2: + resolution: {integrity: sha512-u3xV3X7uzvi5b1MncmZo3i2Aw222Zk1keqLA1YkHldREkAhAqi65wuPfe7lHx8H/Wzy+8CE7S7uS3jekIM5s8g==} + engines: {node: '>=8'} + + uint8array-extras@1.5.0: + resolution: {integrity: sha512-rvKSBiC5zqCCiDZ9kAOszZcDvdAHwwIKJG33Ykj43OKcWsnmcBRL09YTU4nOeHZ8Y2a7l1MgTd08SBe9A8Qj6A==} + engines: {node: '>=18'} + + ulid@2.4.0: + resolution: {integrity: sha512-fIRiVTJNcSRmXKPZtGzFQv9WRrZ3M9eoptl/teFJvjOzmpU+/K/JH6HZ8deBfb5vMEpicJcLn7JmvdknlMq7Zg==} + hasBin: true + + ulid@3.0.2: + resolution: {integrity: sha512-yu26mwteFYzBAot7KVMqFGCVpsF6g8wXfJzQUHvu1no3+rRRSFcSV2nKeYvNPLD2J4b08jYBDhHUjeH0ygIl9w==} + hasBin: true + + unbzip2-stream@1.4.3: + resolution: {integrity: sha512-mlExGW4w71ebDJviH16lQLtZS32VKqsSfk80GCfUlwT/4/hNRFsoscrF/c++9xinkMzECL1uL9DDwXqFWkruPg==} + + unctx@2.5.0: + resolution: {integrity: sha512-p+Rz9x0R7X+CYDkT+Xg8/GhpcShTlU8n+cf9OtOEf7zEQsNcCZO1dPKNRDqvUTaq+P32PMMkxWHwfrxkqfqAYg==} + underscore@1.13.8: resolution: {integrity: sha512-DXtD3ZtEQzc7M8m4cXotyHR+FAS18C64asBYY5vqZexfYryNNnDc02W4hKg3rdQuqOYas1jkseX0+nZXjTXnvQ==} undici-types@5.26.5: resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==} + undici-types@6.21.0: + resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==} + undici-types@7.14.0: resolution: {integrity: sha512-QQiYxHuyZ9gQUIrmPo3IA+hUl4KYk8uSA7cHrcKd/l3p1OTpZcM0Tbp9x7FAtXdAYhlasd60ncPpgu6ihG6TOA==} @@ -2725,6 +4332,18 @@ packages: resolution: {integrity: sha512-4yqz8a3n5HmGTlsbADNtr/dJlhkh/55Rq798G6ibiULcXbDtaLpTl1pvdqcbFfeoj3iSi52lePFM7h9H21cw/A==} engines: {node: '>=18.17'} + undici@7.22.0: + resolution: {integrity: sha512-RqslV2Us5BrllB+JeiZnK4peryVTndy9Dnqq62S3yYRRTj0tFQCwEniUy2167skdGOy3vqRzEvl1Dm4sV2ReDg==} + engines: {node: '>=20.18.1'} + + unicorn-magic@0.1.0: + resolution: {integrity: sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==} + engines: {node: '>=18'} + + unicorn-magic@0.3.0: + resolution: {integrity: sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==} + engines: {node: '>=18'} + universalify@2.0.1: resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==} engines: {node: '>= 10.0.0'} @@ -2733,9 +4352,21 @@ packages: resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==} engines: {node: '>= 0.8'} + unplugin@2.3.11: + resolution: {integrity: sha512-5uKD0nqiYVzlmCRs01Fhs2BdkEgBS3SAVP6ndrBsuK42iC2+JHyxM05Rm9G8+5mkmRtzMZGY8Ct5+mliZxU/Ww==} + engines: {node: '>=18.12.0'} + + untyped@2.0.0: + resolution: {integrity: sha512-nwNCjxJTjNuLCgFr42fEak5OcLuB3ecca+9ksPFNvtfYSLpjf+iJqSIaSnIile6ZPbKYxI5k2AfXqeopGudK/g==} + hasBin: true + util-deprecate@1.0.2: resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} + utils-merge@1.0.1: + resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==} + engines: {node: '>= 0.4.0'} + uuid@11.1.1: resolution: {integrity: sha512-vIYxrBCC/N/K+Js3qSN88go7kIfNPssr/hHCesKCQNAjmgvYS2oqr69kIufEG+O4+PfezOH4EbIeHCfFov8ZgQ==} hasBin: true @@ -2829,6 +4460,13 @@ packages: jsdom: optional: true + watchpack@2.5.1: + resolution: {integrity: sha512-Zn5uXdcFNIA1+1Ei5McRd+iRzfhENPCe7LeABkJtNulSxjma+l7ltNx55BWZkRlwRnpOgHqxnjyaDgJnNXnqzg==} + engines: {node: '>=10.13.0'} + + wcwidth@1.0.1: + resolution: {integrity: sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==} + web-streams-polyfill@3.3.3: resolution: {integrity: sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==} engines: {node: '>= 8'} @@ -2837,6 +4475,9 @@ packages: resolution: {integrity: sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug==} engines: {node: '>= 14'} + web-worker@1.5.0: + resolution: {integrity: sha512-RiMReJrTAiA+mBjGONMnjVDP2u3p9R1vkcGz6gDIrOMT3oGuYwX2WRMYI9ipkphSuE5XKEhydbhNEJh4NY9mlw==} + webidl-conversions@3.0.1: resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==} @@ -2847,6 +4488,9 @@ packages: resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==} engines: {node: '>=12'} + webpack-virtual-modules@0.6.2: + resolution: {integrity: sha512-66/V2i5hQanC51vBQKPH4aI8NMAcBW59FVBs+rC7eGHupMyfn34q7rZIE+ETlJ+XTevqfUhVVBgSUNSW2flEUQ==} + whatwg-fetch@3.6.20: resolution: {integrity: sha512-EqhiFU6daOA8kpjOWTL0olhVOF3i7OrFzSYiGsEMB8GcXS+RrzauAERX65xMeNWVqxA6HXH2m69Z9LaKKdisfg==} @@ -2870,10 +4514,30 @@ packages: engines: {node: '>=8'} hasBin: true + widest-line@3.1.0: + resolution: {integrity: sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==} + engines: {node: '>=8'} + + widest-line@5.0.0: + resolution: {integrity: sha512-c9bZp7b5YtRj2wOe6dlj32MK+Bx/M/d+9VB2SHM1OtsUHR0aV0tdP6DWh/iMt0kWi1t5g1Iudu6hQRNd1A4PVA==} + engines: {node: '>=18'} + wordnet-db@3.1.14: resolution: {integrity: sha512-zVyFsvE+mq9MCmwXUWHIcpfbrHHClZWZiVOzKSxNJruIcFn2RbY55zkhiAMMxM8zCVSmtNiViq8FsAZSFpMYag==} engines: {node: '>=0.6.0'} + wordwrap@1.0.0: + resolution: {integrity: sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==} + + workflow@4.3.1: + resolution: {integrity: sha512-G2NxBf9BVerh0/AA14Ona0zamjCjCFvYQ9+k3pMzRnet0A/qzXiRL6t29iLjfau9jEIvR9oaU+i+DXTvCj9JQQ==} + hasBin: true + peerDependencies: + '@opentelemetry/api': '1' + peerDependenciesMeta: + '@opentelemetry/api': + optional: true + wrap-ansi@7.0.0: resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==} engines: {node: '>=10'} @@ -2882,6 +4546,10 @@ packages: resolution: {integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==} engines: {node: '>=12'} + wrap-ansi@9.0.2: + resolution: {integrity: sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==} + engines: {node: '>=18'} + wrappy@1.0.2: resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} @@ -2901,10 +4569,46 @@ packages: resolution: {integrity: sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw==} engines: {node: '>=18'} + xdg-app-paths@5.1.0: + resolution: {integrity: sha512-RAQ3WkPf4KTU1A8RtFx3gWywzVKe00tfOPFfl2NDGqbIFENQO4kqAJp7mhQjNj/33W5x5hiWWUdyfPq/5SU3QA==} + engines: {node: '>=6'} + + xdg-portable@7.3.0: + resolution: {integrity: sha512-sqMMuL1rc0FmMBOzCpd0yuy9trqF2yTTVe+E9ogwCSWQCdDEtQUwrZPT6AxqtsFGRNxycgncbP/xmOOSPw5ZUw==} + engines: {node: '>= 6.0'} + + xml-naming@0.1.0: + resolution: {integrity: sha512-k8KO9hrMyNk6tUWqUfkTEZbezRRpONVOzUTnc97VnCvyj6Tf9lyUR9EDAIeiVLv56jsMcoXEwjW8Kv5yPY52lw==} + engines: {node: '>=16.0.0'} + xtend@4.0.2: resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==} engines: {node: '>=0.4'} + y18n@5.0.8: + resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==} + engines: {node: '>=10'} + + yargs-parser@21.1.1: + resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==} + engines: {node: '>=12'} + + yargs@17.7.2: + resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==} + engines: {node: '>=12'} + + yauzl@3.3.2: + resolution: {integrity: sha512-Md9ankxxN23wncAN8s7+Tn3Co52zLUPMtnrLAbVCnfG5d2tKBFfmygYSgXlqFgXObtzIgqkx7aNgDBpso9+4qA==} + engines: {node: '>=12'} + + yocto-queue@1.2.2: + resolution: {integrity: sha512-4LCcse/U2MHZ63HAJVE+v71o7yOdIe4cZ70Wpf8D/IyjDKYQLV5GD46B+hSTjJsvV5PztjvHoU580EftxjDZFQ==} + engines: {node: '>=12.20'} + + yoctocolors@2.1.2: + resolution: {integrity: sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug==} + engines: {node: '>=18'} + zod-to-json-schema@3.25.2: resolution: {integrity: sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==} peerDependencies: @@ -2913,9 +4617,15 @@ packages: zod@3.25.76: resolution: {integrity: sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==} + zod@4.1.11: + resolution: {integrity: sha512-WPsqwxITS2tzx1bzhIKsEs19ABD5vmCVa4xBo2tq/SrV4RNZtfws1EnCWQXM6yh8bD08a1idvkB5MZSBiZsjwg==} + zod@4.1.12: resolution: {integrity: sha512-JInaHOamG8pt5+Ey8kGmdcAcg3OL9reK8ltczgHTAwNhMys/6ThXHityHxVV2p3fkw/c+MAvBHFVYHFZDmjMCQ==} + zod@4.3.6: + resolution: {integrity: sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==} + snapshots: '@ai-sdk/gateway@3.0.91(zod@4.1.12)': @@ -2960,6 +4670,96 @@ snapshots: transitivePeerDependencies: - encoding + '@aws-crypto/crc32@5.2.0': + dependencies: + '@aws-crypto/util': 5.2.0 + '@aws-sdk/types': 3.973.9 + tslib: 2.8.1 + + '@aws-crypto/sha256-browser@5.2.0': + dependencies: + '@aws-crypto/sha256-js': 5.2.0 + '@aws-crypto/supports-web-crypto': 5.2.0 + '@aws-crypto/util': 5.2.0 + '@aws-sdk/types': 3.973.9 + '@aws-sdk/util-locate-window': 3.965.5 + '@smithy/util-utf8': 2.3.0 + tslib: 2.8.1 + + '@aws-crypto/sha256-js@5.2.0': + dependencies: + '@aws-crypto/util': 5.2.0 + '@aws-sdk/types': 3.973.9 + tslib: 2.8.1 + + '@aws-crypto/supports-web-crypto@5.2.0': + dependencies: + tslib: 2.8.1 + + '@aws-crypto/util@5.2.0': + dependencies: + '@aws-sdk/types': 3.973.9 + '@smithy/util-utf8': 2.3.0 + tslib: 2.8.1 + + '@aws-sdk/core@3.974.15': + dependencies: + '@aws-sdk/types': 3.973.9 + '@aws-sdk/xml-builder': 3.972.26 + '@aws/lambda-invoke-store': 0.2.4 + '@smithy/core': 3.24.6 + '@smithy/signature-v4': 5.4.6 + '@smithy/types': 4.14.3 + bowser: 2.14.1 + tslib: 2.8.1 + + '@aws-sdk/credential-provider-web-identity@3.972.13': + dependencies: + '@aws-sdk/core': 3.974.15 + '@aws-sdk/nested-clients': 3.997.13 + '@aws-sdk/types': 3.973.9 + '@smithy/property-provider': 4.3.6 + '@smithy/shared-ini-file-loader': 4.5.6 + '@smithy/types': 4.14.3 + tslib: 2.8.1 + + '@aws-sdk/nested-clients@3.997.13': + dependencies: + '@aws-crypto/sha256-browser': 5.2.0 + '@aws-crypto/sha256-js': 5.2.0 + '@aws-sdk/core': 3.974.15 + '@aws-sdk/signature-v4-multi-region': 3.996.30 + '@aws-sdk/types': 3.973.9 + '@smithy/core': 3.24.6 + '@smithy/fetch-http-handler': 5.4.6 + '@smithy/node-http-handler': 4.7.6 + '@smithy/types': 4.14.3 + tslib: 2.8.1 + + '@aws-sdk/signature-v4-multi-region@3.996.30': + dependencies: + '@aws-sdk/types': 3.973.9 + '@smithy/signature-v4': 5.4.6 + '@smithy/types': 4.14.3 + tslib: 2.8.1 + + '@aws-sdk/types@3.973.9': + dependencies: + '@smithy/types': 4.14.3 + tslib: 2.8.1 + + '@aws-sdk/util-locate-window@3.965.5': + dependencies: + tslib: 2.8.1 + + '@aws-sdk/xml-builder@3.972.26': + dependencies: + '@smithy/types': 4.14.3 + fast-xml-parser: 5.7.3 + tslib: 2.8.1 + + '@aws/lambda-invoke-store@0.2.4': {} + '@azure/abort-controller@2.1.2': dependencies: tslib: 2.8.1 @@ -3075,6 +4875,26 @@ snapshots: '@babel/helper-validator-identifier@7.29.7': {} + '@borewit/text-codec@0.2.2': {} + + '@cbor-extract/cbor-extract-darwin-arm64@2.2.2': + optional: true + + '@cbor-extract/cbor-extract-darwin-x64@2.2.2': + optional: true + + '@cbor-extract/cbor-extract-linux-arm64@2.2.2': + optional: true + + '@cbor-extract/cbor-extract-linux-arm@2.2.2': + optional: true + + '@cbor-extract/cbor-extract-linux-x64@2.2.2': + optional: true + + '@cbor-extract/cbor-extract-win32-x64@2.2.2': + optional: true + '@cfworker/json-schema@4.1.1': {} '@cloudflare/workers-types@4.20251118.0': {} @@ -3246,6 +5066,8 @@ snapshots: - supports-color - utf-8-validate + '@graphile/logger@0.2.0': {} + '@hono/node-server@1.19.14(hono@4.12.23)': dependencies: hono: 4.12.23 @@ -3285,6 +5107,11 @@ snapshots: '@jridgewell/sourcemap-codec': 1.5.5 '@jridgewell/trace-mapping': 0.3.31 + '@jridgewell/remapping@2.3.5': + dependencies: + '@jridgewell/gen-mapping': 0.3.13 + '@jridgewell/trace-mapping': 0.3.31 + '@jridgewell/resolve-uri@3.1.2': {} '@jridgewell/sourcemap-codec@1.5.5': {} @@ -3294,6 +5121,8 @@ snapshots: '@jridgewell/resolve-uri': 3.1.2 '@jridgewell/sourcemap-codec': 1.5.5 + '@keyv/serialize@1.1.1': {} + '@langchain/core@1.1.48(@opentelemetry/api@1.9.0)(@opentelemetry/sdk-trace-base@2.2.0(@opentelemetry/api@1.9.0))(openai@4.104.0(encoding@0.1.13)(ws@8.21.0)(zod@4.1.12))(ws@8.21.0)': dependencies: '@cfworker/json-schema': 4.1.1 @@ -3322,6 +5151,8 @@ snapshots: '@opentelemetry/exporter-trace-otlp-http': 0.207.0(@opentelemetry/api@1.9.0) '@opentelemetry/sdk-trace-base': 2.2.0(@opentelemetry/api@1.9.0) + '@lukeed/csprng@1.1.0': {} + '@mistralai/mistralai@1.10.0': dependencies: zod: 3.25.76 @@ -3380,6 +5211,158 @@ snapshots: dependencies: sparse-bitfield: 3.0.3 + '@napi-rs/nice-android-arm-eabi@1.1.1': + optional: true + + '@napi-rs/nice-android-arm64@1.1.1': + optional: true + + '@napi-rs/nice-darwin-arm64@1.1.1': + optional: true + + '@napi-rs/nice-darwin-x64@1.1.1': + optional: true + + '@napi-rs/nice-freebsd-x64@1.1.1': + optional: true + + '@napi-rs/nice-linux-arm-gnueabihf@1.1.1': + optional: true + + '@napi-rs/nice-linux-arm64-gnu@1.1.1': + optional: true + + '@napi-rs/nice-linux-arm64-musl@1.1.1': + optional: true + + '@napi-rs/nice-linux-ppc64-gnu@1.1.1': + optional: true + + '@napi-rs/nice-linux-riscv64-gnu@1.1.1': + optional: true + + '@napi-rs/nice-linux-s390x-gnu@1.1.1': + optional: true + + '@napi-rs/nice-linux-x64-gnu@1.1.1': + optional: true + + '@napi-rs/nice-linux-x64-musl@1.1.1': + optional: true + + '@napi-rs/nice-openharmony-arm64@1.1.1': + optional: true + + '@napi-rs/nice-win32-arm64-msvc@1.1.1': + optional: true + + '@napi-rs/nice-win32-ia32-msvc@1.1.1': + optional: true + + '@napi-rs/nice-win32-x64-msvc@1.1.1': + optional: true + + '@napi-rs/nice@1.1.1': + optionalDependencies: + '@napi-rs/nice-android-arm-eabi': 1.1.1 + '@napi-rs/nice-android-arm64': 1.1.1 + '@napi-rs/nice-darwin-arm64': 1.1.1 + '@napi-rs/nice-darwin-x64': 1.1.1 + '@napi-rs/nice-freebsd-x64': 1.1.1 + '@napi-rs/nice-linux-arm-gnueabihf': 1.1.1 + '@napi-rs/nice-linux-arm64-gnu': 1.1.1 + '@napi-rs/nice-linux-arm64-musl': 1.1.1 + '@napi-rs/nice-linux-ppc64-gnu': 1.1.1 + '@napi-rs/nice-linux-riscv64-gnu': 1.1.1 + '@napi-rs/nice-linux-s390x-gnu': 1.1.1 + '@napi-rs/nice-linux-x64-gnu': 1.1.1 + '@napi-rs/nice-linux-x64-musl': 1.1.1 + '@napi-rs/nice-openharmony-arm64': 1.1.1 + '@napi-rs/nice-win32-arm64-msvc': 1.1.1 + '@napi-rs/nice-win32-ia32-msvc': 1.1.1 + '@napi-rs/nice-win32-x64-msvc': 1.1.1 + optional: true + + '@nestjs/common@11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2)': + dependencies: + file-type: 21.3.4 + iterare: 1.2.1 + load-esm: 1.0.3 + reflect-metadata: 0.2.2 + rxjs: 7.8.2 + tslib: 2.8.1 + uid: 2.0.2 + transitivePeerDependencies: + - supports-color + + '@nestjs/core@11.1.24(@nestjs/common@11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2))(reflect-metadata@0.2.2)(rxjs@7.8.2)': + dependencies: + '@nestjs/common': 11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2) + '@nuxt/opencollective': 0.4.1 + fast-safe-stringify: 2.1.1 + iterare: 1.2.1 + path-to-regexp: 8.4.2 + reflect-metadata: 0.2.2 + rxjs: 7.8.2 + tslib: 2.8.1 + uid: 2.0.2 + + '@nodable/entities@2.1.1': {} + + '@nuxt/kit@4.4.2': + dependencies: + c12: 3.3.4 + consola: 3.4.2 + defu: 6.1.7 + destr: 2.0.5 + errx: 0.1.0 + exsolve: 1.0.8 + ignore: 7.0.5 + jiti: 2.7.0 + klona: 2.0.6 + mlly: 1.8.2 + ohash: 2.0.11 + pathe: 2.0.3 + pkg-types: 2.3.1 + rc9: 3.0.1 + scule: 1.3.0 + semver: 7.8.1 + tinyglobby: 0.2.15 + ufo: 1.6.4 + unctx: 2.5.0 + untyped: 2.0.0 + transitivePeerDependencies: + - magicast + + '@nuxt/opencollective@0.4.1': + dependencies: + consola: 3.4.2 + + '@oclif/core@4.8.1': + dependencies: + ansi-escapes: 4.3.2 + ansis: 3.17.0 + clean-stack: 3.0.1 + cli-spinners: 2.9.2 + debug: 4.4.3(supports-color@8.1.1) + ejs: 3.1.10 + get-package-type: 0.1.0 + indent-string: 4.0.0 + is-wsl: 2.2.0 + lilconfig: 3.1.3 + minimatch: 10.2.5 + semver: 7.8.1 + string-width: 4.2.3 + supports-color: 8.1.1 + tinyglobby: 0.2.15 + widest-line: 3.1.0 + wordwrap: 1.0.0 + wrap-ansi: 7.0.0 + + '@oclif/plugin-help@6.2.37': + dependencies: + '@oclif/core': 4.8.1 + '@opentelemetry/api-logs@0.207.0': dependencies: '@opentelemetry/api': 1.9.0 @@ -3586,8 +5569,68 @@ snapshots: '@rollup/rollup-win32-x64-msvc@4.61.0': optional: true + '@sec-ant/readable-stream@0.4.1': {} + '@sinclair/typebox@0.27.10': {} + '@sindresorhus/is@7.2.0': {} + + '@sindresorhus/merge-streams@4.0.0': {} + + '@smithy/core@3.24.6': + dependencies: + '@aws-crypto/crc32': 5.2.0 + '@smithy/types': 4.14.3 + tslib: 2.8.1 + + '@smithy/fetch-http-handler@5.4.6': + dependencies: + '@smithy/core': 3.24.6 + '@smithy/types': 4.14.3 + tslib: 2.8.1 + + '@smithy/is-array-buffer@2.2.0': + dependencies: + tslib: 2.8.1 + + '@smithy/node-http-handler@4.7.6': + dependencies: + '@smithy/core': 3.24.6 + '@smithy/types': 4.14.3 + tslib: 2.8.1 + + '@smithy/property-provider@4.3.6': + dependencies: + '@smithy/core': 3.24.6 + tslib: 2.8.1 + + '@smithy/shared-ini-file-loader@4.5.6': + dependencies: + '@smithy/core': 3.24.6 + tslib: 2.8.1 + + '@smithy/signature-v4@5.4.6': + dependencies: + '@smithy/core': 3.24.6 + '@smithy/types': 4.14.3 + tslib: 2.8.1 + + '@smithy/types@4.14.3': + dependencies: + tslib: 2.8.1 + + '@smithy/util-buffer-from@2.2.0': + dependencies: + '@smithy/is-array-buffer': 2.2.0 + tslib: 2.8.1 + + '@smithy/util-utf8@2.3.0': + dependencies: + '@smithy/util-buffer-from': 2.2.0 + tslib: 2.8.1 + + '@standard-schema/spec@1.0.0': {} + '@standard-schema/spec@1.1.0': {} '@supabase/auth-js@2.83.0': @@ -3627,6 +5670,86 @@ snapshots: - bufferutil - utf-8-validate + '@swc/cli@0.8.1(@swc/core@1.15.3)(chokidar@5.0.0)': + dependencies: + '@swc/core': 1.15.3 + '@swc/counter': 0.1.3 + '@xhmikosr/bin-wrapper': 14.2.5 + commander: 8.3.0 + minimatch: 9.0.9 + piscina: 4.9.2 + semver: 7.8.1 + slash: 3.0.0 + source-map: 0.7.6 + tinyglobby: 0.2.15 + optionalDependencies: + chokidar: 5.0.0 + transitivePeerDependencies: + - bare-abort-controller + - react-native-b4a + - supports-color + + '@swc/core-darwin-arm64@1.15.3': + optional: true + + '@swc/core-darwin-x64@1.15.3': + optional: true + + '@swc/core-linux-arm-gnueabihf@1.15.3': + optional: true + + '@swc/core-linux-arm64-gnu@1.15.3': + optional: true + + '@swc/core-linux-arm64-musl@1.15.3': + optional: true + + '@swc/core-linux-x64-gnu@1.15.3': + optional: true + + '@swc/core-linux-x64-musl@1.15.3': + optional: true + + '@swc/core-win32-arm64-msvc@1.15.3': + optional: true + + '@swc/core-win32-ia32-msvc@1.15.3': + optional: true + + '@swc/core-win32-x64-msvc@1.15.3': + optional: true + + '@swc/core@1.15.3': + dependencies: + '@swc/counter': 0.1.3 + '@swc/types': 0.1.26 + optionalDependencies: + '@swc/core-darwin-arm64': 1.15.3 + '@swc/core-darwin-x64': 1.15.3 + '@swc/core-linux-arm-gnueabihf': 1.15.3 + '@swc/core-linux-arm64-gnu': 1.15.3 + '@swc/core-linux-arm64-musl': 1.15.3 + '@swc/core-linux-x64-gnu': 1.15.3 + '@swc/core-linux-x64-musl': 1.15.3 + '@swc/core-win32-arm64-msvc': 1.15.3 + '@swc/core-win32-ia32-msvc': 1.15.3 + '@swc/core-win32-x64-msvc': 1.15.3 + + '@swc/counter@0.1.3': {} + + '@swc/types@0.1.26': + dependencies: + '@swc/counter': 0.1.3 + + '@tokenizer/inflate@0.4.1': + dependencies: + debug: 4.4.3(supports-color@8.1.1) + token-types: 6.1.2 + transitivePeerDependencies: + - supports-color + + '@tokenizer/token@0.3.0': {} + '@toon-format/toon@0.9.0': {} '@types/chai@5.2.3': @@ -3634,6 +5757,10 @@ snapshots: '@types/deep-eql': 4.0.2 assertion-error: 2.0.1 + '@types/debug@4.1.13': + dependencies: + '@types/ms': 2.1.0 + '@types/deep-eql@4.0.2': {} '@types/estree@1.0.8': {} @@ -3645,6 +5772,12 @@ snapshots: '@types/jsonfile': 6.1.4 '@types/node': 24.7.0 + '@types/http-cache-semantics@4.2.0': {} + + '@types/interpret@1.1.4': + dependencies: + '@types/node': 24.12.4 + '@types/istanbul-lib-coverage@2.0.6': {} '@types/istanbul-lib-report@3.0.3': @@ -3662,17 +5795,23 @@ snapshots: '@types/jsonfile@6.1.4': dependencies: - '@types/node': 24.7.0 + '@types/node': 24.12.4 + + '@types/ms@2.1.0': {} '@types/node-fetch@2.6.13': dependencies: - '@types/node': 24.7.0 + '@types/node': 24.12.4 form-data: 4.0.5 '@types/node@18.19.130': dependencies: undici-types: 5.26.5 + '@types/node@22.19.19': + dependencies: + undici-types: 6.21.0 + '@types/node@24.12.4': dependencies: undici-types: 7.16.0 @@ -3694,10 +5833,16 @@ snapshots: '@types/node': 24.7.0 kleur: 3.0.3 + '@types/semver@7.7.1': {} + '@types/stack-utils@2.0.3': {} '@types/webidl-conversions@7.0.3': {} + '@types/whatwg-url@11.0.5': + dependencies: + '@types/webidl-conversions': 7.0.3 + '@types/whatwg-url@13.0.0': dependencies: '@types/webidl-conversions': 7.0.3 @@ -3720,8 +5865,37 @@ snapshots: transitivePeerDependencies: - supports-color + '@vercel/cli-auth@0.0.1': + dependencies: + async-listen: 3.0.0 + open: 8.4.0 + xdg-app-paths: 5.1.0 + zod: 4.1.11 + + '@vercel/functions@3.6.1(@aws-sdk/credential-provider-web-identity@3.972.13)': + dependencies: + '@vercel/oidc': 3.5.0 + optionalDependencies: + '@aws-sdk/credential-provider-web-identity': 3.972.13 + '@vercel/oidc@3.1.0': {} + '@vercel/oidc@3.2.0': {} + + '@vercel/oidc@3.5.0': {} + + '@vercel/queue@0.0.0-alpha.40': + dependencies: + '@vercel/oidc': 3.1.0 + mixpart: 0.0.5-alpha.1 + + '@vercel/queue@0.1.7': + dependencies: + '@vercel/oidc': 3.1.0 + minimatch: 10.2.5 + mixpart: 0.0.6 + picocolors: 1.1.1 + '@vitest/expect@4.1.8': dependencies: '@standard-schema/spec': 1.1.0 @@ -3731,13 +5905,21 @@ snapshots: chai: 6.2.2 tinyrainbow: 3.1.0 - '@vitest/mocker@4.1.8(vite@7.3.5(@types/node@24.7.0)(tsx@4.20.6))': + '@vitest/mocker@4.1.8(vite@7.3.5(@types/node@24.12.4)(jiti@2.7.0)(tsx@4.20.6))': + dependencies: + '@vitest/spy': 4.1.8 + estree-walker: 3.0.3 + magic-string: 0.30.21 + optionalDependencies: + vite: 7.3.5(@types/node@24.12.4)(jiti@2.7.0)(tsx@4.20.6) + + '@vitest/mocker@4.1.8(vite@7.3.5(@types/node@24.7.0)(jiti@2.7.0)(tsx@4.20.6))': dependencies: '@vitest/spy': 4.1.8 estree-walker: 3.0.3 magic-string: 0.30.21 optionalDependencies: - vite: 7.3.5(@types/node@24.7.0)(tsx@4.20.6) + vite: 7.3.5(@types/node@24.7.0)(jiti@2.7.0)(tsx@4.20.6) '@vitest/pretty-format@4.1.8': dependencies: @@ -3763,10 +5945,423 @@ snapshots: convert-source-map: 2.0.0 tinyrainbow: 3.1.0 + '@workflow-worlds/mongodb@0.2.1(socks@2.8.7)': + dependencies: + '@vercel/queue': 0.0.0-alpha.40 + '@workflow/errors': 4.1.0-beta.14 + '@workflow/world': 4.1.0-beta.2(zod@4.1.12) + mongodb: 6.21.0(socks@2.8.7) + ulid: 2.4.0 + zod: 4.1.12 + transitivePeerDependencies: + - '@aws-sdk/credential-providers' + - '@mongodb-js/zstd' + - gcp-metadata + - kerberos + - mongodb-client-encryption + - snappy + - socks + + '@workflow/astro@4.0.8(@opentelemetry/api@1.9.0)': + dependencies: + '@swc/core': 1.15.3 + '@workflow/builders': 4.0.9(@opentelemetry/api@1.9.0) + '@workflow/rollup': 4.0.8(@opentelemetry/api@1.9.0) + '@workflow/swc-plugin': 4.1.1(@swc/core@1.15.3) + '@workflow/vite': 4.0.8(@opentelemetry/api@1.9.0) + exsolve: 1.0.8 + pathe: 2.0.3 + transitivePeerDependencies: + - '@opentelemetry/api' + - '@swc/helpers' + - supports-color + + '@workflow/builders@4.0.9(@opentelemetry/api@1.9.0)': + dependencies: + '@swc/core': 1.15.3 + '@workflow/core': 4.3.1(@opentelemetry/api@1.9.0) + '@workflow/errors': 4.1.3 + '@workflow/swc-plugin': 4.1.1(@swc/core@1.15.3) + '@workflow/utils': 4.1.2 + builtin-modules: 5.0.0 + chalk: 5.6.2 + enhanced-resolve: 5.19.0 + esbuild: 0.27.7 + find-up: 7.0.0 + json5: 2.2.3 + tinyglobby: 0.2.15 + transitivePeerDependencies: + - '@opentelemetry/api' + - '@swc/helpers' + - supports-color + + '@workflow/cli@4.2.8(@opentelemetry/api@1.9.0)': + dependencies: + '@oclif/core': 4.8.1 + '@oclif/plugin-help': 6.2.37 + '@swc/core': 1.15.3 + '@vercel/cli-auth': 0.0.1 + '@workflow/builders': 4.0.9(@opentelemetry/api@1.9.0) + '@workflow/core': 4.3.1(@opentelemetry/api@1.9.0) + '@workflow/errors': 4.1.3 + '@workflow/swc-plugin': 4.1.1(@swc/core@1.15.3) + '@workflow/utils': 4.1.2 + '@workflow/web': 4.1.9 + '@workflow/world': 4.1.4(zod@4.3.6) + '@workflow/world-local': 4.1.4(@opentelemetry/api@1.9.0) + '@workflow/world-vercel': 4.3.2(@opentelemetry/api@1.9.0) + boxen: 8.0.1 + builtin-modules: 5.0.0 + chalk: 5.6.2 + chokidar: 4.0.3 + date-fns: 4.1.0 + dotenv: 17.4.2 + easy-table: 1.2.0 + enhanced-resolve: 5.19.0 + esbuild: 0.27.7 + find-up: 7.0.0 + mixpart: 0.0.4 + open: 10.2.0 + ora: 8.2.0 + terminal-link: 5.0.0 + tinyglobby: 0.2.15 + xdg-app-paths: 5.1.0 + zod: 4.3.6 + transitivePeerDependencies: + - '@opentelemetry/api' + - '@swc/helpers' + - supports-color + + '@workflow/core@4.3.1(@opentelemetry/api@1.9.0)': + dependencies: + '@aws-sdk/credential-provider-web-identity': 3.972.13 + '@jridgewell/trace-mapping': 0.3.31 + '@standard-schema/spec': 1.0.0 + '@types/ms': 2.1.0 + '@vercel/functions': 3.6.1(@aws-sdk/credential-provider-web-identity@3.972.13) + '@workflow/errors': 4.1.3 + '@workflow/serde': 4.1.1 + '@workflow/utils': 4.1.2 + '@workflow/world': 4.1.4(zod@4.3.6) + '@workflow/world-local': 4.1.4(@opentelemetry/api@1.9.0) + '@workflow/world-vercel': 4.3.2(@opentelemetry/api@1.9.0) + debug: 4.4.3(supports-color@8.1.1) + devalue: 5.6.3 + ms: 2.1.3 + nanoid: 5.1.6 + seedrandom: 3.0.5 + semver: 7.7.4 + ulid: 3.0.2 + zod: 4.3.6 + optionalDependencies: + '@opentelemetry/api': 1.9.0 + transitivePeerDependencies: + - supports-color + + '@workflow/errors@4.1.0-beta.14': + dependencies: + '@workflow/utils': 4.1.0-beta.11 + ms: 2.1.3 + + '@workflow/errors@4.1.3': + dependencies: + '@workflow/utils': 4.1.2 + ms: 2.1.3 + + '@workflow/nest@0.0.8(@nestjs/common@11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24(@nestjs/common@11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2))(reflect-metadata@0.2.2)(rxjs@7.8.2))(@opentelemetry/api@1.9.0)(@swc/cli@0.8.1(@swc/core@1.15.3)(chokidar@5.0.0))(@swc/core@1.15.3)': + dependencies: + '@nestjs/common': 11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2) + '@nestjs/core': 11.1.24(@nestjs/common@11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2))(reflect-metadata@0.2.2)(rxjs@7.8.2) + '@swc/cli': 0.8.1(@swc/core@1.15.3)(chokidar@5.0.0) + '@swc/core': 1.15.3 + '@workflow/builders': 4.0.9(@opentelemetry/api@1.9.0) + '@workflow/swc-plugin': 4.1.1(@swc/core@1.15.3) + pathe: 2.0.3 + transitivePeerDependencies: + - '@opentelemetry/api' + - '@swc/helpers' + - supports-color + + '@workflow/next@4.0.9(@opentelemetry/api@1.9.0)': + dependencies: + '@swc/core': 1.15.3 + '@workflow/builders': 4.0.9(@opentelemetry/api@1.9.0) + '@workflow/core': 4.3.1(@opentelemetry/api@1.9.0) + '@workflow/swc-plugin': 4.1.1(@swc/core@1.15.3) + semver: 7.7.4 + watchpack: 2.5.1 + transitivePeerDependencies: + - '@opentelemetry/api' + - '@swc/helpers' + - supports-color + + '@workflow/nitro@4.0.9(@opentelemetry/api@1.9.0)': + dependencies: + '@swc/core': 1.15.3 + '@workflow/builders': 4.0.9(@opentelemetry/api@1.9.0) + '@workflow/core': 4.3.1(@opentelemetry/api@1.9.0) + '@workflow/rollup': 4.0.8(@opentelemetry/api@1.9.0) + '@workflow/swc-plugin': 4.1.1(@swc/core@1.15.3) + '@workflow/vite': 4.0.8(@opentelemetry/api@1.9.0) + exsolve: 1.0.8 + pathe: 2.0.3 + transitivePeerDependencies: + - '@opentelemetry/api' + - '@swc/helpers' + - supports-color + + '@workflow/nuxt@4.0.9(@opentelemetry/api@1.9.0)': + dependencies: + '@nuxt/kit': 4.4.2 + '@workflow/nitro': 4.0.9(@opentelemetry/api@1.9.0) + transitivePeerDependencies: + - '@opentelemetry/api' + - '@swc/helpers' + - magicast + - supports-color + + '@workflow/rollup@4.0.8(@opentelemetry/api@1.9.0)': + dependencies: + '@swc/core': 1.15.3 + '@workflow/builders': 4.0.9(@opentelemetry/api@1.9.0) + '@workflow/swc-plugin': 4.1.1(@swc/core@1.15.3) + exsolve: 1.0.7 + transitivePeerDependencies: + - '@opentelemetry/api' + - '@swc/helpers' + - supports-color + + '@workflow/serde@4.1.1': {} + + '@workflow/sveltekit@4.0.8(@opentelemetry/api@1.9.0)': + dependencies: + '@swc/core': 1.15.3 + '@workflow/builders': 4.0.9(@opentelemetry/api@1.9.0) + '@workflow/rollup': 4.0.8(@opentelemetry/api@1.9.0) + '@workflow/swc-plugin': 4.1.1(@swc/core@1.15.3) + '@workflow/vite': 4.0.8(@opentelemetry/api@1.9.0) + exsolve: 1.0.8 + fs-extra: 11.3.2 + pathe: 2.0.3 + transitivePeerDependencies: + - '@opentelemetry/api' + - '@swc/helpers' + - supports-color + + '@workflow/swc-plugin@4.1.1(@swc/core@1.15.3)': + dependencies: + '@swc/core': 1.15.3 + + '@workflow/typescript-plugin@4.0.2(typescript@5.9.3)': + dependencies: + typescript: 5.9.3 + + '@workflow/utils@4.1.0-beta.11': + dependencies: + ms: 2.1.3 + + '@workflow/utils@4.1.2': + dependencies: + ms: 2.1.3 + + '@workflow/vite@4.0.8(@opentelemetry/api@1.9.0)': + dependencies: + '@workflow/builders': 4.0.9(@opentelemetry/api@1.9.0) + transitivePeerDependencies: + - '@opentelemetry/api' + - '@swc/helpers' + - supports-color + + '@workflow/web@4.1.9': + dependencies: + express: 4.22.2 + transitivePeerDependencies: + - supports-color + + '@workflow/world-local@4.1.4(@opentelemetry/api@1.9.0)': + dependencies: + '@vercel/queue': 0.1.7 + '@workflow/errors': 4.1.3 + '@workflow/utils': 4.1.2 + '@workflow/world': 4.1.4(zod@4.3.6) + async-sema: 3.1.1 + ulid: 3.0.2 + undici: 7.22.0 + zod: 4.3.6 + optionalDependencies: + '@opentelemetry/api': 1.9.0 + + '@workflow/world-postgres@4.1.4(@cloudflare/workers-types@4.20251118.0)(@opentelemetry/api@1.9.0)(@types/pg@8.15.6)(better-sqlite3@12.10.0)(typescript@5.9.3)': + dependencies: + '@vercel/queue': 0.1.7 + '@workflow/errors': 4.1.3 + '@workflow/utils': 4.1.2 + '@workflow/world': 4.1.4(zod@4.3.6) + '@workflow/world-local': 4.1.4(@opentelemetry/api@1.9.0) + cbor-x: 1.6.0 + dotenv: 17.3.1 + drizzle-orm: 0.45.1(@cloudflare/workers-types@4.20251118.0)(@opentelemetry/api@1.9.0)(@types/pg@8.15.6)(better-sqlite3@12.10.0)(pg@8.20.0) + graphile-worker: 0.16.6(typescript@5.9.3) + pg: 8.20.0 + ulid: 3.0.2 + zod: 4.3.6 + transitivePeerDependencies: + - '@aws-sdk/client-rds-data' + - '@cloudflare/workers-types' + - '@electric-sql/pglite' + - '@libsql/client' + - '@libsql/client-wasm' + - '@neondatabase/serverless' + - '@op-engineering/op-sqlite' + - '@opentelemetry/api' + - '@planetscale/database' + - '@prisma/client' + - '@tidbcloud/serverless' + - '@types/better-sqlite3' + - '@types/pg' + - '@types/sql.js' + - '@upstash/redis' + - '@vercel/postgres' + - '@xata.io/client' + - better-sqlite3 + - bun-types + - expo-sqlite + - gel + - knex + - kysely + - mysql2 + - pg-native + - postgres + - prisma + - sql.js + - sqlite3 + - supports-color + - typescript + + '@workflow/world-vercel@4.3.2(@opentelemetry/api@1.9.0)': + dependencies: + '@vercel/oidc': 3.2.0 + '@vercel/queue': 0.1.7 + '@workflow/errors': 4.1.3 + '@workflow/world': 4.1.4(zod@4.3.6) + cbor-x: 1.6.0 + undici: 7.22.0 + zod: 4.3.6 + optionalDependencies: + '@opentelemetry/api': 1.9.0 + + '@workflow/world@4.1.0-beta.2(zod@4.1.12)': + dependencies: + zod: 4.1.12 + + '@workflow/world@4.1.4(zod@4.3.6)': + dependencies: + ulid: 3.0.2 + zod: 4.3.6 + + '@xhmikosr/archive-type@8.0.1': + dependencies: + file-type: 21.3.4 + transitivePeerDependencies: + - supports-color + + '@xhmikosr/bin-check@8.2.1': + dependencies: + execa: 9.6.1 + isexe: 4.0.0 + + '@xhmikosr/bin-wrapper@14.2.5': + dependencies: + '@xhmikosr/bin-check': 8.2.1 + '@xhmikosr/downloader': 16.1.3 + '@xhmikosr/os-filter-obj': 4.1.0 + binary-version-check: 6.1.0 + transitivePeerDependencies: + - bare-abort-controller + - react-native-b4a + - supports-color + + '@xhmikosr/decompress-tar@9.0.1': + dependencies: + file-type: 21.3.4 + is-stream: 4.0.1 + tar-stream: 3.1.7 + transitivePeerDependencies: + - bare-abort-controller + - react-native-b4a + - supports-color + + '@xhmikosr/decompress-tarbz2@9.0.1': + dependencies: + '@xhmikosr/decompress-tar': 9.0.1 + file-type: 21.3.4 + is-stream: 4.0.1 + seek-bzip: 2.0.0 + unbzip2-stream: 1.4.3 + transitivePeerDependencies: + - bare-abort-controller + - react-native-b4a + - supports-color + + '@xhmikosr/decompress-targz@9.0.1': + dependencies: + '@xhmikosr/decompress-tar': 9.0.1 + file-type: 21.3.4 + is-stream: 4.0.1 + transitivePeerDependencies: + - bare-abort-controller + - react-native-b4a + - supports-color + + '@xhmikosr/decompress-unzip@8.1.1': + dependencies: + file-type: 21.3.4 + get-stream: 9.0.1 + yauzl: 3.3.2 + transitivePeerDependencies: + - supports-color + + '@xhmikosr/decompress@11.1.3': + dependencies: + '@xhmikosr/decompress-tar': 9.0.1 + '@xhmikosr/decompress-tarbz2': 9.0.1 + '@xhmikosr/decompress-targz': 9.0.1 + '@xhmikosr/decompress-unzip': 8.1.1 + graceful-fs: 4.2.11 + strip-dirs: 3.0.0 + transitivePeerDependencies: + - bare-abort-controller + - react-native-b4a + - supports-color + + '@xhmikosr/downloader@16.1.3': + dependencies: + '@xhmikosr/archive-type': 8.0.1 + '@xhmikosr/decompress': 11.1.3 + content-disposition: 2.0.1 + ext-name: 5.0.0 + file-type: 21.3.4 + filenamify: 7.0.1 + get-stream: 9.0.1 + got: 14.6.6 + transitivePeerDependencies: + - bare-abort-controller + - react-native-b4a + - supports-color + + '@xhmikosr/os-filter-obj@4.1.0': + dependencies: + system-architecture: 1.0.0 + abort-controller@3.0.0: dependencies: event-target-shim: 5.0.1 + accepts@1.3.8: + dependencies: + mime-types: 2.1.35 + negotiator: 0.6.3 + accepts@2.0.0: dependencies: mime-types: 3.0.1 @@ -3774,13 +6369,15 @@ snapshots: acorn@8.15.0: {} + acorn@8.16.0: {} + afinn-165-financialmarketnews@3.0.0: {} afinn-165@2.0.2: {} agent-base@6.0.2: dependencies: - debug: 4.4.3 + debug: 4.4.3(supports-color@8.1.1) transitivePeerDependencies: - supports-color @@ -3809,6 +6406,18 @@ snapshots: json-schema-traverse: 1.0.0 require-from-string: 2.0.2 + ansi-align@3.0.1: + dependencies: + string-width: 4.2.3 + + ansi-escapes@4.3.2: + dependencies: + type-fest: 0.21.3 + + ansi-escapes@7.3.0: + dependencies: + environment: 1.1.0 + ansi-regex@5.0.1: {} ansi-regex@6.2.2: {} @@ -3821,14 +6430,26 @@ snapshots: ansi-styles@6.2.3: {} + ansis@3.17.0: {} + any-promise@1.3.0: {} apparatus@0.0.10: dependencies: sylvester: 0.0.21 + argparse@2.0.1: {} + + array-flatten@1.1.1: {} + assertion-error@2.0.1: {} + async-listen@3.0.0: {} + + async-sema@3.1.1: {} + + async@3.2.6: {} + asynckit@0.4.0: {} axios@1.16.1: @@ -3841,8 +6462,14 @@ snapshots: - debug - supports-color + b4a@1.8.1: {} + balanced-match@1.0.2: {} + balanced-match@4.0.4: {} + + bare-events@2.9.1: {} + base-64@0.1.0: {} base64-js@1.5.1: {} @@ -3854,6 +6481,17 @@ snapshots: bignumber.js@9.3.1: {} + binary-version-check@6.1.0: + dependencies: + binary-version: 7.1.0 + semver: 7.8.1 + semver-truncate: 3.0.0 + + binary-version@7.1.0: + dependencies: + execa: 8.0.1 + find-versions: 6.0.0 + bindings@1.5.0: dependencies: file-uri-to-path: 1.0.0 @@ -3864,11 +6502,28 @@ snapshots: inherits: 2.0.4 readable-stream: 3.6.2 + body-parser@1.20.5: + dependencies: + bytes: 3.1.2 + content-type: 1.0.5 + debug: 2.6.9 + depd: 2.0.0 + destroy: 1.2.0 + http-errors: 2.0.1 + iconv-lite: 0.4.24 + on-finished: 2.4.1 + qs: 6.15.2 + raw-body: 2.5.3 + type-is: 1.6.18 + unpipe: 1.0.0 + transitivePeerDependencies: + - supports-color + body-parser@2.2.2: dependencies: bytes: 3.1.2 content-type: 1.0.5 - debug: 4.4.3 + debug: 4.4.3(supports-color@8.1.1) http-errors: 2.0.0 iconv-lite: 0.7.0 on-finished: 2.4.1 @@ -3878,14 +6533,33 @@ snapshots: transitivePeerDependencies: - supports-color + bowser@2.14.1: {} + + boxen@8.0.1: + dependencies: + ansi-align: 3.0.1 + camelcase: 8.0.0 + chalk: 5.6.2 + cli-boxes: 3.0.0 + string-width: 7.2.0 + type-fest: 4.41.0 + widest-line: 5.0.0 + wrap-ansi: 9.0.2 + brace-expansion@2.1.1: dependencies: balanced-match: 1.0.2 + brace-expansion@5.0.6: + dependencies: + balanced-match: 4.0.4 + braces@3.0.3: dependencies: fill-range: 7.1.1 + bson@6.10.4: {} + bson@7.2.0: {} buffer-equal-constant-time@1.0.1: {} @@ -3895,6 +6569,8 @@ snapshots: base64-js: 1.5.1 ieee754: 1.2.1 + builtin-modules@5.0.0: {} + bundle-name@4.1.0: dependencies: run-applescript: 7.1.0 @@ -3904,10 +6580,39 @@ snapshots: esbuild: 0.25.12 load-tsconfig: 0.2.5 + byte-counter@0.1.0: {} + bytes@3.1.2: {} + c12@3.3.4: + dependencies: + chokidar: 5.0.0 + confbox: 0.2.4 + defu: 6.1.7 + dotenv: 17.4.2 + exsolve: 1.0.8 + giget: 3.2.0 + jiti: 2.7.0 + ohash: 2.0.11 + pathe: 2.0.3 + perfect-debounce: 2.1.0 + pkg-types: 2.3.1 + rc9: 3.0.1 + cac@6.7.14: {} + cacheable-lookup@7.0.0: {} + + cacheable-request@13.0.19: + dependencies: + '@types/http-cache-semantics': 4.2.0 + get-stream: 9.0.1 + http-cache-semantics: 4.2.0 + keyv: 5.6.0 + mimic-response: 4.0.0 + normalize-url: 8.1.1 + responselike: 4.0.2 + call-bind-apply-helpers@1.0.2: dependencies: es-errors: 1.3.0 @@ -3918,6 +6623,26 @@ snapshots: call-bind-apply-helpers: 1.0.2 get-intrinsic: 1.3.0 + callsites@3.1.0: {} + + camelcase@8.0.0: {} + + cbor-extract@2.2.2: + dependencies: + node-gyp-build-optional-packages: 5.1.1 + optionalDependencies: + '@cbor-extract/cbor-extract-darwin-arm64': 2.2.2 + '@cbor-extract/cbor-extract-darwin-x64': 2.2.2 + '@cbor-extract/cbor-extract-linux-arm': 2.2.2 + '@cbor-extract/cbor-extract-linux-arm64': 2.2.2 + '@cbor-extract/cbor-extract-linux-x64': 2.2.2 + '@cbor-extract/cbor-extract-win32-x64': 2.2.2 + optional: true + + cbor-x@1.6.0: + optionalDependencies: + cbor-extract: 2.2.2 + chai@6.2.2: {} chalk@4.1.2: @@ -3933,16 +6658,39 @@ snapshots: dependencies: readdirp: 4.1.2 + chokidar@5.0.0: + dependencies: + readdirp: 5.0.0 + chownr@1.1.4: {} ci-info@3.9.0: {} + citty@0.1.6: + dependencies: + consola: 3.4.2 + + clean-stack@3.0.1: + dependencies: + escape-string-regexp: 4.0.0 + + cli-boxes@3.0.0: {} + cli-cursor@5.0.0: dependencies: restore-cursor: 5.1.0 cli-spinners@2.9.2: {} + cliui@8.0.1: + dependencies: + string-width: 4.2.3 + strip-ansi: 6.0.1 + wrap-ansi: 7.0.0 + + clone@1.0.4: + optional: true + cloudflare@4.5.0(encoding@0.1.13): dependencies: '@types/node': 18.19.130 @@ -3971,6 +6719,10 @@ snapshots: commander@4.1.1: {} + commander@6.2.1: {} + + commander@8.3.0: {} + compromise@14.15.1: dependencies: efrt: 2.7.0 @@ -3979,16 +6731,28 @@ snapshots: confbox@0.1.8: {} + confbox@0.2.4: {} + consola@3.4.2: {} + content-disposition@0.5.4: + dependencies: + safe-buffer: 5.2.1 + content-disposition@1.0.0: dependencies: safe-buffer: 5.2.1 + content-disposition@2.0.1: {} + content-type@1.0.5: {} + convert-hrtime@5.0.0: {} + convert-source-map@2.0.0: {} + cookie-signature@1.0.7: {} + cookie-signature@1.2.2: {} cookie@0.7.2: {} @@ -3998,6 +6762,15 @@ snapshots: object-assign: 4.1.1 vary: 1.1.2 + cosmiconfig@8.3.6(typescript@5.9.3): + dependencies: + import-fresh: 3.3.1 + js-yaml: 4.2.0 + parse-json: 5.2.0 + path-type: 4.0.0 + optionalDependencies: + typescript: 5.9.3 + cross-spawn@7.0.6: dependencies: path-key: 3.1.1 @@ -4008,9 +6781,21 @@ snapshots: data-uri-to-buffer@4.0.1: {} - debug@4.4.3: + date-fns@4.1.0: {} + + debug@2.6.9: + dependencies: + ms: 2.0.0 + + debug@4.4.3(supports-color@8.1.1): dependencies: ms: 2.1.3 + optionalDependencies: + supports-color: 8.1.1 + + decompress-response@10.0.0: + dependencies: + mimic-response: 4.0.0 decompress-response@6.0.0: dependencies: @@ -4025,14 +6810,29 @@ snapshots: bundle-name: 4.1.0 default-browser-id: 5.0.1 + defaults@1.0.4: + dependencies: + clone: 1.0.4 + optional: true + + define-lazy-prop@2.0.0: {} + define-lazy-prop@3.0.0: {} + defu@6.1.7: {} + delayed-stream@1.0.0: {} depd@2.0.0: {} + destr@2.0.5: {} + + destroy@1.2.0: {} + detect-libc@2.1.2: {} + devalue@5.6.3: {} + diff-sequences@29.6.3: {} digest-fetch@1.3.0: @@ -4042,8 +6842,18 @@ snapshots: dotenv@17.2.3: {} + dotenv@17.3.1: {} + dotenv@17.4.2: {} + drizzle-orm@0.45.1(@cloudflare/workers-types@4.20251118.0)(@opentelemetry/api@1.9.0)(@types/pg@8.15.6)(better-sqlite3@12.10.0)(pg@8.20.0): + optionalDependencies: + '@cloudflare/workers-types': 4.20251118.0 + '@opentelemetry/api': 1.9.0 + '@types/pg': 8.15.6 + better-sqlite3: 12.10.0 + pg: 8.20.0 + dunder-proto@1.0.1: dependencies: call-bind-apply-helpers: 1.0.2 @@ -4052,6 +6862,12 @@ snapshots: eastasianwidth@0.2.0: {} + easy-table@1.2.0: + dependencies: + ansi-regex: 5.0.1 + optionalDependencies: + wcwidth: 1.0.1 + ecdsa-sig-formatter@1.0.11: dependencies: safe-buffer: 5.2.1 @@ -4060,6 +6876,10 @@ snapshots: efrt@2.7.0: {} + ejs@3.1.10: + dependencies: + jake: 10.9.4 + emoji-regex@10.6.0: {} emoji-regex@8.0.0: {} @@ -4077,6 +6897,19 @@ snapshots: dependencies: once: 1.4.0 + enhanced-resolve@5.19.0: + dependencies: + graceful-fs: 4.2.11 + tapable: 2.3.3 + + environment@1.1.0: {} + + error-ex@1.3.4: + dependencies: + is-arrayish: 0.2.1 + + errx@0.1.0: {} + es-define-property@1.0.1: {} es-errors@1.3.0: {} @@ -4152,10 +6985,14 @@ snapshots: '@esbuild/win32-ia32': 0.27.7 '@esbuild/win32-x64': 0.27.7 + escalade@3.2.0: {} + escape-html@1.0.3: {} escape-string-regexp@2.0.0: {} + escape-string-regexp@4.0.0: {} + estree-walker@3.0.3: dependencies: '@types/estree': 1.0.8 @@ -4166,6 +7003,12 @@ snapshots: eventemitter3@4.0.7: {} + events-universal@1.0.1: + dependencies: + bare-events: 2.9.1 + transitivePeerDependencies: + - bare-abort-controller + events@3.3.0: {} eventsource-parser@3.0.6: {} @@ -4174,6 +7017,33 @@ snapshots: dependencies: eventsource-parser: 3.0.6 + execa@8.0.1: + dependencies: + cross-spawn: 7.0.6 + get-stream: 8.0.1 + human-signals: 5.0.0 + is-stream: 3.0.0 + merge-stream: 2.0.0 + npm-run-path: 5.3.0 + onetime: 6.0.0 + signal-exit: 4.1.0 + strip-final-newline: 3.0.0 + + execa@9.6.1: + dependencies: + '@sindresorhus/merge-streams': 4.0.0 + cross-spawn: 7.0.6 + figures: 6.1.0 + get-stream: 9.0.1 + human-signals: 8.0.1 + is-plain-obj: 4.1.0 + is-stream: 4.0.1 + npm-run-path: 6.0.0 + pretty-ms: 9.3.0 + signal-exit: 4.1.0 + strip-final-newline: 4.0.0 + yoctocolors: 2.1.2 + expand-template@2.0.3: {} expect-type@1.3.0: {} @@ -4191,6 +7061,42 @@ snapshots: express: 5.2.1 ip-address: 10.2.0 + express@4.22.2: + dependencies: + accepts: 1.3.8 + array-flatten: 1.1.1 + body-parser: 1.20.5 + content-disposition: 0.5.4 + content-type: 1.0.5 + cookie: 0.7.2 + cookie-signature: 1.0.7 + debug: 2.6.9 + depd: 2.0.0 + encodeurl: 2.0.0 + escape-html: 1.0.3 + etag: 1.8.1 + finalhandler: 1.3.2 + fresh: 0.5.2 + http-errors: 2.0.0 + merge-descriptors: 1.0.3 + methods: 1.1.2 + on-finished: 2.4.1 + parseurl: 1.3.3 + path-to-regexp: 0.1.13 + proxy-addr: 2.0.7 + qs: 6.15.2 + range-parser: 1.2.1 + safe-buffer: 5.2.1 + send: 0.19.2 + serve-static: 1.16.3 + setprototypeof: 1.2.0 + statuses: 2.0.2 + type-is: 1.6.18 + utils-merge: 1.0.1 + vary: 1.1.2 + transitivePeerDependencies: + - supports-color + express@5.2.1: dependencies: accepts: 2.0.0 @@ -4199,7 +7105,7 @@ snapshots: content-type: 1.0.5 cookie: 0.7.2 cookie-signature: 1.2.2 - debug: 4.4.3 + debug: 4.4.3(supports-color@8.1.1) depd: 2.0.0 encodeurl: 2.0.0 escape-html: 1.0.3 @@ -4224,12 +7130,41 @@ snapshots: transitivePeerDependencies: - supports-color + exsolve@1.0.7: {} + + exsolve@1.0.8: {} + + ext-list@2.2.2: + dependencies: + mime-db: 1.54.0 + + ext-name@5.0.0: + dependencies: + ext-list: 2.2.2 + sort-keys-length: 1.0.1 + extend@3.0.2: {} fast-deep-equal@3.1.3: {} + fast-fifo@1.3.2: {} + + fast-safe-stringify@2.1.1: {} + fast-uri@3.1.2: {} + fast-xml-builder@1.2.0: + dependencies: + path-expression-matcher: 1.5.0 + xml-naming: 0.1.0 + + fast-xml-parser@5.7.3: + dependencies: + '@nodable/entities': 2.1.1 + fast-xml-builder: 1.2.0 + path-expression-matcher: 1.5.0 + strnum: 2.3.0 + fdir@6.5.0(picomatch@4.0.4): optionalDependencies: picomatch: 4.0.4 @@ -4239,15 +7174,50 @@ snapshots: node-domexception: 1.0.0 web-streams-polyfill: 3.3.3 + figures@6.1.0: + dependencies: + is-unicode-supported: 2.1.0 + + file-type@21.3.4: + dependencies: + '@tokenizer/inflate': 0.4.1 + strtok3: 10.3.5 + token-types: 6.1.2 + uint8array-extras: 1.5.0 + transitivePeerDependencies: + - supports-color + file-uri-to-path@1.0.0: {} + filelist@1.0.6: + dependencies: + minimatch: 5.1.9 + + filename-reserved-regex@4.0.0: {} + + filenamify@7.0.1: + dependencies: + filename-reserved-regex: 4.0.0 + fill-range@7.1.1: dependencies: to-regex-range: 5.0.1 + finalhandler@1.3.2: + dependencies: + debug: 2.6.9 + encodeurl: 2.0.0 + escape-html: 1.0.3 + on-finished: 2.4.1 + parseurl: 1.3.3 + statuses: 2.0.2 + unpipe: 1.0.0 + transitivePeerDependencies: + - supports-color + finalhandler@2.1.0: dependencies: - debug: 4.4.3 + debug: 4.4.3(supports-color@8.1.1) encodeurl: 2.0.0 escape-html: 1.0.3 on-finished: 2.4.1 @@ -4256,6 +7226,17 @@ snapshots: transitivePeerDependencies: - supports-color + find-up@7.0.0: + dependencies: + locate-path: 7.2.0 + path-exists: 5.0.0 + unicorn-magic: 0.1.0 + + find-versions@6.0.0: + dependencies: + semver-regex: 4.0.5 + super-regex: 1.1.0 + fix-dts-default-cjs-exports@1.0.1: dependencies: magic-string: 0.30.19 @@ -4271,6 +7252,8 @@ snapshots: form-data-encoder@1.7.2: {} + form-data-encoder@4.1.0: {} + form-data@4.0.5: dependencies: asynckit: 0.4.0 @@ -4290,6 +7273,8 @@ snapshots: forwarded@0.2.0: {} + fresh@0.5.2: {} + fresh@2.0.0: {} fs-constants@1.0.0: {} @@ -4305,6 +7290,8 @@ snapshots: function-bind@1.1.2: {} + function-timeout@1.0.2: {} + gaxios@7.1.4: dependencies: extend: 3.0.2 @@ -4321,6 +7308,8 @@ snapshots: transitivePeerDependencies: - supports-color + get-caller-file@2.0.5: {} + get-east-asian-width@1.4.0: {} get-intrinsic@1.3.0: @@ -4336,17 +7325,30 @@ snapshots: hasown: 2.0.2 math-intrinsics: 1.1.0 + get-package-type@0.1.0: {} + get-proto@1.0.1: dependencies: dunder-proto: 1.0.1 es-object-atoms: 1.1.1 + get-stream@8.0.1: {} + + get-stream@9.0.1: + dependencies: + '@sec-ant/readable-stream': 0.4.1 + is-stream: 4.0.1 + get-tsconfig@4.11.0: dependencies: resolve-pkg-maps: 1.0.0 + giget@3.2.0: {} + github-from-package@0.0.0: {} + glob-to-regexp@0.4.1: {} + glob@10.5.0: dependencies: foreground-child: 3.3.1 @@ -4371,10 +7373,55 @@ snapshots: gopd@1.2.0: {} + got@14.6.6: + dependencies: + '@sindresorhus/is': 7.2.0 + byte-counter: 0.1.0 + cacheable-lookup: 7.0.0 + cacheable-request: 13.0.19 + decompress-response: 10.0.0 + form-data-encoder: 4.1.0 + http2-wrapper: 2.2.1 + keyv: 5.6.0 + lowercase-keys: 3.0.0 + p-cancelable: 4.0.1 + responselike: 4.0.2 + type-fest: 4.41.0 + graceful-fs@4.2.11: {} grad-school@0.0.5: {} + graphile-config@0.0.1-beta.18: + dependencies: + '@types/interpret': 1.1.4 + '@types/node': 22.19.19 + '@types/semver': 7.7.1 + chalk: 4.1.2 + debug: 4.4.3(supports-color@8.1.1) + interpret: 3.1.1 + semver: 7.8.1 + tslib: 2.8.1 + yargs: 17.7.2 + transitivePeerDependencies: + - supports-color + + graphile-worker@0.16.6(typescript@5.9.3): + dependencies: + '@graphile/logger': 0.2.0 + '@types/debug': 4.1.13 + '@types/pg': 8.15.6 + cosmiconfig: 8.3.6(typescript@5.9.3) + graphile-config: 0.0.1-beta.18 + json5: 2.2.3 + pg: 8.21.0 + tslib: 2.8.1 + yargs: 17.7.2 + transitivePeerDependencies: + - pg-native + - supports-color + - typescript + groq-sdk@0.3.0(encoding@0.1.13): dependencies: '@types/node': 18.19.130 @@ -4391,6 +7438,8 @@ snapshots: has-flag@4.0.0: {} + has-flag@5.0.1: {} + has-symbols@1.1.0: {} has-tostringtag@1.0.2: @@ -4403,6 +7452,8 @@ snapshots: hono@4.12.23: {} + http-cache-semantics@4.2.0: {} + http-errors@2.0.0: dependencies: depd: 2.0.0 @@ -4411,31 +7462,52 @@ snapshots: statuses: 2.0.1 toidentifier: 1.0.1 + http-errors@2.0.1: + dependencies: + depd: 2.0.0 + inherits: 2.0.4 + setprototypeof: 1.2.0 + statuses: 2.0.2 + toidentifier: 1.0.1 + http-proxy-agent@7.0.2: dependencies: agent-base: 7.1.4 - debug: 4.4.3 + debug: 4.4.3(supports-color@8.1.1) transitivePeerDependencies: - supports-color + http2-wrapper@2.2.1: + dependencies: + quick-lru: 5.1.1 + resolve-alpn: 1.2.1 + https-proxy-agent@5.0.1: dependencies: agent-base: 6.0.2 - debug: 4.4.3 + debug: 4.4.3(supports-color@8.1.1) transitivePeerDependencies: - supports-color https-proxy-agent@7.0.6: dependencies: agent-base: 7.1.4 - debug: 4.4.3 + debug: 4.4.3(supports-color@8.1.1) transitivePeerDependencies: - supports-color + human-signals@5.0.0: {} + + human-signals@8.0.1: {} + humanize-ms@1.2.1: dependencies: ms: 2.1.3 + iconv-lite@0.4.24: + dependencies: + safer-buffer: 2.1.2 + iconv-lite@0.6.3: dependencies: safer-buffer: 2.1.2 @@ -4447,16 +7519,35 @@ snapshots: ieee754@1.2.1: {} + ignore@7.0.5: {} + + import-fresh@3.3.1: + dependencies: + parent-module: 1.0.1 + resolve-from: 4.0.0 + + indent-string@4.0.0: {} + inherits@2.0.4: {} ini@1.3.8: {} + inspect-with-kind@1.0.5: + dependencies: + kind-of: 6.0.3 + + interpret@3.1.1: {} + ip-address@10.2.0: {} ipaddr.js@1.9.1: {} + is-arrayish@0.2.1: {} + is-buffer@1.1.6: {} + is-docker@2.2.1: {} + is-docker@3.0.0: {} is-fullwidth-code-point@3.0.0: {} @@ -4469,24 +7560,46 @@ snapshots: is-number@7.0.0: {} + is-plain-obj@1.1.0: {} + + is-plain-obj@4.1.0: {} + is-promise@4.0.0: {} + is-stream@3.0.0: {} + + is-stream@4.0.1: {} + is-unicode-supported@1.3.0: {} is-unicode-supported@2.1.0: {} + is-wsl@2.2.0: + dependencies: + is-docker: 2.2.1 + is-wsl@3.1.1: dependencies: is-inside-container: 1.0.0 isexe@2.0.0: {} + isexe@4.0.0: {} + + iterare@1.2.1: {} + jackspeak@3.4.3: dependencies: '@isaacs/cliui': 8.0.2 optionalDependencies: '@pkgjs/parseargs': 0.11.0 + jake@10.9.4: + dependencies: + async: 3.2.6 + filelist: 1.0.6 + picocolors: 1.1.1 + jest-diff@29.7.0: dependencies: chalk: 4.1.2 @@ -4524,6 +7637,8 @@ snapshots: graceful-fs: 4.2.11 picomatch: 2.3.2 + jiti@2.7.0: {} + jose@6.1.1: {} jose@6.2.3: {} @@ -4536,16 +7651,24 @@ snapshots: js-tokens@4.0.0: {} + js-yaml@4.2.0: + dependencies: + argparse: 2.0.1 + json-bigint@1.0.0: dependencies: bignumber.js: 9.3.1 + json-parse-even-better-errors@2.3.1: {} + json-schema-traverse@1.0.0: {} json-schema-typed@8.0.2: {} json-schema@0.4.0: {} + json5@2.2.3: {} + jsonfile@6.2.0: dependencies: universalify: 2.0.1 @@ -4578,8 +7701,18 @@ snapshots: kareem@3.3.0: {} + keyv@5.6.0: + dependencies: + '@keyv/serialize': 1.1.1 + + kind-of@6.0.3: {} + kleur@3.0.3: {} + klona@2.0.6: {} + + knitwork@1.3.0: {} + langsmith@0.7.3(@opentelemetry/api@1.9.0)(@opentelemetry/sdk-trace-base@2.2.0(@opentelemetry/api@1.9.0))(openai@4.104.0(encoding@0.1.13)(ws@8.21.0)(zod@4.1.12))(ws@8.21.0): dependencies: p-queue: 6.6.2 @@ -4593,8 +7726,14 @@ snapshots: lines-and-columns@1.2.4: {} + load-esm@1.0.3: {} + load-tsconfig@0.2.5: {} + locate-path@7.2.0: + dependencies: + p-locate: 6.0.0 + lodash.includes@4.3.0: {} lodash.isboolean@3.0.3: {} @@ -4618,6 +7757,8 @@ snapshots: long@5.3.2: {} + lowercase-keys@3.0.0: {} + lru-cache@10.4.3: {} magic-string@0.30.19: @@ -4628,6 +7769,12 @@ snapshots: dependencies: '@jridgewell/sourcemap-codec': 1.5.5 + make-asynchronous@1.1.0: + dependencies: + p-event: 6.0.1 + type-fest: 4.41.0 + web-worker: 1.5.0 + math-intrinsics@1.1.0: {} md5@2.3.0: @@ -4636,6 +7783,8 @@ snapshots: crypt: 0.0.2 is-buffer: 1.1.6 + media-typer@0.3.0: {} + media-typer@1.1.0: {} mem0ai@3.0.6(@anthropic-ai/sdk@0.40.1(encoding@0.1.13))(@azure/identity@4.13.1)(@azure/search-documents@12.2.0)(@cloudflare/workers-types@4.20251118.0)(@google/genai@1.30.0(@modelcontextprotocol/sdk@1.29.0(@cfworker/json-schema@4.1.1)(zod@4.1.12)))(@langchain/core@1.1.48(@opentelemetry/api@1.9.0)(@opentelemetry/sdk-trace-base@2.2.0(@opentelemetry/api@1.9.0))(openai@4.104.0(encoding@0.1.13)(ws@8.21.0)(zod@4.1.12))(ws@8.21.0))(@mistralai/mistralai@1.10.0)(@qdrant/js-client-rest@1.18.0(typescript@5.9.3))(@supabase/supabase-js@2.83.0)(@types/jest@29.5.14)(@types/pg@8.15.6)(better-sqlite3@12.10.0)(cloudflare@4.5.0(encoding@0.1.13))(compromise@14.15.1)(encoding@0.1.13)(groq-sdk@0.3.0(encoding@0.1.13))(natural@8.1.1(@opentelemetry/api@1.9.0)(socks@2.8.7))(ollama@0.5.18)(pg@8.16.3)(redis@5.12.1(@opentelemetry/api@1.9.0))(ws@8.21.0): @@ -4673,8 +7822,14 @@ snapshots: memory-pager@1.5.0: {} + merge-descriptors@1.0.3: {} + merge-descriptors@2.0.0: {} + merge-stream@2.0.0: {} + + methods@1.1.2: {} + micromatch@4.0.8: dependencies: braces: 3.0.3 @@ -4692,10 +7847,24 @@ snapshots: dependencies: mime-db: 1.54.0 + mime@1.6.0: {} + + mimic-fn@4.0.0: {} + mimic-function@5.0.1: {} mimic-response@3.1.0: {} + mimic-response@4.0.0: {} + + minimatch@10.2.5: + dependencies: + brace-expansion: 5.0.6 + + minimatch@5.1.9: + dependencies: + brace-expansion: 2.1.1 + minimatch@9.0.9: dependencies: brace-expansion: 2.1.1 @@ -4704,6 +7873,12 @@ snapshots: minipass@7.1.2: {} + mixpart@0.0.4: {} + + mixpart@0.0.5-alpha.1: {} + + mixpart@0.0.6: {} + mkdirp-classic@0.5.3: {} mlly@1.8.0: @@ -4713,11 +7888,31 @@ snapshots: pkg-types: 1.3.1 ufo: 1.6.1 + mlly@1.8.2: + dependencies: + acorn: 8.16.0 + pathe: 2.0.3 + pkg-types: 1.3.1 + ufo: 1.6.4 + + mongodb-connection-string-url@3.0.2: + dependencies: + '@types/whatwg-url': 11.0.5 + whatwg-url: 14.2.0 + mongodb-connection-string-url@7.0.1: dependencies: '@types/whatwg-url': 13.0.0 whatwg-url: 14.2.0 + mongodb@6.21.0(socks@2.8.7): + dependencies: + '@mongodb-js/saslprep': 1.4.11 + bson: 6.10.4 + mongodb-connection-string-url: 3.0.2 + optionalDependencies: + socks: 2.8.7 + mongodb@7.2.0(socks@2.8.7): dependencies: '@mongodb-js/saslprep': 1.4.11 @@ -4747,6 +7942,8 @@ snapshots: mquery@6.0.0: {} + ms@2.0.0: {} + ms@2.1.3: {} mustache@4.2.0: {} @@ -4759,6 +7956,8 @@ snapshots: nanoid@3.3.12: {} + nanoid@5.1.6: {} + napi-build-utils@2.0.0: {} natural@8.1.1(@opentelemetry/api@1.9.0)(socks@2.8.7): @@ -4789,6 +7988,8 @@ snapshots: - snappy - socks + negotiator@0.6.3: {} + negotiator@1.0.0: {} node-abi@3.92.0: @@ -4809,12 +8010,30 @@ snapshots: fetch-blob: 3.2.0 formdata-polyfill: 4.0.10 + node-gyp-build-optional-packages@5.1.1: + dependencies: + detect-libc: 2.1.2 + optional: true + + normalize-url@8.1.1: {} + + npm-run-path@5.3.0: + dependencies: + path-key: 4.0.0 + + npm-run-path@6.0.0: + dependencies: + path-key: 4.0.0 + unicorn-magic: 0.3.0 + object-assign@4.1.1: {} object-inspect@1.13.4: {} obug@2.1.1: {} + ohash@2.0.11: {} + ollama@0.5.18: dependencies: whatwg-fetch: 3.6.20 @@ -4827,6 +8046,10 @@ snapshots: dependencies: wrappy: 1.0.2 + onetime@6.0.0: + dependencies: + mimic-fn: 4.0.0 + onetime@7.0.0: dependencies: mimic-function: 5.0.1 @@ -4838,6 +8061,12 @@ snapshots: is-inside-container: 1.0.0 wsl-utils: 0.1.0 + open@8.4.0: + dependencies: + define-lazy-prop: 2.0.0 + is-docker: 2.2.1 + is-wsl: 2.2.0 + openai@4.104.0(encoding@0.1.13)(ws@8.21.0)(zod@3.25.76): dependencies: '@types/node': 18.19.130 @@ -4883,8 +8112,24 @@ snapshots: string-width: 7.2.0 strip-ansi: 7.1.2 + os-paths@4.4.0: {} + + p-cancelable@4.0.1: {} + + p-event@6.0.1: + dependencies: + p-timeout: 6.1.4 + p-finally@1.0.0: {} + p-limit@4.0.0: + dependencies: + yocto-queue: 1.2.2 + + p-locate@6.0.0: + dependencies: + p-limit: 4.0.0 + p-queue@6.6.2: dependencies: eventemitter3: 4.0.7 @@ -4894,21 +8139,50 @@ snapshots: dependencies: p-finally: 1.0.0 + p-timeout@6.1.4: {} + package-json-from-dist@1.0.1: {} + parent-module@1.0.1: + dependencies: + callsites: 3.1.0 + + parse-json@5.2.0: + dependencies: + '@babel/code-frame': 7.29.7 + error-ex: 1.3.4 + json-parse-even-better-errors: 2.3.1 + lines-and-columns: 1.2.4 + + parse-ms@4.0.0: {} + parseurl@1.3.3: {} + path-exists@5.0.0: {} + + path-expression-matcher@1.5.0: {} + path-key@3.1.1: {} + path-key@4.0.0: {} + path-scurry@1.11.1: dependencies: lru-cache: 10.4.3 minipass: 7.1.2 + path-to-regexp@0.1.13: {} + path-to-regexp@8.4.2: {} + path-type@4.0.0: {} + pathe@2.0.3: {} + pend@1.2.0: {} + + perfect-debounce@2.1.0: {} + pg-cloudflare@1.2.7: optional: true @@ -4925,6 +8199,10 @@ snapshots: dependencies: pg: 8.16.3 + pg-pool@3.14.0(pg@8.20.0): + dependencies: + pg: 8.20.0 + pg-pool@3.14.0(pg@8.21.0): dependencies: pg: 8.21.0 @@ -4951,6 +8229,16 @@ snapshots: optionalDependencies: pg-cloudflare: 1.2.7 + pg@8.20.0: + dependencies: + pg-connection-string: 2.13.0 + pg-pool: 3.14.0(pg@8.20.0) + pg-protocol: 1.14.0 + pg-types: 2.2.0 + pgpass: 1.0.5 + optionalDependencies: + pg-cloudflare: 1.4.0 + pg@8.21.0: dependencies: pg-connection-string: 2.13.0 @@ -4975,6 +8263,10 @@ snapshots: pirates@4.0.7: {} + piscina@4.9.2: + optionalDependencies: + '@napi-rs/nice': 1.1.1 + pkce-challenge@5.0.0: {} pkg-types@1.3.1: @@ -4983,10 +8275,17 @@ snapshots: mlly: 1.8.0 pathe: 2.0.3 - postcss-load-config@6.0.1(postcss@8.5.15)(tsx@4.20.6): + pkg-types@2.3.1: + dependencies: + confbox: 0.2.4 + exsolve: 1.0.8 + pathe: 2.0.3 + + postcss-load-config@6.0.1(jiti@2.7.0)(postcss@8.5.15)(tsx@4.20.6): dependencies: lilconfig: 3.1.3 optionalDependencies: + jiti: 2.7.0 postcss: 8.5.15 tsx: 4.20.6 @@ -5027,6 +8326,10 @@ snapshots: ansi-styles: 5.2.0 react-is: 18.3.1 + pretty-ms@9.3.0: + dependencies: + parse-ms: 4.0.0 + prompts@2.4.2: dependencies: kleur: 3.0.3 @@ -5065,8 +8368,17 @@ snapshots: dependencies: side-channel: 1.1.0 + quick-lru@5.1.1: {} + range-parser@1.2.1: {} + raw-body@2.5.3: + dependencies: + bytes: 3.1.2 + http-errors: 2.0.1 + iconv-lite: 0.4.24 + unpipe: 1.0.0 + raw-body@3.0.1: dependencies: bytes: 3.1.2 @@ -5074,6 +8386,11 @@ snapshots: iconv-lite: 0.7.0 unpipe: 1.0.0 + rc9@3.0.1: + dependencies: + defu: 6.1.7 + destr: 2.0.5 + rc@1.2.8: dependencies: deep-extend: 0.6.0 @@ -5091,6 +8408,8 @@ snapshots: readdirp@4.1.2: {} + readdirp@5.0.0: {} + redis@5.12.1(@opentelemetry/api@1.9.0): dependencies: '@redis/bloom': 5.12.1(@redis/client@5.12.1(@opentelemetry/api@1.9.0)) @@ -5102,12 +8421,24 @@ snapshots: - '@node-rs/xxhash' - '@opentelemetry/api' + reflect-metadata@0.2.2: {} + + require-directory@2.1.1: {} + require-from-string@2.0.2: {} + resolve-alpn@1.2.1: {} + + resolve-from@4.0.0: {} + resolve-from@5.0.0: {} resolve-pkg-maps@1.0.0: {} + responselike@4.0.2: + dependencies: + lowercase-keys: 3.0.0 + restore-cursor@5.1.0: dependencies: onetime: 7.0.0 @@ -5146,7 +8477,7 @@ snapshots: router@2.2.0: dependencies: - debug: 4.4.3 + debug: 4.4.3(supports-color@8.1.1) depd: 2.0.0 is-promise: 4.0.0 parseurl: 1.3.3 @@ -5156,17 +8487,55 @@ snapshots: run-applescript@7.1.0: {} + rxjs@7.8.2: + dependencies: + tslib: 2.8.1 + safe-buffer@5.2.1: {} safe-stable-stringify@2.5.0: {} safer-buffer@2.1.2: {} + scule@1.3.0: {} + + seedrandom@3.0.5: {} + + seek-bzip@2.0.0: + dependencies: + commander: 6.2.1 + + semver-regex@4.0.5: {} + + semver-truncate@3.0.0: + dependencies: + semver: 7.8.1 + + semver@7.7.4: {} + semver@7.8.1: {} + send@0.19.2: + dependencies: + debug: 2.6.9 + depd: 2.0.0 + destroy: 1.2.0 + encodeurl: 2.0.0 + escape-html: 1.0.3 + etag: 1.8.1 + fresh: 0.5.2 + http-errors: 2.0.1 + mime: 1.6.0 + ms: 2.1.3 + on-finished: 2.4.1 + range-parser: 1.2.1 + statuses: 2.0.2 + transitivePeerDependencies: + - supports-color + send@1.2.0: dependencies: - debug: 4.4.3 + debug: 4.4.3(supports-color@8.1.1) encodeurl: 2.0.0 escape-html: 1.0.3 etag: 1.8.1 @@ -5180,6 +8549,15 @@ snapshots: transitivePeerDependencies: - supports-color + serve-static@1.16.3: + dependencies: + encodeurl: 2.0.0 + escape-html: 1.0.3 + parseurl: 1.3.3 + send: 0.19.2 + transitivePeerDependencies: + - supports-color + serve-static@2.2.0: dependencies: encodeurl: 2.0.0 @@ -5252,8 +8630,18 @@ snapshots: smart-buffer: 4.2.0 optional: true + sort-keys-length@1.0.1: + dependencies: + sort-keys: 1.1.2 + + sort-keys@1.1.2: + dependencies: + is-plain-obj: 1.1.0 + source-map-js@1.2.1: {} + source-map@0.7.6: {} + source-map@0.8.0-beta.0: dependencies: whatwg-url: 7.1.0 @@ -5280,6 +8668,15 @@ snapshots: stopwords-iso@1.1.0: {} + streamx@2.26.0: + dependencies: + events-universal: 1.0.1 + fast-fifo: 1.3.2 + text-decoder: 1.2.7 + transitivePeerDependencies: + - bare-abort-controller + - react-native-b4a + string-width@4.2.3: dependencies: emoji-regex: 8.0.0 @@ -5310,8 +8707,23 @@ snapshots: dependencies: ansi-regex: 6.2.2 + strip-dirs@3.0.0: + dependencies: + inspect-with-kind: 1.0.5 + is-plain-obj: 1.1.0 + + strip-final-newline@3.0.0: {} + + strip-final-newline@4.0.0: {} + strip-json-comments@2.0.1: {} + strnum@2.3.0: {} + + strtok3@10.3.5: + dependencies: + '@tokenizer/token': 0.3.0 + sucrase@3.35.0: dependencies: '@jridgewell/gen-mapping': 0.3.13 @@ -5324,12 +8736,33 @@ snapshots: suffix-thumb@5.0.2: {} + super-regex@1.1.0: + dependencies: + function-timeout: 1.0.2 + make-asynchronous: 1.1.0 + time-span: 5.1.0 + + supports-color@10.2.2: {} + supports-color@7.2.0: dependencies: has-flag: 4.0.0 + supports-color@8.1.1: + dependencies: + has-flag: 4.0.0 + + supports-hyperlinks@4.4.0: + dependencies: + has-flag: 5.0.1 + supports-color: 10.2.2 + sylvester@0.0.21: {} + system-architecture@1.0.0: {} + + tapable@2.3.3: {} + tar-fs@2.1.4: dependencies: chownr: 1.1.4 @@ -5345,6 +8778,26 @@ snapshots: inherits: 2.0.4 readable-stream: 3.6.2 + tar-stream@3.1.7: + dependencies: + b4a: 1.8.1 + fast-fifo: 1.3.2 + streamx: 2.26.0 + transitivePeerDependencies: + - bare-abort-controller + - react-native-b4a + + terminal-link@5.0.0: + dependencies: + ansi-escapes: 7.3.0 + supports-hyperlinks: 4.4.0 + + text-decoder@1.2.7: + dependencies: + b4a: 1.8.1 + transitivePeerDependencies: + - react-native-b4a + thenify-all@1.6.0: dependencies: thenify: 3.3.1 @@ -5353,6 +8806,12 @@ snapshots: dependencies: any-promise: 1.3.0 + through@2.3.8: {} + + time-span@5.1.0: + dependencies: + convert-hrtime: 5.0.0 + tinybench@2.9.0: {} tinyexec@0.3.2: {} @@ -5372,6 +8831,12 @@ snapshots: toidentifier@1.0.1: {} + token-types@6.1.2: + dependencies: + '@borewit/text-codec': 0.2.2 + '@tokenizer/token': 0.3.0 + ieee754: 1.2.1 + tr46@0.0.3: {} tr46@1.0.1: @@ -5388,18 +8853,18 @@ snapshots: tslib@2.8.1: {} - tsup@8.5.0(postcss@8.5.15)(tsx@4.20.6)(typescript@5.9.3): + tsup@8.5.0(@swc/core@1.15.3)(jiti@2.7.0)(postcss@8.5.15)(tsx@4.20.6)(typescript@5.9.3): dependencies: bundle-require: 5.1.0(esbuild@0.25.12) cac: 6.7.14 chokidar: 4.0.3 consola: 3.4.2 - debug: 4.4.3 + debug: 4.4.3(supports-color@8.1.1) esbuild: 0.25.12 fix-dts-default-cjs-exports: 1.0.1 joycon: 3.1.1 picocolors: 1.1.1 - postcss-load-config: 6.0.1(postcss@8.5.15)(tsx@4.20.6) + postcss-load-config: 6.0.1(jiti@2.7.0)(postcss@8.5.15)(tsx@4.20.6) resolve-from: 5.0.0 rollup: 4.61.0 source-map: 0.8.0-beta.0 @@ -5408,6 +8873,7 @@ snapshots: tinyglobby: 0.2.15 tree-kill: 1.2.2 optionalDependencies: + '@swc/core': 1.15.3 postcss: 8.5.15 typescript: 5.9.3 transitivePeerDependencies: @@ -5427,6 +8893,15 @@ snapshots: dependencies: safe-buffer: 5.2.1 + type-fest@0.21.3: {} + + type-fest@4.41.0: {} + + type-is@1.6.18: + dependencies: + media-typer: 0.3.0 + mime-types: 2.1.35 + type-is@2.0.1: dependencies: content-type: 1.0.5 @@ -5437,29 +8912,92 @@ snapshots: ufo@1.6.1: {} + ufo@1.6.4: {} + + uid@2.0.2: + dependencies: + '@lukeed/csprng': 1.1.0 + + uint8array-extras@1.5.0: {} + + ulid@2.4.0: {} + + ulid@3.0.2: {} + + unbzip2-stream@1.4.3: + dependencies: + buffer: 5.7.1 + through: 2.3.8 + + unctx@2.5.0: + dependencies: + acorn: 8.15.0 + estree-walker: 3.0.3 + magic-string: 0.30.21 + unplugin: 2.3.11 + underscore@1.13.8: {} undici-types@5.26.5: {} + undici-types@6.21.0: {} + undici-types@7.14.0: {} undici-types@7.16.0: {} undici@6.26.0: {} + undici@7.22.0: {} + + unicorn-magic@0.1.0: {} + + unicorn-magic@0.3.0: {} + universalify@2.0.1: {} unpipe@1.0.0: {} + unplugin@2.3.11: + dependencies: + '@jridgewell/remapping': 2.3.5 + acorn: 8.15.0 + picomatch: 4.0.4 + webpack-virtual-modules: 0.6.2 + + untyped@2.0.0: + dependencies: + citty: 0.1.6 + defu: 6.1.7 + jiti: 2.7.0 + knitwork: 1.3.0 + scule: 1.3.0 + util-deprecate@1.0.2: {} + utils-merge@1.0.1: {} + uuid@11.1.1: {} uuid@13.0.2: {} vary@1.1.2: {} - vite@7.3.5(@types/node@24.7.0)(tsx@4.20.6): + vite@7.3.5(@types/node@24.12.4)(jiti@2.7.0)(tsx@4.20.6): + dependencies: + esbuild: 0.27.7 + fdir: 6.5.0(picomatch@4.0.4) + picomatch: 4.0.4 + postcss: 8.5.15 + rollup: 4.61.0 + tinyglobby: 0.2.15 + optionalDependencies: + '@types/node': 24.12.4 + fsevents: 2.3.3 + jiti: 2.7.0 + tsx: 4.20.6 + + vite@7.3.5(@types/node@24.7.0)(jiti@2.7.0)(tsx@4.20.6): dependencies: esbuild: 0.27.7 fdir: 6.5.0(picomatch@4.0.4) @@ -5470,12 +9008,41 @@ snapshots: optionalDependencies: '@types/node': 24.7.0 fsevents: 2.3.3 + jiti: 2.7.0 tsx: 4.20.6 - vitest@4.1.8(@opentelemetry/api@1.9.0)(@types/node@24.7.0)(vite@7.3.5(@types/node@24.7.0)(tsx@4.20.6)): + vitest@4.1.8(@opentelemetry/api@1.9.0)(@types/node@24.12.4)(vite@7.3.5(@types/node@24.12.4)(jiti@2.7.0)(tsx@4.20.6)): + dependencies: + '@vitest/expect': 4.1.8 + '@vitest/mocker': 4.1.8(vite@7.3.5(@types/node@24.12.4)(jiti@2.7.0)(tsx@4.20.6)) + '@vitest/pretty-format': 4.1.8 + '@vitest/runner': 4.1.8 + '@vitest/snapshot': 4.1.8 + '@vitest/spy': 4.1.8 + '@vitest/utils': 4.1.8 + es-module-lexer: 2.1.0 + expect-type: 1.3.0 + magic-string: 0.30.21 + obug: 2.1.1 + pathe: 2.0.3 + picomatch: 4.0.4 + std-env: 4.1.0 + tinybench: 2.9.0 + tinyexec: 1.2.4 + tinyglobby: 0.2.15 + tinyrainbow: 3.1.0 + vite: 7.3.5(@types/node@24.12.4)(jiti@2.7.0)(tsx@4.20.6) + why-is-node-running: 2.3.0 + optionalDependencies: + '@opentelemetry/api': 1.9.0 + '@types/node': 24.12.4 + transitivePeerDependencies: + - msw + + vitest@4.1.8(@opentelemetry/api@1.9.0)(@types/node@24.7.0)(vite@7.3.5(@types/node@24.7.0)(jiti@2.7.0)(tsx@4.20.6)): dependencies: '@vitest/expect': 4.1.8 - '@vitest/mocker': 4.1.8(vite@7.3.5(@types/node@24.7.0)(tsx@4.20.6)) + '@vitest/mocker': 4.1.8(vite@7.3.5(@types/node@24.7.0)(jiti@2.7.0)(tsx@4.20.6)) '@vitest/pretty-format': 4.1.8 '@vitest/runner': 4.1.8 '@vitest/snapshot': 4.1.8 @@ -5492,7 +9059,7 @@ snapshots: tinyexec: 1.2.4 tinyglobby: 0.2.15 tinyrainbow: 3.1.0 - vite: 7.3.5(@types/node@24.7.0)(tsx@4.20.6) + vite: 7.3.5(@types/node@24.7.0)(jiti@2.7.0)(tsx@4.20.6) why-is-node-running: 2.3.0 optionalDependencies: '@opentelemetry/api': 1.9.0 @@ -5500,16 +9067,30 @@ snapshots: transitivePeerDependencies: - msw + watchpack@2.5.1: + dependencies: + glob-to-regexp: 0.4.1 + graceful-fs: 4.2.11 + + wcwidth@1.0.1: + dependencies: + defaults: 1.0.4 + optional: true + web-streams-polyfill@3.3.3: {} web-streams-polyfill@4.0.0-beta.3: {} + web-worker@1.5.0: {} + webidl-conversions@3.0.1: {} webidl-conversions@4.0.2: {} webidl-conversions@7.0.0: {} + webpack-virtual-modules@0.6.2: {} + whatwg-fetch@3.6.20: {} whatwg-url@14.2.0: @@ -5537,8 +9118,46 @@ snapshots: siginfo: 2.0.0 stackback: 0.0.2 + widest-line@3.1.0: + dependencies: + string-width: 4.2.3 + + widest-line@5.0.0: + dependencies: + string-width: 7.2.0 + wordnet-db@3.1.14: {} + wordwrap@1.0.0: {} + + workflow@4.3.1(@nestjs/common@11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24(@nestjs/common@11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2))(reflect-metadata@0.2.2)(rxjs@7.8.2))(@opentelemetry/api@1.9.0)(@swc/cli@0.8.1(@swc/core@1.15.3)(chokidar@5.0.0))(@swc/core@1.15.3)(typescript@5.9.3): + dependencies: + '@workflow/astro': 4.0.8(@opentelemetry/api@1.9.0) + '@workflow/cli': 4.2.8(@opentelemetry/api@1.9.0) + '@workflow/core': 4.3.1(@opentelemetry/api@1.9.0) + '@workflow/errors': 4.1.3 + '@workflow/nest': 0.0.8(@nestjs/common@11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24(@nestjs/common@11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2))(reflect-metadata@0.2.2)(rxjs@7.8.2))(@opentelemetry/api@1.9.0)(@swc/cli@0.8.1(@swc/core@1.15.3)(chokidar@5.0.0))(@swc/core@1.15.3) + '@workflow/next': 4.0.9(@opentelemetry/api@1.9.0) + '@workflow/nitro': 4.0.9(@opentelemetry/api@1.9.0) + '@workflow/nuxt': 4.0.9(@opentelemetry/api@1.9.0) + '@workflow/rollup': 4.0.8(@opentelemetry/api@1.9.0) + '@workflow/sveltekit': 4.0.8(@opentelemetry/api@1.9.0) + '@workflow/typescript-plugin': 4.0.2(typescript@5.9.3) + '@workflow/utils': 4.1.2 + ms: 2.1.3 + optionalDependencies: + '@opentelemetry/api': 1.9.0 + transitivePeerDependencies: + - '@nestjs/common' + - '@nestjs/core' + - '@swc/cli' + - '@swc/core' + - '@swc/helpers' + - magicast + - next + - supports-color + - typescript + wrap-ansi@7.0.0: dependencies: ansi-styles: 4.3.0 @@ -5551,6 +9170,12 @@ snapshots: string-width: 5.1.2 strip-ansi: 7.1.2 + wrap-ansi@9.0.2: + dependencies: + ansi-styles: 6.2.3 + string-width: 7.2.0 + strip-ansi: 7.1.2 + wrappy@1.0.2: {} ws@8.21.0: {} @@ -5559,8 +9184,40 @@ snapshots: dependencies: is-wsl: 3.1.1 + xdg-app-paths@5.1.0: + dependencies: + xdg-portable: 7.3.0 + + xdg-portable@7.3.0: + dependencies: + os-paths: 4.4.0 + + xml-naming@0.1.0: {} + xtend@4.0.2: {} + y18n@5.0.8: {} + + yargs-parser@21.1.1: {} + + yargs@17.7.2: + dependencies: + cliui: 8.0.1 + escalade: 3.2.0 + get-caller-file: 2.0.5 + require-directory: 2.1.1 + string-width: 4.2.3 + y18n: 5.0.8 + yargs-parser: 21.1.1 + + yauzl@3.3.2: + dependencies: + pend: 1.2.0 + + yocto-queue@1.2.2: {} + + yoctocolors@2.1.2: {} + zod-to-json-schema@3.25.2(zod@3.25.76): dependencies: zod: 3.25.76 @@ -5572,4 +9229,8 @@ snapshots: zod@3.25.76: {} + zod@4.1.11: {} + zod@4.1.12: {} + + zod@4.3.6: {} diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml index ffe3bf8..d6ba34d 100644 --- a/pnpm-workspace.yaml +++ b/pnpm-workspace.yaml @@ -1,5 +1,6 @@ packages: - packages/core + - packages/workflow-world - packages/types - packages/mcp-docs-server - packages/mcp From 35a0a4c280ea8b6ac73b0df7bcc1e841de5a824d Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 17:55:58 +0200 Subject: [PATCH 05/21] feat(core): add WorkflowKit contract types Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/core/src/workflows/kit/types.ts | 48 ++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 packages/core/src/workflows/kit/types.ts diff --git a/packages/core/src/workflows/kit/types.ts b/packages/core/src/workflows/kit/types.ts new file mode 100644 index 0000000..086d2ab --- /dev/null +++ b/packages/core/src/workflows/kit/types.ts @@ -0,0 +1,48 @@ +import type { Workflow } from "../workflow.js"; +import type { WorkflowRunOptions, WorkflowRunResult } from "../types.js"; + +export type WorkflowEngine = "legacy" | "world"; + +export interface WorldConfig { + type: "postgres" | "mongodb"; + /** Connection string (postgres:// ou mongodb://). */ + url: string; + /** Postgres : namespacing des jobs si DB partagée. */ + jobPrefix?: string; + /** Postgres : nombre de workers concurrents. */ + workerConcurrency?: number; + /** Postgres : taille du pool de connexions. */ + maxPoolSize?: number; +} + +export interface WorkflowKitOptions { + /** Moteur par défaut. Défaut : "legacy". */ + engine?: WorkflowEngine; + /** Config du world. Requis si engine === "world". */ + world?: WorldConfig; +} + +/** Handle opaque renvoyé par le moteur world (pass-through du SDK Vercel). */ +export interface WorldRunHandle { + runId?: string; + [key: string]: unknown; +} + +/** Contrat implémenté par @ai_kit/workflow-world. Défini ici pour découpler core du SDK. */ +export interface WorldEngineAdapter { + start(): Promise; + stop(): Promise; + run(workflow: (...args: any[]) => unknown, args: unknown[]): Promise; +} + +/** Forme du module @ai_kit/workflow-world chargé dynamiquement. */ +export interface WorkflowWorldModule { + createWorldAdapter(config: WorldConfig): WorldEngineAdapter; +} + +/** Options par appel de WorkflowKit.run. */ +export interface WorkflowRunDispatchOptions { + engine?: WorkflowEngine; +} + +export type { Workflow, WorkflowRunOptions, WorkflowRunResult }; From 1ec27172d55952fc9a507c221d0714e9a3f1f19b Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 17:57:26 +0200 Subject: [PATCH 06/21] feat(core): export WorkflowKit contract types from public API Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/core/src/workflows/index.ts | 1 + packages/core/src/workflows/kit/index.ts | 9 +++++++++ 2 files changed, 10 insertions(+) create mode 100644 packages/core/src/workflows/kit/index.ts diff --git a/packages/core/src/workflows/index.ts b/packages/core/src/workflows/index.ts index 01b1808..ea964dd 100644 --- a/packages/core/src/workflows/index.ts +++ b/packages/core/src/workflows/index.ts @@ -48,3 +48,4 @@ export { WorkflowBuilder, createWorkflow } from "./workflowBuilder.js"; export { Workflow, withTelemetry } from "./workflow.js"; export { WorkflowRun } from "./workflowRun.js"; export { renderWorkflowGraphJSON } from "./inspector.js"; +export * from "./kit/index.js"; diff --git a/packages/core/src/workflows/kit/index.ts b/packages/core/src/workflows/kit/index.ts new file mode 100644 index 0000000..aebffa2 --- /dev/null +++ b/packages/core/src/workflows/kit/index.ts @@ -0,0 +1,9 @@ +export type { + WorkflowEngine, + WorldConfig, + WorkflowKitOptions, + WorldRunHandle, + WorldEngineAdapter, + WorkflowWorldModule, + WorkflowRunDispatchOptions, +} from "./types.js"; From f70aeb2046b8bd347bbaef34610a0e3edf8cf27b Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 17:59:56 +0200 Subject: [PATCH 07/21] feat(workflow-world): world type resolution and createWorld option mapping Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/workflow-world/src/worlds.test.ts | 48 ++++++++++++++++++++++ packages/workflow-world/src/worlds.ts | 30 ++++++++++++++ 2 files changed, 78 insertions(+) create mode 100644 packages/workflow-world/src/worlds.test.ts create mode 100644 packages/workflow-world/src/worlds.ts diff --git a/packages/workflow-world/src/worlds.test.ts b/packages/workflow-world/src/worlds.test.ts new file mode 100644 index 0000000..7fe4cc4 --- /dev/null +++ b/packages/workflow-world/src/worlds.test.ts @@ -0,0 +1,48 @@ +import { describe, expect, it } from "vitest"; +import { buildWorldOptions, WORLD_TARGETS } from "./worlds.js"; + +describe("WORLD_TARGETS", () => { + it("mappe les types vers les packages SDK", () => { + expect(WORLD_TARGETS.postgres).toBe("@workflow/world-postgres"); + expect(WORLD_TARGETS.mongodb).toBe("@workflow-worlds/mongodb"); + }); +}); + +describe("buildWorldOptions", () => { + it("postgres : mappe url→connectionString et workerConcurrency→queueConcurrency", () => { + const opts = buildWorldOptions({ + type: "postgres", + url: "postgres://u:p@h:5432/db", + jobPrefix: "wf__", + workerConcurrency: 5, + maxPoolSize: 12, + }); + expect(opts).toEqual({ + connectionString: "postgres://u:p@h:5432/db", + jobPrefix: "wf__", + queueConcurrency: 5, + maxPoolSize: 12, + }); + }); + + it("postgres : omet les champs optionnels absents", () => { + expect(buildWorldOptions({ type: "postgres", url: "postgres://x" })).toEqual({ + connectionString: "postgres://x", + }); + }); + + it("mongodb : mappe url→mongoUrl", () => { + expect(buildWorldOptions({ type: "mongodb", url: "mongodb://h:27017/db" })).toEqual({ + mongoUrl: "mongodb://h:27017/db", + }); + }); + + it("rejette une url manquante", () => { + expect(() => buildWorldOptions({ type: "postgres", url: "" })).toThrow(/url/i); + }); + + it("rejette un type inconnu", () => { + // @ts-expect-error test runtime + expect(() => buildWorldOptions({ type: "redis", url: "x" })).toThrow(/unsupported|inconnu/i); + }); +}); diff --git a/packages/workflow-world/src/worlds.ts b/packages/workflow-world/src/worlds.ts new file mode 100644 index 0000000..9818b08 --- /dev/null +++ b/packages/workflow-world/src/worlds.ts @@ -0,0 +1,30 @@ +import type { WorldConfig } from "@ai_kit/core"; + +export const WORLD_TARGETS = { + postgres: "@workflow/world-postgres", + mongodb: "@workflow-worlds/mongodb", +} as const; + +/** + * Construit l'objet d'options passé à `createWorld(...)` du SDK Vercel, selon le type. + * Pas de mutation d'env : on injecte le world programmatiquement (cf. adapter). + */ +export function buildWorldOptions(config: WorldConfig): Record { + if (!config.url) { + throw new Error("workflow-world: 'url' is required in WorldConfig"); + } + if (!(config.type in WORLD_TARGETS)) { + throw new Error(`workflow-world: unsupported world type '${config.type}'`); + } + + if (config.type === "postgres") { + const opts: Record = { connectionString: config.url }; + if (config.jobPrefix) opts.jobPrefix = config.jobPrefix; + if (config.workerConcurrency != null) opts.queueConcurrency = config.workerConcurrency; + if (config.maxPoolSize != null) opts.maxPoolSize = config.maxPoolSize; + return opts; + } + + // mongodb + return { mongoUrl: config.url }; +} From 040d60c0b8481eabaa6fb0cca8ee8925cc0ec045 Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 18:02:42 +0200 Subject: [PATCH 08/21] feat(workflow-world): createWorldAdapter with programmatic world injection Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/workflow-world/src/adapter.test.ts | 87 +++++++++++++++++++++ packages/workflow-world/src/adapter.ts | 77 ++++++++++++++++++ 2 files changed, 164 insertions(+) create mode 100644 packages/workflow-world/src/adapter.test.ts create mode 100644 packages/workflow-world/src/adapter.ts diff --git a/packages/workflow-world/src/adapter.test.ts b/packages/workflow-world/src/adapter.test.ts new file mode 100644 index 0000000..bc891fe --- /dev/null +++ b/packages/workflow-world/src/adapter.test.ts @@ -0,0 +1,87 @@ +import { afterEach, describe, expect, it, vi } from "vitest"; +import { createWorldAdapter, __setWorldModuleLoaders } from "./adapter.js"; + +afterEach(() => __setWorldModuleLoaders()); + +function mockPostgres() { + const start = vi.fn().mockResolvedValue(undefined); + const close = vi.fn().mockResolvedValue(undefined); + const world = { start, close }; + const createWorld = vi.fn(() => world); + const setWorld = vi.fn(); + const startRun = vi.fn().mockResolvedValue({ runId: "r_1" }); + __setWorldModuleLoaders({ + postgres: async () => ({ createWorld }), + runtime: async () => ({ setWorld }), + api: async () => ({ start: startRun }), + }); + return { createWorld, world, start, close, setWorld, startRun }; +} + +describe("createWorldAdapter (postgres)", () => { + it("start: crée le world avec les options mappées, l'injecte et démarre le worker", async () => { + const m = mockPostgres(); + const adapter = createWorldAdapter({ + type: "postgres", + url: "postgres://u:p@h:5432/db", + jobPrefix: "wf__", + workerConcurrency: 5, + }); + await adapter.start(); + expect(m.createWorld).toHaveBeenCalledWith({ + connectionString: "postgres://u:p@h:5432/db", + jobPrefix: "wf__", + queueConcurrency: 5, + }); + expect(m.setWorld).toHaveBeenCalledWith(m.world); + expect(m.start).toHaveBeenCalledTimes(1); + }); + + it("run: délègue à start() du SDK en passant l'instance world", async () => { + const m = mockPostgres(); + const adapter = createWorldAdapter({ type: "postgres", url: "postgres://x" }); + await adapter.start(); + const fn = async () => 1; + const handle = await adapter.run(fn, ["a"]); + expect(m.startRun).toHaveBeenCalledWith(fn, ["a"], { world: m.world }); + expect(handle).toEqual({ runId: "r_1" }); + }); + + it("stop: ferme le world et réinitialise l'injection", async () => { + const m = mockPostgres(); + const adapter = createWorldAdapter({ type: "postgres", url: "postgres://x" }); + await adapter.start(); + await adapter.stop(); + expect(m.close).toHaveBeenCalledTimes(1); + expect(m.setWorld).toHaveBeenLastCalledWith(undefined); + }); + + it("erreur claire si le package world manque", async () => { + __setWorldModuleLoaders({ + postgres: async () => { + const e = new Error("nf") as Error & { code?: string }; + e.code = "ERR_MODULE_NOT_FOUND"; + throw e; + }, + }); + const adapter = createWorldAdapter({ type: "postgres", url: "postgres://x" }); + await expect(adapter.start()).rejects.toThrow("@workflow/world-postgres"); + }); +}); + +describe("createWorldAdapter (mongodb)", () => { + it("start: world Mongo sans start() ne throw pas (connexion lazy)", async () => { + const close = vi.fn().mockResolvedValue(undefined); + const world = { close }; // pas de start() + const createWorld = vi.fn(() => world); + const setWorld = vi.fn(); + __setWorldModuleLoaders({ + mongodb: async () => ({ createWorld }), + runtime: async () => ({ setWorld }), + }); + const adapter = createWorldAdapter({ type: "mongodb", url: "mongodb://h:27017/db" }); + await expect(adapter.start()).resolves.toBeUndefined(); + expect(createWorld).toHaveBeenCalledWith({ mongoUrl: "mongodb://h:27017/db" }); + expect(setWorld).toHaveBeenCalledWith(world); + }); +}); diff --git a/packages/workflow-world/src/adapter.ts b/packages/workflow-world/src/adapter.ts new file mode 100644 index 0000000..85140dc --- /dev/null +++ b/packages/workflow-world/src/adapter.ts @@ -0,0 +1,77 @@ +import type { WorldConfig, WorldEngineAdapter, WorldRunHandle } from "@ai_kit/core"; +import { buildWorldOptions, WORLD_TARGETS } from "./worlds.js"; + +interface SdkWorld { + start?(): Promise; + close?(): Promise; +} + +interface WorldModuleLoaders { + postgres: () => Promise<{ createWorld: (opts: Record) => SdkWorld }>; + mongodb: () => Promise<{ createWorld: (opts: Record) => SdkWorld }>; + api: () => Promise<{ + start: ( + fn: (...args: any[]) => unknown, + args: unknown[], + options?: { world?: SdkWorld }, + ) => Promise; + }>; + runtime: () => Promise<{ setWorld: (world: SdkWorld | undefined) => void }>; +} + +function defaultLoaders(): WorldModuleLoaders { + return { + postgres: () => import(WORLD_TARGETS.postgres) as Promise, + mongodb: () => import(WORLD_TARGETS.mongodb) as Promise, + api: () => import("workflow/api") as Promise, + runtime: () => import("workflow/runtime") as Promise, + }; +} + +let loaders: WorldModuleLoaders = defaultLoaders(); + +/** @internal Test seam. Called with no argument, it resets to the default loaders. */ +export function __setWorldModuleLoaders(custom?: Partial): void { + loaders = { ...defaultLoaders(), ...custom }; +} + +async function loadWorldModule(type: WorldConfig["type"]) { + try { + return type === "postgres" ? await loaders.postgres() : await loaders.mongodb(); + } catch (err) { + if ((err as { code?: string }).code === "ERR_MODULE_NOT_FOUND") { + throw new Error( + `workflow-world: the optional dependency '${WORLD_TARGETS[type]}' is not installed. ` + + `Install it: pnpm add ${WORLD_TARGETS[type]}`, + ); + } + throw err; + } +} + +export function createWorldAdapter(config: WorldConfig): WorldEngineAdapter { + let world: SdkWorld | undefined; + + return { + async start() { + const mod = await loadWorldModule(config.type); + world = mod.createWorld(buildWorldOptions(config)); + const { setWorld } = await loaders.runtime(); + setWorld(world); + await world.start?.(); + }, + + async stop() { + if (!world) return; + await world.close?.(); + const { setWorld } = await loaders.runtime(); + setWorld(undefined); + world = undefined; + }, + + async run(fn, args) { + const { start } = await loaders.api(); + return start(fn, args, { world }); + }, + }; +} From 4d427beab7617e668b595502e55d593e5eee660e Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 18:13:00 +0200 Subject: [PATCH 09/21] fix(workflow-world): exception-safe stop, run guard, optional-peer world backends Addresses code review: stop() releases injection before close, run() guards uninitialized world, world backends moved to optional peerDependencies, minor cleanups (loaders lookup, jobPrefix guard). Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/workflow-world/package.json | 14 ++++++++++---- packages/workflow-world/src/adapter.test.ts | 10 ++++++++++ packages/workflow-world/src/adapter.ts | 13 +++++++++---- packages/workflow-world/src/worlds.ts | 2 +- pnpm-lock.yaml | 12 ++++++------ 5 files changed, 36 insertions(+), 15 deletions(-) diff --git a/packages/workflow-world/package.json b/packages/workflow-world/package.json index d66daa5..19cd792 100644 --- a/packages/workflow-world/package.json +++ b/packages/workflow-world/package.json @@ -23,15 +23,21 @@ "packageManager": "pnpm@10.15.0", "publishConfig": { "access": "public" }, "dependencies": { - "workflow": "^4.3.1", - "@workflow/world-postgres": "^4.1.4", - "@workflow-worlds/mongodb": "^0.2.1" + "workflow": "^4.3.1" }, "peerDependencies": { - "@ai_kit/core": ">=1.3.0 <2" + "@ai_kit/core": ">=1.3.0 <2", + "@workflow/world-postgres": ">=4.1.4 <5", + "@workflow-worlds/mongodb": ">=0.2.1 <1" + }, + "peerDependenciesMeta": { + "@workflow/world-postgres": { "optional": true }, + "@workflow-worlds/mongodb": { "optional": true } }, "devDependencies": { "@ai_kit/core": "workspace:*", + "@workflow/world-postgres": "^4.1.4", + "@workflow-worlds/mongodb": "^0.2.1", "@types/node": "^24.7.0", "typescript": "^5.9.2", "vitest": "^4.1.8" diff --git a/packages/workflow-world/src/adapter.test.ts b/packages/workflow-world/src/adapter.test.ts index bc891fe..a15e100 100644 --- a/packages/workflow-world/src/adapter.test.ts +++ b/packages/workflow-world/src/adapter.test.ts @@ -67,6 +67,16 @@ describe("createWorldAdapter (postgres)", () => { const adapter = createWorldAdapter({ type: "postgres", url: "postgres://x" }); await expect(adapter.start()).rejects.toThrow("@workflow/world-postgres"); }); + + it("stop avant start: ne throw pas", async () => { + const adapter = createWorldAdapter({ type: "postgres", url: "postgres://x" }); + await expect(adapter.stop()).resolves.toBeUndefined(); + }); + + it("run avant start: throw une erreur claire", async () => { + const adapter = createWorldAdapter({ type: "postgres", url: "postgres://x" }); + await expect(adapter.run(async () => 1, [])).rejects.toThrow(/start\(\) before run\(\)/); + }); }); describe("createWorldAdapter (mongodb)", () => { diff --git a/packages/workflow-world/src/adapter.ts b/packages/workflow-world/src/adapter.ts index 85140dc..4b02f9e 100644 --- a/packages/workflow-world/src/adapter.ts +++ b/packages/workflow-world/src/adapter.ts @@ -3,6 +3,7 @@ import { buildWorldOptions, WORLD_TARGETS } from "./worlds.js"; interface SdkWorld { start?(): Promise; + /** Present at runtime on @workflow/world-postgres (undocumented); absent on @workflow-worlds/mongodb (lazy/no-op). */ close?(): Promise; } @@ -37,7 +38,7 @@ export function __setWorldModuleLoaders(custom?: Partial): v async function loadWorldModule(type: WorldConfig["type"]) { try { - return type === "postgres" ? await loaders.postgres() : await loaders.mongodb(); + return await loaders[type](); } catch (err) { if ((err as { code?: string }).code === "ERR_MODULE_NOT_FOUND") { throw new Error( @@ -63,13 +64,17 @@ export function createWorldAdapter(config: WorldConfig): WorldEngineAdapter { async stop() { if (!world) return; - await world.close?.(); const { setWorld } = await loaders.runtime(); - setWorld(undefined); - world = undefined; + const closing = world; + world = undefined; // clear local ref first + setWorld(undefined); // release SDK injection first + await closing.close?.(); // best-effort cleanup (may throw; injection already released) }, async run(fn, args) { + if (!world) { + throw new Error("workflow-world: call start() before run() (the world is not initialized)"); + } const { start } = await loaders.api(); return start(fn, args, { world }); }, diff --git a/packages/workflow-world/src/worlds.ts b/packages/workflow-world/src/worlds.ts index 9818b08..9dfc522 100644 --- a/packages/workflow-world/src/worlds.ts +++ b/packages/workflow-world/src/worlds.ts @@ -19,7 +19,7 @@ export function buildWorldOptions(config: WorldConfig): Record if (config.type === "postgres") { const opts: Record = { connectionString: config.url }; - if (config.jobPrefix) opts.jobPrefix = config.jobPrefix; + if (config.jobPrefix != null) opts.jobPrefix = config.jobPrefix; if (config.workerConcurrency != null) opts.queueConcurrency = config.workerConcurrency; if (config.maxPoolSize != null) opts.maxPoolSize = config.maxPoolSize; return opts; diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index fa30c06..9077ca2 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -228,12 +228,6 @@ importers: packages/workflow-world: dependencies: - '@workflow-worlds/mongodb': - specifier: ^0.2.1 - version: 0.2.1(socks@2.8.7) - '@workflow/world-postgres': - specifier: ^4.1.4 - version: 4.1.4(@cloudflare/workers-types@4.20251118.0)(@opentelemetry/api@1.9.0)(@types/pg@8.15.6)(better-sqlite3@12.10.0)(typescript@5.9.3) workflow: specifier: ^4.3.1 version: 4.3.1(@nestjs/common@11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24(@nestjs/common@11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2))(reflect-metadata@0.2.2)(rxjs@7.8.2))(@opentelemetry/api@1.9.0)(@swc/cli@0.8.1(@swc/core@1.15.3)(chokidar@5.0.0))(@swc/core@1.15.3)(typescript@5.9.3) @@ -244,6 +238,12 @@ importers: '@types/node': specifier: ^24.7.0 version: 24.12.4 + '@workflow-worlds/mongodb': + specifier: ^0.2.1 + version: 0.2.1(socks@2.8.7) + '@workflow/world-postgres': + specifier: ^4.1.4 + version: 4.1.4(@cloudflare/workers-types@4.20251118.0)(@opentelemetry/api@1.9.0)(@types/pg@8.15.6)(better-sqlite3@12.10.0)(typescript@5.9.3) typescript: specifier: ^5.9.2 version: 5.9.3 From e019b7f8259618e636bc0b76627492cd6c8c13f8 Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 18:15:05 +0200 Subject: [PATCH 10/21] feat(workflow-world): type-only authoring helpers (WorldStep/WorldWorkflow) Per spike verdict 2: directives are only detected on top-level bindings, so no runtime defineWorldStep wrapper is shipped; types document the required form. Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/workflow-world/src/authoring.test.ts | 11 +++++++ packages/workflow-world/src/authoring.ts | 32 +++++++++++++++++++ 2 files changed, 43 insertions(+) create mode 100644 packages/workflow-world/src/authoring.test.ts create mode 100644 packages/workflow-world/src/authoring.ts diff --git a/packages/workflow-world/src/authoring.test.ts b/packages/workflow-world/src/authoring.test.ts new file mode 100644 index 0000000..22294ce --- /dev/null +++ b/packages/workflow-world/src/authoring.test.ts @@ -0,0 +1,11 @@ +import { describe, it, expectTypeOf } from "vitest"; +import type { WorldStep, WorldWorkflow } from "./authoring.js"; + +describe("authoring types (verdict 2: type-only)", () => { + it("WorldStep est une fonction async typée par args/retour", () => { + expectTypeOf>().toEqualTypeOf<(x: number) => Promise>(); + }); + it("WorldWorkflow est une fonction async typée par args/retour", () => { + expectTypeOf>().toEqualTypeOf<(a: string, b: number) => Promise>(); + }); +}); diff --git a/packages/workflow-world/src/authoring.ts b/packages/workflow-world/src/authoring.ts new file mode 100644 index 0000000..b8fbecb --- /dev/null +++ b/packages/workflow-world/src/authoring.ts @@ -0,0 +1,32 @@ +/** + * Types d'aide pour écrire des workflows/steps "world" (SDK Vercel). + * + * ⚠️ Il n'existe PAS de helper runtime `defineWorldStep`/`defineWorldWorkflow` : + * le compilateur `workflow/nitro` ne détecte les directives `"use step"` / + * `"use workflow"` que sur des **liaisons top-level** (fonction nommée, ou + * arrow/fonction liée directement à un `const`, ou méthode d'objet). Passer la + * fonction à un wrapper casserait la détection (non-durabilité silencieuse). + * + * Écris donc une liaison top-level avec la directive en première instruction, + * et annote-la avec ces types pour l'ergonomie : + * + * @example + * // Forme nommée (canonique) + * export async function charge(order: Order): Promise { + * "use step"; + * return chargePayment(order); + * } + * + * @example + * // Forme const (équivalente, détectée car liée directement au const) + * export const charge: WorldStep<[Order], Receipt> = async (order) => { + * "use step"; + * return chargePayment(order); + * }; + */ + +/** Signature d'un step world : fonction async dont le corps commence par `"use step"`. */ +export type WorldStep = (...args: Args) => Promise; + +/** Signature d'un workflow world : fonction async dont le corps commence par `"use workflow"`. */ +export type WorldWorkflow = (...args: Args) => Promise; From 76ec6e233962f6cb25aaa78b073fa9f0885782e9 Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 18:15:56 +0200 Subject: [PATCH 11/21] feat(workflow-world): public exports (createWorldAdapter, WORLD_TARGETS, types) Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/workflow-world/src/index.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/packages/workflow-world/src/index.ts b/packages/workflow-world/src/index.ts index cb0ff5c..dbe4186 100644 --- a/packages/workflow-world/src/index.ts +++ b/packages/workflow-world/src/index.ts @@ -1 +1,3 @@ -export {}; +export { createWorldAdapter } from "./adapter.js"; +export { WORLD_TARGETS } from "./worlds.js"; +export type { WorldStep, WorldWorkflow } from "./authoring.js"; From 58ceaf19c1983d8dfcf395608b4334d83763ab4e Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 18:16:34 +0200 Subject: [PATCH 12/21] chore(core): add @ai_kit/workflow-world as optional peer dependency Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/core/package.json | 5 +++++ pnpm-lock.yaml | 3 +++ 2 files changed, 8 insertions(+) diff --git a/packages/core/package.json b/packages/core/package.json index a2cf2ba..a4f39a2 100644 --- a/packages/core/package.json +++ b/packages/core/package.json @@ -47,10 +47,14 @@ "zod": "^4.1.12" }, "peerDependencies": { + "@ai_kit/workflow-world": ">=0.1.0 <1", "@langfuse/otel": "^5.4.1", "@opentelemetry/sdk-trace-node": "^2.2.0" }, "peerDependenciesMeta": { + "@ai_kit/workflow-world": { + "optional": true + }, "@langfuse/otel": { "optional": true }, @@ -59,6 +63,7 @@ } }, "devDependencies": { + "@ai_kit/workflow-world": "workspace:*", "@langchain/core": "^1.1.48", "@opentelemetry/sdk-trace-base": "^2.2.0", "@qdrant/js-client-rest": "^1.18.0", diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 9077ca2..1ae9d5f 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -72,6 +72,9 @@ importers: specifier: ^4.1.12 version: 4.1.12 devDependencies: + '@ai_kit/workflow-world': + specifier: workspace:* + version: link:../workflow-world '@langchain/core': specifier: ^1.1.48 version: 1.1.48(@opentelemetry/api@1.9.0)(@opentelemetry/sdk-trace-base@2.2.0(@opentelemetry/api@1.9.0))(openai@4.104.0(encoding@0.1.13)(ws@8.21.0)(zod@4.1.12))(ws@8.21.0) From 41427e16a770e70e103805ece0fba41f465aee9f Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 18:21:52 +0200 Subject: [PATCH 13/21] fix(workflow-world): decouple package build from @ai_kit/core Define the WorldConfig/WorldEngineAdapter/WorldRunHandle contract locally in workflow-world (src/contract.ts) instead of importing from @ai_kit/core. A peerDependency does not guarantee build order under pnpm, so the install-time prepare build of workflow-world failed to resolve @ai_kit/core's freshly-cleaned dist. workflow-world is consumed BY core (dynamically), never the reverse, so it needs no dependency on core. Also drop the core->workflow-world devDependency (it created a dev/peer cycle); core keeps workflow-world as an optional peer. Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/core/package.json | 1 - packages/workflow-world/package.json | 2 -- packages/workflow-world/src/adapter.ts | 2 +- packages/workflow-world/src/contract.ts | 36 +++++++++++++++++++++++++ packages/workflow-world/src/worlds.ts | 2 +- pnpm-lock.yaml | 9 +++---- 6 files changed, 41 insertions(+), 11 deletions(-) create mode 100644 packages/workflow-world/src/contract.ts diff --git a/packages/core/package.json b/packages/core/package.json index a4f39a2..4586f92 100644 --- a/packages/core/package.json +++ b/packages/core/package.json @@ -63,7 +63,6 @@ } }, "devDependencies": { - "@ai_kit/workflow-world": "workspace:*", "@langchain/core": "^1.1.48", "@opentelemetry/sdk-trace-base": "^2.2.0", "@qdrant/js-client-rest": "^1.18.0", diff --git a/packages/workflow-world/package.json b/packages/workflow-world/package.json index 19cd792..bd1a7b2 100644 --- a/packages/workflow-world/package.json +++ b/packages/workflow-world/package.json @@ -26,7 +26,6 @@ "workflow": "^4.3.1" }, "peerDependencies": { - "@ai_kit/core": ">=1.3.0 <2", "@workflow/world-postgres": ">=4.1.4 <5", "@workflow-worlds/mongodb": ">=0.2.1 <1" }, @@ -35,7 +34,6 @@ "@workflow-worlds/mongodb": { "optional": true } }, "devDependencies": { - "@ai_kit/core": "workspace:*", "@workflow/world-postgres": "^4.1.4", "@workflow-worlds/mongodb": "^0.2.1", "@types/node": "^24.7.0", diff --git a/packages/workflow-world/src/adapter.ts b/packages/workflow-world/src/adapter.ts index 4b02f9e..7d07a85 100644 --- a/packages/workflow-world/src/adapter.ts +++ b/packages/workflow-world/src/adapter.ts @@ -1,4 +1,4 @@ -import type { WorldConfig, WorldEngineAdapter, WorldRunHandle } from "@ai_kit/core"; +import type { WorldConfig, WorldEngineAdapter, WorldRunHandle } from "./contract.js"; import { buildWorldOptions, WORLD_TARGETS } from "./worlds.js"; interface SdkWorld { diff --git a/packages/workflow-world/src/contract.ts b/packages/workflow-world/src/contract.ts new file mode 100644 index 0000000..5d11da9 --- /dev/null +++ b/packages/workflow-world/src/contract.ts @@ -0,0 +1,36 @@ +/** + * Contrat partagé avec la façade `WorkflowKit` de `@ai_kit/core`. + * + * Défini LOCALEMENT (et non importé de `@ai_kit/core`) pour que ce package + * compile de façon autonome, sans dépendance de build inter-packages. + * Les formes sont structurellement identiques à + * `packages/core/src/workflows/kit/types.ts` → compatibilité au runtime quand + * core charge ce module dynamiquement (via son loader de world). + */ + +export type WorldType = "postgres" | "mongodb"; + +export interface WorldConfig { + type: WorldType; + /** Connection string (postgres:// ou mongodb://). */ + url: string; + /** Postgres : namespacing des jobs si DB partagée. */ + jobPrefix?: string; + /** Postgres : nombre de workers concurrents. */ + workerConcurrency?: number; + /** Postgres : taille du pool de connexions. */ + maxPoolSize?: number; +} + +/** Handle opaque renvoyé par le moteur world (pass-through du SDK Vercel). */ +export interface WorldRunHandle { + runId?: string; + [key: string]: unknown; +} + +/** Contrat consommé par `WorkflowKit`. */ +export interface WorldEngineAdapter { + start(): Promise; + stop(): Promise; + run(workflow: (...args: any[]) => unknown, args: unknown[]): Promise; +} diff --git a/packages/workflow-world/src/worlds.ts b/packages/workflow-world/src/worlds.ts index 9dfc522..6a5ee56 100644 --- a/packages/workflow-world/src/worlds.ts +++ b/packages/workflow-world/src/worlds.ts @@ -1,4 +1,4 @@ -import type { WorldConfig } from "@ai_kit/core"; +import type { WorldConfig } from "./contract.js"; export const WORLD_TARGETS = { postgres: "@workflow/world-postgres", diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 1ae9d5f..2f520b6 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -44,6 +44,9 @@ importers: '@ai-sdk/provider-utils': specifier: ^4.0.23 version: 4.0.23(zod@4.1.12) + '@ai_kit/workflow-world': + specifier: '>=0.1.0 <1' + version: link:../workflow-world '@langfuse/otel': specifier: ^5.4.1 version: 5.4.1(@opentelemetry/api@1.9.0)(@opentelemetry/core@2.2.0(@opentelemetry/api@1.9.0))(@opentelemetry/exporter-trace-otlp-http@0.207.0(@opentelemetry/api@1.9.0))(@opentelemetry/sdk-trace-base@2.2.0(@opentelemetry/api@1.9.0)) @@ -72,9 +75,6 @@ importers: specifier: ^4.1.12 version: 4.1.12 devDependencies: - '@ai_kit/workflow-world': - specifier: workspace:* - version: link:../workflow-world '@langchain/core': specifier: ^1.1.48 version: 1.1.48(@opentelemetry/api@1.9.0)(@opentelemetry/sdk-trace-base@2.2.0(@opentelemetry/api@1.9.0))(openai@4.104.0(encoding@0.1.13)(ws@8.21.0)(zod@4.1.12))(ws@8.21.0) @@ -235,9 +235,6 @@ importers: specifier: ^4.3.1 version: 4.3.1(@nestjs/common@11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2))(@nestjs/core@11.1.24(@nestjs/common@11.1.24(reflect-metadata@0.2.2)(rxjs@7.8.2))(reflect-metadata@0.2.2)(rxjs@7.8.2))(@opentelemetry/api@1.9.0)(@swc/cli@0.8.1(@swc/core@1.15.3)(chokidar@5.0.0))(@swc/core@1.15.3)(typescript@5.9.3) devDependencies: - '@ai_kit/core': - specifier: workspace:* - version: link:../core '@types/node': specifier: ^24.7.0 version: 24.12.4 From 8bf9f2105505485aa8adaf4b2ab28e0f95e7d093 Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 18:24:28 +0200 Subject: [PATCH 14/21] =?UTF-8?q?feat(core):=20WorkflowKit=20facade=20?= =?UTF-8?q?=E2=80=94=20config,=20lifecycle,=20run=20dispatch=20(legacy+wor?= =?UTF-8?q?ld)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Lazy-loads the optional @ai_kit/workflow-world via a variable-specifier import behind a test seam, so core has no hard dependency on it. Co-Authored-By: Claude Opus 4.8 (1M context) --- .../src/workflows/kit/WorkflowKit.test.ts | 66 +++++++++++++ .../core/src/workflows/kit/WorkflowKit.ts | 96 +++++++++++++++++++ 2 files changed, 162 insertions(+) create mode 100644 packages/core/src/workflows/kit/WorkflowKit.test.ts create mode 100644 packages/core/src/workflows/kit/WorkflowKit.ts diff --git a/packages/core/src/workflows/kit/WorkflowKit.test.ts b/packages/core/src/workflows/kit/WorkflowKit.test.ts new file mode 100644 index 0000000..dac2c8f --- /dev/null +++ b/packages/core/src/workflows/kit/WorkflowKit.test.ts @@ -0,0 +1,66 @@ +import { afterEach, describe, expect, it, vi } from "vitest"; +import { WorkflowKit, __setWorkflowWorldLoader } from "./WorkflowKit.js"; + +afterEach(() => __setWorkflowWorldLoader()); + +describe("WorkflowKit — config", () => { + it("défaut = engine legacy", () => { + expect(new WorkflowKit().engine).toBe("legacy"); + }); + + it("engine 'world' sans config world → throw", () => { + expect(() => new WorkflowKit({ engine: "world" })).toThrow(/world/i); + }); + + it("type de world inconnu → throw", () => { + // @ts-expect-error test runtime + expect(() => new WorkflowKit({ engine: "world", world: { type: "redis", url: "x" } })).toThrow(); + }); + + it("start/stop sont no-op en legacy", async () => { + const kit = new WorkflowKit(); + await expect(kit.start()).resolves.toBeUndefined(); + await expect(kit.stop()).resolves.toBeUndefined(); + }); +}); + +describe("WorkflowKit — dispatch run", () => { + it("legacy : délègue à Workflow.run", async () => { + const fakeWorkflow = { run: vi.fn().mockResolvedValue({ status: "success" }) }; + const kit = new WorkflowKit(); + const res = await kit.run(fakeWorkflow as any, { inputData: { id: 1 } }); + expect(fakeWorkflow.run).toHaveBeenCalledWith({ inputData: { id: 1 } }); + expect(res).toEqual({ status: "success" }); + }); + + it("world : start/run/stop délèguent à l'adapter chargé via le seam", async () => { + const adapter = { + start: vi.fn().mockResolvedValue(undefined), + stop: vi.fn().mockResolvedValue(undefined), + run: vi.fn().mockResolvedValue({ runId: "r_9" }), + }; + const createWorldAdapter = vi.fn(() => adapter); + __setWorkflowWorldLoader(async () => ({ createWorldAdapter })); + + const kit = new WorkflowKit({ engine: "world", world: { type: "postgres", url: "postgres://x" } }); + await kit.start(); + expect(createWorldAdapter).toHaveBeenCalledWith({ type: "postgres", url: "postgres://x" }); + expect(adapter.start).toHaveBeenCalledTimes(1); + + const fn = async () => 1; + const handle = await kit.run(fn, ["a"]); + expect(adapter.run).toHaveBeenCalledWith(fn, ["a"]); + expect(handle).toEqual({ runId: "r_9" }); + + await kit.stop(); + expect(adapter.stop).toHaveBeenCalledTimes(1); + }); + + it("world : erreur claire si le package @ai_kit/workflow-world manque", async () => { + __setWorkflowWorldLoader(async () => { + throw new Error("not found"); + }); + const kit = new WorkflowKit({ engine: "world", world: { type: "postgres", url: "postgres://x" } }); + await expect(kit.start()).rejects.toThrow("@ai_kit/workflow-world"); + }); +}); diff --git a/packages/core/src/workflows/kit/WorkflowKit.ts b/packages/core/src/workflows/kit/WorkflowKit.ts new file mode 100644 index 0000000..ed7dcac --- /dev/null +++ b/packages/core/src/workflows/kit/WorkflowKit.ts @@ -0,0 +1,96 @@ +import type { Workflow } from "../workflow.js"; +import type { WorkflowRunOptions, WorkflowRunResult } from "../types.js"; +import type { + WorkflowEngine, + WorkflowKitOptions, + WorldConfig, + WorldEngineAdapter, + WorkflowWorldModule, + WorldRunHandle, + WorkflowRunDispatchOptions, +} from "./types.js"; + +const VALID_WORLD_TYPES = ["postgres", "mongodb"] as const; + +// `: string` (not a literal) so tsc does NOT statically resolve the optional +// package; resolved at runtime by Node, or swapped by the test seam below. +const WORLD_PACKAGE: string = "@ai_kit/workflow-world"; + +type WorldModuleLoader = () => Promise; + +let worldModuleLoader: WorldModuleLoader = () => + import(WORLD_PACKAGE) as Promise; + +/** @internal Test seam. No argument resets to the default dynamic import. */ +export function __setWorkflowWorldLoader(loader?: WorldModuleLoader): void { + worldModuleLoader = loader ?? (() => import(WORLD_PACKAGE) as Promise); +} + +export class WorkflowKit { + readonly engine: WorkflowEngine; + readonly world?: WorldConfig; + #adapter?: WorldEngineAdapter; + + constructor(options: WorkflowKitOptions = {}) { + this.engine = options.engine ?? "legacy"; + this.world = options.world; + + if (this.engine === "world" && !this.world) { + throw new Error("WorkflowKit: engine 'world' requires a 'world' config"); + } + if (this.world && !VALID_WORLD_TYPES.includes(this.world.type)) { + throw new Error(`WorkflowKit: unsupported world type '${this.world.type}'`); + } + } + + async start(): Promise { + if (this.engine !== "world") return; + const adapter = await this.#ensureAdapter(); + await adapter.start(); + } + + async stop(): Promise { + if (this.engine !== "world" || !this.#adapter) return; + await this.#adapter.stop(); + } + + // Overload: legacy engine + run( + workflow: Workflow, + options: WorkflowRunOptions, + dispatch?: WorkflowRunDispatchOptions, + ): Promise>; + // Overload: world engine + run( + workflow: (...args: any[]) => unknown, + args: unknown[], + dispatch?: WorkflowRunDispatchOptions, + ): Promise; + // Implementation + async run(workflow: any, input: any, dispatch?: WorkflowRunDispatchOptions): Promise { + const engine = dispatch?.engine ?? this.engine; + if (engine === "legacy") { + return (workflow as Workflow).run(input); + } + const adapter = await this.#ensureAdapter(); + return adapter.run(workflow, input as unknown[]); + } + + async #ensureAdapter(): Promise { + if (this.#adapter) return this.#adapter; + if (!this.world) { + throw new Error("WorkflowKit: engine 'world' requires a 'world' config"); + } + let mod: WorkflowWorldModule; + try { + mod = await worldModuleLoader(); + } catch { + throw new Error( + "WorkflowKit: engine 'world' requires the '@ai_kit/workflow-world' package. " + + "Install it: pnpm add @ai_kit/workflow-world", + ); + } + this.#adapter = mod.createWorldAdapter(this.world); + return this.#adapter; + } +} From 850c8e3876644a27a00b305e2cd7b3fd114e1f50 Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 18:25:07 +0200 Subject: [PATCH 15/21] feat(core): export WorkflowKit class from public API Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/core/src/workflows/kit/index.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/packages/core/src/workflows/kit/index.ts b/packages/core/src/workflows/kit/index.ts index aebffa2..aba6a4d 100644 --- a/packages/core/src/workflows/kit/index.ts +++ b/packages/core/src/workflows/kit/index.ts @@ -1,3 +1,4 @@ +export { WorkflowKit } from "./WorkflowKit.js"; export type { WorkflowEngine, WorldConfig, From d023d913e498197a54619d8818ed9ea2d504d487 Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 18:26:35 +0200 Subject: [PATCH 16/21] test(workflow-world): docker-compose for postgres+mongo integration Adds docker-compose.test.yml (postgres:16 + mongo:7 with healthchecks) and db:up/db:down/test:integration scripts for opt-in integration tests. Co-Authored-By: Claude Opus 4.8 (1M context) --- .../workflow-world/docker-compose.test.yml | 23 +++++++++++++++++++ packages/workflow-world/package.json | 5 +++- 2 files changed, 27 insertions(+), 1 deletion(-) create mode 100644 packages/workflow-world/docker-compose.test.yml diff --git a/packages/workflow-world/docker-compose.test.yml b/packages/workflow-world/docker-compose.test.yml new file mode 100644 index 0000000..65e82bd --- /dev/null +++ b/packages/workflow-world/docker-compose.test.yml @@ -0,0 +1,23 @@ +services: + postgres: + image: postgres:16 + environment: + POSTGRES_USER: world + POSTGRES_PASSWORD: world + POSTGRES_DB: world + ports: + - "5432:5432" + healthcheck: + test: ["CMD-SHELL", "pg_isready -U world -d world"] + interval: 2s + timeout: 3s + retries: 30 + mongo: + image: mongo:7 + ports: + - "27017:27017" + healthcheck: + test: ["CMD", "mongosh", "--quiet", "--eval", "db.adminCommand('ping')"] + interval: 2s + timeout: 3s + retries: 30 diff --git a/packages/workflow-world/package.json b/packages/workflow-world/package.json index bd1a7b2..9b0f839 100644 --- a/packages/workflow-world/package.json +++ b/packages/workflow-world/package.json @@ -16,7 +16,10 @@ "clean": "rm -rf dist tsconfig.build.tsbuildinfo", "build": "pnpm run clean && tsc -p tsconfig.build.json", "prepare": "pnpm run build", - "test": "vitest run" + "test": "vitest run", + "db:up": "docker compose -f docker-compose.test.yml up -d --wait", + "db:down": "docker compose -f docker-compose.test.yml down -v", + "test:integration": "WORKFLOW_WORLD_PG_URL=postgres://world:world@localhost:5432/world WORKFLOW_WORLD_MONGO_URL=mongodb://localhost:27017/world vitest run integration" }, "keywords": ["ai", "workflow", "vercel", "world", "postgres", "mongodb"], "license": "MIT", From 038c27a54d87a3c0abb84f4b7ef808feb1c12086 Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 18:27:10 +0200 Subject: [PATCH 17/21] test(workflow-world): opt-in postgres + mongodb integration tests Skipped by default; run via 'pnpm run db:up && pnpm run test:integration'. Co-Authored-By: Claude Opus 4.8 (1M context) --- .../src/integration.mongo.test.ts | 18 ++++++++++++++++++ .../src/integration.postgres.test.ts | 17 +++++++++++++++++ 2 files changed, 35 insertions(+) create mode 100644 packages/workflow-world/src/integration.mongo.test.ts create mode 100644 packages/workflow-world/src/integration.postgres.test.ts diff --git a/packages/workflow-world/src/integration.mongo.test.ts b/packages/workflow-world/src/integration.mongo.test.ts new file mode 100644 index 0000000..91e1c7f --- /dev/null +++ b/packages/workflow-world/src/integration.mongo.test.ts @@ -0,0 +1,18 @@ +import { describe, expect, it } from "vitest"; +import { createWorldAdapter } from "./adapter.js"; + +// Opt-in : ne s'exécute que si WORKFLOW_WORLD_MONGO_URL est défini (cf. script test:integration). +// World Mongo = communautaire / expérimental (cf. spec §1, §7.2). +const RUN_IT = process.env.WORKFLOW_WORLD_MONGO_URL ? describe : describe.skip; + +RUN_IT("integration: mongodb world (expérimental)", () => { + it("démarre et arrête un world MongoDB réel", async () => { + const adapter = createWorldAdapter({ + type: "mongodb", + url: process.env.WORKFLOW_WORLD_MONGO_URL!, + }); + await adapter.start(); + await adapter.stop(); + expect(true).toBe(true); + }, 60_000); +}); diff --git a/packages/workflow-world/src/integration.postgres.test.ts b/packages/workflow-world/src/integration.postgres.test.ts new file mode 100644 index 0000000..f930720 --- /dev/null +++ b/packages/workflow-world/src/integration.postgres.test.ts @@ -0,0 +1,17 @@ +import { describe, expect, it } from "vitest"; +import { createWorldAdapter } from "./adapter.js"; + +// Opt-in : ne s'exécute que si WORKFLOW_WORLD_PG_URL est défini (cf. script test:integration). +const RUN_IT = process.env.WORKFLOW_WORLD_PG_URL ? describe : describe.skip; + +RUN_IT("integration: postgres world", () => { + it("démarre et arrête un world Postgres réel", async () => { + const adapter = createWorldAdapter({ + type: "postgres", + url: process.env.WORKFLOW_WORLD_PG_URL!, + }); + await adapter.start(); + await adapter.stop(); + expect(true).toBe(true); + }, 60_000); +}); From 6c5f6ad1ded5cfad8e0f05118e68cf4be718f96d Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 18:27:55 +0200 Subject: [PATCH 18/21] docs(workflow-world): package README (usage, authoring, tests) Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/workflow-world/README.md | 83 +++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 packages/workflow-world/README.md diff --git a/packages/workflow-world/README.md b/packages/workflow-world/README.md new file mode 100644 index 0000000..a36c4b9 --- /dev/null +++ b/packages/workflow-world/README.md @@ -0,0 +1,83 @@ +# @ai_kit/workflow-world + +Moteur de workflow **"world"** pour AI Kit : adapte le [Vercel Workflow SDK](https://workflow-sdk.dev) +(persistance durable Postgres/MongoDB) derrière la façade `WorkflowKit` de `@ai_kit/core`. + +Package **optionnel** : il n'est requis que si tu utilises `engine: 'world'`. Le moteur +legacy (en mémoire) de `@ai_kit/core` ne dépend pas de ce package. + +## Installation + +```bash +pnpm add @ai_kit/core @ai_kit/workflow-world workflow +# + le world voulu (optionnel, à installer toi-même) : +pnpm add @workflow/world-postgres # Postgres (officiel) +# ou +pnpm add @workflow-worlds/mongodb # MongoDB (communautaire, expérimental) +# build de l'app hôte : +pnpm add -D nitro rollup +``` + +## Contrainte (à connaître) + +Le SDK Vercel **exige une étape de build** (Nitro + rollup, module `workflow/nitro`) pour +compiler les fonctions `"use workflow"` / `"use step"`, **et** un **worker long-vivant** +(incompatible serverless pur). ai-kit lisse la configuration runtime mais ne peut pas +masquer cette étape de build : l'app hôte doit l'adopter. Voir le design complet et les +exemples end-to-end : `docs/superpowers/specs/2026-06-02-workflow-world-engine-design.md`. + +## Usage + +```ts +import { WorkflowKit } from '@ai_kit/core'; + +const kit = new WorkflowKit({ + engine: 'world', + world: { type: 'postgres', url: process.env.WORKFLOW_POSTGRES_URL! }, +}); + +await kit.start(); // démarre le worker (graphile pour Postgres) +const handle = await kit.run(myWorldWorkflow, [arg]); // → start() du SDK +await kit.stop(); // arrêt propre +``` + +## Écriture des workflows/steps (important) + +Il n'existe **pas** de helper runtime `defineWorldStep` : le compilateur `workflow/nitro` +ne détecte les directives `"use step"` / `"use workflow"` que sur des **liaisons top-level** +(fonction nommée, ou arrow/fonction liée directement à un `const`). Passer la fonction à un +wrapper casserait la détection (non-durabilité silencieuse). + +Écris donc une liaison top-level avec la directive en première instruction. Tu peux annoter +avec les types `WorldStep` / `WorldWorkflow` exportés par ce package : + +```ts +import type { WorldStep } from '@ai_kit/workflow-world'; +import { chargePayment } from '../domain/payment.js'; + +export const charge: WorldStep<[Order], Receipt> = async (order) => { + "use step"; // obligatoire, en première instruction + return chargePayment(order); +}; + +export async function paymentWorkflow(order: Order) { + "use workflow"; + return await charge(order); +} +``` + +## Tests + +- **Unitaires** (sans DB, mockés) : `pnpm test` +- **Intégration** (opt-in, DB réelle via Docker) : + ```bash + pnpm run db:up && pnpm run test:integration && pnpm run db:down + ``` + (lance Postgres + MongoDB via `docker-compose.test.yml` ; les tests se skippent + automatiquement si les URLs d'env ne sont pas posées). + +## API publique + +- `createWorldAdapter(config)` — implémente le contrat `WorldEngineAdapter` consommé par `WorkflowKit` (chargé dynamiquement par core). +- `WORLD_TARGETS` — mapping `type` → nom de package SDK. +- types `WorldStep`, `WorldWorkflow`. From 8a848f29aea84ba2995012849f1c51f7f8d88a26 Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 18:34:02 +0200 Subject: [PATCH 19/21] test(workflow-world): provision postgres schema in integration test + document it The postgres world requires a one-time schema setup ('workflow-postgres-setup') before use; the integration test now runs it as a subprocess (the CLI calls process.exit, so it can't run in-process under vitest). Validated end-to-end against real postgres:16 and mongo:7. README documents the provisioning step. Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/workflow-world/README.md | 11 ++++++++++ .../src/integration.postgres.test.ts | 21 ++++++++++++++++--- 2 files changed, 29 insertions(+), 3 deletions(-) diff --git a/packages/workflow-world/README.md b/packages/workflow-world/README.md index a36c4b9..8f126d6 100644 --- a/packages/workflow-world/README.md +++ b/packages/workflow-world/README.md @@ -18,6 +18,17 @@ pnpm add @workflow-worlds/mongodb # MongoDB (communautaire, expérime pnpm add -D nitro rollup ``` +## Provisioning du schéma (Postgres) + +Le world Postgres exige que son schéma soit créé **une fois** avant le premier run +(sinon erreur `undefined_table` / `42P01`). C'est une étape de déploiement : + +```bash +WORKFLOW_POSTGRES_URL=postgres://world:world@localhost:5432/world npx workflow-postgres-setup +``` + +(Le world MongoDB ne nécessite pas cette étape : il provisionne à la connexion.) + ## Contrainte (à connaître) Le SDK Vercel **exige une étape de build** (Nitro + rollup, module `workflow/nitro`) pour diff --git a/packages/workflow-world/src/integration.postgres.test.ts b/packages/workflow-world/src/integration.postgres.test.ts index f930720..b274255 100644 --- a/packages/workflow-world/src/integration.postgres.test.ts +++ b/packages/workflow-world/src/integration.postgres.test.ts @@ -1,14 +1,29 @@ -import { describe, expect, it } from "vitest"; +import { execFileSync } from "node:child_process"; +import { beforeAll, describe, expect, it } from "vitest"; import { createWorldAdapter } from "./adapter.js"; +const url = process.env.WORKFLOW_WORLD_PG_URL; + // Opt-in : ne s'exécute que si WORKFLOW_WORLD_PG_URL est défini (cf. script test:integration). -const RUN_IT = process.env.WORKFLOW_WORLD_PG_URL ? describe : describe.skip; +const RUN_IT = url ? describe : describe.skip; RUN_IT("integration: postgres world", () => { + beforeAll(() => { + // Le world Postgres exige un provisioning de schéma AVANT usage (sinon + // erreur "undefined_table" 42P01). En production c'est une étape de + // déploiement : `npx workflow-postgres-setup` (lit WORKFLOW_POSTGRES_URL). + // On l'exécute en SOUS-PROCESSUS car le CLI appelle process.exit (incompatible + // avec un import in-process sous vitest). + execFileSync("pnpm", ["exec", "workflow-postgres-setup"], { + env: { ...process.env, WORKFLOW_POSTGRES_URL: url }, + stdio: "inherit", + }); + }, 60_000); + it("démarre et arrête un world Postgres réel", async () => { const adapter = createWorldAdapter({ type: "postgres", - url: process.env.WORKFLOW_WORLD_PG_URL!, + url: url!, }); await adapter.start(); await adapter.stop(); From 7602db7067765e79428bfb2005f6a7050f095765 Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 18:47:12 +0200 Subject: [PATCH 20/21] docs(workflow-world): user + AI docs for the world engine / WorkflowKit (EN+FR) Adds a 'World engine (durable workflows)' guide and a WorkflowKit API-reference page in both English and French, registered in docs.json. The English pages are sourced by @ai_kit/mcp-docs, so the MCP docs server serves them to AI tools too. Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/mintlify-docs/docs.json | 8 +- .../en/api-reference/workflow-kit.mdx | 123 +++++++++ .../en/workflows/world-engine.mdx | 242 ++++++++++++++++++ .../fr/api-reference/workflow-kit.mdx | 123 +++++++++ .../fr/workflows/world-engine.mdx | 242 ++++++++++++++++++ 5 files changed, 736 insertions(+), 2 deletions(-) create mode 100644 packages/mintlify-docs/en/api-reference/workflow-kit.mdx create mode 100644 packages/mintlify-docs/en/workflows/world-engine.mdx create mode 100644 packages/mintlify-docs/fr/api-reference/workflow-kit.mdx create mode 100644 packages/mintlify-docs/fr/workflows/world-engine.mdx diff --git a/packages/mintlify-docs/docs.json b/packages/mintlify-docs/docs.json index b73c037..d3c0faa 100644 --- a/packages/mintlify-docs/docs.json +++ b/packages/mintlify-docs/docs.json @@ -84,7 +84,8 @@ "fr/workflows/branch-parallel", "fr/workflows/human-steps", "fr/workflows/while", - "fr/workflows/telemetry" + "fr/workflows/telemetry", + "fr/workflows/world-engine" ] }, { @@ -130,6 +131,7 @@ "fr/api-reference/agent", "fr/api-reference/workflow", "fr/api-reference/workflow-run", + "fr/api-reference/workflow-kit", "fr/api-reference/runtime-store" ] } @@ -183,7 +185,8 @@ "en/workflows/branch-parallel", "en/workflows/human-steps", "en/workflows/while", - "en/workflows/telemetry" + "en/workflows/telemetry", + "en/workflows/world-engine" ] }, { @@ -229,6 +232,7 @@ "en/api-reference/agent", "en/api-reference/workflow", "en/api-reference/workflow-run", + "en/api-reference/workflow-kit", "en/api-reference/runtime-store" ] } diff --git a/packages/mintlify-docs/en/api-reference/workflow-kit.mdx b/packages/mintlify-docs/en/api-reference/workflow-kit.mdx new file mode 100644 index 0000000..d43c71f --- /dev/null +++ b/packages/mintlify-docs/en/api-reference/workflow-kit.mdx @@ -0,0 +1,123 @@ +--- +title: "WorkflowKit class" +description: "Unified facade to run AI Kit workflows on the legacy in-memory engine or the durable world engine." +locale: en +--- + +```ts +import { + WorkflowKit, + type WorkflowEngine, + type WorkflowKitOptions, + type WorldConfig, + type WorldRunHandle, +} from "@ai_kit/core"; +``` + +`WorkflowKit` selects the workflow engine and exposes a unified lifecycle. The default engine is `legacy` (the in-memory engine); `world` runs on the Vercel Workflow SDK with a durable Postgres/MongoDB backend (requires the optional [`@ai_kit/workflow-world`](/en/workflows/world-engine) package). + +## `WorkflowKitOptions` + +| Property | Type | Default | Description | +| --- | --- | --- | --- | +| `engine` | `"legacy" \| "world"` | `"legacy"` | Engine used by default for `run`. | +| `world` | `WorldConfig` | `undefined` | World backend config. **Required** when `engine === "world"`. | + +## `WorldConfig` + +| Property | Type | Default | Description | +| --- | --- | --- | --- | +| `type` | `"postgres" \| "mongodb"` | required | World backend. `mongodb` is experimental. | +| `url` | `string` | required | Connection string (`postgres://` / `mongodb://`). | +| `jobPrefix` | `string` | `undefined` | Postgres: namespace jobs on a shared database. | +| `workerConcurrency` | `number` | SDK default | Postgres: concurrent workers (maps to `queueConcurrency`). | +| `maxPoolSize` | `number` | SDK default | Postgres: connection pool size. | + +## Construction + +```ts +const kit = new WorkflowKit({ + engine: "world", + world: { type: "postgres", url: process.env.WORKFLOW_POSTGRES_URL! }, +}); +``` + +The constructor validates the config: + +- `engine: "world"` without a `world` config throws. +- An unknown `world.type` throws. +- `engine: "legacy"` with a `world` config is allowed (lets you toggle engines via an env var without rewriting config). + +## Properties + +| Property | Type | Description | +| --- | --- | --- | +| `engine` | `WorkflowEngine` | The configured default engine (read-only). | +| `world` | `WorldConfig \| undefined` | The world config, if any (read-only). | + +## Methods + +### `start()` + +```ts +start(): Promise; +``` + +Starts the durable world worker (lazily loading `@ai_kit/workflow-world` and creating the adapter). **No-op when `engine === "legacy"`**, so the same lifecycle code works for both engines. Throws a clear error if `@ai_kit/workflow-world` is not installed. + +### `stop()` + +```ts +stop(): Promise; +``` + +Gracefully stops the world worker. **No-op when `engine === "legacy"`** or when the world was never started. + +### `run(workflow, input, dispatch?)` + +Dispatches to the configured engine (overridable per call via `dispatch.engine`). + +```ts +// Legacy overload — workflow is an AI Kit Workflow +run( + workflow: Workflow, + options: WorkflowRunOptions, + dispatch?: { engine?: WorkflowEngine }, +): Promise>; + +// World overload — workflow is a "use workflow" function, input is the args array +run( + workflow: (...args: any[]) => unknown, + args: unknown[], + dispatch?: { engine?: WorkflowEngine }, +): Promise; +``` + +- **`legacy`** → delegates to `Workflow.run(options)` and returns a [`WorkflowRunResult`](/en/api-reference/workflow). +- **`world`** → delegates to the SDK's `start(fn, args)` and returns a `WorldRunHandle`. + +### `WorldRunHandle` + +The opaque handle returned by a world run (pass-through of the SDK `Run`): + +| Property | Type | Description | +| --- | --- | --- | +| `runId` | `string` | Identifier of the durable run. | + +## Example + +```ts +import { WorkflowKit } from "@ai_kit/core"; + +// One config, switchable via env — legacy locally, world in production +export const kit = new WorkflowKit({ + engine: (process.env.WORKFLOW_ENGINE as "legacy" | "world") ?? "legacy", + world: { type: "postgres", url: process.env.WORKFLOW_POSTGRES_URL ?? "" }, +}); + +await kit.start(); // no-op on legacy +const handle = await kit.run(myWorkflow, ["arg"]); +await kit.stop(); +``` + +See the [World engine guide](/en/workflows/world-engine) for installation, authoring rules, and migration. diff --git a/packages/mintlify-docs/en/workflows/world-engine.mdx b/packages/mintlify-docs/en/workflows/world-engine.mdx new file mode 100644 index 0000000..72c2589 --- /dev/null +++ b/packages/mintlify-docs/en/workflows/world-engine.mdx @@ -0,0 +1,242 @@ +--- +title: "World engine (durable workflows)" +description: "Run workflows on a durable Vercel Workflow SDK backend (self-hosted Postgres/MongoDB) via the WorkflowKit facade, alongside the legacy in-memory engine." +locale: en +--- + +AI Kit ships **two workflow engines** behind a single facade, `WorkflowKit`: + +- **`legacy`** (default) — the in-memory engine you build with [`createWorkflow`](/en/workflows/introduction) / `WorkflowBuilder`. Zero extra dependencies, runs in-process, state lives in memory. +- **`world`** — the [Vercel Workflow SDK](https://workflow-sdk.dev) backed by a durable **world**: self-hosted **Postgres** (`@workflow/world-postgres`) or **MongoDB** (`@workflow-worlds/mongodb`). Runs survive restarts (durable replay, job queue, event log). + +`WorkflowKit` lets you pick the engine through configuration; the default is always `legacy`, so existing code keeps working and legacy users never pull a single Vercel dependency. + +## When to use which + +| | `legacy` (default) | `world` | +|---|---|---| +| Persistence | In memory only | Durable (Postgres / MongoDB) | +| Survives restarts / crashes | No | Yes (replay) | +| Extra dependencies | None | `@ai_kit/workflow-world` + `workflow` + a world backend | +| Build step | None | **Nitro build required** (compiles `"use workflow"`) | +| Runtime | Any (in-process) | Long-lived worker (not serverless) | +| Authoring | `createWorkflow().then(...)` builder | `"use workflow"` / `"use step"` functions | + +Use `legacy` for fast in-process orchestration and local development; use `world` when you need durability, suspension (`sleep`), and resumable long-running processes. + +## The `WorkflowKit` facade + +```ts +import { WorkflowKit } from "@ai_kit/core"; + +const kit = new WorkflowKit({ + engine: "legacy", // default — can be omitted +}); + +// Legacy: workflow = an AI Kit Workflow, input = WorkflowRunOptions +const result = await kit.run(myLegacyWorkflow, { inputData: { id: 42 } }); +console.log(result.status); // "success" | "failed" | ... +``` + +Switch to the durable engine by setting `engine: "world"` and providing a `world` config: + +```ts +const kit = new WorkflowKit({ + engine: "world", + world: { type: "postgres", url: process.env.WORKFLOW_POSTGRES_URL! }, +}); + +await kit.start(); // starts the durable worker +const handle = await kit.run(handleUserSignup, ["hello@example.com"]); +console.log(handle.runId); +await kit.stop(); // graceful shutdown +``` + +- `kit.start()` / `kit.stop()` manage the long-lived world worker. **They are no-ops on `legacy`**, so the same lifecycle code works for both engines. +- `kit.run(...)` dispatches to the configured engine. You can override per call: `kit.run(wf, input, { engine: "world" })`. + +### Configuration + +```ts +interface WorkflowKitOptions { + engine?: "legacy" | "world"; // default "legacy" + world?: WorldConfig; // required when engine === "world" +} + +interface WorldConfig { + type: "postgres" | "mongodb"; + url: string; // connection string + jobPrefix?: string; // postgres: namespace jobs on a shared DB + workerConcurrency?: number; // postgres: concurrent workers + maxPoolSize?: number; // postgres: connection pool size +} +``` + +The constructor validates the config: `engine: "world"` without a `world` throws, and an unknown `world.type` throws. + +See the [`WorkflowKit` API reference](/en/api-reference/workflow-kit) for the full surface. + +## Installing the world engine + +The world engine lives in an optional package so the core stays lightweight: + +```bash +pnpm add @ai_kit/core @ai_kit/workflow-world workflow +# choose the world backend you need (optional peer dependency): +pnpm add @workflow/world-postgres # Postgres (official) +# or +pnpm add @workflow-worlds/mongodb # MongoDB (community, experimental) +# host-app build: +pnpm add -D nitro rollup +``` + +If you select `engine: "world"` without `@ai_kit/workflow-world` installed, `WorkflowKit` throws a clear error telling you to install it. + +## Authoring world workflows + +A world workflow is a plain async function marked with the `"use workflow"` directive; the real work goes in `"use step"` functions. These directives are detected **at build time** by the `workflow/nitro` compiler. + +```ts +import { sleep, FatalError } from "workflow"; + +export async function handleUserSignup(email: string) { + "use workflow"; // body must be deterministic + const user = await createUser(email); // each await is a durable checkpoint + await sendWelcomeEmail(user); + await sleep("5s"); + return { userId: user.id }; +} + +async function createUser(email: string) { + "use step"; // full Node runtime, auto-retried + if (!email.includes("@")) throw new FatalError("invalid email"); + return { id: crypto.randomUUID(), email }; +} + +async function sendWelcomeEmail(user: { id: string; email: string }) { + "use step"; + return { sent: true }; +} +``` + + +There is **no `defineWorldStep` runtime helper**. The Vercel compiler only instruments directives on **top-level bindings** (a named function, or an arrow/function bound directly to a `const`). Passing the function to a wrapper call would silently break detection — the step would run as plain, non-durable code. So you write the directive yourself and (optionally) annotate with the exported types. + + +`@ai_kit/workflow-world` exports `WorldStep` / `WorldWorkflow` **types** for ergonomics: + +```ts +import type { WorldStep } from "@ai_kit/workflow-world"; + +// arrow bound directly to a const is also detected by the compiler +export const charge: WorldStep<[Order], Receipt> = async (order) => { + "use step"; + return chargePayment(order); +}; +``` + +### Control flow is native JavaScript + +Because a world workflow is just an async function, you don't need special primitives — use the language: + +| Need | World engine | +|---|---| +| Sequential | successive `await` | +| Loop / iterate | `for` / `while`, `for (const x of items)` | +| Parallel / fan-out | `await Promise.all(items.map(step))` | +| Race / timeout | `await Promise.race([hook, sleep("24h")])` | +| Condition | `if` / `switch` | +| Human-in-the-loop | `createWebhook()` or `defineHook()` + `hook.resume(...)` | +| Durable delay | `await sleep("30d")` | +| Retries | automatic (max 3) + `FatalError` / `RetryableError` | + +The `"use workflow"` body must stay **deterministic** (no `Date.now()`, `Math.random()`, `fetch`, direct I/O) — put those effects inside `"use step"` functions. + +## Postgres: provision the schema once + +Before the first run, the Postgres world needs its schema created (otherwise you get an `undefined_table` / `42P01` error). This is a one-time deployment step: + +```bash +WORKFLOW_POSTGRES_URL=postgres://world:world@localhost:5432/world npx workflow-postgres-setup +``` + +MongoDB does not need this step — it provisions on connection. + +## MongoDB (experimental) + +The MongoDB world is community-maintained. Only the configuration changes; no application code differs from Postgres: + +```ts +const kit = new WorkflowKit({ + engine: "world", + world: { type: "mongodb", url: process.env.WORKFLOW_MONGODB_URI! }, +}); +await kit.start(); +``` + +## Build & runtime constraints + +The Vercel Workflow SDK requires: + +1. **A build step** — Nitro compiles the `"use workflow"` / `"use step"` functions. Add the `workflow/nitro` module to your host app's `nitro.config.ts`. AI Kit smooths runtime configuration but cannot remove this build step. +2. **A long-lived worker** — the world polls the database for jobs, so the world engine is **not** compatible with pure serverless deployments. + +```ts +// nitro.config.ts (host app) +import { defineNitroConfig } from "nitro/config"; + +export default defineNitroConfig({ + modules: ["workflow/nitro"], + routes: { "/**": { handler: "./src/index.ts", format: "node" } }, +}); +``` + +## Migrating a legacy workflow to the world engine + +Migration is a rewrite from the declarative builder to an imperative function — there is no automatic translator. + +**Before (legacy):** + +```ts +import { createWorkflow, createStep } from "@ai_kit/core"; + +const fetchOrder = createStep({ id: "fetchOrder", handler: async ({ inputData }) => getOrder(inputData.id) }); +const charge = createStep({ id: "charge", handler: async ({ inputData }) => chargePayment(inputData) }); + +export const orderWorkflow = createWorkflow({ id: "order" }) + .then(fetchOrder) + .then(charge) + .commit(); + +await orderWorkflow.run({ inputData: { id: "o_123" } }); +``` + +**After (world):** + +```ts +export async function orderWorkflow(orderId: string) { + "use workflow"; + const order = await fetchOrder(orderId); + const charged = await charge(order); + return { orderId, status: "completed" }; +} + +async function fetchOrder(id: string) { "use step"; return getOrder(id); } +async function charge(order: Order) { "use step"; return chargePayment(order); } + +// launched through the facade +await kit.run(orderWorkflow, ["o_123"]); +``` + +| Legacy builder | World rewrite | +|---|---| +| `.then(step)` | successive `await step()` | +| `.while({ condition })` | `while (await condition()) { ... }` | +| `forEach` (parallel) | `await Promise.all(items.map(step))` | +| `.branchParallel(...)` | `await Promise.all([stepA(), stepB()])` | +| `.conditions(...).then(...)` | `if (...) {} else {}` | +| `.human(...)` + `resumeWithHumanInput` | `defineHook()` + `hook.resume(...)` | + +## Feature coverage + +Because the `world` engine embeds the real Vercel SDK, it inherits **all** of its capabilities: durable execution, `sleep`, webhooks/hooks (human-in-the-loop), streaming, durable agents, automatic retries, and the `npx workflow web` observability dashboard. Advanced runtime APIs are used directly from the `workflow` package — the thin `WorkflowKit` facade only handles engine selection, lifecycle, and run dispatch. diff --git a/packages/mintlify-docs/fr/api-reference/workflow-kit.mdx b/packages/mintlify-docs/fr/api-reference/workflow-kit.mdx new file mode 100644 index 0000000..5684f63 --- /dev/null +++ b/packages/mintlify-docs/fr/api-reference/workflow-kit.mdx @@ -0,0 +1,123 @@ +--- +title: "Classe WorkflowKit" +description: "Façade unifiée pour exécuter des workflows AI Kit sur le moteur en mémoire legacy ou le moteur world durable." +locale: fr +--- + +```ts +import { + WorkflowKit, + type WorkflowEngine, + type WorkflowKitOptions, + type WorldConfig, + type WorldRunHandle, +} from "@ai_kit/core"; +``` + +`WorkflowKit` sélectionne le moteur de workflow et expose un cycle de vie unifié. Le moteur par défaut est `legacy` (le moteur en mémoire) ; `world` s'exécute sur le Vercel Workflow SDK avec un backend Postgres/MongoDB durable (nécessite le package optionnel [`@ai_kit/workflow-world`](/fr/workflows/world-engine)). + +## `WorkflowKitOptions` + +| Propriété | Type | Défaut | Description | +| --- | --- | --- | --- | +| `engine` | `"legacy" \| "world"` | `"legacy"` | Moteur utilisé par défaut pour `run`. | +| `world` | `WorldConfig` | `undefined` | Configuration du backend world. **Requis** quand `engine === "world"`. | + +## `WorldConfig` + +| Propriété | Type | Défaut | Description | +| --- | --- | --- | --- | +| `type` | `"postgres" \| "mongodb"` | requis | Backend world. `mongodb` est expérimental. | +| `url` | `string` | requis | Chaîne de connexion (`postgres://` / `mongodb://`). | +| `jobPrefix` | `string` | `undefined` | Postgres : espace de noms des jobs sur une base partagée. | +| `workerConcurrency` | `number` | Défaut SDK | Postgres : workers concurrents (correspond à `queueConcurrency`). | +| `maxPoolSize` | `number` | Défaut SDK | Postgres : taille du pool de connexions. | + +## Construction + +```ts +const kit = new WorkflowKit({ + engine: "world", + world: { type: "postgres", url: process.env.WORKFLOW_POSTGRES_URL! }, +}); +``` + +Le constructeur valide la configuration : + +- `engine: "world"` sans config `world` lève une erreur. +- Un `world.type` inconnu lève une erreur. +- `engine: "legacy"` avec une config `world` est autorisé (permet de basculer entre les moteurs via une variable d'environnement sans réécrire la configuration). + +## Propriétés + +| Propriété | Type | Description | +| --- | --- | --- | +| `engine` | `WorkflowEngine` | Le moteur par défaut configuré (lecture seule). | +| `world` | `WorldConfig \| undefined` | La configuration world, le cas échéant (lecture seule). | + +## Méthodes + +### `start()` + +```ts +start(): Promise; +``` + +Démarre le worker world durable (charge `@ai_kit/workflow-world` à la demande et crée l'adaptateur). **No-op quand `engine === "legacy"`**, donc le même code de cycle de vie fonctionne pour les deux moteurs. Lève une erreur claire si `@ai_kit/workflow-world` n'est pas installé. + +### `stop()` + +```ts +stop(): Promise; +``` + +Arrête proprement le worker world. **No-op quand `engine === "legacy"`** ou quand le world n'a jamais été démarré. + +### `run(workflow, input, dispatch?)` + +Dispatche vers le moteur configuré (surchargeable par appel via `dispatch.engine`). + +```ts +// Surcharge legacy — workflow est un Workflow AI Kit +run( + workflow: Workflow, + options: WorkflowRunOptions, + dispatch?: { engine?: WorkflowEngine }, +): Promise>; + +// Surcharge world — workflow est une fonction "use workflow", input est le tableau d'args +run( + workflow: (...args: any[]) => unknown, + args: unknown[], + dispatch?: { engine?: WorkflowEngine }, +): Promise; +``` + +- **`legacy`** → délègue à `Workflow.run(options)` et retourne un [`WorkflowRunResult`](/fr/api-reference/workflow). +- **`world`** → délègue au `start(fn, args)` du SDK et retourne un `WorldRunHandle`. + +### `WorldRunHandle` + +Le handle opaque retourné par un run world (pass-through du `Run` SDK) : + +| Propriété | Type | Description | +| --- | --- | --- | +| `runId` | `string` | Identifiant du run durable. | + +## Exemple + +```ts +import { WorkflowKit } from "@ai_kit/core"; + +// Une seule config, basculable via env — legacy en local, world en production +export const kit = new WorkflowKit({ + engine: (process.env.WORKFLOW_ENGINE as "legacy" | "world") ?? "legacy", + world: { type: "postgres", url: process.env.WORKFLOW_POSTGRES_URL ?? "" }, +}); + +await kit.start(); // no-op sur legacy +const handle = await kit.run(myWorkflow, ["arg"]); +await kit.stop(); +``` + +Consultez le [guide du moteur world](/fr/workflows/world-engine) pour l'installation, les règles d'écriture et la migration. diff --git a/packages/mintlify-docs/fr/workflows/world-engine.mdx b/packages/mintlify-docs/fr/workflows/world-engine.mdx new file mode 100644 index 0000000..a24462e --- /dev/null +++ b/packages/mintlify-docs/fr/workflows/world-engine.mdx @@ -0,0 +1,242 @@ +--- +title: "World engine (workflows durables)" +description: "Exécutez des workflows sur un backend Vercel Workflow SDK durable (Postgres/MongoDB auto-hébergé) via la facade WorkflowKit, en parallèle du moteur en mémoire historique." +locale: fr +--- + +AI Kit embarque **deux moteurs de workflow** derrière une façade unique, `WorkflowKit` : + +- **`legacy`** (défaut) — le moteur en mémoire que vous construisez avec [`createWorkflow`](/fr/workflows/introduction) / `WorkflowBuilder`. Zéro dépendance supplémentaire, s'exécute en mémoire, l'état vit en mémoire. +- **`world`** — le [Vercel Workflow SDK](https://workflow-sdk.dev) adossé à un **world** durable : **Postgres** auto-hébergé (`@workflow/world-postgres`) ou **MongoDB** (`@workflow-worlds/mongodb`). Les runs survivent aux redémarrages (replay durable, file de jobs, journal d'événements). + +`WorkflowKit` vous permet de choisir le moteur via la configuration ; le défaut est toujours `legacy`, donc le code existant continue de fonctionner et les utilisateurs du mode legacy n'importent jamais une dépendance Vercel. + +## Quand utiliser lequel + +| | `legacy` (défaut) | `world` | +|---|---|---| +| Persistance | En mémoire uniquement | Durable (Postgres / MongoDB) | +| Survit aux redémarrages / crashs | Non | Oui (replay) | +| Dépendances supplémentaires | Aucune | `@ai_kit/workflow-world` + `workflow` + un backend world | +| Étape de build | Aucune | **Build Nitro requis** (compile `"use workflow"`) | +| Runtime | Quelconque (en process) | Worker long-lived (pas serverless) | +| Écriture | Builder `createWorkflow().then(...)` | Fonctions `"use workflow"` / `"use step"` | + +Utilisez `legacy` pour l'orchestration rapide en process et le développement local ; utilisez `world` quand vous avez besoin de durabilité, de suspension (`sleep`) et de processus longs reprennables. + +## La façade `WorkflowKit` + +```ts +import { WorkflowKit } from "@ai_kit/core"; + +const kit = new WorkflowKit({ + engine: "legacy", // défaut — peut être omis +}); + +// Legacy: workflow = un Workflow AI Kit, input = WorkflowRunOptions +const result = await kit.run(myLegacyWorkflow, { inputData: { id: 42 } }); +console.log(result.status); // "success" | "failed" | ... +``` + +Passez au moteur durable en définissant `engine: "world"` et en fournissant une config `world` : + +```ts +const kit = new WorkflowKit({ + engine: "world", + world: { type: "postgres", url: process.env.WORKFLOW_POSTGRES_URL! }, +}); + +await kit.start(); // démarre le worker durable +const handle = await kit.run(handleUserSignup, ["hello@example.com"]); +console.log(handle.runId); +await kit.stop(); // arrêt propre +``` + +- `kit.start()` / `kit.stop()` gèrent le worker world long-lived. **Ce sont des no-ops sur `legacy`**, donc le même code de cycle de vie fonctionne pour les deux moteurs. +- `kit.run(...)` dispatche vers le moteur configuré. Vous pouvez surcharger par appel : `kit.run(wf, input, { engine: "world" })`. + +### Configuration + +```ts +interface WorkflowKitOptions { + engine?: "legacy" | "world"; // défaut "legacy" + world?: WorldConfig; // requis quand engine === "world" +} + +interface WorldConfig { + type: "postgres" | "mongodb"; + url: string; // chaîne de connexion + jobPrefix?: string; // postgres: espace de noms des jobs sur une DB partagée + workerConcurrency?: number; // postgres: workers concurrents + maxPoolSize?: number; // postgres: taille du pool de connexions +} +``` + +Le constructeur valide la configuration : `engine: "world"` sans `world` lève une erreur, et un `world.type` inconnu lève également une erreur. + +Consultez la [référence API `WorkflowKit`](/fr/api-reference/workflow-kit) pour la surface complète. + +## Installer le moteur world + +Le moteur world vit dans un package optionnel afin que le core reste léger : + +```bash +pnpm add @ai_kit/core @ai_kit/workflow-world workflow +# choisissez le backend world dont vous avez besoin (peer dependency optionnelle) : +pnpm add @workflow/world-postgres # Postgres (officiel) +# ou +pnpm add @workflow-worlds/mongodb # MongoDB (communauté, expérimental) +# build de l'application hôte : +pnpm add -D nitro rollup +``` + +Si vous sélectionnez `engine: "world"` sans `@ai_kit/workflow-world` installé, `WorkflowKit` lève une erreur claire vous demandant de l'installer. + +## Écrire des workflows world + +Un workflow world est une simple fonction async marquée avec la directive `"use workflow"` ; le vrai travail se passe dans des fonctions `"use step"`. Ces directives sont détectées **à la compilation** par le compilateur `workflow/nitro`. + +```ts +import { sleep, FatalError } from "workflow"; + +export async function handleUserSignup(email: string) { + "use workflow"; // le corps doit être déterministe + const user = await createUser(email); // chaque await est un checkpoint durable + await sendWelcomeEmail(user); + await sleep("5s"); + return { userId: user.id }; +} + +async function createUser(email: string) { + "use step"; // runtime Node complet, ré-essayé automatiquement + if (!email.includes("@")) throw new FatalError("invalid email"); + return { id: crypto.randomUUID(), email }; +} + +async function sendWelcomeEmail(user: { id: string; email: string }) { + "use step"; + return { sent: true }; +} +``` + + +Il n'existe **pas de helper runtime `defineWorldStep`**. Le compilateur Vercel n'instrumente les directives que sur des **liaisons de niveau supérieur** (une fonction nommée, ou une flèche/fonction liée directement à un `const`). Passer la fonction à un appel wrapper casserait silencieusement la détection — l'étape s'exécuterait comme du code ordinaire non durable. Écrivez donc la directive vous-même et annotez (optionnellement) avec les types exportés. + + +`@ai_kit/workflow-world` exporte les **types** `WorldStep` / `WorldWorkflow` pour l'ergonomie : + +```ts +import type { WorldStep } from "@ai_kit/workflow-world"; + +// une flèche liée directement à un const est également détectée par le compilateur +export const charge: WorldStep<[Order], Receipt> = async (order) => { + "use step"; + return chargePayment(order); +}; +``` + +### Le flux de contrôle est du JavaScript natif + +Parce qu'un workflow world est simplement une fonction async, vous n'avez pas besoin de primitives spéciales — utilisez le langage : + +| Besoin | Moteur world | +|---|---| +| Séquentiel | `await` successifs | +| Boucle / itération | `for` / `while`, `for (const x of items)` | +| Parallèle / fan-out | `await Promise.all(items.map(step))` | +| Race / timeout | `await Promise.race([hook, sleep("24h")])` | +| Condition | `if` / `switch` | +| Human-in-the-loop | `createWebhook()` ou `defineHook()` + `hook.resume(...)` | +| Délai durable | `await sleep("30d")` | +| Nouvelles tentatives | automatiques (max 3) + `FatalError` / `RetryableError` | + +Le corps `"use workflow"` doit rester **déterministe** (pas de `Date.now()`, `Math.random()`, `fetch`, I/O directe) — mettez ces effets dans des fonctions `"use step"`. + +## Postgres : provisionner le schéma une fois + +Avant le premier run, le world Postgres a besoin que son schéma soit créé (sinon vous obtenez une erreur `undefined_table` / `42P01`). C'est une opération unique au déploiement : + +```bash +WORKFLOW_POSTGRES_URL=postgres://world:world@localhost:5432/world npx workflow-postgres-setup +``` + +MongoDB n'a pas besoin de cette étape — il se provisionne à la connexion. + +## MongoDB (expérimental) + +Le world MongoDB est maintenu par la communauté. Seule la configuration change ; le code applicatif est identique à Postgres : + +```ts +const kit = new WorkflowKit({ + engine: "world", + world: { type: "mongodb", url: process.env.WORKFLOW_MONGODB_URI! }, +}); +await kit.start(); +``` + +## Contraintes de build & de runtime + +Le Vercel Workflow SDK impose : + +1. **Une étape de build** — Nitro compile les fonctions `"use workflow"` / `"use step"`. Ajoutez le module `workflow/nitro` au `nitro.config.ts` de votre application hôte. AI Kit simplifie la configuration runtime mais ne peut pas supprimer cette étape de build. +2. **Un worker long-lived** — le world interroge la base de données pour les jobs, donc le moteur world n'est **pas** compatible avec les déploiements purement serverless. + +```ts +// nitro.config.ts (application hôte) +import { defineNitroConfig } from "nitro/config"; + +export default defineNitroConfig({ + modules: ["workflow/nitro"], + routes: { "/**": { handler: "./src/index.ts", format: "node" } }, +}); +``` + +## Migrer un workflow legacy vers le moteur world + +La migration est une réécriture du builder déclaratif vers une fonction impérative — il n'existe pas de traducteur automatique. + +**Avant (legacy) :** + +```ts +import { createWorkflow, createStep } from "@ai_kit/core"; + +const fetchOrder = createStep({ id: "fetchOrder", handler: async ({ inputData }) => getOrder(inputData.id) }); +const charge = createStep({ id: "charge", handler: async ({ inputData }) => chargePayment(inputData) }); + +export const orderWorkflow = createWorkflow({ id: "order" }) + .then(fetchOrder) + .then(charge) + .commit(); + +await orderWorkflow.run({ inputData: { id: "o_123" } }); +``` + +**Après (world) :** + +```ts +export async function orderWorkflow(orderId: string) { + "use workflow"; + const order = await fetchOrder(orderId); + const charged = await charge(order); + return { orderId, status: "completed" }; +} + +async function fetchOrder(id: string) { "use step"; return getOrder(id); } +async function charge(order: Order) { "use step"; return chargePayment(order); } + +// lancé via la façade +await kit.run(orderWorkflow, ["o_123"]); +``` + +| Builder legacy | Réécriture world | +|---|---| +| `.then(step)` | `await step()` successifs | +| `.while({ condition })` | `while (await condition()) { ... }` | +| `forEach` (parallèle) | `await Promise.all(items.map(step))` | +| `.branchParallel(...)` | `await Promise.all([stepA(), stepB()])` | +| `.conditions(...).then(...)` | `if (...) {} else {}` | +| `.human(...)` + `resumeWithHumanInput` | `defineHook()` + `hook.resume(...)` | + +## Couverture fonctionnelle + +Parce que le moteur `world` embarque le vrai SDK Vercel, il hérite de **toutes** ses capacités : exécution durable, `sleep`, webhooks/hooks (human-in-the-loop), streaming, agents durables, nouvelles tentatives automatiques, et le tableau de bord d'observabilité `npx workflow web`. Les API runtime avancées s'utilisent directement depuis le package `workflow` — la fine façade `WorkflowKit` gère uniquement la sélection du moteur, le cycle de vie et le dispatch des runs. From bea08c4d42899bf82afc0ec82712a1325109ea37 Mon Sep 17 00:00:00 2001 From: Killian-Aidalinfo Date: Tue, 2 Jun 2026 18:57:13 +0200 Subject: [PATCH 21/21] chore(release): bump @ai_kit/core 1.4.0 + @ai_kit/mcp-docs 1.0.7, add workflow-world publish CI - @ai_kit/core 1.3.1 -> 1.4.0 (new WorkflowKit facade / world engine) - @ai_kit/mcp-docs 1.0.6 -> 1.0.7 (rebundles the new world-engine docs) - @ai_kit/workflow-world stays 0.1.0 (initial release) - add .github/workflows/release-workflow-world.yml (mirrors release-rag.yml: publishes on push to main touching packages/workflow-world/package.json) Co-Authored-By: Claude Opus 4.8 (1M context) --- .github/workflows/release-workflow-world.yml | 83 ++++++++++++++++++++ packages/core/package.json | 2 +- packages/mcp-docs-server/package.json | 2 +- 3 files changed, 85 insertions(+), 2 deletions(-) create mode 100644 .github/workflows/release-workflow-world.yml diff --git a/.github/workflows/release-workflow-world.yml b/.github/workflows/release-workflow-world.yml new file mode 100644 index 0000000..1c757ae --- /dev/null +++ b/.github/workflows/release-workflow-world.yml @@ -0,0 +1,83 @@ +name: NPM Publish Workflow World + +on: + push: + branches: [ main ] + paths: + - 'packages/workflow-world/package.json' + workflow_dispatch: + +jobs: + publish: + runs-on: ${{ vars.USE_SELF_HOSTED == 'true' && 'self-hosted' || 'ubuntu-latest' }} + + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Setup Node.js + uses: actions/setup-node@v4 + with: + node-version: '22' + registry-url: 'https://registry.npmjs.org' + scope: '@ai_kit' + + - name: Setup pnpm + uses: pnpm/action-setup@v4 + with: + version: 10.15.0 + + - name: Get package version + id: package + run: | + VERSION=$(cd packages/workflow-world && node -p "require('./package.json').version") + PACKAGE_NAME=$(cd packages/workflow-world && node -p "require('./package.json').name") + echo "version=$VERSION" >> $GITHUB_OUTPUT + echo "name=$PACKAGE_NAME" >> $GITHUB_OUTPUT + echo "Package: $PACKAGE_NAME@$VERSION" + + - name: Check if version exists on NPM + id: npm-check + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} + run: | + cd packages/workflow-world + if npm view ${{ steps.package.outputs.name }}@${{ steps.package.outputs.version }} version 2>/dev/null; then + echo "exists=true" >> $GITHUB_OUTPUT + echo "Version ${{ steps.package.outputs.version }} already exists on NPM" + exit 1 + else + echo "exists=false" >> $GITHUB_OUTPUT + echo "Version ${{ steps.package.outputs.version }} does not exist on NPM" + fi + + - name: Install dependencies + run: | + cd packages/workflow-world + pnpm install + + - name: Build package + run: | + cd packages/workflow-world + pnpm build + + - name: Publish to NPM + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} + run: | + cd packages/workflow-world + pnpm publish --access public + + - name: Create Release + uses: softprops/action-gh-release@v2 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + with: + tag_name: v${{ steps.package.outputs.version }}-workflow-world + name: AI KIT workflow-world - Release v${{ steps.package.outputs.version }} + body: | + ## Changes + + Package ${{ steps.package.outputs.name }} has been updated to version ${{ steps.package.outputs.version }}. + draft: false + prerelease: false diff --git a/packages/core/package.json b/packages/core/package.json index 4586f92..6cc79c9 100644 --- a/packages/core/package.json +++ b/packages/core/package.json @@ -1,6 +1,6 @@ { "name": "@ai_kit/core", - "version": "1.3.1", + "version": "1.4.0", "description": "", "type": "module", "main": "./dist/index.js", diff --git a/packages/mcp-docs-server/package.json b/packages/mcp-docs-server/package.json index 9ae2ecb..7bcf244 100644 --- a/packages/mcp-docs-server/package.json +++ b/packages/mcp-docs-server/package.json @@ -1,6 +1,6 @@ { "name": "@ai_kit/mcp-docs", - "version": "1.0.6", + "version": "1.0.7", "description": "MCP server exposing AI Kit documentation", "type": "module", "main": "./dist/index.js",