Skip to content

Commit 1431994

Browse files
authored
💥 Add expansion identity and pinned-commit workflow runs (#341)
* 📝 Document workflow-run architecture * 💥 Replace invocation() with getExpansion() and derive expansion identity ## Motivation Durable workflow effects (#291) and workflow-owned worktrees (#293) need a deterministic identity for one logical evaluation of an authored element. Nothing in the engine could supply one: the only run-scoped identifier was the `BlockCounter`, which advances with however much has already run and so moves under retry and under a branch that did or did not execute. `invocation()` already answered the other half of the question — the authored name and where it was written — but only for function components, and only as a Component Api operation any middleware could intercept, while four families of durable record name are derived from it. ## Approach `getExpansion()` replaces `invocation()` with no alias, and covers Markdown component expansions as well. It answers with `{ id, name, position? }`. `id` is derived from the root document and the structural path that reached the element. Each step contributes a frame — root document, authored element, loop iteration, each item, projection — and the path is threaded explicitly as the digest so far, so extending it costs one hash. An element is placed by its own source path and offset rather than by an index into the list being expanded, which is what makes the derivation independent of how much ran before it. `Expansion` is delivered as a plain context value. An Effection context is identified by its name, and two descriptors built with the same name address the same context — the portability mechanism that lets a second instance of core read what the engine published, which is what a repository `.ts` component importing core from disk is while the compiled binary carries its own copy. A first attempt branded the value with a private class field; every Deno check stayed green while the compiled binary failed 2 of 10 documents. Every produced location string is unchanged, so `elicit:`, `prompt:`, `test:`, `testing:` and the web-form record names are byte-identical and existing journals still replay. ## Verification Tier XP (17 tests) discriminates each claim by the derivation it would kill, including two concurrent projections of one slot keeping their identifiers when completion order reverses, a projection operation constructed but never interpreted consuming no ordinal, and a context descriptor built elsewhere reading the engine's expansion — which moves the compiled-binary-only break into the fast suite. `deno task lint`, `check`, `test` (352), `check:jsr`, `tsc --project tsconfig.node.json`, `bun run test:bun` (2342), `deno task build` with the compiled-binary smoke over `packages/core/src`, and `git diff --check` are all green. * ✨ Add @executablemd/workflow with pinned-commit workflow runs ## Motivation A workflow run needs one starting repository state chosen once, so a branch that moves afterwards cannot change what a recorded run started from, and so durable records and effects have an explicit identity to hang on. ## Approach `useWorkflow({ base })` installs middleware and nothing else — installing it creates no run; executing a document under it does. The run is installed in the scope that owns the document execution, so it is unreadable before `execute()`, readable by every descendant of the expansion and by output emitted after the durable run, and gone once that execution ends. Two middlewares, because a journal has three states. Live: `Execution.document` allocates the run id, resolves `${base}^{commit}` through `Git.revParse()`, and records one immutable value before the root is imported. Truncated: a `ReplayGuard` check restores the value and the durable operation still runs so the cursor advances past its own entry. Completed: `durableRun` returns the recorded root result without invoking the workflow at all, so the check phase — which runs before that shortcut — is the only place a completed journal can restore its run, or refuse a base that disagrees with the recorded one before the result reaches the caller. Divergence detection compares only an entry's type and name, so the supplied base is checked against the stored value rather than against the entry's identity. The journal is parsed, never trusted: a malformed record is described, never quoted. `Git.revParse()` is a contextual capability whose default runs `git rev-parse --verify --end-of-options <revision>` as an argument array in the contextual working directory. Core never imports workflow or Git. ## Verification Tiers WR (14) and GT (4). Three mutations show the tests discriminate: removing the ReplayGuard fails only the three completed-journal tests; dropping the base comparison fails only the refusal test; and replacing the live run-id allocation with a throw reddens live initialization while the two hand-seeded replay tests stay green — the evidence that replay allocates no identifier and invokes no Git, with no test seam in production code. `deno task lint`, `check`, `test` (363), `check:jsr`, `tsc --project tsconfig.node.json`, `pnpm test:node` (2402 of 2403 — the one failure is `config-api.test.ts`, which reproduces identically on origin/main under local Node 26), `bun run test:bun` (2402), `deno task build` with the compiled-binary smoke, and `git diff --check` are green. * ♻️ Derive an element's expansion through one helper The markdown and function component paths computed the same path and snapshot from the same four values, under the same three-line comment. `enterElement()` carries the derivation and the reason once, so the two call sites say only which element they are. * 🐛 Give every recursing element its own frame, and drop the inert root frame ## Motivation Review of #341 reproduced a real collision: two positionless `<If>` elements, each holding a positionless `<Probe />` at child index 0, produced one identifier. `<If>`, `<Capture>`, `<PrintErrors>` and `<Answers>` recursed on the unchanged parent path, and only ordinary components contributed a frame — so the `@index` fallback separated siblings in one list but not children at the same local index under different parents. ## Approach The element frame is now derived once, in the dispatch arm, for every element — structural construct and component alike — and every recursion boundary carries it. `<Loop>` and `<Each>` iteration frames extend that element path rather than re-encoding the site, and a claimed `<Content />` anchors on its own element path, which already descends from the invocation whose body holds it. The root document's frame is removed. A mutation showed it inert: with `rootPath = ""` every test still passed, because every element in a root's body carries that document's path in its own source position. Root identity therefore enters through positions, which XP19 pins, and an untestable frame is not kept for reassurance. ## Verification XP18 covers the collision and is red without the structural-parent frame. XP19, XP20 and XP21 drive `execute()` — two root documents differ, one root reproduces its identifiers, and a truncated replay derives the ones already recorded — the boundaries the `expandSegments`-driven cases could not reach. WR15 pins that expansion identifiers do not move with the workflow run, WR16 that cancelling an execution does not erase a recorded run, and WR17 that a descriptor of the same name built elsewhere reads the run. The specification claimed "nothing intercepts what durable identities are derived from" and that a same-named context is "refused rather than answered". Both were false once the instance-local brand came out. `getExpansion()` and `getWorkflowRun()` are now described as portable contextual observations that a descendant may rebind — composition boundaries, not authority boundaries — and the Tier XP rows say what the tests actually prove. * 🐛 Give <Else> its own frame `<Else>` is consumed by `ifStructure()` and never reaches expansion's dispatch, so it contributed no frame: both arms of one `<If>` expanded under the same path, and a positionless probe in each arm received one identifier. `ifStructure()` now carries the element and where it sat, and the false arm expands beneath its frame. XP22 covers it and asserts each arm reproduces its own identifier. This is the first of the consumed-parent category review found; `<Answer>`, `<Output>` and body chunking are not yet repaired. * 🐛 Frame every consumed structural parent, and keep chunked indices `<Output>` is consumed by `buildBody()` and `<Answer>` by `<Answers>`, so neither reached expansion's dispatch and neither contributed a frame. Body chunking compounded it: a documentation chunk is one segment, so every positionless element in one arrived as index 0. `buildBody()` now carries each chunk's path and where it started in the body, `expandSegments()` takes that index base, and `<Answer>` template children expand beneath their own element's frame while the region's body expands beneath its own. `expandValueBody()` chunks the same way and passes the same base. Per review, no index base is threaded through `execute.ts`: a root body always comes from `parseMarkdownDefinition()`, which scans with a path origin, so no supported path supplies positionless root segments. WR16 no longer races a timer. The component signals through `withResolvers()` once it has observed the recorded run, and the test cancels only after that. Specification and comments drop "composition boundary" and "authority boundary", which #340 owns and main does not yet register; they state the same fact in plain language until #341 rebases onto #340. * ✅ Pin the chunk and <Output> identity boundaries XP24 and XP25 cover the two consumed boundaries a hand-built fixture can reach: positionless elements in different documentation chunks, and an `<Output>` region's first child against the documentation segment at the same index. Both also assert repeatability. Mutations: dropping the chunk index base reddens XP24; dropping the `<Output>` frame reddens both. `<Answer>` expands beneath its own element's frame, but no test proves it — a hand-built region needs a parseable template per answer and the fixture kept collapsing to one matcher. Recorded in the test file and the PR description rather than left implicit. Specification and comments now use #340's registered vocabulary, which merged into main ahead of this rebase. * ✅ Prove the <Answer> identity boundary XP23 builds a positionless `<Answers>` region with two positionless `<Answer>` children, each holding a positionless component that records its expansion and renders the text its answer parses from. Both run, their identifiers differ, and repeating the expansion reproduces both. The fixture needed two things the earlier attempt lacked: a template child that returns valid text, since an empty template is refused and the region stops at the first answer, and a `value` prop that is JSON, since a bare word fails to parse. Neither is about identity, which is why the boundary looked untestable. Removing the frame `readAnswer()` passes makes XP23 fail — checked with an explicit match assertion, after a silent no-match replace made an earlier mutation run report a false negative. --------- Co-authored-by: Taras Mankovski <[email protected]>
1 parent 3689623 commit 1431994

36 files changed

Lines changed: 2854 additions & 214 deletions

‎.github/workflows/publish-packages.yml‎

Lines changed: 8 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@ jobs:
3030
- name: Validate the manifests declare this version
3131
run: |
3232
VERSION="${{ steps.resolve.outputs.value }}"
33-
for f in packages/durable-streams/deno.json packages/runtime/deno.json packages/core/deno.json packages/acp/deno.json packages/testing/deno.json packages/test-agent/deno.json packages/web/deno.json packages/cli/deno.json packages/code-review-agent/deno.json; do
33+
for f in packages/durable-streams/deno.json packages/runtime/deno.json packages/core/deno.json packages/acp/deno.json packages/testing/deno.json packages/test-agent/deno.json packages/web/deno.json packages/cli/deno.json packages/code-review-agent/deno.json packages/workflow/deno.json; do
3434
declared="$(jq -r .version "$f")"
3535
if [ "$declared" != "$VERSION" ]; then
3636
echo "::error::$f declares $declared, not $VERSION — the tag does not match the manifests"
@@ -124,6 +124,13 @@ jobs:
124124
package: packages/code-review-agent
125125
version: ${{ needs.version.outputs.value }}
126126

127+
workflow:
128+
needs: [version, core, durable-streams, runtime]
129+
uses: ./.github/workflows/publish-one.yml
130+
with:
131+
package: packages/workflow
132+
version: ${{ needs.version.outputs.value }}
133+
127134
jsr:
128135
needs: [version]
129136
runs-on: ubuntu-latest

‎architecture.md‎

Lines changed: 152 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -18,12 +18,21 @@ Existing documents and code get aligned to this section retroactively.
1818
| Term | Meaning |
1919
| --- | --- |
2020
| behavioral predictability | a plan as a program: ~80% deterministic, ~20% probabilistic |
21-
| replay determinism | the journal doesn't lose the execution chain: replaying arrives at the same state, where execution can resume |
21+
| replay determinism | the journal doesn't lose the execution chain: replaying arrives at the same state, where execution can continue |
22+
| replay | using the durable journal to restore the recorded portion of a document execution without repeating durable effects; after the recorded entries are consumed, execution may continue live |
2223
| divergence | reserved for replay: a replay that departs from the recorded journal |
2324
| middleware | applied by the lexical structure, used by runtime execution |
25+
| workflow run | a workflow being carried out with its progress and outcome recorded durably; document executions perform its work, while ongoing effects remain scoped to the document execution in which they run |
26+
| document execution | one evaluation of a root document initiated through `execute()`, producing one output stream and one completion result while reading and appending a durable journal; its ongoing effects belong to the Effection scope in which the evaluation runs |
27+
| run ID | an opaque stable identifier assigned to a workflow run; it associates the run's durable records and effects, remains unchanged for the life of the run, and supports equality only |
28+
| base | the Git revision supplied to choose a workflow run's starting repository state |
29+
| pinned commit | the commit obtained by resolving a base once; it remains the workflow run's starting repository state even as the run creates descendant commits |
30+
| expansion | one logical evaluation of an authored executable element within a document execution |
31+
| expansion ID | a deterministic identifier for one logical expansion; restoring or retrying that expansion preserves the ID, while a distinct evaluation requested by the document receives another |
32+
| Git capability | the contextual interface through which workflow infrastructure queries the Git repository associated with the current working directory |
2433
| printed error | an error printed into the document (`ErrorSegment`); data, not control flow |
2534
| failure | an error that propagates (`ComponentFailure`, `DocumentationError`) |
26-
| error mode | what an undecided error in a region becomes: `print` (printed into the document), `output` (fails the run; `<PrintErrors>` can print instead), `throw` (fails the run) |
35+
| error mode | what an undecided error in a region becomes: `print` (printed into the document), `output` (fails the document execution; `<PrintErrors>` can print instead), `throw` (fails the document execution) |
2736
| attempt | one execution of a retried operation or region |
2837
| raise | where an error no middleware converted is decided: printed or failed, per the error mode; observed exactly once, where raised |
2938
| blocker | execution needs input (auth, a human answer); not a failure |
@@ -42,7 +51,108 @@ Determinism is two properties:
4251
program where ~80% is deterministic and ~20% is probabilistic.
4352
- **Replay determinism** — the journal doesn't lose the execution chain:
4453
replaying the journal arrives at the same state, where execution can
45-
resume.
54+
continue.
55+
56+
## Workflow runs
57+
58+
Core retains one document-execution entry point: `execute()`. A host that needs
59+
workflow-run metadata installs `useWorkflow({ base })` in the child scope that
60+
owns one document execution. The installation applies ordinary
61+
`Execution.document` middleware, so the durable journal is active before the
62+
workflow run is created or restored and before the root document is imported.
63+
A later document execution, including one that continues the same workflow
64+
run, gets a new child scope and a new middleware installation. Workflow
65+
metadata is durable; the middleware and every ongoing effect remain
66+
scope-owned.
67+
68+
Installing the middleware alone creates no workflow run. On the first live
69+
document execution, the first durable operation installed by the middleware
70+
allocates an opaque run ID using cryptographic randomness, resolves the supplied
71+
base to a commit, and durably records one value:
72+
73+
```ts
74+
interface WorkflowRun {
75+
readonly runId: string;
76+
readonly base: string;
77+
readonly pinnedCommit: string;
78+
}
79+
```
80+
81+
The workflow run exists once that value is durably recorded. A document failure
82+
or cancellation after that point does not erase it. Failure before that point
83+
creates no workflow run and the root document does not expand.
84+
85+
Base resolution goes through the contextual Git capability:
86+
87+
```ts
88+
interface GitApi {
89+
revParse(revision: string): Operation<string>;
90+
}
91+
```
92+
93+
`Git.revParse(revision)` has the semantics of
94+
`git rev-parse --verify --end-of-options <revision>` in the contextual working
95+
directory. Its default provider invokes the Git CLI; another provider may
96+
replace it lexically. Workflow initialization calls it with
97+
`${base}^{commit}`, which verifies that the result is a commit and returns its
98+
full object ID. Starting a workflow run fails before root expansion when Git
99+
cannot be invoked, the working directory is not a Git repository, or the base
100+
does not resolve to a commit. Ordinary `execute()` remains Git-independent.
101+
102+
Replay restores the recorded `WorkflowRun` without allocating another run ID
103+
or invoking Git. The supplied base must equal the recorded base. Git is not
104+
consulted to compare the current value of a moving branch with the pinned
105+
commit.
106+
107+
`getWorkflowRun()` returns the frozen `WorkflowRun` for the current document
108+
execution. Every call in one live execution returns the same object. It throws
109+
outside a document execution associated with `useWorkflow()`, and it exposes no
110+
journal, Git, workspace or continuation capability. Replay preserves the field
111+
values, not JavaScript object identity.
112+
113+
The `@executablemd/workflow` package owns `WorkflowRun`, `useWorkflow()`,
114+
`getWorkflowRun()` and the Git capability. It depends on `@executablemd/core`,
115+
`@executablemd/durable-streams` and `@executablemd/runtime`, whose contextual
116+
`exec()` and `cwd()` the Git provider invokes; core never imports workflow or
117+
Git. The CLI adds the `xmd workflow run` and `xmd workflow continue` lifecycle
118+
together with the durable lookup that continuation requires. Ordinary `xmd run`
119+
remains unchanged.
120+
121+
## Expansion identity
122+
123+
Core describes the executable element currently being expanded:
124+
125+
```ts
126+
interface Expansion {
127+
readonly id: string;
128+
readonly name: string;
129+
readonly position?: Readonly<SourcePosition>;
130+
}
131+
```
132+
133+
`getExpansion()` returns the same frozen snapshot throughout one live
134+
expansion. `name` is the authored tag name, independent of which repository,
135+
registered or built-in component resolves it. `position` is the opening tag's
136+
source position, including its workspace-relative path when known; dynamically
137+
rendered markup may have no position. A nested expansion temporarily replaces
138+
the contextual expansion and returning restores the enclosing one. Calling the
139+
operation outside an executable element expansion throws. The snapshot exposes
140+
no props, bindings, projected content, selected component definition or live
141+
scope.
142+
143+
An expansion ID is derived from the root document and structural expansion
144+
path. It uses no process-global counter, time, randomness or scheduling order.
145+
Replay, continuation, retry attempts and restoration of the same loop
146+
iteration preserve it. Different authored elements, loop iterations,
147+
projections, component expansions and root documents receive different IDs.
148+
The ID is opaque and supports equality only. Two workflow runs may contain the
149+
same expansion ID; a durable effect that needs workflow-wide identity uses the
150+
run ID and expansion ID together. Replay preserves the snapshot's fields, not
151+
JavaScript object identity.
152+
153+
`Expansion` and `getExpansion()` belong to `@executablemd/core`, so ordinary
154+
document execution receives expansion identity without installing workflow
155+
middleware.
46156

47157
## Two layers
48158

@@ -73,7 +183,8 @@ network directly.
73183
An error, once decided, is one of two things:
74184

75185
- **printed error** — printed into the document; data
76-
- **failure** — propagates until middleware handles it or the run fails
186+
- **failure** — propagates until middleware handles it or the document
187+
execution fails
77188

78189
### 1. Middleware wraps the work
79190

@@ -107,14 +218,14 @@ An error no middleware handles is decided exactly once, where it is raised,
107218
by the region's error mode — and the two outcomes move differently:
108219

109220
- A failure propagates by throwing up the scope tree, tearing down as it
110-
goes, until middleware handles it or the run fails.
221+
goes, until middleware handles it or the document execution fails.
111222
- A printed error does not propagate. It is printed into the document — data.
112223

113224
A decision is final in both directions: nothing turns a printed error back
114-
into a failure, and nothing resumes past a stop — re-executing a whole region
115-
as a new attempt is not a resume. Reacting is allowed: anything that can see
116-
a printed error may raise a new failure in response, decided once at its own
117-
raise point.
225+
into a failure, and execution does not continue past a stop — re-executing a
226+
whole region starts a new attempt. Reacting is allowed: anything that can see a
227+
printed error may raise a new failure in response, decided once at its own raise
228+
point.
118229

119230
### 3. Error mode is lexical
120231

@@ -124,9 +235,9 @@ layers).
124235

