Add a Swift runtime for Prompty

[sethjuarez]

Adds a Swift implementation of the Prompty runtime. There was no Swift runtime in this repo before; nothing existing changes behaviour.

The Rust runtime is the behavioural reference throughout, and both are held to the same cross-runtime vectors in spec/vectors.

Important

Status: complete and green on the pinned @typra/emitter@0.4.2. Merge is gated on an upstream emitter release.

The runtime is finished and passes on Linux, macOS and Windows: 77 tests, 0 failures, including live provider E2E. Generated model files are never hand-edited; a scripted post-generation repair shim (schema/scripts/patch-swift-emitter-defects.mjs) stands in for unfixed emitter defects and must be deleted before this is considered done.

Six published emitter releases were probed and rejected, two of them prepared as commits and then deliberately reverted. 0.4.10 is the closest yet — 23 of the 24 shim patch sites are fixed upstream — but one residual and one new defect remain, and its effect on C#/TypeScript is unmeasured. 0.4.9 fixes the last Swift defect (Connection.unknown) and the C# break, but a new named-collection feature emits struct-style accessors against polymorphic enums — 48 fresh compile errors. 0.4.8 leaves just one Swift defect (Connection.unknown) but still breaks C#. 0.4.6 fixes six Swift defects and regresses C# and TypeScript. 0.4.5 was announced upstream as carrying the generated-test fixes, but measured worse than 0.4.9 on Swift. 0.4.3 fixes four and was committed, until CI showed the same C# break — a regression the local run had masked. A shared emitter pin cannot be bumped for one language, so that belongs in its own repo-wide PR. See Validated against each upstream emitter release.

Remaining merge acceptance: consume an emitter fixing the Swift defects without the regressions carried by 0.4.3 through 0.4.9 → delete the shim and its call site → restore Swift test-dir in schema/tspconfig.yaml (still unusable: 1184 compile errors at 0.4.3, and 180 at both 0.4.8 and 0.4.9, across four test-generator defect classes) → regenerate cleanly → run the generated model tests, the 77 runtime tests, and the live E2E → push the final reviewed commit. See Upstream emitter defects.

What's here

Two SwiftPM packages, and the split is the point:

Package	Module	Contents	Hand-written?
prompty-model	PromptyModel	Domain types and pipeline protocols	No — Typra-generated
prompty	Prompty	Loader, renderers, parser, registry, harness	Yes
prompty	PromptyOpenAI	OpenAI executor and processor	Yes

135 generated model files, 26 hand-written sources, 14 test files.

The runtime defines no domain types of its own. Prompty, Model, Message, ContentPart, Tool and the four pipeline protocols (Renderer, Parser, Executor, Processor) all come from the generated model, and the hand-written code conforms to them. Partway through this work I found that the generated model already emits the pipeline protocols, so I deleted the hand-written declarations I had started with and adopted the generated ones — a competing type layer is exactly what this port is meant to avoid.

Covered: loading (including ${env:} / ${file:}), rendering, parsing, preparation, protocols and registries, provider execution and processing, tools and turns, structured output, streaming, and harness durability/replay.

Commits

99ab256b	Generate the Swift Prompty model via Typra
86eb1265	Add the Swift Prompty core runtime
68f04e2e	Add the OpenAI provider
e5e4c6b7	Add the turn harness and durability replay
a64ed071	Fix Windows line-ending handling; add live OpenAI E2E tests
56f638d8	Document the Swift runtime
3d60d232	Guard inherited fields on composite Property subtypes
05f70409	Conform the hand-written runtime to swift-format defaults
97c3a7a7	Add the PROMPTY_SKIP_SWIFT_SHIM emitter-validation escape hatch
d13109af	Add the Swift CI workflow
2a724c03	Stop silently discarding CRLF frontmatter
66b60ec3	Adopt @typra/emitter 0.4.3, minimize and harden the Swift shim
0a5a5e99	Revert the 0.4.3 pin after CI caught a C# regression; keep the hardening
15f7e620	Correct the name classification in the shim header (retirement criterion)
fa15d77e	Record the @typra/emitter 0.4.8 probe: Swift near-clean, C# still blocking
66de5c52	Record the @typra/emitter 0.4.9 probe: both blockers fixed, new enum defect
406fc882	Record the @typra/emitter 0.4.5 probe: announced as fixed, measured worse
75a38073	Map the per-patch residual shim at 0.4.5: 13 of 24 sites fixed upstream, 11 residual
dde5c617	Record the @typra/emitter 0.4.10 probe: 23 of 24 sites fixed upstream, one residual
dfb3aee6	Reconcile the test-dir error counts: raw lines vs primary unique
383058c2	Pin the Connection base-field gap with measured load/save evidence

