https://studnicky.github.io/Dagonizer/ Dagonizer is a TypeScript framework for orchestrating work as a directed acyclic graph of typed nodes — type-safe routing, abortable execution, deterministic resume, deep-DAG composition, per-node retry policies, JSON-LD canonical wire format, FSM-driven lifecycle, and pluggable visualization. No external runtime required. en-US https://studnicky.github.io/Dagonizer/#0.9.2 https://studnicky.github.io/Dagonizer/changelog/0.9.2 Wed, 20 May 2026 12:00:00 GMT https://studnicky.github.io/Dagonizer/#0.9.1 https://studnicky.github.io/Dagonizer/changelog/0.9.1 Wed, 20 May 2026 12:00:00 GMT ` with a password input, reveal toggle, link to the key page, and a set/not-set status chip. Desktop-only chip on `gemini-nano` and `web-llm` rows when `isMobile` is true. ⦿ Stub adapter is now surfaced on mobile as the zero-setup fallback; the mobile banner makes the canned-vs-real LLM distinction explicit so visitors know what they're seeing until a key is entered. ⦿ 18-book sci-fi / philosophy seed library (`SeedLibrary`) auto-loaded into `urn:dagonizer:memory` on mount. The Memory tab has content from first paint; stub responses cite real titles from the seed graph; `reset()` restores the seed alongside the ontology TBox. ### Changed ⦿ `ProviderId` union extended: `'groq' | 'cerebras' | 'mistral' | 'openrouter'` added. ⦿ `BROWSER_VISIBLE` list extended to include the four new cloud providers. ⦿ `DetectionInputs.apiKeys` replaces the previous single `apiKey?: string`. All callers updated. ⦿ `pickBestBackend(backends, options?)` gains an optional `{ isMobile: boolean }` second argument. Mobile suppresses `gemini-nano` and `web-llm` from ranking. Priority order: groq → cerebras → gemini-api → mistral → openrouter → gemini-nano → web-llm → stub. ⦿ `hasNoRunnableModel` forwards `isMobile` option to `pickBestBackend`. ⦿ `instantiateProvider` extended to construct all four new adapters; throws `LlmError` (AUTH_FAILED) for missing keys, and handles the exhaustive `never` case. ⦿ `BackendPicker` emits `update:apiKeys` (full map) instead of `update:apiKey` (single string). `ArchivistRunner` updated accordingly. ⦿ Archivist docs (`docs/examples/the-archivist.md`) Backends section enumerates all eight backends with mobile detection behavior documented.]]> https://studnicky.github.io/Dagonizer/#0.9.0 https://studnicky.github.io/Dagonizer/changelog/0.9.0 Wed, 20 May 2026 12:00:00 GMT ` — compile-time type utility exported from `NodeInterface`. Resolves to `true` when `B`'s `hardRequired` set is fully satisfied by `A`'s `produces` set, `never` otherwise. Most useful with `as const` literal-tuple contracts. ⦿ Exports: `OperationContractFragment` and `Chainable` added to `@noocodex/dagonizer/contracts`, `@noocodex/dagonizer/types`, and the root barrel. `ContractRegistryValidator` exported from `@noocodex/dagonizer/derive`. ⦿ `DAGBuilder.build(onContractWarning?)` runs dangling-read / dead-write contract validation when any node placement registered via `.node()` or `.fanOut()` carries a `contract` field on its `NodeInterface`. Dangling reads throw `DAGError`; dead writes call the optional `onContractWarning` callback (no-op when omitted). Matches the validation `DAGDeriver` runs at derive time — drift fails at build time, before the DAG is registered. ⦿ `DAGBuilder.fromNodes({ name, version, entrypoint, nodes, annotations? })` — static convenience method that delegates to `DAGDeriver.derive({ nodes })` for the linear-topology common case. Produces the same canonical `DAG` document as the equivalent `.node()` chain, without requiring manual placement. Throws `DAGError` when no node carries a `contract` field (matches deriver behavior). ### Changed ⦿ `DAGDeriverOptions.contracts` is now optional (was required). The standalone `contracts` path is unchanged and fully backward-compatible. ⦿ `DAGDeriverOptions`: `contracts` and `nodes` are mutually exclusive — supplying both throws `DAGError`. Supplying neither throws `DAGError`. ⦿ `Dagonizer.registerDAG` runs a third validation pass (contract validation) after the existing schema and semantic passes, for DAGs whose nodes carry co-located contracts. ⦿ Docs updated: `docs/reference/contracts.md` introduces `OperationContractFragment` and the co-located pattern; `docs/guide/derive.md` adds "Co-located contracts" and "Catching contract drift" sections; `docs/reference/dagonizer.md` documents the third validation pass and `onContractWarning` hook.]]> https://studnicky.github.io/Dagonizer/#0.8.4 https://studnicky.github.io/Dagonizer/changelog/0.8.4 Wed, 20 May 2026 12:00:00 GMT ` and displays inbound triples rather than showing "No triples mention this IRI." ### Added ⦿ Archivist demo: `PanesTabs` exposes a `#tab-suffix` named slot rendered at the right edge of the tab row with `margin-left: auto`. The right-column `PanesTabs` uses it to host a compact persistence toggle button (replaces the "Memory store" section in the Config tab). ⦿ Archivist demo: D-pad pan on `MemoryGraph`. The four directional buttons shift all point positions by 250 world-units via `getPointPositions`/`setPointPositions(next, true)` and call `render(0)`, providing manual pan without a native cosmos.gl API. ⦿ Archivist demo: drag-and-throw physics on `MemoryGraph` via `enableDrag: true` in the cosmos.gl config. ⦿ Archivist demo: `humanLabel` helper in `MemoryGraph`. Run IRIs render as "Run <6-char prefix>"; book IRIs look up `dag:title` and fall back to "Book "; `xsd:dateTime` literals render as `HH:MM:SS` only; `dag:` vocabulary terms show only the local name. ### Changed ⦿ Archivist demo: starter-query, greeting, and visitor-reply LLM prompts bias toward science fiction and philosophy (Liu Cixin, Gibson, Le Guin, Lem, Ted Chiang, Borges, Camus, Foucault, Deleuze, Wittgenstein) instead of generic world literature. Static fallback pool updated to match. ⦿ Archivist demo: `MemoryGraph` emits a structured `MemorySelection` union on node click (`{ kind: 'iri'; iri } | { kind: 'literal'; value }`) instead of a raw IRI string. `ArchivistRunner` tracks `selectedSelection: Ref` and passes it to `TripleInspector`. ⦿ `package.json` keywords gain LLM / agent-orchestration and semantic-web terms (`agent-framework`, `llm-orchestration`, `ai-agent`, `tool-use`, `function-calling`, `rag`, `sparql`, `n3`, `ontology`, `owl`, `named-graphs`, `provenance`, `prov-o`, `task-graph`) for npm discoverability. GitHub repository topics seeded with a matching 20-topic subset.]]> https://studnicky.github.io/Dagonizer/#0.8.3 https://studnicky.github.io/Dagonizer/changelog/0.8.3 Wed, 20 May 2026 12:00:00 GMT https://studnicky.github.io/Dagonizer/#0.8.2 https://studnicky.github.io/Dagonizer/changelog/0.8.2 Wed, 20 May 2026 12:00:00 GMT .fanInOperation` as if it were universally present — pre-dated the v0.8.0 discriminated union. Rewrote to scope to `strategy === 'custom'` and added the full validation invariants the deriver enforces (terminal/partition/parallel-membership/placement-kind mismatch). ⦿ `docs/examples/05-deepflows.md` only showed the imperative `DAGBuilder.deepDAG(...)` composition path. Added a "Composing the same flow via `DAGDeriver.subDAGs`" section with a worked example and a cross-link to `examples/derive.ts` so the declarative path is discoverable from the deep-DAG composition page.]]> https://studnicky.github.io/Dagonizer/#0.8.1 https://studnicky.github.io/Dagonizer/changelog/0.8.1 Tue, 19 May 2026 12:00:00 GMT https://studnicky.github.io/Dagonizer/#0.8.0 https://studnicky.github.io/Dagonizer/changelog/0.8.0 Tue, 19 May 2026 12:00:00 GMT `), and `'append'` (with `target: statePath`) — each carrying its strategy-specific required fields. The top-level `node: string` field is required (registered node invoked per item). Existing fan-out annotations fail at `tsc` with "Property 'strategy' is missing" until updated. ### Added ⦿ **`DAGDeriverFanOut.strategy: 'partition' | 'append'`** alongside `'custom'`. DAGDeriver can now emit fan-out placements with any of the three fan-in strategies the engine supports — closes the long-standing "DAGDeriver forces 'custom'" gap. Partition keys are validated against `outcomes` at derive time; out-of-band keys throw `DAGError`. ⦿ **`DAGDeriverAnnotations.parallels`** — explicit `ParallelNode` grouping with chosen combine strategy. Without it, same-topological-depth operations auto-group with `combine: 'collect'` as before. With it, the named group forces members into one `ParallelNode` with `combine: 'all-success' | 'any-success' | 'collect'`. Membership is exclusive across groups; members can't also appear in `fanouts` or `subDAGs`. Validated at derive time. ⦿ **`docs/guide/authoring.md`** — top-level framing doc that establishes the positioning publicly. The DAG JSON-LD object is the API; DAGBuilder and DAGDeriver are two authoring journeys. DAGBuilder is for *deterministic workflows you control end-to-end* (ETL, transformation chains, fixed sequences). DAGDeriver is for *agentic flows where reaching the final state matters more than authoring the order* (tool-driven agents, exploratory pipelines, contract-registries). Includes decision matrix, capability matrix, and explicit documentation of the two patterns that are imperative-only (recursive trampoline, runtime-conditional topology). ### Changed ⦿ `guide/builder.md` and `guide/derive.md` open with the deterministic-vs-agentic positioning and cross-link to `guide/authoring.md`. `examples/02-builder.ts` and `examples/derive.ts` JSDoc headers reframe each as the canonical surface for its respective mental model. ⦿ DAGDeriver capability parity with DAGBuilder at the static-topology level. Both authoring journeys can now express every DAG the schema allows: any placement kind, any fan-in strategy, any combine strategy, multi-port routing, sub-DAG composition, explicit or auto-derived parallel grouping. The two surfaces remain shape-different deliberately — DAGBuilder's chain narrows route types at compile time; DAGDeriver's flat registry derives topology from the data graph. Imperative-only patterns (recursive trampoline via `services.dispatcher.execute`, runtime-conditional topology) live in node bodies regardless of authoring journey.]]> https://studnicky.github.io/Dagonizer/#0.7.0 https://studnicky.github.io/Dagonizer/changelog/0.7.0 Tue, 19 May 2026 12:00:00 GMT >; readonly output?: Readonly> }; readonly outputs: readonly string[]; } ``` Closes the last legitimate `DAGBuilder` use-case outside cycle-bounded loops: plugin dispatch, phase composition, and runtime-resolved child flows can now derive cleanly from contracts. ### Changed ⦿ `FlowDeriver.renderNodes` resolves output maps for both `SingleNode` and `DeepDAGNode` placements through one helper. Every port in `subDAG.outputs` auto-wires to the next derived stage; `FlowAnnotations.terminals` overrides individual ports; a terminal whose `outcome` doesn't appear in `subDAG.outputs` throws `DAGError` at derive time with the same fail-fast semantics as `contract.outputs`. An operation appearing in both `fanouts` and `subDAGs` throws — placement kind must be unambiguous.]]> https://studnicky.github.io/Dagonizer/#0.6.0 https://studnicky.github.io/Dagonizer/changelog/0.6.0 Tue, 19 May 2026 12:00:00 GMT ` second generic + `DagonizerOptionsInterface` documented; `NodeInterface.timeoutMs` listed in operations table; `NodeContextInterface.services` added; `SchedulerProvider` / `SchedulerHandle` interfaces rewritten to the actual `after`/`at`/`every`/`cancelAll` shape (the old `scheduleAt`/`scheduleAfter`/`scheduleEvery` API never existed); `Clock.hrtime()` corrected to reference `performance.now()` not `process.hrtime.bigint()`; entity discriminators corrected from `type: 'single'` to `'@type': 'SingleNode'` etc.; `NodeTimeoutError` added to the error hierarchy; `Execution` clarified as a class (value import) not type-only; `viz.md` documents the previously-undocumented `JsonLdRenderer`, `CytoscapeRenderer`, `DAGONIZER_VOCAB`, and associated types. ⦿ `Composing Dagonizer with other runtimes` section in `concepts.md` replaces the prior `vs alternatives` framing. Each pairing (Temporal, XState, BullMQ) describes the integration pattern — Temporal Activities wrap Dagonizer DAGs, XState transitions invoke `dispatcher.execute()`, BullMQ jobs hydrate state and dispatch — rather than telling readers to use a different tool. ⦿ Mermaid diagrams render labels contained inside their rects. Root causes fixed: font-size and font-weight overrides removed from CSS so mermaid's measurement matches the rendered glyph metrics; font stack pinned to system monospace (`SF Mono, ui-monospace, Menlo, Consolas`) to eliminate the JetBrains Mono web-font-load measurement race; `white-space: nowrap` on `.edgeLabel` / `.nodeLabel` foreignObjects + paragraph margin/line-height reset inside foreignObjects so VitePress's prose styles don't bleed in; `useMaxWidth: false` + SVG `max-width: 100%` so wide LR diagrams scale down to fit the column without scaling tall TB diagrams to viewport-tall; `wrappingWidth` raised to 220; state diagrams enable `htmlLabels: true` so state name rects size to fit (no more `pending` → `pendin` truncation); `--mermaid-state-stroke` realigned with `--dagonizer-brand` (cyan) instead of brand2 (violet) so state diagrams match flowchart styling. ⦿ Cytoscape DAG canvas unified with the mermaid theme. Pearl-black node interior (`#020306`), cyan border (`#22e8ff`), pearl text (`#eef3f7`), monospace font, 14px labels, `curve-style: taxi` for angled segments matching mermaid's `linear` curve, navy-panel edge label background. Compound parents (`node:parent`) use the cluster steel-on-deepest-navy palette. State styling (`dag-active` / `dag-completed` / `dag-errored`) keeps the dark interior and shifts the border color so one active node pops without flooding the viewport. Canvas surface uses the canonical `--dagonizer-surface-bg-deep` + grain texture so the cytoscape viewport and the mermaid SVG frames read as the same panel family. ⦿ Bullet lists render with alternating ⦿ (cyan) / ⦾ (gold) glyph markers via `.vp-doc ul > li::before`. Nested lists use `▸`. Ordered lists keep numeric markers in cyan mono. 6 paragraph-prefixed pseudo-bullet sections in `concepts.md` rewritten as proper markdown bullet lists so the canonical styling applies. ⦿ Canonical surface treatment unified across all boxed elements. CSS variables `--dagonizer-surface-{radius,border,bg,bg-deep,grain,grain-size,pad}` drive feature cards, code blocks, mermaid frames, blockquotes, tables, and `.custom-block` (tip/info/warning/danger/details) so they read as one family. Code blocks and mermaid frames use the deep `pearl-black` surface; tables, blockquotes, feature cards use the `bg-alt` navy. ⦿ Navbar architecture refactored to use VitePress CSS-variable shadowing instead of `!important` overrides. `.VPNav` paints the surface (VitePress's scoped CSS hard-codes `.VPNavBar` to `transparent` at ≥960px); `--vp-sidebar-width: 0px` and `--vp-layout-max-width: 100%` shadowed inside `.VPNavBar` neutralize the sidebar-reservation padding without per-element overrides. `.VPNav.VPNav { width: 100vw; z-index: 1000; }` selector-specificity beats VitePress's scoped `[data-v-…]` (0,1,1) without `!important`; spans the scrollbar gutter and outranks any positioned `.VPContent` descendant that could bleed through. Page scrollbar styled (`scrollbar-color: pewter on --vp-c-bg-alt`) so the gutter matches the navbar surface. Net effect: ~13 navbar `!important`s removed; remaining `!important`s are all legitimate mermaid SVG inline-style overrides. ### Fixed ⦿ `the-archivist.md` referenced non-existent `toJsonLd` / `fromJsonLd` exports — replaced with the real `Dagonizer.serialize` / `Dagonizer.load` API. ⦿ `getting-started.md` minimal example now constructs a canonical JSON-LD DAG with `@context`, `@id`, `@type: 'DAG'`, and `'@type': 'SingleNode'` on the placement, matching `DAGSchema`. The prior `type: 'single'` shape was schema-invalid. ⦿ `concepts.md` referenced non-existent `registerFlow` — corrected to `registerDAG`. ⦿ `guide/cancellation.md` + `guide/observability.md` used the non-existent `context.flowName` field — corrected to `context.dagName`. ⦿ `guide/builder.md` showed a `deepDAG` example with `error: null` routing, which `registerDAG` rejects (null-targeted DeepDAGNode outputs throw). Updated to route through a finalize placement. ⦿ `guide/schema.md` imported `sharedAjv` from `./validation` — that's an internal export not on the barrel. Replaced with the real `Validator` sub-validator API (`is`, `validate`, `errors`). ⦿ All 8 phase examples confirmed to exit 0 under `npx tsx`. Phase 02 had inverted URL-length comments in the inline annotation table; corrected.]]> https://studnicky.github.io/Dagonizer/#0.5.0 https://studnicky.github.io/Dagonizer/changelog/0.5.0 Mon, 18 May 2026 12:00:00 GMT ` option drives full-fidelity expansion of nested DAGs into compound parents (no opaque shortcut nodes). Cycle-safe via `visited` set and `maxDepth` (default 6). ⦿ Archivist demo: full multi-source fan-out per intent. Five intent branches (`lookup-author`, `find-reviews`, `describe-book`, `recommend-similar`, `on-topic`) each fan out across `openLibraryScout` + `googleBooksScout` + `wikipediaScout` via `parallel` placements with `combine: 'collect'`. Results merge through `CanonicalId.dedupe` (ISBN-13 → ISBN-10 → `urn:work: https://studnicky.github.io/Dagonizer/#0.4.0 https://studnicky.github.io/Dagonizer/changelog/0.4.0 Fri, 15 May 2026 12:00:00 GMT https://studnicky.github.io/Dagonizer/#0.4.0 https://studnicky.github.io/Dagonizer/changelog/0.4.0 Thu, 14 May 2026 12:00:00 GMT /.ts`) with a `*Schema` const and a `FromSchema`-derived type. New domains: `node/`, `execution/`, `validation/`, `errors/`, `constants/`, `runtime/`. ⦿ Node domain: `Node`, `NodeContext`, `NodeError`, `NodeWarning`, `NodeOutput`, `NodeResult`, `NodeStateData` ⦿ Execution domain: `ExecutionResult` ⦿ Validation domain: `ValidationResult` ⦿ Errors domain: `DAGErrorJSON` (the `toJSON()` wire shape) ⦿ Constants domain: `FanInStrategy`, `FanOutOutput`, `MetadataKey`, `Output`, `ParallelCombine`, `NodeType` — each with a JSON Schema enum, a `FromSchema`-derived union type, and a const object namespace satisfying that type ⦿ Runtime domain: `BackoffStrategy` (migrated from `runtime/RetryPolicy.ts` to `entities/runtime/BackoffStrategy.ts`) ⦿ **Interface refactors.** Interfaces in `src/types/` that hold data now extend or re-export their corresponding entity types: ⦿ `NodeOutputInterface` extends `Omit` and narrows both fields ⦿ `NodeInterface` extends `Omit` and narrows `outputs` ⦿ `NodeContextInterface` extends `NodeContext` and adds `signal: AbortSignal` ⦿ `NodeErrorInterface` extends `Omit` and narrows `context` ⦿ `NodeWarningInterface` = `NodeWarning` (type alias) ⦿ `ValidationResultInterface` = `ValidationResult` (type alias) ⦿ `ExecutionResultInterface` extends `Omit` and narrows `state` ⦿ `NodeResultInterface` extends `Omit` and narrows `state` ⦿ `DAGErrorJSONInterface` = `DAGErrorJSON` (type alias) ⦿ `FlowConfigInterface` = `FlowConfig`, `FanInConfigInterface` = `FanInConfig`, `FanOutNodeInterface` = `FanOutNode`, `ParallelNodeInterface` = `ParallelNode`, `SubFlowNodeInterface` = `SubFlowNode`, `SingleNodeInterface` extends `Omit` and narrows `outputs` ⦿ `NodeStateData` entity documents the persistence wire shape for `NodeStateBase.snapshot()` without `NodeStateInterface` extending it (the `lifecycle.error` field carries an in-memory `Error`, not JSON-expressible) ⦿ `entities/index.ts` barrel updated — all new schema constants and derived types are exported, grouped by domain. ⦿ `src/index.ts` re-exports constants (`FanInStrategy`, `FanOutOutput`, `MetadataKey`, `Output`, `ParallelCombine`, `NodeType`) from `entities/index.js` instead of the now-removed `constants.ts`. ### Removed ⦿ `FlowLoader` class (`src/validation/FlowLoader.ts`) — superseded by `Dagonizer.load` / `Dagonizer.fromValue`. ⦿ `FlowSerializer` class (`src/validation/FlowSerializer.ts`) — superseded by `Dagonizer.serialize` / `Dagonizer.serializeCompact`. ⦿ `src/constants.ts` — all constants migrated to `entities/constants/` with JSON Schema backing. ⦿ **Single execution path.** `Dagonizer.execute()` and `Dagonizer.resume()` now both return an `Execution` that is both async-iterable (yields each node as it completes) and `PromiseLike` (awaits the final summary). One generator body — sync-style is just iteration that consumes every node before resolving. Iteration and `await` on the same execution share the same underlying generator; the flow body runs exactly once. ⦿ `Dagonizer.resume(flowName, state, fromNode, options?)` — continues a flow from a given node. Caller rehydrates `state` first (typically via `Checkpoint.restore`). ⦿ `cursor: string | null` field on `ExecutionResultInterface` — the next node to run on abort, or `null` on clean completion. ⦿ `NodeStateBase.snapshot()` — serialize state to a `JsonObject` (metadata + errors + warnings, lifecycle excluded). Subclasses override `snapshotData()` to include domain fields. ⦿ `NodeStateBase.restore(snapshot)` — static factory rehydrating a state instance with fresh `pending` lifecycle. Subclasses override `restoreData()` to read their fields. ⦿ `CheckpointData` entity (`entities/checkpoint/CheckpointData.ts`) — schema + `FromSchema`-derived type. Schema fields: `version`, `flowName`, `cursor`, `state`, `executedNodes`, `skippedNodes`. `CHECKPOINT_DATA_VERSION` = `'1'`. ⦿ `CheckpointDataValidator` (`schema/CheckpointDataValidator.ts`) — pre-compiled Ajv validator. Shares the `sharedAjv` 2020-12 instance with `FlowConfigValidator`. ⦿ `Checkpoint` (`checkpoint/Checkpoint.ts`) — `from(flowName, result)` builds a `CheckpointData`; `restore(data, restoreFn)` parses + validates + rehydrates via a state-factory callback; `toJson(checkpoint)` for serialization. ⦿ `JsonValue` / `JsonObject` / `JsonArray` / `JsonPrimitive` types at `entities/json.ts`. ⦿ New subpath export: `@noocodex/dagonizer/checkpoint`. ⦿ Example `08-checkpoint.ts` — abort, persist as JSON, parse back, resume. ⦿ 8 new unit tests covering snapshot/restore round-trip (base + subclass), cursor population on abort vs clean completion, full abort → snapshot → restore → resume cycle using `VirtualClock` / `VirtualScheduler` for deterministic time, schema rejection of malformed checkpoints. ### Changed ⦿ **`execute()` and `resume()` no longer throw on abort, deadline, or node error.** They return an `Execution` that resolves to an `ExecutionResultInterface` with `cursor` set and the state's lifecycle marked (`cancelled` / `failed` / `timed_out`). One result shape, never a thrown exception except for genuinely fatal validation errors at registration time. Catch-and-inspect is replaced with await-and-inspect. ⦿ **`executeIterative()` is removed.** `execute()` is the canonical method for both streaming and sync-style consumption. `for await (const node of dispatcher.execute(...))` replaces every prior `executeIterative` call site. ⦿ v0.2 tests that asserted `assert.rejects` on cancellation / timeout / unwired-output flows now assert on the returned `ExecutionResult.cursor` and `state.lifecycle.kind`. ⦿ Sub-flow execution internally uses the canonical `runStages` generator instead of the removed `executeIterative` method. ### Breaking ⦿ `executeIterative(flowName, state, options?)` → use `execute(flowName, state, options?)` and iterate the returned `Execution`. Identical streaming semantics. ⦿ `execute()` return type changes from `Promise` to `Execution`. `await dispatcher.execute(...)` still works because `Execution` is `PromiseLike` — most call sites need no change. ⦿ Aborted / failed / timed-out runs no longer reject. The result's `cursor` and the state's `lifecycle.kind` indicate what happened. Code that did `await assert.rejects(execute(...))` must move to `const result = await execute(...); assert.equal(result.state.lifecycle.kind, 'cancelled')`. ⦿ `ExecutionResultInterface` gains a required `cursor: string | null` field.]]> https://studnicky.github.io/Dagonizer/#0.3.0 https://studnicky.github.io/Dagonizer/changelog/0.3.0 Tue, 12 May 2026 12:00:00 GMT Schema` constant + `FromSchema` derived type. Layout: ⦿ `entities/flow/` — `FlowConfig`, `SingleNode`, `ParallelNode`, `FanOutNode`, `SubFlowNode`, `FanInConfig` ⦿ `entities/state-machines/` — `DAGLifecycleState` (wire shape; in-memory `Error` type still lives at `lifecycle/`) ⦿ `FlowConfigSchema` — JSON Schema draft-2020-12 with `$id` `https://noocodex.dev/schemas/dagonizer/FlowConfig`. Inlines node-entry sub-shapes via `oneOf`; standalone sub-shape schemas remain exported for per-shape validation. ⦿ `FlowConfigValidator` — pre-compiled Ajv validator (`Ajv2020`, `allErrors: true`). `is(value)` predicate, `validate(value)` throwing `ValidationError`, `errors(value)` returning a formatted list. ⦿ `FlowLoader.fromJson(text)` / `fromValue(value)` — single permitted ingest boundary where `unknown` enters the package. JSON.parse → Ajv-narrow → `FlowConfig`. ⦿ `FlowSerializer.toJson(flow)` / `toCompactJson(flow)` — symmetric counterpart for the round-trip. ⦿ `Dagonizer.registerFlow()` now runs the schema validator as a structural pre-pass before semantic validation. Schema errors surface as `ValidationError`; semantic errors (unknown nodes, missing outputs, sub-flow cycles) continue to surface as `DAGError`. ⦿ New subpath exports: `@noocodex/dagonizer/schema`, `@noocodex/dagonizer/entities`. ⦿ Example `07-schema.ts` — load + validate + execute + round-trip a JSON flow. ⦿ 12 new unit tests covering Ajv success/failure paths, FlowLoader malformed-JSON handling, round-trip equality, and the `ValidationError` vs `DAGError` boundary. ### Changed ⦿ Added runtime deps: `ajv` (^8.20.0) and `json-schema-to-ts` (^3.1.1). No Zod. ### Schema entity pattern Each entity file follows the swap-friendly pattern: ```ts import type { FromSchema } from 'json-schema-to-ts'; export const FooSchema = { '$id': '...', ... } as const; export type Foo = FromSchema; ``` The schema bodies and `$id`s are stable. Type derivation can be migrated to a future schema-registry package without changing entity definitions.]]> https://studnicky.github.io/Dagonizer/#0.2.0 https://studnicky.github.io/Dagonizer/changelog/0.2.0 Tue, 12 May 2026 12:00:00 GMT ` and `SingleNodeInterface` parameterize the output union. `outputs: Record` is exhaustiveness-checked at compile time when the node declares a narrow union. ⦿ `FlowBuilder` (in `builder/`): chainable authoring of `FlowConfig`. `node()`, `parallel()`, `fanOut()`, `subFlow()`, `entrypoint()`, `build()`. ⦿ New subpath exports: `@noocodex/dagonizer/runtime`, `@noocodex/dagonizer/builder`. ⦿ Examples 01–06 runnable via `tsx`: linear chain, fan-out + partition, sub-flows, cancellation + deadline, RetryPolicy, FlowBuilder. ⦿ 32 new unit tests covering runtime, retry, cancellation, hooks, builder, fan-in strategies (partition / custom), fan-out concurrency cap, and `NodeStateBase.clone` semantics. ### Changed ⦿ **Canonical instantiation is `new`, not factories.** `Dagonizer.create()` and `FlowBuilder.create(name, version)` are removed. Use `new Dagonizer()` and `new FlowBuilder(name, version)`. Single path, supports subclassing directly. ⦿ `Dagonizer` constructor is `public` to support subclass-based observability. ⦿ Nodes are registered widened: internal storage is `NodeInterface` while `registerNode` accepts any narrower `TOutput`. Narrow → wide is sound covariantly on both `outputs` and result `output`. ⦿ Lifecycle FSM (`DAGLifecycleMachine`) now reads time via `Clock.now()` instead of `Date.now()` inline. ### Breaking ⦿ `Dagonizer.create()` → `new Dagonizer()`. ⦿ `FlowBuilder.create(name, version)` → `new FlowBuilder(name, version)` (FlowBuilder itself is new in 0.2.0). ⦿ `NodeInterface.execute(state)` → `execute(state, ctx)`. The second arg is required by the type, optional in practice (existing single-arg implementations still work because the extra param is ignored at runtime).]]> https://studnicky.github.io/Dagonizer/#0.1.0 https://studnicky.github.io/Dagonizer/changelog/0.1.0 Tue, 12 May 2026 12:00:00 GMT