125236
| Mode | An undecided error… | Installed by |
126237
| --- | --- | --- |
127-
| `print` | is printed; the run continues | the root; `<PrintErrors>`; `printErrors(fn)` |
128-
| `output` | fails the run; `<PrintErrors>` can print instead | every `<Output>` region |
129-
| `throw` | fails the run, even inside `<PrintErrors>` | documentation; value roots |
238+
| `print` | is printed; the document execution continues | the root; `<PrintErrors>`; `printErrors(fn)` |
239+
| `output` | fails the document execution; `<PrintErrors>` can print instead | every `<Output>` region |
240+
| `throw` | fails the document execution, even inside `<PrintErrors>` | documentation; value roots |
130241

131242
Projections carry the caller's error mode; they never set their own.
132243

@@ -136,8 +247,8 @@ The nearest `<PrintErrors>` or `printErrors(fn)` turns a propagating
136247
failure into exactly one printed error whose `cause` is the complete original
137248
failure, and sets `print` for its region. `printErrors(fn)` is keyed to the
138249
exact function object — nothing is shared by name. Inside documentation a
139-
failure still ends the run — a hidden region gives the author nothing to
140-
read.
250+
failure still ends the document execution — a hidden region gives the author
251+
nothing to read.
141252

142253
### 5. Raise decides by value
143254