Each of the first four was verified to build and test standalone, by moving the not-yet-committed files aside — so no commit depends on a later one.

Continuous integration

Every other runtime has a prompty-<lang>-check.yml; Swift had none, so nothing in CI compiled or ran this code. .github/workflows/prompty-swift-check.yml builds, tests and format-checks on ubuntu-latest and macos-latest.

Three decisions worth flagging:

• spec/** is in the trigger paths. The Swift tests are validated against the shared cross-runtime vectors, so a spec change has to re-run them. The other runtimes' check workflows watch only their own directory and have the same blind spot — fixing those is out of scope here.
• The SwiftPM cache keys on a stamp of swift --version, not just the manifests, so a runner-image or toolchain change can never restore artifacts built by a different compiler. Package.resolved is untracked — a library must not pin its consumers — so it can't contribute to the key.
• windows-latest is deliberately absent. swift-actions/setup-swift maps Windows releases only through 5.6.3, and the swift format subcommand needs 6.x. Windows is covered by local development, and the line-ending tests build their inputs from explicit \r\n literals so they're platform-independent anyway.

swift test is hermetic on CI because the live tests skip themselves without credentials.

The formatting commit is not cosmetic drive-by work: the 135 generated PromptyModel files already pass swift-format lint --strict with zero findings, which establishes swift-format defaults as the house Swift style here. The hand-written runtime didn't conform, so CI would have failed on its first run. Only the hand-written code is linted — the generated sources are the emitter's output, and an upstream formatting change must not break CI. Formatting was authored under Swift 6.3.3 and the lint gate runs under 6.0.3, so the first green run also confirms the two formatter versions agree.

Evidence

CI, this branch — run 30904239140, both jobs green:

Runner	Toolchain	Build	Tests	Format
ubuntu-latest	Swift 6.0.3	0 errors, 0 warnings	77 executed, 7 skipped, 0 failures	0 findings
macos-latest	Apple Swift 6.3.3	0 errors, 0 warnings	77 executed, 7 skipped, 0 failures	— (Linux only)

The 7 skips are the live OpenAI tests declining to run without OPENAI_API_KEY — the intended hermetic CI shape.

Locally, Swift 6.3.3 on x86_64-unknown-windows-msvc, where the credentials are present:

swift package clean && swift build --build-tests      → Build complete!, zero warnings
swift test  (credentials present)                     → Executed 77 tests, with 0 failures
swift test  (.env removed)                            → Executed 77 tests, 7 skipped, 0 failures
swift format lint --strict --recursive Sources Tests  → 0 findings

Between them that's the runtime building and passing on Linux, macOS and Windows, and across two different Swift versions.

Live tests are real. Seven tests hit the actual OpenAI API — chat, token caps, streaming, streamed accumulation, structured output, tool calling, and a .prompty file with ${env:} references — and they pass. They were run repeatedly with fresh random values to confirm they aren't flaky.

I deliberately hardened them after review, because the first versions could pass for the wrong reasons:

• the token cap is now a relative two-call comparison rather than a substring guess;
• structured output is proven by a prompt that explicitly demands prose and forbids JSON, so a successful decode proves the schema won;
• tool use is proven by an opaque run-time station code the model cannot guess. An earlier version used a random temperature, and the model rejected 641582 °C as a tool error — a genuine finding from the test, not a flake. The sentinel is alphabetic so it can't accidentally satisfy the temperature assertion;
• the streaming test asserts ordered reassembly of all twenty items instead of comparing two independent requests, which assumed a determinism the API doesn't promise.

A Swift-specific bug worth calling out

Swift treats a CRLF pair as a single Character. For "a\r\nb", both components(separatedBy: "\n") and split(separator: "\n") return the whole string as one element, and text.contains("\r") is false.

So a prompt assembled in memory with Windows endings missed every role marker and collapsed into one lumped message; a CRLF journal replayed as zero records; the buffered SSE path yielded one unparseable line. Rust splits at the byte level and degrades gracefully, so this hazard has no counterpart in the reference and no LF-only spec vector can catch it.

Fixed with Lines, a scalar-based splitter. Scanning unicodeScalars rather than Characters is what makes it correct: normalising first and splitting on characters afterwards still fails, because rewriting "a\r\r\nb" yields "a\r\nb" whose CR and LF are now adjacent and cluster into one grapheme again.

Character.isNewline is deliberately not used — it also matches U+0085, U+2028 and U+2029, which are legal unescaped inside JSON strings, so splitting on them tore journal records in half and discarded them silently.

A later pass found one more instance of the same hazard, and it was the worst of them. Frontmatter.split located its delimiters with firstIndex(of: "\n"), which matches nothing in a CRLF document — so the opening --- looked unterminated and the function returned empty frontmatter and an empty body, with no error at all. Loader happened to normalise before calling in, so files read from disk were unaffected and every existing test passed; but Frontmatter.split is public API, and any direct caller silently lost the entire document. It is now line-based on the same scalar scanner. The regression tests cover it directly, and also add the two cases the suite had never exercised: a .prompty file whose bytes on disk contain CRLF, and CRLF-delimited SSE. SSE.payload was trimming with CharacterSet.whitespaces, which is space and tab only, so a surviving CR defeated the [DONE] sentinel comparison.

Fixing it surfaced two subtler faults that review caught before the commit landed. Once split normalises, Loader doing so as well is not merely redundant but lossy: the first pass turns a\r\r\nb into a\r\nb, and the second reads that residual CR + LF as a terminator and deletes a lone CR that both Lines and the Rust reference preserve. Loader no longer normalises, leaving exactly one pass. And skipping leading blank lines with CharacterSet.whitespaces is wrong for the same reason Character.isNewline is wrong elsewhere — the set is horizontal-only, so a document opening with a vertical tab, form feed, NEL, or a Unicode separator would have been demoted to body-only, a genuine LF-input regression against the replaced algorithm. It now uses allSatisfy(isWhitespace).

Because that rewrite sits under every vector test's load path, equivalence with the replaced algorithm was not argued but measured: a temporary differential harness reimplemented the original character-index algorithm and asserted the two agree across a 54-sample corpus, including four documents that must throw. A negative control — reverting the whitespace predicate — made it fail on exactly the vertical-tab and NEL samples, confirming the harness discriminates rather than passing vacuously.

Every fix in this area was mutation-verified: reverted deliberately, and confirmed to produce the exact predicted failure.

Upstream emitter defects

Twelve defects in the Typra Swift emitter were characterised and reported to the schema owner across five change requests. The highest-value one drops extends base fields from three Property subtypes, all five Tool subtypes and the Connection subtypes — silent data corruption. Four of the twelve are fixed in 0.4.3, that one in 0.4.6, and the last Swift source defect in 0.4.9 — but every release from 0.4.3 on is rejected, the earlier ones for regressions in other runtimes and 0.4.9 for a new Swift defect of its own; see Validated against each upstream emitter release.

schema/scripts/patch-swift-emitter-defects.mjs runs as part of generation and repairs the output. It is a scripted post-generation step, so generated files are still never hand-edited. It is pinned to the emitter version it was written against and fails loudly — rather than silently mis-patching — on an unrecognised version, a missing anchor, or a half-patched file. GeneratedModelRoundTripTests covers every field it injects, so a silently regressed patch fails the suite rather than the runtime. It's designed to shrink to nothing and be deleted as upstream fixes land.

Validated against each upstream emitter release

Setting PROMPTY_SKIP_SWIFT_SHIM=1 skips the patch so native emitter output can be evaluated. Every candidate release is regenerated and built this way, and the results reported upstream with line-level citations.

The pin remains 0.4.2. Every later release was probed by generating unpatched Swift under it and diffing — so every verdict below is a per-file determination, not an inference from release notes — and all were rejected. Through 0.4.8 the reason was that the emitter is shared, so a bump regenerates every runtime and Swift gains arrived with C#/TypeScript regressions. At 0.4.9 those regressions are gone and the reason is Swift's own: a new defect that makes the shim larger, not smaller.

Contract item	0.4.2 (pinned)	0.4.3	0.4.5	0.4.6	0.4.8	0.4.9	0.4.10
Tool.customTool(CustomTool) wildcard fallback, with load/save	❌ shimmed	✅ fixed	✅	✅	✅	✅ ✅
indirect only on genuinely recursive polymorphic enums	❌ shimmed	✅ fixed	✅	✅	✅	✅ ✅
Factories emit typed cases (role: .assistant, .textPart(TextPart(…)))	❌ shimmed	✅ fixed	✅	✅	✅	✅ ✅
unknown? → Any?, Record<unknown>? → [String: Any]?, Message[] → [Message]	❌ shimmed	✅ fixed	✅	✅	✅	✅ ✅
Inherited extends fields on Property / Tool / Connection subtypes	❌ shimmed	❌ shimmed	❌ measured missing	✅ fixed	✅	✅ ✅ incl. memberwise init
Connection fallback .unknown([String: Any])	❌ shimmed	❌ shimmed	❌ 30 errors	❌ not emitted	❌ only defect left	✅ fixed ⚠️ case + save only; load still throws
Named-collection helpers work on polymorphic enums	✅ n/a — feature absent	✅ n/a	✅ n/a	✅ n/a	✅ n/a	❌ new: 48 errors ❌ 10 errors
Map-form bindings loading (array-only today)	❌ shimmed	❌ shimmed	— not probed	❌ not emitted	❌ not emitted	— not re-probed — not re-probed
C# *Yaml* generated tests	✅ green	❌ 16 break	— not measured	❌ 16 break	❌ 16 break	✅ 48/48 green — not measured
TypeScript = [] on fields with an explicit = #[]	✅ kept	✅ kept	— not measured	❌ 13 lost	— not re-probed	❌ still lost — not measured

0.4.3 is a real Swift gain — it would cut the shim from 419 to 345 lines and its generated Swift is byte-identical to what the current shim produces. It was adopted in 66b60ec3 and reverted in 0a5a5e99 once CI showed the C# break. Swift gains cannot be bought with a C# regression, and a shared pin cannot be regenerated for one language.

At 0.4.8 the Swift source generator is close to clean. Compiling native 0.4.8 output yields exactly 30 errors, every one type 'Connection' has no member 'unknown', every one in tool.swift. Probe-patching only that single enum case into the native output makes the model package compile — so a release adding Connection.unknown would likely collapse this shim to nothing. Likely, not certainly: compiling is not the same as being correct. Dropped fields produce zero diagnostics, so each patch still has to be retired against swift build --build-tests and swift test, never a clean build alone.

0.4.8 also fixes the inherited-extends defect including name, which matters: name is not extends-inherited (model Property and model Tool never declare it; it arrives via the Named<…> spread in core/core.tsp), so a fix scoped to extends alone would have restored every other base field and silently dropped that one.

0.4.9 clears both blockers that were reported upstream, and is still rejected. Connection.unknown is emitted in exactly the requested shape, and the C# literal asymmetry is gone — Prompty.Core.Tests reports 48 passed, 0 failed, which beats even the pinned 0.4.2 baseline (it fails 16 *Json* tests locally to a CRLF artifact). Go improves to 17 FAIL lines from 44; Rust stays green.

What blocks it is new. 0.4.9 adds named-dict collections — the feature Prompty needs so inputs: and tools: can be read as name-keyed maps. The generated helper assumes its element type is a struct, so for the polymorphic enums Property and Tool it emits item.name = name and Property.shorthandProperty, neither of which those enums declare (only the concrete ArrayProperty / FunctionTool / … structs do). That is 48 fresh compile errors — agent/prompty.swift 30, core/property.swift 10, tools/tool.swift 8 — where 0.4.8 had 30. The shim would have to grow, not shrink. Routing the name through the dictionary before load, mirroring the save path that already calls removeValue(forKey: "name"), would make the helper agnostic to struct-vs-enum elements; that has been reported upstream.

The generated test-dir is no better either. After probe-patching those 48 source errors so the library would compile and the test target would actually build, it produced the same 180 errors as 0.4.8 — which is the whole reason the library must be made to compile first: if it fails, the test target is never built and the error count looks deceptively small.

0.4.5 is the one release probed out of order, and it is a cautionary case. It was announced upstream as carrying fixes for the four test-generator defect classes, so it was probed even though it is numerically behind the already-rejected 0.4.9. It is not a candidate: published before both 0.4.6 and 0.4.9, it predates the inherited-extends fix and still omits Connection.unknown, so native output is 30 errors in tool.swift. Probe-patching only that case makes the library compile and then yields 228 test-build error lines, 57 unique, across six files — against 0.4.9's 180 and 45 across five. The extra file is tools/ToolTests.swift, whose eight errors are all FunctionTool missing name and description; ReferenceConnection drops authenticationMode and usageDescription too, but silently, which is precisely why restoring test-dir matters. The four columns marked ✅ above are inherited from 0.4.3 and corroborated by the library compiling once Connection alone was patched. Rejected on Swift, so the other runtimes were not measured.

Because 0.4.5 is the first probed release to clear a majority of this shim, it was also classified patch by patch — mechanically, against native output, using the shim's own anchors. 13 of the 24 patch sites are fixed upstream and 11 are residual: the three Connection.unknown patches and all eight base-field injections. Applying only those 11 compiles the library, passes all 76 runtime tests including live E2E, and clears ToolTests entirely — the first direct evidence that the base-field injections are load-bearing rather than defensive, since defect 10 otherwise fails silently. 49 generated-test errors remain across five files, so test-dir stays out and the shim cannot be retired. Two measurement traps found here are now documented next to the code they affect: the parser.swift patch false-negatives against a fixed emitter because its replacement text is pre-wrapped to the formatter's width, and baseFieldInjections deliberately excludes Connection subtypes even though the generated tests assert them.

0.4.10 is the closest any release has come to making this shim deletable, and it is still rejected. Published after 0.4.9 and now latest, it fixes 23 of the 24 patch sites — every base-field injection, and the inherited fields land in the memberwise initializer too, which would settle the construction limitation recorded at the top of the shim. Connection gains its unknown case and save arm. The single residual is Connection.load's default:, which still throws unknownDiscriminator instead of returning .unknown, leaving that case declared but unreachable by the loader.

The 0.4.9 named-collection defect persists, though it is much reduced: item.name = name and Property.shorthandProperty are still emitted against the polymorphic enums, now costing 10 errors confined to agent/prompty.swift where 0.4.9 cost 48 across three files. Hand-synthesising the enum-level forwarders plus that one Connection line takes swift build to exit 0. That measures compilation only — the forwarders are themselves a workaround, and the generated test-dir is still unusable at 45 errors across five files — so deleting the shim needs both fixes upstream and a green generated-test run. C# and TypeScript were not re-measured, and every Swift-clean release so far has failed on exactly that gate.

One contract wrinkle worth recording: Tool now emits both customTool(CustomTool) and unknown([String: Any]), but Tool.load's default: still routes the wildcard to .customTool, so Prompty's * semantics survive and unknown tool kinds still arrive typed. .unknown is therefore unreachable through load while still forcing any exhaustive consumer switch without a catch-all to grow an arm — it broke this runtime's own boundParameterNames. Both fixes and that observation are specified upstream.

Compiling is not the bar for a type layer whose failure mode is silent, so the 0.4.10 probe was extended to load/save round-trips: a dropped field emits no diagnostic at all. Over three Property kinds, five Tool kinds including the wildcard, ReferenceConnection, and the Connection unknown fallback, 0.4.10-generated output scores 42/42 where this pinned configuration scores 40/42. The two-check delta is not a regression — it is the Connection scope gap the shim has always declined to patch, and the probe covered only ReferenceConnection of the six connection subtypes, so the 0.4.10 result is scoped to that type.

That gap was documented but never measured, which left nothing separating "deliberately unpatched" from "quietly broken". It is now pinned by a test walking all six Connection subtypes: every one silently loses authenticationMode and usageDescription between load and save. The scoping decision stands — injecting them restores data the runtime never reads and no vector covers, at the price of two more patches to delete on adoption — but it is recorded as an accepted limitation of the published model package rather than a free win. The test fails if either field starts surviving, which is the signal to re-audit and assert preservation instead. One further difference must be settled before adopting 0.4.10, not after: this shim writes name only when non-empty while 0.4.10 writes it unconditionally, and Prompty.save maps inputs/outputs/tools straight through without stripping name, so an unnamed composite can reach vector output as "name": "".
The 0.4.10 probe also invalidated the mechanical classifier used at 0.4.5: keyed on the shim's own anchors, it reported all eight base-field sites as still residual when the generated source proves them fixed, because the structural anchors had moved. Every verdict above was re-confirmed by reading generated source. That is now the documented rule, and the second known false-negative mechanism after the pre-wrapped replace text.

Adoption of 0.4.8 is blocked by C#, and the cause is now pinned down: schema/model/agent/agent.tsp:166 genuinely ends with a trailing space; the emitter writes 56 escaped expected-value literals that preserve it and 24 verbatim input-YAML literals that lose it. At 0.4.2 both forms dropped it consistently and the suite passed. The escaped form is arguably the faithful one — the defect is the asymmetry, not the escaping.

Three defects therefore still need shimming at the pinned 0.4.2:

• Connection.unknown is never declared, yet the emitter writes .unknown([:]) as a stored-property default at six sites in its own tool.swift. The generated model package does not compile standalone. Property already emits exactly the right shape, so the fix is one enum case, a save arm and a load fallback. Rust tolerates unknown kinds via _ => ConnectionKind::default(), so accepting them is parity-correct.
• Inherited extends fields are dropped from derived structs, so three Property subtypes and all five Tool subtypes silently lose their base fields on both load and save.
• bindings only loads array form. The shared spec (spec/fixtures/tools_function.prompty) and the Rust reference (load_bindings) both accept map form, keyed by parameter name.

Worth recording: those defect classes fail very differently. Missing Connection.unknown is a hard compile failure. Missing inherited Property fields produce zero compile errors, because the runtime reads those through the raw dictionary — the data simply disappears. That asymmetry is why InheritedPropertyFieldTests exists and why the shim's retirement criterion is swift build --build-tests and swift test, never a clean build alone.

Cross-runtime effect of a bump

Every suite was measured against HEAD rather than assumed:

Runtime	Effect of 0.4.3	Verdict
Swift	four defects fixed, shim 419 → 345 lines	✅ gain
Rust	byte-identical output, ~896 tests green	✅ neutral
Go	unreachable default: clauses removed, so unknown discriminators fall through to the map load instead of returning an empty value	✅ 44 → 17 failures, fixes 27
C#	generated-test string literals reshaped	❌ 16 *Yaml* tests break

The C# result is why compare-the-counts is not good enough, and this PR got it wrong once before CI caught it. On this Windows checkout, PromptyConversionTests already fails 16 tests at HEAD — but as LoadJsonInput*/RoundtripJson*, a CRLF artifact of the local checkout. Under 0.4.3 it also fails 16 — but as LoadYamlInput*/RoundtripYaml*. Identical totals, completely disjoint identities. A count comparison reports "unchanged"; the truth is that a pre-existing local failure masked a real regression. The 0.4.3 failures are content-based ("some \npersonal" vs "some\npersonal"), so they reproduce on Linux CI. Both releases and this trap are now documented next to PINNED_EMITTER_VERSION.

