@codemation/core 0.8.1 → 0.10.1

package/CHANGELOG.md

@@ -1,5 +1,391 @@
 # @codemation/core
 
+## 0.10.1
+
+### Patch Changes
+
+- [#127](https://github.com/MadeRelevant/codemation/pull/127) [`1f10121`](https://github.com/MadeRelevant/codemation/commit/1f10121a093ef0612a33c873419b032709c9964d) Thanks [@cblokland90](https://github.com/cblokland90)! - Add regression test suite confirming `item.binary` slots survive SubWorkflow boundaries in both directions (parent→child and child→parent), including stream readback of bytes across run boundaries. Document the shared-BinaryStorage pattern required for tests that call `ctx.binary.attach`.
+
+## 0.10.0
+
+### Minor Changes
+
+- [#119](https://github.com/MadeRelevant/codemation/pull/119) [`847deb4`](https://github.com/MadeRelevant/codemation/commit/847deb4c42801632bfb970cdb2625cd0755241cb) Thanks [@cblokland90](https://github.com/cblokland90)! - Reset source version line back to 0.x. Earlier releases prematurely jumped these packages to 1.x and 2.x via silent `major` changesets buried under unrelated work; the framework is still in beta. The npm versions 1.x and 2.0.0 are deprecated upstream — consume the 0.x line going forward.
+  - `@codemation/core` 2.0.0 → 0.9.0 (continues from 0.8.1)
+  - `@codemation/core-nodes` 1.1.0 → 0.5.0 (continues from 0.4.3)
+  - `@codemation/host` 1.1.0 → 0.4.0 (continues from 0.3.1)
+
+  `@codemation/agent-skills`, `create-codemation`, `@codemation/cli`, and `@codemation/core-nodes-msgraph` already track 0.x and are unaffected.
+
+  `create-codemation` template dependency ranges updated from `1.x` to `0.x` to track the corrected line.
+
+## 2.0.0
+
+### Major Changes
+
+- [#102](https://github.com/MadeRelevant/codemation/pull/102) [`6566d55`](https://github.com/MadeRelevant/codemation/commit/6566d55c829f6631357ac95052b0852e86092ac5) Thanks [@cblokland90](https://github.com/cblokland90)! - **Breaking change:** Default node ids in `WorkflowBuilder` now derive from a slug of the node's label (`config.name`) instead of a sequential counter (`${tokenName}:${seq}`).
+
+  Previously, adding or reordering nodes changed their auto-assigned ids, silently orphaning credential bindings stored in the database (keyed by `workflowId + nodeId + slotKey`). The new scheme makes ids stable across reorders and inserts.
+
+  **Migration required:** Any existing credential bindings keyed by the old `${tokenName}:${seq}` format will appear unbound after this change. Users must re-bind credentials manually in the workflow editor. To avoid disruption, add an explicit `id:` field to node configs before upgrading — explicit ids are unaffected by this change and take priority over the label slug.
+
+  **Validation added:** `WorkflowBuilder.build()` now throws `WorkflowDefinitionError` if any node has an empty effective id (blank label + no explicit id) or if two nodes share the same effective id. Fix: provide a unique `id:` on the offending node configs.
+
+### Minor Changes
+
+- [#111](https://github.com/MadeRelevant/codemation/pull/111) [`a77505f`](https://github.com/MadeRelevant/codemation/commit/a77505f331d7d3892f3c1c8f19dc37952b4d96bd) Thanks [@cblokland90](https://github.com/cblokland90)! - Add `definePollingTrigger` helper for declarative polling trigger authoring.
+
+  Plugin authors can now define polling triggers with a single `definePollingTrigger({...})` call instead of manually wiring `PollingTriggerRuntime` + `RunnableNodeConfig` + `@node` class pairs. The helper synthesises both the trigger config class and the runtime adapter, handles internal dedup-key bookkeeping, and exposes a `poll()` test seam for unit testing without spinning up the runtime.
+
+- [#101](https://github.com/MadeRelevant/codemation/pull/101) [`2c0723f`](https://github.com/MadeRelevant/codemation/commit/2c0723fb1670e842c272939b5db73d4b95b25535) Thanks [@cblokland90](https://github.com/cblokland90)! - Add collections: declare typed Postgres/SQLite-backed data tables in the codemation config via `defineCollection({...})`. Schema sync runs at runtime startup behind an advisory lock (Postgres) or in-process mutex (SQLite).
+
+  Workflow access:
+  - `ctx.collections.<name>.crud(...)` from inside custom node code
+  - Six new canvas nodes: `CollectionInsert`, `CollectionGet`, `CollectionFindOne`, `CollectionList`, `CollectionUpdate`, `CollectionDelete`
+
+  Operator surfaces:
+  - HTTP API at `/collections/*`
+  - CLI: `codemation collections list|show|rows|get|insert|update|delete|sync`
+  - UI at `/collections`
+
+  Destructive schema changes (column drops, type changes) require `CODEMATION_COLLECTIONS_ALLOW_DESTRUCTIVE=1`.
+
+  Out of scope (separate PRs):
+  - Real leader election (advisory lock at boot is sufficient for sync; trigger double-firing during container swap is unaddressed)
+  - Admin-role gating on the UI
+  - Runtime user-defined schemas (Airtable-style)
+  - Joins, aggregates, query DSL beyond indexed-field equality
+
+- [#109](https://github.com/MadeRelevant/codemation/pull/109) [`fb9f7fe`](https://github.com/MadeRelevant/codemation/commit/fb9f7fed9bf5a3d6b0c5f78a30027be3ab7bcaca) Thanks [@cblokland90](https://github.com/cblokland90)! - OAuth2 plugin authors can now declare `authorizeUrl` / `tokenUrl` (with `{publicFieldKey}` template substitution) directly on a credential type's `auth` definition — no core change required to add a new provider. Migrated `@codemation/core-nodes-msgraph` to use this for Microsoft tenant-templated URLs (fixes "Unsupported OAuth2 provider id: microsoft" on connect).
+
+  Removed dead `@codemation/core-nodes-gmail` devDep from `@codemation/host` and the matching `serverExternalPackages` entry from `@codemation/next-host` so plugin-author `pnpm dev` no longer rebuilds gmail when working on an unrelated plugin.
+
+  Softened the credentials UI's "Not set in host env: …" message: it's now an informational tip with neutral styling (was destructive/error styling), since the field works perfectly fine when filled in manually.
+
+- [#101](https://github.com/MadeRelevant/codemation/pull/101) [`2c0723f`](https://github.com/MadeRelevant/codemation/commit/2c0723fb1670e842c272939b5db73d4b95b25535) Thanks [@cblokland90](https://github.com/cblokland90)! - Add collections authoring API: `defineCollection()` for declaring typed data tables, `DefinedCollectionRegistry` for registration, and `CollectionStore` contract for runtime access. Includes column DSL (`c.text()`, `c.int()`, etc.) with validation for field/index names and reserved fields.
+
+- [#108](https://github.com/MadeRelevant/codemation/pull/108) [`781c146`](https://github.com/MadeRelevant/codemation/commit/781c146eb9d8bb8bdbc1963ea2a4b9abe4b7bfbf) Thanks [@cblokland90](https://github.com/cblokland90)! - Extract generic polling-trigger machinery from gmail into core and expose it via setup context.
+
+  **`@codemation/core`** — new polling-trigger API
+  - New `PollingTriggerRuntime` class: owns the set-interval loop, overlap guard, and state persistence via `TriggerSetupStateRepository`. Plugin authors no longer need to implement these themselves.
+  - New `PollingTriggerDedupWindow` class: merges processed-ID sets with a configurable cap (default 2000). Prevents unbounded memory growth across polling cycles.
+  - New `PollingTriggerHandle` interface exposed on `TriggerSetupContext.polling`: pre-binds trigger id, emit, and registerCleanup so plugin code only supplies `intervalMs` and `runCycle`. The handle also carries a `.dedup` reference for message-level deduplication.
+  - `EngineDeps.pollingTriggerLogger` optional field: hosts may wire a real logger; defaults to a no-op.
+  - `PollingTriggerRuntime`, `PollingTriggerDedupWindow`, and `NoOpPollingTriggerLogger` are exported from the main `@codemation/core` barrel.
+  - ESLint `allowedConstructorNames` extended to include `AbortController` (a global built-in, not a DI-managed class).
+
+  **`@codemation/core-nodes-gmail`** — internal refactor, no external API change
+  - `GmailPollingTriggerRuntime` deleted; loop/overlap-guard/persistence now come from the core runtime.
+  - `GmailPollingService.poll` renamed to `runCycle`; repo injection and `persist()` method removed; dedup delegated to `PollingTriggerDedupWindow`.
+  - `OnNewGmailTriggerNode.setup` now calls `ctx.polling.start(...)` instead of `gmailPollingTriggerRuntime.ensureStarted(...)`.
+  - `GmailNodeTokens.RuntimeLogger` token removed (no longer needed).
+
+- [#100](https://github.com/MadeRelevant/codemation/pull/100) [`11616ae`](https://github.com/MadeRelevant/codemation/commit/11616aefb91d4b96b7eb9af4b935eec055a8a7bb) Thanks [@cblokland90](https://github.com/cblokland90)! - Foundation for first-class **workflow testing**: a TestTrigger node, an IsTestRun branching node, an Assertion node, a `TestSuiteOrchestrator` service that fans one workflow run per yielded fixture item, host-side persistence (Prisma `TestSuiteRun` + `TestAssertion` tables, repositories, `TestRunnerService`), and a per-suite event tracker that records assertions and node coverage. HTTP routes and the canvas Tests tab (next-host) ship in follow-up slices.
+
+  **What this slice adds**
+  - **`@codemation/core` — additive contract changes**
+    - `RunExecutionOptions.testContext?: { testSuiteRunId; testCaseIndex }` — set by the orchestrator on each test-case run; threaded through `ExecutionContext` so nodes can read it as `ctx.testContext`. Propagates to subworkflow runs via `ParentExecutionRef.testContext` + `EngineExecutionLimitsPolicy.mergeExecutionOptionsForNewRun`, so assertions emitted by subworkflows land under the correct parent test case.
+    - `TriggerNodeConfig.triggerKind?: "live" | "test"` — `"test"` triggers are skipped by `TriggerRuntimeService` (live activation, webhooks, polling) and are only invoked by the orchestrator.
+    - `NodeConfigBase.emitsAssertions?: true` — marker the host-side `TestAssertionPersister` (next slice) keys off when subscribing to `nodeCompleted`.
+    - New `AssertionResult` type (`pass | fail | error`, plus `score`, `expected`, `actual`, `message`, `details`) — the stable shape every assertion node emits on `main`.
+    - New `TestTriggerNodeConfig` + `TestTriggerSetupContext` — author callback signature returns `AsyncIterable<Item>` and exposes credential resolution + an `AbortSignal`.
+    - New `RunEvent` kinds: `testSuiteStarted`, `testCaseStarted`, `testCaseCompleted`, `testSuiteFinished` (with terminal status `succeeded | failed | partial | cancelled | errored`).
+    - New `TestSuiteOrchestrator` service in `orchestration/` — drives the iterator, applies a per-suite concurrency semaphore (default 4), dispatches one `engine.runWorkflow(...)` per item with `executionOptions.testContext` set, awaits terminal status, and publishes lifecycle events on the existing `RunEventBus`. No persistence, no HTTP — pure engine logic so tests can drive it via in-memory deps.
+    - `TestSuiteRunIdFactory`, `AbortControllerFactory` — DI-friendly minters used by the orchestrator.
+  - **`@codemation/core-nodes` — three new nodes**
+    - **`TestTrigger`** / `TestTriggerNode`: drop on the canvas alongside live triggers. `setup` is a no-op; `execute` is a passthrough. The author's `generateItems` is consumed by the orchestrator.
+    - **`IsTestRun`** / `IsTestRunNode`: per-item router with `true` / `false` ports. Routes to `true` iff `ctx.testContext` is set — lets workflows skip real side-effects in test runs (e.g. don't actually send the reply).
+    - **`Assertion`** / `AssertionNode`: generic callback-style assertion node. Author returns `Promise<AssertionResult[]>` per item; the node emits one workflow `Item` per result. Sets `emitsAssertions: true` so the host persister can identify it.
+    - Declarative shorthands (`StringEqualsAssertionNode`, `JudgeByAgentAssertionNode`) intentionally deferred — the generic callback node covers Phase 1 and the declarative variants compose on top.
+  - **`@codemation/host` — persistence + orchestration + HTTP**
+    - **Prisma schema**: new `TestSuiteRun` and `TestAssertion` tables in both Postgres and SQLite mirrors. Adds `Run.testSuiteRunId` (FK with `ON DELETE SET NULL`) and `Run.testCaseIndex` (indexed for join + ordering). Workflow definition itself is **not** FK'd — workflows live in code; `TestSuiteRun.triggerNodeName` is snapshotted at creation so historical viewing survives node renames/deletions.
+    - **`TestSuiteRunRepository`** + **`TestAssertionRepository`** domain interfaces with Prisma + in-memory adapters.
+    - **`TestRunnerService`** (host application layer) — single facade for "start a test suite": creates the persistence row, drives the orchestrator, awaits, finalizes counts + coverage. Subscribes to `RunEventBus.subscribeToWorkflow` only for the lifetime of one suite (no global subscriber, no shared mutable state across concurrent suites).
+    - **`TestSuiteRunTracker`** + **`TestSuiteRunTrackerFactory`** — per-suite event accumulator. Two-stage event buffering tolerates inline runners that emit `nodeCompleted` synchronously inside `runWorkflow` (before the orchestrator publishes `testCaseStarted`); without it, fast/in-memory engines drop assertions silently.
+    - **`AssertionResultGuard`** — type-guard the tracker uses to skip junk output if a misconfigured `emitsAssertions: true` node emits non-assertion items (defensive, not crash-on-bad-input).
+    - **HTTP routes** (Hono, all behind the existing session-verifier middleware):
+      - `POST /api/workflows/:workflowId/test-suite-runs` body `{ triggerNodeId, concurrency? }` → 201 with `{ testSuiteRunId, status, totalCases, passedCases, failedCases }`
+      - `GET /api/workflows/:workflowId/test-suite-runs` → list summaries
+      - `GET /api/test-suite-runs/:id` → detail (including `concurrency`, `nodeCoverage`, `errorMessage`)
+      - `GET /api/test-suite-runs/:id/assertions` → all assertions across the suite's child runs
+      - `GET /api/runs/:runId/assertions` → assertions for one child run
+      - Paths exposed through `ApiPaths.workflowTestSuiteRuns/testSuiteRun/testSuiteRunAssertions/runAssertions` so the next-host React Query layer can call them by helper instead of string literals.
+    - **DI bootstrap** in `AppContainerFactory`: registers all new singletons (factories, mappers, guard, repository selector, route handler + registrar) and wires Prisma vs in-memory `TestSuiteRunRepository` / `TestAssertionRepository` based on `appConfig.persistence.kind` (mirroring the existing `WorkflowRunRepository` selection). `TestSuiteOrchestrator` itself is registered via a tsyringe factory that injects `Engine` + the engine-side `RunEventBus` + a fresh `CredentialResolverFactory(CredentialSessionService)`.
+    - **DTOs** in `application/contracts/TestingContracts.ts`: `StartTestSuiteRunRequest/Response`, `TestSuiteRunSummaryDto`, `TestSuiteRunDetailDto`, `TestAssertionDto`. Mappers (`TestSuiteRunSummaryMapper`, `TestAssertionMapper`) translate persistence records → wire shape.
+    - **WebSocket / event narrowing** — `WorkflowWebsocketServer` and one integration test reader updated to type-narrow on the new test-suite event kinds (which carry `testSuiteRunId` rather than `runId`).
+
+  **Tests**
+  - `TestSuiteOrchestrator` unit suite (6 tests): per-item dispatch with `testContext`, partial-pass aggregation, lifecycle event emission, concurrency cap, `errored` status when `generateItems` throws, rejection of non-test triggers.
+  - Node unit suite (6 tests): TestTrigger passthrough + `triggerKind === "test"`, IsTestRun routing on both branches, AssertionNode emitting one item per result, `emitsAssertions === true`.
+  - `TestRunnerService` integration suite (2 tests): creates the persistence row, finalizes counts + coverage, persists 3 `TestAssertion` rows from a 2-case suite (one passing, one failing); rejects non-test triggers without leaving a phantom row.
+  - **`@codemation/next-host` — Tests tab UI**
+    - **Third canvas tab** ("Tests") next to Live workflow / Executions, mutually exclusive with both. Local React state for now (Phase 1) — promotion to the URL codec is a Phase 2 cleanup once the UX is settled.
+    - **`TestsPanel`** — top-level container with a trigger picker (shadcn `Select` populated from workflow nodes whose `triggerKind === "test"`), a "Run tests" CTA wired through `useStartTestSuiteRunMutation`, a left list of past suite runs, and a right detail panel.
+    - **`TestSuitePassRateChart`** — recharts line chart of pass rate over time across this workflow's suite runs. Carries an explicit `rolling-input` label so authors don't read trends as agent regressions when the underlying fixtures drift (Phase 2 ships snapshots).
+    - **`TestSuiteRunsList`** + **`TestSuiteRunStatusBadge`** — list rows + colored status badges (`running` / `succeeded` / `partial` / `failed` / `cancelled` / `errored`).
+    - **`TestSuiteRunDetailPanel`** — header with pass-rate + counts + concurrency + nodes-covered + (when set) an `errorMessage` callout; the body is a per-run grouped assertions list.
+    - **`TestAssertionsList`** + **`TestAssertionRow`** — each assertion shows status badge, optional score, optional `expected`/`actual` JSON viewers side-by-side.
+    - **React Query hooks** (`testSuiteHooks.ts`) cover all four GET endpoints plus the start mutation, with cache invalidation on `workflowTestSuiteRunsQueryKey` after a successful run.
+    - **WorkflowNodeDto** + **mapper additions** (host + next-host's `PersistedWorkflowSnapshotMapper`) propagate `triggerKind` to the wire shape so the Tests panel can identify test triggers without server round-trips. Both mappers default omitted values to `"live"` to keep the wire DTO consistent.
+
+  **Not in this slice (planned follow-ups)**
+  - Test-input snapshots (Phase 2 — Phase 1 inputs are always live; UI carries a "rolling-input" label so charts aren't read as agent regressions).
+  - Declarative assertion family (StringEquals, JsonPath, JudgeByAgent helpers — generic callback `Assertion` covers Phase 1).
+  - Cancellation endpoint (`POST /api/test-suite-runs/:id/cancel`) — orchestrator already supports `AbortSignal` cancellation; the HTTP surface for it is deferred until the UI surfaces it.
+  - Realtime updates on the Tests panel — currently the suite list refetches on mutation success; live `testSuite*` events arrive via the existing realtime bridge but the Tests panel doesn't subscribe yet.
+  - URL codec entry for `pane=tests` so suite drilldowns are deep-linkable (currently in-memory React state).
+  - Coverage heatmap overlay on the canvas itself.
+
+  The contract additions are **strictly additive**; no existing API surface changed shape.
+
+### Patch Changes
+
+- [#110](https://github.com/MadeRelevant/codemation/pull/110) [`4902978`](https://github.com/MadeRelevant/codemation/commit/49029782243ece59ab6aa5bb46396db445cad47c) Thanks [@cblokland90](https://github.com/cblokland90)! - Add per-package `test:unit` scripts so Turbo can address each package individually for affected-only filtering. No runtime changes — dev-tooling only.
+
+- [#100](https://github.com/MadeRelevant/codemation/pull/100) [`11616ae`](https://github.com/MadeRelevant/codemation/commit/11616aefb91d4b96b7eb9af4b935eec055a8a7bb) Thanks [@cblokland90](https://github.com/cblokland90)! - Major dev-server startup-time and bundle-size improvements, plus dev-CLI hardening.
+
+  **Why this matters**
+
+  Before this work, opening the workflow detail page on a 4-cpu / 8-GB WSL box would
+  OOM-kill `next-server` mid-compile (~5 GB peak RSS). After: the page cold-compiles in
+  **5.5 s** with peak **1.8 GB** and the dev server stays comfortably alive. The dev CLI
+  also boots significantly faster and survives consumer-source errors without tearing
+  the whole session down.
+
+  **Hard numbers**
+  - Workflow page Turbopack RSS peak: **5.0 GB → 1.8 GB** (-64%)
+  - Workflow page cold compile time: **~14 s → ~5.5 s**
+  - Lucide-react files in workflow page bundle: **1,713 → 74** (-95.7%)
+  - Host package typecheck: **17.5 s / 4,093 files / 2.1 GB → 8.8 s / 2,806 files / 1.9 GB**
+  - Host source tree: **-112,492 lines** of generated Prisma `.d.ts`
+  - Host circular dep cycles: **92 → 21**
+  - Core circular dep cycles: **53 → 50**
+
+  **`@codemation/next-host`**
+  - New `WorkflowCanvasLucideIconRegistry` — curated 18-icon set used by core node plugins.
+    Replaces `lucide-react/dynamic` (which forced bundling of all 1,713 icons because it
+    loads them by string at runtime). Workflows using `icon: "lucide:<unknown>"` now fall
+    back to the `Boxes` icon and emit a one-time `console.warn`. **Plugin authors needing
+    custom icons must ship SVG via `builtin:` / `si:` / URL tokens.**
+  - New slim subpath exports on `@codemation/host`: **`@codemation/host/dto`**,
+    **`@codemation/host/mapping`**, plus extensions to **`@codemation/host/client`**.
+    All 65 deep `@codemation/host-src/*` imports replaced; `@codemation/host-src/*`
+    tsconfig path removed. Prevents the UI from dragging the heavy host runtime graph
+    through Turbopack on every UI route compile.
+  - 42 lucide-react named imports rewritten to per-icon deep imports
+    (`lucide-react/dist/esm/icons/<kebab>`).
+  - Workflow detail page lazy-loads `WorkflowDetailScreenTestsView` and the
+    Monaco-backed `WorkflowJsonEditorDialog`.
+  - Removed `@codemation/core` and `@codemation/host` from `transpilePackages` and
+    dropped the corresponding root-barrel tsconfig paths so Next loads them from
+    compiled `dist/` instead of TypeScript source.
+  - Dev: `EdgeSessionVerifier` resolves `/api/auth/session` via
+    `x-forwarded-host` (the dev gateway) instead of `request.nextUrl.origin` (Next's
+    loopback). Previously the auth-check fetch looped back into Next, forcing
+    Turbopack to compile the catch-all `/api/[[...path]]` route on every page load.
+
+  **`@codemation/host`**
+  - Generated Prisma clients (`prisma-client`, `prisma-postgresql-client`,
+    `prisma-sqlite-client`) moved out of `src/infrastructure/persistence/generated/`
+    to `prisma-generated/` (sibling of `src/`). They're still typechecked and bundled
+    by the host build, but no longer pollute the public source surface that downstream
+    packages walk.
+  - New **`@codemation/host/dto`**, **`@codemation/host/mapping`** subpath exports
+    re-exposing only the contract DTO types and presentation factories the UI needs.
+    The existing **`@codemation/host/client`** subpath gained `ApiPaths`,
+    `BrowserLoggerFactory`, `logLevelPolicyFactory`, `InAppCallbackUrlPolicy`, and
+    `Logger` so the UI no longer needs deep imports.
+
+  **`@codemation/core`**
+  - New **`@codemation/core/contracts`** subpath — re-exports only pure-type contracts
+    (`assertionTypes`, `runTypes`, `workflowTypes`, etc.) using `export type *`. Type-only
+    consumers can import from here to avoid dragging the workflow DSL runtime into their
+    compile graph. Existing `@codemation/core` (root barrel) is unchanged for backwards
+    compatibility.
+  - Extracted `core/src/contracts/baseTypes.ts` (six fundamental id types) to break a
+    long-standing `credentialTypes ↔ workflowTypes` cycle.
+
+  **`@codemation/cli` — dev-CLI hardening**
+  - **`DevHttpProbe`**: TCP-listener probe replaces the HTTP-response probe, so a slow
+    Next dev cold compile no longer SIGTERMs the dev tree.
+  - **Single-runtime swap** in `runQueuedRebuild`: stops the old in-process runtime
+    before creating the new one, freeing ~1.5 GB during dev source-changes. Consumer
+    errors are now non-fatal — the gateway returns 503 and the dev session stays up
+    until the next save fixes the build.
+  - **Workspace-plugin watch is now opt-in** via `CODEMATION_DEV_WATCH_PLUGINS=true`.
+    By default `pnpm dev` no longer spawns `tsdown --watch` for each workspace plugin
+    (saves ~500 MB baseline + the rebuild-loop pressure). Plugins still load from
+    their existing `dist/` output; opt in only when actively editing a plugin's source.
+  - **`DevSourceWatcher`**: 75 ms → 750 ms debounce so a single `tsdown` rebuild collapses
+    into one runtime swap. Defense-in-depth ignore re-check at the event handler (chokidar
+    doesn't always re-evaluate `ignored` for files created post-start). 20 s startup grace
+    period to drop initial-build noise.
+  - **Workspace plugin watch root** narrowed from `dist/` to the plugin's entry file —
+    tsdown rewrites the entry once per real build, so one watch event per build instead of
+    a dozen.
+  - Removed `--conditions=development` from the Next-host's `NODE_OPTIONS`. Previously
+    this resolved `@codemation/{core,host}` to TypeScript source; combined with
+    `transpilePackages` it forced Turbopack to walk the full source tree on every
+    UI route compile.
+
+  **Architectural guard rails (no behavior change, prevent regressions)**
+  - ESLint `no-restricted-imports` blocks `@codemation/host-src/*` and root
+    `@codemation/host` from `next-host` UI; blocks `prisma-generated/*` outside host's
+    persistence layer.
+  - New **`dependency-cruiser`** config + `pnpm depcruise` script.
+  - New **`knip`** config + `pnpm lint:knip` script.
+  - New `tooling/scripts/check-circular-deps.mjs` + `pnpm lint:circular` wired into
+    `pnpm lint` with frozen baselines (core: 50, host: 21, core-nodes: 73).
+  - **`@next/bundle-analyzer`** wired up; `pnpm analyze` available for on-demand
+    inspection (uses `next experimental-analyze` for Turbopack-mode introspection).
+  - New `AGENTS.md` "Cross-package imports" section documenting the slim-subpath
+    discipline and the rationale for it.
+
+  The contract additions are strictly additive; no existing API surface changed shape.
+
+- [#112](https://github.com/MadeRelevant/codemation/pull/112) [`6fc7d3f`](https://github.com/MadeRelevant/codemation/commit/6fc7d3fe95f8d88386c16971fffa8dd3faa7704f) Thanks [@cblokland90](https://github.com/cblokland90)! - Surface workflow-planning errors in the node inspector instead of swallowing them as `[codemation-http] unhandled route error`. When `NodeInstanceFactory` fails to instantiate a node (e.g. tsyringe `TypeInfo not known` for a constructor param), the offending `nodeId` is preserved via a new `NodeInstantiationError`, and `RunStartService` now persists a failed run with the error attached to that node — same shape execution errors already use, so the UI shows `name`/`message`/`stack` in the node "output" panel.
+
+- [#100](https://github.com/MadeRelevant/codemation/pull/100) [`11616ae`](https://github.com/MadeRelevant/codemation/commit/11616aefb91d4b96b7eb9af4b935eec055a8a7bb) Thanks [@cblokland90](https://github.com/cblokland90)! - Workflow Testing UI polish and end-to-end correctness fixes.
+
+  **`@codemation/next-host`** — Tests UI
+  - Fix `Maximum update depth exceeded` on the Tests panel. The trends chart was receiving a
+    fresh `[]` reference per render (`?? []` inline) which made recharts' internal effects loop;
+    every `?? EMPTY_*` fallback the chart consumes is now a module-scoped stable reference.
+  - Fix the same loop class on the canvas-play-dropdown → Tests path. The auto-start `useEffect`
+    had `startMutation` (a react-query mutation result, unstable per render) in its deps array,
+    which re-fired the mutation on every render. Now uses a ref keyed on `autoStartTriggerNodeId`
+    with explicit reset when the prop clears.
+  - Fix the canvas inspector showing `{ "json": {...} }` for historical / test-suite child runs.
+    `WorkflowDetailPresenter.jsonValueToMainItems` was wrapping every array entry as
+    `{ json: <entry> }`, but trigger outputs are persisted **already-Item-shaped**, producing
+    `{json: {json: {...}}}`. Detects already-Item entries and passes them through.
+  - Surface assertion-rollup-corrected status on the executions list. New `RunSummary.testCaseStatus`
+    is preferred over engine `status` so a test-case run whose assertions failed shows as
+    **failed** instead of "completed" (engine status is unchanged — only the UI display).
+  - Tabs no longer overlap the test-cases detail panel — moved from absolute positioning to a flow
+    header in the Tests view.
+  - Filter strip above the case tree-table: All / Passing / Failing / Errored / In flight, with
+    live counts. Empty buckets are disabled so users can't filter into a confusing empty state.
+  - Collapse all / Expand all controls on the case tree-table; expansion state lifted from
+    per-row `useState` to the table so broadcasts work. Auto-open-on-failure heuristic still fires
+    per-row but only the first time each run id appears, so a row the user explicitly collapsed
+    stays collapsed when realtime updates stream in.
+  - Trend chart x-axis is now numeric `idx` with subsampled ticks (~5 evenly-spaced labels) and
+    time-aware formatting (`HH:MM` when all runs share a day, `M/D HH:MM` across days).
+  - Status icon expanded to cover the full case-status union (`succeeded` / `failed` / `errored` /
+    `cancelled` / `running` / `queued`) with distinct icons and colors.
+
+  **`@codemation/host`** — Testing framework correctness
+  - Fix `TestSuiteRunTracker` race that left the last test case stuck on `testCaseStatus="running"`
+    and the suite counters off by one. The bus dispatched events fire-and-forget; `finalize` ran
+    before in-flight handlers wrote their `updateTestCaseStatus` calls. Tracker now serializes
+    events through a `processingTail` chain and `finalize` awaits it before reading
+    `listChildRuns`.
+  - Initialize `Run.testCaseStatus` to `"running"` at row creation when `executionOptions.testContext`
+    is present. Previously the tracker's `persistCaseStarted` raced the engine inserting the row
+    and silently swallowed P2025 — the suite-detail page never showed a "running" transition.
+  - `TestSuiteChildRunDto` exposes the new `testCaseStatus?: TestCaseRunStatus` field; mapper
+    narrows the persistence string through a known-statuses guard.
+  - `PrismaWorkflowRunRepository.listRuns` threads `testCaseStatus` into `RunSummary` so the
+    executions list can render the corrected outcome.
+
+  **`@codemation/core`**
+  - `RunSummary` gains an optional `testCaseStatus?: TestCaseRunStatus`. Additive, non-breaking.
+
+  **Dev experience**
+  - `pnpm dev` (root) now runs `tsdown --watch` for `@codemation/host` alongside `test-dev` under
+    `concurrently`, so host source edits rebuild `dist/` automatically. Without this, host changes
+    were invisible to the running Next dev server (which deliberately resolves host from `dist/`
+    to keep Turbopack memory bounded on 8 GB WSL boxes), forcing a manual
+    `pnpm --filter @codemation/host build` after every host edit.
+
+  **Documentation**
+  - Top-level `docs/workflow-testing.md` and the `codemation-workflow-dsl` skill reference
+    rewritten for the score-based assertion model (`score: 0..1` + `passThreshold?` + `errored?`),
+    with examples for boolean assertions, continuous metrics, and judge-by-agent assertions.
+
+  **Tests**
+  - New HTTP-driven e2e suite (`packages/host/test/e2e/testSuiteRunHttpFlow.e2e.test.ts`) drives
+    the full real-orchestrator + real-Prisma + real-engine lifecycle through `POST` →
+    `GET /api/test-suite-runs/:id` → child runs → assertions, asserting the partial-suite
+    outcome with assertion-rollup downgrade.
+  - New unit tests cover the case-status filter engine, the historical-run double-wrap regression,
+    and the chart prop-stability regression class.
+
+## 1.0.1
+
+### Patch Changes
+
+- [`ed75183`](https://github.com/MadeRelevant/codemation/commit/ed75183f51ae71b06aa2e57ae4fc48ce9db2e4ce) - Establish "per Item per Call" identity end-to-end so the workflow run inspector reports, visualizes, and dashboards multi-item AI agents correctly.
+
+  Previously, an orchestrator agent that processed N items emitted one flat list of LLM rounds and tool calls — the bottom execution tree, the right-panel agent timeline, cost dashboards, and the realtime event stream all collapsed iterations into one bucket, making sub-agent fan-outs (and parallel item processing in general) unreadable.
+
+  **What changed**
+  - **Engine** (`@codemation/core`): `NodeExecutor` mints a `NodeIterationId` per item inside per-item runnable activations and stamps it (with `itemIndex`) onto `NodeExecutionContext`. Connection invocations, telemetry spans (`gen_ai.chat.completion`, `agent.tool.call`), metric points (`codemation.cost.estimated`, `codemation.agent.turns`, `codemation.agent.tool_calls`), and run events all carry the per-item identity. New `ChildExecutionScopeFactory` re-roots `NodeExecutionContext` for sub-agents so credentials and iteration ids resolve correctly across the orchestrator → tool → sub-agent boundary.
+  - **Sub-agent credentials** (`@codemation/core-nodes`): `NodeBackedToolRuntime.resolveNodeCtx` no longer re-wraps `args.ctx.nodeId` with `ConnectionNodeIdFactory.toolConnectionNodeId` — the caller already pre-wraps it. The previous double-nesting produced exponentially deep node ids (`AIAgentNode:2__conn__tool__conn__searchInMail__conn__tool__conn__searchInMail__conn__llm`) that didn't match user-bound credential slots. Sub-agent OpenAI / API-key slots resolve again.
+  - **Realtime events**: new `connectionInvocationStarted` / `connectionInvocationCompleted` / `connectionInvocationFailed` events carry the full `ConnectionInvocationRecord` (incl. `iterationId`, `itemIndex`, `parentInvocationId`) and surgical reducers update the run cache without waiting for a coarse `runSaved` snapshot. Run-query polling dropped from 250 ms → 5 s now that WebSocket events drive most updates.
+  - **Persistence** (`@codemation/host`): Prisma `ExecutionInstance` model gains `iteration_id`, `item_index`, `parent_invocation_id` columns + index (sqlite + postgres migrations); `PrismaWorkflowRunRepository` round-trips them on read/save and via `ExecutionInstanceDto`. Without this the cold reload of a finished run silently flattens the per-item tree because `runSaved` events stream through Prisma. Telemetry tables already carried these columns from Phase 4; both sides now agree.
+  - **Iteration projection / cost queries** (`@codemation/host`): new `RunIterationProjectionFactory` projects `RunIterationRecord`s from connection invocations + iteration cost metrics and `GetIterationCostQueryHandler` serves per-iteration cost rollups for dashboards.
+  - **Inspector view model** (`@codemation/next-host`): `NodeInspectorTelemetryPresenter` groups LLM and tool spans by `iterationId` into "Item N" accordion entries (single-item agents fall back to flat layout). New `FocusedInvocationModelFactory` powers item-level prev/next navigation when a specific invocation is selected — the breadcrumb shows "Item X of Y" and nav targets the first invocation of adjacent items. Tool spans now interleave chronologically with LLM rounds (request → tools → response) instead of LLM rounds first then orphan tools at the bottom.
+  - **Bottom execution tree** (`@codemation/next-host`): new `ExecutionTreeItemGroupInjector` injects synthetic "Item N" parent rows between an agent and its connection invocations when the agent processed 2+ items. Single-item activations are left untouched; sub-agent invocations whose `parentInvocationId` already points at a tool-call row stay nested under the orchestrator's specific tool call.
+  - **Sub-agent credential boundary**: `ChildExecutionScopeFactory.forSubAgent` ensures sub-agent `NodeExecutionContext` keeps the parent invocation id and span context intact so trace nesting and credential resolution agree on the connection-node id.
+  - **Tests**: new unit + UI suites for each layer (sub-agent scope, item-group injector, focused invocation model, agent timeline per-item grouping, chronological ordering, Prisma iterationId round trip, item-aware properties panel, connection-invocation event publisher) and a runnable `apps/test-dev` sample (`agentSubAgentToolFanout`) that exercises the orchestrator → sub-agent fan-out across 2 items end-to-end.
+
+## 1.0.0
+
+### Major Changes
+
+- [#93](https://github.com/MadeRelevant/codemation/pull/93) [`640e303`](https://github.com/MadeRelevant/codemation/commit/640e3032b1386568df725980a27761b6e230302c) Thanks [@cblokland90](https://github.com/cblokland90)! - Replace LangChain with the Vercel AI SDK for all AIAgent flows.
+
+  Codemation no longer depends on `@langchain/core` or `@langchain/openai`. Chat model providers, the turn loop, structured output, and tool calls now run on top of the Vercel **AI SDK** (`ai`, `@ai-sdk/openai`, `@ai-sdk/provider`). Custom Codemation behaviors that LangChain did not cover — the **tool-args repair loop**, the **structured-output repair loop**, **connection-invocation tracking**, and our **telemetry / cost-tracking spans** — are preserved and built on top of the new primitives.
+
+  ### Dependency changes
+  - **Removed**: `@langchain/core`, `@langchain/openai` (from `@codemation/core-nodes`).
+  - **Added**: `ai` `^6.0.168`, `@ai-sdk/openai` `^3.0.53`, `@ai-sdk/provider` `^3.0.8` (to `@codemation/core-nodes`). `@codemation/host` picks up `ai` + `@ai-sdk/provider` for its test harness only.
+
+  ### Public API renames (`@codemation/core`)
+
+  | Before                                               | After                                                                                                             |
+  | ---------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
+  | `LangChainChatModelLike`                             | `ChatLanguageModel`                                                                                               |
+  | `LangChainStructuredOutputModelLike`                 | _(removed — replaced by `StructuredOutputOptions` + `generateText({ experimental_output: Output.object(...) })`)_ |
+  | `ChatModelFactory.create` → `LangChainChatModelLike` | `ChatModelFactory.create` → `ChatLanguageModel` (thin wrapper around an AI SDK `LanguageModelV2`)                 |
+
+  `ChatLanguageModel` exposes the underlying AI SDK `LanguageModel` via `languageModel` plus `modelName`, `provider`, and optional `defaultCallOptions` (`maxOutputTokens`, `temperature`, `providerOptions`). `StructuredOutputOptions` mirrors `generateText({ output: Output.object(...) })` and carries an optional `schemaName` plus `strict` flag.
+
+  ### Custom behavior preserved (not delegated to the AI SDK)
+  - **Tool dispatch + tool-args repair**: tools are passed to `generateText` **without `execute`** so tool calls surface back to Codemation; `AgentToolExecutionCoordinator` still drives parallel execution, per-tool Zod-input validation, repair prompts, and retry accounting via `repairAttemptsByToolName`.
+  - **Structured output repair**: `AgentStructuredOutputRunner` still runs the `OpenAiStrictJsonSchemaFactory` + `AgentStructuredOutputRepairPromptFactory` loop; AI SDK's `Output.object(...)` is used only for the **first** structured attempt when the provider supports it.
+  - **Connection-invocation tracking**: `ConnectionInvocationIdFactory` + synthetic `LanguageModelConnectionNode` / tool connection node states (`queued` / `running` / `completed` / `failed`) are still emitted per turn and per tool call.
+  - **Telemetry span names (intentional, short-term)**: LLM calls stay on `gen_ai.chat.completion`, tool calls on `agent.tool.call`, metrics on `codemation.ai.turns` / `codemation.ai.tool_calls` / `codemation.cost.estimated`. We disable AI SDK's built-in telemetry (`experimental_telemetry`) for this cut so host-side telemetry aggregations keep working unchanged. Migrating to AI SDK native span names is intentionally deferred.
+  - **Engine-level retry control**: every `generateText` call uses `maxRetries: 0` so Codemation's own retry / repair policy is the single source of truth.
+
+  ### New test utilities
+
+  Tests that previously scripted `LangChainChatModelLike` now script AI SDK `LanguageModelV3` via `MockLanguageModelV3` from `ai/test`. `@codemation/core-nodes` and `@codemation/host` test files ship small adapters (`ScriptedResponseConverter`, `ScriptedDoGenerateFactory`, `TelemetryResponseConverter`) that translate Codemation's legacy `{ content, tool_calls, usage_metadata }` fixtures into `LanguageModelV3GenerateResult`.
+
+  ### Migration notes for consumers
+  - If you implemented a **custom `ChatModelFactory`**, return a `ChatLanguageModel` (wrap an AI SDK `LanguageModelV2`) instead of a LangChain-shaped chat model. The `name` / `modelName` / `provider` on your config still drive cost tracking.
+  - If you imported the type `LangChainChatModelLike` (or `LangChainStructuredOutputModelLike`) from `@codemation/core`, switch to `ChatLanguageModel` (and drop structured-output-method imports — `generateText({ experimental_output })` covers it).
+  - `OpenAIChatModelFactory` now builds an AI SDK OpenAI provider under the hood; behavior for end users (model presets, credential resolution, token accounting, structured output against strict mode) is unchanged.
+  - Telemetry dashboards, trace views, and cost-tracking queries continue to work against the existing Codemation span / metric names.
+
+### Patch Changes
+
+- [#93](https://github.com/MadeRelevant/codemation/pull/93) [`640e303`](https://github.com/MadeRelevant/codemation/commit/640e3032b1386568df725980a27761b6e230302c) Thanks [@cblokland90](https://github.com/cblokland90)! - Fix `Unique constraint failed on the fields: (instance_id)` crash when rerunning a workflow that contains an AI agent.
+
+  Reproduction: build `Manual trigger → AI agent → node → node`, click play on the agent, then click play on the next node (sometimes twice). The second run would fail at `PrismaWorkflowRunRepository.saveOnce` with a Postgres PK violation on the `ExecutionInstance` table.
+
+  Root cause: `RunStartService.createRunCurrentState` was deep-copying the prior run's `connectionInvocations` verbatim into the new run's initial state. Each record kept its original globally-unique `invocationId`, which is the primary key in `ExecutionInstance`. `saveOnce`'s existing-row lookup is scoped to the current `runId`, so the collision against the prior run's rows was only detected by Postgres when the insert fired.
+
+  Beyond the crash, the old behavior was also a data-model lie for compliance / OTEL: a `ConnectionInvocationRecord` represents a single auditable LLM / tool call and must belong to exactly one run. Copying it into another run made the same event appear to have happened twice.
+
+  Fix (domain + defense-in-depth):
+  - `@codemation/core` — `RunStartService.createRunCurrentState` now starts new runs with an empty invocation ledger. The prior run's invocations remain queryable on that run's persisted state (their true owner).
+  - `@codemation/host` — `PrismaWorkflowRunRepository.buildExecutionInstances` skips any invocation whose `runId` differs from the run being saved, so a stray carry-over from any other code path self-heals instead of crashing the save.
+
+  UI impact: none for the historical-run view (it reads invocations directly from the selected run). The client-side debugger overlay continues to surface the prior run's invocations locally during a rerun, and inspector telemetry already fetches against each invocation's original `runId`.
+
 ## 0.8.1
 
 ### Patch Changes

package/dist/{EngineRuntimeRegistration.types-BP6tsaNP.d.ts → EngineRuntimeRegistration.types-D1fyApMI.d.ts}

@@ -1,4 +1,4 @@
-import { Ar as WebhookTriggerRoutingDiagnostics, Or as WebhookTriggerMatcher, Pa as EngineExecutionLimitsPolicyConfig, ha as DependencyContainer, hn as WorkflowPolicyRuntimeDefaults, pr as TriggerRuntimeDiagnostics } from "./RunIntentService-BqhmdoA1.js";
+import { Mr as WebhookTriggerMatcher, Pr as WebhookTriggerRoutingDiagnostics, Ta as DependencyContainer, Wa as EngineExecutionLimitsPolicyConfig, _r as TriggerRuntimeDiagnostics, vn as WorkflowPolicyRuntimeDefaults } from "./RunIntentService-BE9CAkbf.js";
 
 //#region src/bootstrap/runtime/EngineRuntimeRegistration.types.d.ts
 
@@ -41,4 +41,4 @@ interface EngineRuntimeRegistrationOptions {
 }
 //#endregion
 export { TriggerRuntimeDiagnosticsProvider as n, WebhookTriggerMatcherProvider as r, EngineRuntimeRegistrationOptions as t };
-//# sourceMappingURL=EngineRuntimeRegistration.types-BP6tsaNP.d.ts.map
+//# sourceMappingURL=EngineRuntimeRegistration.types-D1fyApMI.d.ts.map

package/dist/{EngineWorkflowRunnerService-DzOCa1BW.d.cts → EngineRuntimeRegistration.types-pB3FnzqR.d.cts}

@@ -1,4 +1,4 @@
-import { E as NodeId, F as ParentExecutionRef, Ln as PersistedWorkflowSnapshot, Rn as PersistedWorkflowSnapshotNode, Si as EngineExecutionLimitsPolicyConfig, Y as WorkflowDefinition, b as NodeConfigBase, f as Items, gn as WebhookTriggerMatcher, qn as RunResult, r as Engine, ri as DependencyContainer, rt as WorkflowPolicyRuntimeDefaults, sn as WorkflowRepository, tn as TriggerRuntimeDiagnostics, tt as WorkflowId, vn as WebhookTriggerRoutingDiagnostics, zn as PersistedWorkflowTokenRegistryLike } from "./RunIntentService-S-1lW-gS.cjs";
+import { Br as PersistedWorkflowTokenRegistryLike, Fi as NodeId, G as WorkflowDefinition, Jr as RunResult, M as ParentExecutionRef, Q as WorkflowPolicyRuntimeDefaults, Ri as WorkflowId, Rr as PersistedWorkflowSnapshot, Zt as TriggerRuntimeDiagnostics, ai as DependencyContainer, d as Items, fn as WebhookTriggerMatcher, mn as WebhookTriggerRoutingDiagnostics, r as Engine, rn as WorkflowRepository, wi as EngineExecutionLimitsPolicyConfig, y as NodeConfigBase, zr as PersistedWorkflowSnapshotNode } from "./RunIntentService-siBSjaaY.cjs";
 
 //#region src/workflowSnapshots/WorkflowSnapshotCodec.d.ts
 declare class WorkflowSnapshotCodec {
@@ -18,6 +18,20 @@ declare class WorkflowSnapshotCodec {
   private asRecord;
 }
 //#endregion
+//#region src/runtime/EngineWorkflowRunnerService.d.ts
+declare class EngineWorkflowRunnerService {
+  private readonly engine;
+  private readonly workflowRepository;
+  constructor(engine: Engine, workflowRepository: WorkflowRepository);
+  runById(args: {
+    workflowId: WorkflowId;
+    startAt?: NodeId;
+    items: Items;
+    parent?: ParentExecutionRef;
+  }): Promise<RunResult>;
+  private findDefaultStartNodeId;
+}
+//#endregion
 //#region src/bootstrap/runtime/EngineRuntimeRegistration.types.d.ts
 /**
  * Creates the webhook route matcher used by {@link import("../api/Engine").Engine}.
@@ -57,19 +71,5 @@ interface EngineRuntimeRegistrationOptions {
   workflowPolicyRuntimeDefaults?: WorkflowPolicyRuntimeDefaults;
 }
 //#endregion
-//#region src/runtime/EngineWorkflowRunnerService.d.ts
-declare class EngineWorkflowRunnerService {
-  private readonly engine;
-  private readonly workflowRepository;
-  constructor(engine: Engine, workflowRepository: WorkflowRepository);
-  runById(args: {
-    workflowId: WorkflowId;
-    startAt?: NodeId;
-    items: Items;
-    parent?: ParentExecutionRef;
-  }): Promise<RunResult>;
-  private findDefaultStartNodeId;
-}
-//#endregion
-export { WorkflowSnapshotCodec as a, WebhookTriggerMatcherProvider as i, EngineRuntimeRegistrationOptions as n, TriggerRuntimeDiagnosticsProvider as r, EngineWorkflowRunnerService as t };
-//# sourceMappingURL=EngineWorkflowRunnerService-DzOCa1BW.d.cts.map
+export { WorkflowSnapshotCodec as a, EngineWorkflowRunnerService as i, TriggerRuntimeDiagnosticsProvider as n, WebhookTriggerMatcherProvider as r, EngineRuntimeRegistrationOptions as t };
+//# sourceMappingURL=EngineRuntimeRegistration.types-pB3FnzqR.d.cts.map

package/dist/{InMemoryRunDataFactory-1iz7_SnO.d.cts → InMemoryRunDataFactory-Xw7v4-sj.d.cts}

@@ -1,4 +1,4 @@
-import { A as NodeOutputs, At as ExecutionContext, B as RunId, Bt as NodeBinaryAttachmentService, Ct as BinaryStorageStatResult, Dr as CostTrackingTelemetryFactory, E as NodeId, F as ParentExecutionRef, Gt as NodeExecutionStatePublisher, H as RunnableNodeConfig, I as PersistedRunPolicySnapshot, Jr as CredentialSessionService, R as RunDataFactory, St as BinaryStorageReadResult, Tt as BinaryStorageWriteResult, Vt as NodeExecutionContext, a as BinaryAttachment, bt as BinaryBody, jt as ExecutionContextFactory, kr as CostTrackingUsageRecord, kt as ExecutionBinaryService, rr as ExecutionTelemetryFactory, tt as WorkflowId, u as Item, v as MutableRunData, vt as RetryPolicySpec, xt as BinaryStorage, y as NodeActivationId, z as RunDataSnapshot } from "./RunIntentService-S-1lW-gS.cjs";
+import { $r as RunTestContext, Bt as NodeExecutionStatePublisher, Et as ExecutionContextFactory, F as RunDataSnapshot, Fi as NodeId, Ft as NodeBinaryAttachmentService, Hn as CostTrackingTelemetryFactory, I as RunId, It as NodeExecutionContext, Kn as CollectionsContext, M as ParentExecutionRef, N as PersistedRunPolicySnapshot, O as NodeOutputs, P as RunDataFactory, R as RunnableNodeConfig, Ri as WorkflowId, Tt as ExecutionContext, Wn as CostTrackingUsageRecord, _ as MutableRunData, _t as BinaryStorageReadResult, a as BinaryAttachment, bt as BinaryStorageWriteResult, dr as CredentialSessionService, gt as BinaryStorage, ht as BinaryBody, l as Item, pt as RetryPolicySpec, v as NodeActivationId, vn as ExecutionTelemetryFactory, vt as BinaryStorageStatResult, wt as ExecutionBinaryService } from "./RunIntentService-siBSjaaY.cjs";
 
 //#region src/contracts/CostCatalogContract.d.ts
 interface CostCatalogEntry {
@@ -22,6 +22,31 @@ declare class CredentialResolverFactory {
   create(workflowId: WorkflowId, nodeId: NodeId, config?: NodeExecutionContext["config"]): NodeExecutionContext["getCredential"];
 }
 //#endregion
+//#region src/binaries/UnavailableBinaryStorage.d.ts
+declare class UnavailableBinaryStorage implements BinaryStorage {
+  readonly driverName = "unavailable";
+  write(): Promise<never>;
+  openReadStream(): Promise<undefined>;
+  stat(): Promise<{
+    exists: false;
+  }>;
+  delete(): Promise<void>;
+}
+//#endregion
+//#region src/binaries/DefaultExecutionBinaryServiceFactory.d.ts
+declare class DefaultExecutionBinaryService implements ExecutionBinaryService {
+  private readonly storage;
+  private readonly workflowId;
+  private readonly runId;
+  private readonly now;
+  constructor(storage: BinaryStorage, workflowId: WorkflowId, runId: RunId, now: () => Date);
+  forNode(args: {
+    nodeId: NodeId;
+    activationId: NodeActivationId;
+  }): NodeBinaryAttachmentService;
+  openReadStream(attachment: BinaryAttachment): Promise<BinaryStorageReadResult | undefined>;
+}
+//#endregion
 //#region src/execution/asyncSleeper.types.d.ts
 interface AsyncSleeper {
   sleep(ms: number): Promise<void>;
@@ -38,8 +63,9 @@ declare class DefaultExecutionContextFactory implements ExecutionContextFactory
   private readonly telemetryFactory;
   private readonly costTrackingFactory;
   private readonly currentDate;
+  private readonly collections?;
   private readonly telemetryDecoratorFactory;
-  constructor(binaryStorage?: BinaryStorage, telemetryFactory?: ExecutionTelemetryFactory, costTrackingFactory?: CostTrackingTelemetryFactory, currentDate?: () => Date);
+  constructor(binaryStorage?: BinaryStorage, telemetryFactory?: ExecutionTelemetryFactory, costTrackingFactory?: CostTrackingTelemetryFactory, currentDate?: () => Date, collections?: CollectionsContext | undefined);
   create(args: {
     runId: RunId;
     workflowId: WorkflowId;
@@ -52,6 +78,7 @@ declare class DefaultExecutionContextFactory implements ExecutionContextFactory
     nodeState?: NodeExecutionStatePublisher;
     telemetry?: ExecutionContext["telemetry"];
     getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
+    testContext?: RunTestContext;
   }): ExecutionContext;
 }
 //#endregion
@@ -84,31 +111,6 @@ declare class RunnableOutputBehaviorResolver {
   private isKeepBinariesEnabled;
 }
 //#endregion
-//#region src/binaries/UnavailableBinaryStorage.d.ts
-declare class UnavailableBinaryStorage implements BinaryStorage {
-  readonly driverName = "unavailable";
-  write(): Promise<never>;
-  openReadStream(): Promise<undefined>;
-  stat(): Promise<{
-    exists: false;
-  }>;
-  delete(): Promise<void>;
-}
-//#endregion
-//#region src/binaries/DefaultExecutionBinaryServiceFactory.d.ts
-declare class DefaultExecutionBinaryService implements ExecutionBinaryService {
-  private readonly storage;
-  private readonly workflowId;
-  private readonly runId;
-  private readonly now;
-  constructor(storage: BinaryStorage, workflowId: WorkflowId, runId: RunId, now: () => Date);
-  forNode(args: {
-    nodeId: NodeId;
-    activationId: NodeActivationId;
-  }): NodeBinaryAttachmentService;
-  openReadStream(attachment: BinaryAttachment): Promise<BinaryStorageReadResult | undefined>;
-}
-//#endregion
 //#region src/runStorage/InMemoryBinaryStorageRegistry.d.ts
 declare class InMemoryBinaryStorage implements BinaryStorage {
   readonly driverName = "memory";
@@ -127,5 +129,5 @@ declare class InMemoryRunDataFactory implements RunDataFactory {
   create(initial?: Record<NodeId, NodeOutputs>): MutableRunData;
 }
 //#endregion
-export { RunnableOutputBehavior as a, InProcessRetryRunner as c, AsyncSleeper as d, CredentialResolverFactory as f, UnavailableBinaryStorage as i, DefaultExecutionContextFactory as l, CostCatalogEntry as m, InMemoryBinaryStorage as n, RunnableOutputBehaviorResolver as o, CostCatalog as p, DefaultExecutionBinaryService as r, ItemExprResolver as s, InMemoryRunDataFactory as t, DefaultAsyncSleeper as u };
-//# sourceMappingURL=InMemoryRunDataFactory-1iz7_SnO.d.cts.map
+export { ItemExprResolver as a, DefaultAsyncSleeper as c, UnavailableBinaryStorage as d, CredentialResolverFactory as f, RunnableOutputBehaviorResolver as i, AsyncSleeper as l, CostCatalogEntry as m, InMemoryBinaryStorage as n, InProcessRetryRunner as o, CostCatalog as p, RunnableOutputBehavior as r, DefaultExecutionContextFactory as s, InMemoryRunDataFactory as t, DefaultExecutionBinaryService as u };
+//# sourceMappingURL=InMemoryRunDataFactory-Xw7v4-sj.d.cts.map

package/dist/InMemoryRunEventBusRegistry-VM3OWnHo.cjs

@@ -0,0 +1,47 @@
+
+//#region src/events/InMemoryRunEventSubscription.ts
+var InMemoryRunEventSubscription = class {
+	constructor(onClose) {
+		this.onClose = onClose;
+	}
+	async close() {
+		this.onClose();
+	}
+};
+
+//#endregion
+//#region src/events/InMemoryRunEventBusRegistry.ts
+var InMemoryRunEventBus = class {
+	globalListeners = /* @__PURE__ */ new Set();
+	listenersByWorkflowId = /* @__PURE__ */ new Map();
+	async publish(event) {
+		for (const listener of this.globalListeners) listener(event);
+		for (const listener of this.listenersByWorkflowId.get(event.workflowId) ?? []) listener(event);
+	}
+	async subscribe(onEvent) {
+		this.globalListeners.add(onEvent);
+		return new InMemoryRunEventSubscription(() => {
+			this.globalListeners.delete(onEvent);
+		});
+	}
+	async subscribeToWorkflow(workflowId, onEvent) {
+		const existing = this.listenersByWorkflowId.get(workflowId) ?? /* @__PURE__ */ new Set();
+		existing.add(onEvent);
+		this.listenersByWorkflowId.set(workflowId, existing);
+		return new InMemoryRunEventSubscription(() => {
+			const listeners = this.listenersByWorkflowId.get(workflowId);
+			if (!listeners) return;
+			listeners.delete(onEvent);
+			if (listeners.size === 0) this.listenersByWorkflowId.delete(workflowId);
+		});
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'InMemoryRunEventBus', {
+  enumerable: true,
+  get: function () {
+    return InMemoryRunEventBus;
+  }
+});
+//# sourceMappingURL=InMemoryRunEventBusRegistry-VM3OWnHo.cjs.map