@@ -160,25 +271,25 @@ before any raise. Private buffers never merge into document output.
160271

161272
### 7. A blocker is not a failure
162273

163-
A run waiting for input — auth, a human answer, days if needed — has not
164-
failed. Suspension is a durable effect: the journal records up to the wait,
165-
the process may terminate, restart arrives back at the same wait. An error
166-
that reveals a blocker (an expired login) reaches suspension through
167-
middleware; waiting itself is never raised.
274+
A workflow run waiting for input — auth, a human answer, days if needed — has
275+
not failed. Suspension is a durable effect: the journal records up to the wait,
276+
the process may terminate, and a later document execution arrives back at the
277+
same wait. An error that reveals a blocker (an expired login) reaches suspension
278+
through middleware; waiting itself is never raised.
168279

169280
### 8. Durability failures are outside the model
170281

171-
A durability failure (§6.11) says the journal no longer describes the run. No
172-
middleware sees it; it is never the document's own outcome.
282+
A durability failure (§6.11) says the journal no longer describes the document
283+
execution. No middleware sees it; it is never the document's own outcome.
173284

174285
## Attempts
175286

176287
- The journal records every attempt in full; replay restores the outcome
177288
without re-executing.
178289
- Rendered output shows the winning attempt plus a brief summary of failed
179290
ones; verbose rendering expands the detail.
180-
- On final failure, the last attempt's partial output renders, then the run
181-
fails.
291+
- On final failure, the last attempt's partial output renders, then the document
292+
execution fails.
182293