The shim, the omitted test-dir, and this section all come out once an emitter carries the Swift fixes without the C#/TypeScript regressions.

Scope

This port is not parity-complete, and the README says so explicitly rather than implying coverage that isn't there. Six of the ten shared vector files are exercised — load (25), render (23), parse (15), wire (22 of 27), process (17 of 21) and harness replay (5). The nine skipped wire and process cases are Anthropic ones: this package ships the OpenAI provider only, so both suites filter on input.provider and an Anthropic package would pick them up unchanged. Four files are not run at all:

Vector file	Cases	Missing capability
engine/turn_vectors.json	5	not wired; delegated provider state and cancellation absent
agent/agent_vectors.json	28	agent layer
discovery/discovery_vectors.json	7	model discovery
discovery/enrichment_vectors.json	9	discovery enrichment

These are a deliberate scoping decision for an initial port. The engine row is the nuanced one, and worth stating precisely rather than overclaiming the gap: ReferenceTurnRunner already implements the iteration loop, permission mediation, host tool execution and checkpointing, so three of the five engine vectors (final_output, ordered_tool_round, permission_denial_is_model_visible) describe behaviour that exists but is not yet asserted against the shared file. Only delegated_provider_state and cancel_before_context need capabilities this port lacks. Tool calling is covered at the wire and processing layers — request serialization and response extraction. Wiring the engine vectors and closing those two capabilities is follow-up work tracked separately from this PR.

Notes

.env is gitignored and was never committed — verified against the whole branch history. Outside runtime/swift, this branch touches .gitignore, the new workflow, schema/tspconfig.yaml, the generation scripts, and the Swift emitter shim. The emitter pin stays at 0.4.2 and no other runtime's generated output is modified — see Cross-runtime effect of a bump.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of lines (20,000). Try reducing the number of changed lines and requesting a review from Copilot again.