183294
## Partial output
184295

@@ -190,20 +301,23 @@ middleware sees it; it is never the document's own outcome.
190301

191302
## Outcomes and the journal
192303

193-
- A run that fails is still a complete record: replaying it restores the
194-
output and the failure without re-executing anything. Only a durability
195-
failure means the journal no longer describes the run.
196-
- Object identity never crosses the journal: a live run reports the failure
197-
it caught; a replay reports what the record describes. The journal is
198-
parsed, never trusted — an unreadable record is refused, not coerced.
304+
- A document execution that fails is still a complete record: replaying it
305+
restores the output and the failure without re-executing anything. Only a
306+
durability failure means the journal no longer describes the document
307+
execution.
308+
- Object identity never crosses the journal: a live document execution reports
309+
the failure it caught; a replay reports what the record describes. The
310+
journal is parsed, never trusted — an unreadable record is refused, not
311+
coerced.
199312

200313
## State ownership
201314

202315
All state is scoped to the operation that owns it, so it is torn down when
203-
the operation is torn down: created inside the run it describes, provided via
204-
context. No module-scoped registries — not as collections, not hidden inside
205-
library objects that accumulate. One exception: metadata an author declares
206-
at module evaluation, about a value the author owns, may live on that value.
316+
the operation is torn down: created inside the operation it describes,
317+
provided via context. No module-scoped registries — not as collections, not
318+
hidden inside library objects that accumulate. One exception: metadata an
319+
author declares at module evaluation, about a value the author owns, may live
320+
on that value.
207321

208322
## State across loaded copies
209323

@@ -244,7 +358,11 @@ Status is measured against main.
244358
| Construct | Does | Status |
245359
| --- | --- | --- |
246360
| `<PrintErrors>` / `printErrors(fn)` | prints failures | built on main |
247-
| `<Output>` region `output` mode | an undecided error fails the run | built on main |
361+
| `<Output>` region `output` mode | an undecided error fails the document execution | built on main |
362+
| `Expansion` / `getExpansion()` | describes the current logical element expansion | built on main |
363+
| `useWorkflow()` / `getWorkflowRun()` | associates one document execution with a workflow run | built on main |
364+
| `Git.revParse()` | verifies and resolves one Git revision expression contextually | built on main |
365+
| `xmd workflow run` / `xmd workflow continue` | starts or continues a workflow run from the CLI | defined, unbuilt; ships with durable lookup |
248366
| `<Retry max timeout>` | retry a region until it completes | defined, unbuilt |
249367
| suspension effect | suspend durably | defined, unbuilt |
250368
| `<Result as>` | binds `{ok: true, value}` or `{ok: false, error}`; a failure becomes a bound value, not a raise | defined, unbuilt |

‎bun.lock‎

Lines changed: 14 additions & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎deno.lock‎

Lines changed: 8 additions & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎package.json‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -59,6 +59,7 @@
5959
"@executablemd/test-agent": "workspace:*",
6060
"@executablemd/test-support": "workspace:*",
6161
"@executablemd/testing": "workspace:*",
62+
"@executablemd/workflow": "workspace:*",
6263
"@types/node": "^22.0.0",
6364
"expect": "^30.0.0",
6465
"oxfmt": "^0.41.0",

‎packages/core/mod.ts‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,6 @@ export type {
2525
ReturnsSchema,
2626
ComponentDefinition,
2727
ComponentFailure,
28-
ComponentInvocationMetadata,
2928
ComponentOrigin,
3029
PartialContent,
3130
ComponentRegistry,
@@ -61,7 +60,6 @@ export {
6160
persistent,
6261
content,
6362
retain,
64-
invocation,
6563
tryContent,
6664
hasCapture,
6765
capture,
@@ -97,6 +95,8 @@ export type { NameKind, SchemaVisitor } from "./src/schema-walk.ts";
9795

9896
export { hasContent, useContent } from "./src/content-context.ts";
9997
export { ContentError } from "./src/errors.ts";
98+
export { getExpansion } from "./src/expansion.ts";
99+
export type { Expansion } from "./src/expansion.ts";
100100
export { InvocationTeardownError, withInvocation } from "./src/invocation.ts";
101101
export type { Invocation } from "./src/invocation.ts";
102102
export { Sample } from "./src/sample-api.ts";

0 commit comments

Comments
 (0)