Swift-JSON 1.5.0 — bounded CLI and exact pull queries

Swift-JSON 1.5.0 adds swift-json, a bounded command-line executable for exact JSON workflows, with a pull-based filter language and offline schema-provider helpers. The package now offers six library products plus the executable, with no external root-package dependencies.

What's new

• Everyday JSON commands: strict formatting and validation, RFC 6901 Pointer selection, staged RFC 6902 Patch, stream checking/copying/root-array processing, and explicit offline schema compilation.
• Pull-based queries: ordered multiple results, field/index/path selection, lexical functions, reductions, bounded collections, scalar-aware strings, interpolation and staged path mutation. Driver input and input/inputs share one cursor. An earlier result does not certify an unread malformed tail.
• Exact bounded arithmetic: decimal calculations use the native exact model, without Double or Foundation Decimal as arithmetic authority. Terminating division is exact; nonterminating division fails unless explicit scale and half-even rounding are selected. Operational failures and cancellation bypass language catches.
• Local schema-provider adapters: schema provider openai-format and openai-tool inspect the documented frozen subset and produce fragments while preserving exact values and scalar keys. Completed incompatibility differs from malformed schemas, exhausted budgets, IO failure and cancellation. These helpers make no API requests and perform no credential lookup, model session or online resolution.
• Inspection output: JSONHTML-backed static HTML, explicitly selected interactive HTML, plain text and Markdown. Text and Markdown use actual tab indentation. CLI rendering does not silently prepare PDF or invoke Apple model services.
• Observable finite work: sixteen CLI quotas compose with the original 49 JSON metrics in one cumulative job. Reports distinguish provisional results, accepted stdout and committed file output. Named outputs install through owned staging after successful completion; previously accepted stdout bytes cannot be recalled.

Build from the source distribution with Swift 6.4 or later:

swift build -c release --product swift-json
.build/release/swift-json format --compact input.json
.build/release/swift-json query --compact -- '.items[] | select(.active) | .name' input.json
.build/release/swift-json query --null-input -- '0.1 + 0.2' </dev/null
.build/release/swift-json validate --schema schema.json input.json
.build/release/swift-json patch --patch operations.json input.json
.build/release/swift-json schema provider openai-format schema.json --name result

Input defaults to stdin. Use -- for filters or operands beginning with a dash.
When installing a built CLI, retain its complete Swift-JSON_JSONSchema.bundle
sibling with all nine pinned meta-schema files; copying only the executable is
not a qualified schema installation. LICENSE, NOTICE and upstream notices remain
part of redistribution. This release supplies qualified source, not standalone
prebuilt CLI binaries or a Homebrew formula.

Compatibility and scope

The annotated version tag targets 8a5cf73dfe9b674f7c635f5f6d21a7051d66bb51,
the reviewed merge of PRs #23–#27. The existing protected 1.4.0 tag and its
separate ergonomics/JSONBridges draft remain unchanged. Six library products
remain available: JSON, JSONSchema, JSONStreaming, JSONPatch, JSONHTML and
opt-in JSONBridges. JSONRegexRuntime, JSONFilterRuntime and JSONCLIEngine remain
private targets. Exact decimals, decoded Unicode scalar identity, strict UTF-8,
finite profiles, Apache-2.0 original code and upstream notices are preserved.

Library deployment minima remain macOS/iOS/iPadOS 27; Swift tools/compiler 6.4+
and language mode 6 remain required. Native qualification uses macOS/SDK 27+.
Linux execution is qualified separately on Swift 6.4 / Ubuntu 24.04 / glibc for
x86_64 and ARM64. Existing mobile and WASI library evidence keeps its original
scope; these CLI Mac/Linux results do not establish mobile CLI execution or a
complete WASI argv/filesystem/signal host. Physical iPad qualification remains
deferred under the approved policy.

The filter dialect is swift-json-filter/1, a documented subset, not a claim
of full jq compatibility. Unsupported regex/approximate-math/filter features are
explicit errors. Apple model/schema helpers remain unavailable. Provider compatibility
is a local profile result, not remote model/service acceptance. Projection,
JSON text-sequence framing and unselected optimization experiments remain deferred.

Frozen-source version metadata: swift-json --version reports
1.4.0-dev; JSON metadata reports that version and revision: "unknown".
Those are the actual labels in this independently qualified source. The package
tag/release version is 1.5.0. Development/Unreleased labels in the frozen
README, changelog and historical planning records are not rewritten during
tagging. No prebuilt binary claiming corrected metadata is supplied.

Qualification

Post-merge Native CI
and Linux CI
passed all seven qualification jobs at the exact release commit, followed by the
existing automatic Pages deployment. Materialized public receipts include actual
commands, environments, source/input hashes, nonzero counts and limitations.

• Native debug/release/ASan: 395 root functions, including 85 CLI functions,
  plus 199 parameter invocations per full run. TSan: 14 shared-state functions.
• Linux debug/release/ASan: 381 functions plus 199 parameter invocations on each
  architecture; TSan: 13 shared-state functions. Strict memory-safety builds
  retain warnings as errors.
• Per behavior lane: 53 foundation subprocess scenarios, 37 integration,
  33 CLI quota/report scenarios covering 16 metrics, 111 C1–C5 vectors,
  14 public provider-consumer outcomes and 37 provider processes. All
  49 original metric probes retain their exact expected outcomes.
• Independent syntax suite: 318 observed = 287 evaluated successes + 31 policy
  cases. Schema suite: 2,337 = 2,300 evaluated successes + 37 policy cases.
  Policy exclusions are not evaluated successes. Authored qualification retains
  4,396 malformed-input replays and twenty explicitly rooted downstream cases;
  ordinary invalidity and operational errors are distinct.
• Six matching native DocC catalogues: 855/855 authored public symbols
  documented, 2,996 catalog files verified, 15 executable README fences.
• Source distribution: 995 source files plus manifest, reproduced byte-for-byte
  from an independent extraction. The accompanying qualification receipt records
  the clean archive-native and exact-version remote consumer outcomes.

The unchanged 10% performance review trigger and existing dispositions remain
in force, including the reviewed stream median 1.0749626803 s versus
0.968493986 s (+10.9932%). No new speed, controlled A/B or hard RSS guarantee is
claimed. Work quotas constrain owned operations; caller/kernel work and logical
retained bytes remain distinct from caller instruction counts and process RSS.

Assets and support

Verify the source, matching DocC, materialized public evidence and qualification
receipt against SHA256SUMS. Evidence paths and manifests resolve delivered
bytes. Public receipts normalize private local/home paths and retain original and
delivered hashes. Private maintainer records, input clones, credentials and
SDK-linked specimen binaries are excluded.

Command reference
· Filter and arithmetic contracts
· Documentation
· Support
· Private security reporting

The attached qualification records preserve the frozen candidate and draft-preparation history. This release publishes those same verified asset bytes.

Swift-JSON 1.3.0 — JSONHTML and prepared exports

Swift-JSON 1.3.0 adds JSONHTML: exact standalone HTML, offline inspection and immutable prepared exports. The existing JSON, JSONSchema, JSONStreaming and JSONPatch products retain their contracts. The root package dependency graph remains empty; JSONRegexRuntime stays private.

What's new

• Formatted HTML: complete, highlighted, script-free output from the shared strict writer. Exact decimal spellings, decoded Unicode scalar identity, insertion order and array order survive rendering.
• Offline exploration: opt-in native disclosures, bounded outline and literal search, exact JSON/Pointer copy and download, embedded CSP-authorized assets, and full-content printing independent of disclosure state. No browser numeric reconstruction or network resolver is introduced.
• Typed diagnostics: attach caller diagnostics by exact typed path, identify missing targets at the nearest existing parent, and display coherent JSONDocument byte spans. Replaced roots invent no locations; rendering never asserts schema validity.
• Prepared export: immutable JSON, UTF-8 text, Markdown with actual tab indentation, expanded static HTML and opt-in styled RTF. One finite cumulative native preparation budget covers admission, helpers and final artifacts. Explicit format selection controls what an item offers.
• Apple transfer: importing JSONHTML adds JSON's CoreTransferable conformance. Native JSON imports through the strict bounded parser; presentation formats are export-only. Transfer closures offer completed bytes and never start a PDF render or mutate a shared cache.
• Explicit Apple PDF: asynchronous main-actor preparation from the item's own static HTML, genuine A4/US Letter pagination and an explicit continuous mode. Finite page/byte/bundle allowances, cancellation, soft deadlines, invocation-owned lifecycle and late-result rejection preserve immutable success. The default is paginated A4 with 36-point margins.
• Additive writer formatting: literal tabs are available through an explicit indentation-unit overload. The original initializer function type, output defaults and accounting remain compatible.

.package(url: "https://github.com/ThorFuchs/Swift-JSON.git", from: "1.3.0")

Add .product(name: "JSONHTML", package: "swift-json") to use the fifth product. JSONHTML depends on JSON only; core JSON acquires no UI or transfer dependency.

Compatibility and platform scope

Swift tools/compiler 6.4+, Swift language mode 6, and Apple OS/SDK 27+ remain required. Original contributions remain Apache-2.0, with upstream licenses and notices retained. Linux support retains Swift 6.4 on 64-bit Ubuntu 24.04/glibc, ARM64 and x86-64. Full-language wasm32-unknown-wasip1 retains the pinned matching Swift 6.4 WASI SDK and qualified command hosts. Browser hosting, Embedded Swift, WASI threads, wasm64, other Linux distributions and musl require separate qualification.

Portable JSONHTML rendering/native preparation and styled RTF are distinct from the conditional Apple Transferable/PDF boundary. Pure rendering does not start WebKit. Opaque SDK allocations, receiver behavior and caller callbacks remain outside owned instruction quotas; logical retained bytes are not process RSS caps.

The frozen README/changelog retain development/Unreleased labels for the 1.3 work, and SUPPORT retains an older Apple-only platform paragraph. The executed platform scope is stated above and in the versioned Linux/WASI contracts and qualification receipt. These versioned notes bind the new JSONHTML entries to 1.3.0 without changing the qualified commit. The earlier Linux/WASI changes and schema-builder correction in that historical section were already released and are not new 1.3 features.

Qualification

The annotated tag targets 9517233ef0a3c1b961b738df58fe3ee4081d780c, the reviewed merge of #21 and #22. Post-merge Native CI and Linux CI pass all seven qualification lanes, followed by documentation deployment. No branch or tag protection was weakened.

• Native debug, release and ASAN each execute 270 test functions and 173 parameter invocations; TSAN covers ten concurrent functions, and strict memory-safety compilation passes. Linux executes 256 functions/173 parameter invocations per full run, with its actual architecture-specific sanitizer results recorded separately.
• The exact source archive is reproduced byte-for-byte, independently extracted and exercised through the full native lane and a fresh remote exact-version five-product consumer. It contains 887 source files plus its manifest. All 49 baseline cap probes retain their exact expected outcomes.
• Five matching DocC catalogues document 771/771 authored declarations, with 13 executable README examples. The attached documentation matches the tag; the website follows qualified main.
• Independent syntax: 318 observed / 287 evaluated successes / 31 policy cases. Schema: 2,337 / 2,300 / 37. Exclusions are not evaluated successes. Authored qualification retains 82 public semantic cases, nine budget/report cases and 4,396 deterministic malformed-input replays. The public downstream schema consumer explicitly selects 20 definitions: eight valid, twelve ordinarily invalid, with two separate operational-error probes. It does not establish MCP conformance.
• Focused export qualification executes 38 functions, plus 65 distinct public consumer outcomes and eight artifacts per runtime on Mac, physical iPhone, iPhone simulator and iPad simulator. This is not 260 distinct behavior cases. Actual Mac drop callbacks, unedited A4.pdf sharing, local Files save/reopen, seven pages and final-content sentinel are separately attributed to native observations and maintainer confirmations. Physical iPad remains deferred under the approved simulator acceptance policy.
• Browser qualification executes 46 cases across Chromium, Firefox and WebKit with zero skips. Native Safari and human VoiceOver checks are recorded separately; automated WebKit is not native Safari or audible speech evidence. TextEdit rich RTF save can canonically normalize a decomposed key, despite exact emitted/native-decoded RTF; native JSON is the interchange authority.
• Unchanged-runtime WASI evidence retains 71 qualification commands: Node debug/release root suites execute 256 functions/173 parameter invocations, while WasmKit has the narrower recorded 14-function public-consumer/probe scope. Unavailable WASI sanitizer instrumentation is not counted as a pass. The evidence explicitly binds reused implementation receipts across documentation-only changes.

Performance and boundaries

Six representative workloads have 18 release-native and 54 browser observations. Median generation was 44.693 ms for a 5,000-member formatted object and 71.459 ms for an interactive 1,000-member object with 128 coherent mapped diagnostics. The latter emitted 980,689 bytes, charged 4,202,193 owned work units and peaked at 1,961,378 logical retained bytes. Its actual browser DOM remained below the conservative bound in all three engines; controls and bounded search completed.

These are representative busy-host measurements, not idle A/B, maximum-workload throughput, hard RSS or platform instruction guarantees. The unchanged 10% review trigger and historical streaming/schema performance dispositions remain retained with their original baselines and host-noise limits. No quota/profile increase or new optimization is hidden in this release. SIMD/parallel batch experiments, E11 projection and E12 JSON text-sequence framing remain deferred.

Assets and support

Verify the source, matching compiled DocC, normalized public evidence and qualification JSON against SHA256SUMS. The source/evidence archives have exact manifests; the DocC manifest accompanies its archive. Evidence includes actual command exits, source hashes, nonzero counts and input pins. Private maintainer/device records, credentials, local clones and SDK-linked build binaries are excluded from the public assets.

Online documentation · JSONHTML reference · Release source contracts · Support · Private security reporting.

Swift-JSON 1.2.1 — test coverage and schema reliability

Swift-JSON 1.2.1 expands behavior and acceptance testing and corrects two schema failure paths. This is a patch on release/1.2; it excludes main's JSONHTML/1.3 work.

Changes and compatibility

• Best-effort schema diagnostics may omit oversized optional output without latching a terminal resource failure. Ordinary invalidity remains a completed result with incomplete diagnostics; required work, retention and annotation failures remain operational errors. Complete-diagnostic policy remains strict.
• A wholly missing native schema resource bundle now throws structured metaSchema compilation failure instead of SwiftPM's generated fatal error. Search is finite, and all nine resource size/hash pins remain enforced.
• Add 126 meaningful Swift Testing functions over 1.2.0, covering native/foreign Codable, exact values and keys, precise errors, causal streaming completion/backpressure, Patch and schema/regex decisions. Twenty public integration functions combine the four products without private meter imports.
• Fix compiler-probe provenance for source archives: an unpacked or nested archive reports no Git identity, retains all source hashes and runs every original ownership/reader case. The first clean run exposed this tooling assumption; the failed receipt is preserved and the successor is requalified.
• Export all five implementation coverage denominators from six test runners, with atomic counters, saturation rejection and actual omitted-schema rejection. Retain fixed-seed valid/invalid replay, nine minimized cases and the bounded native mutation pilot: 26 selected behavioral kills after two minimized assertion repairs. This is not exhaustive assurance.
• Public signatures, exact number/scalar semantics, all 49 finite profile metrics, logical weights and the empty root dependency graph remain unchanged. Exact Int128/UInt128 JSONNumber projection is qualified; typed 128-bit Codable remains unsupported as documented.

Swift tools/compiler 6.4+, Swift language mode 6, macOS/iOS/iPadOS 27+, qualified 64-bit Ubuntu 24.04/glibc ARM64/x86_64, and the existing full-language Swift 6.4 wasm32 WASI command scope remain unchanged. Four products: JSON, JSONSchema, JSONStreaming, JSONPatch; JSONRegexRuntime remains private. Apache-2.0 and all upstream notices are retained.

.package(url: "https://github.com/ThorFuchs/Swift-JSON.git", exact: "1.2.1")

Qualification

The annotated tag targets e8b687f822c577311156b13bf1d15c2d5620b84e, a release-preparation successor to the reviewed maintenance merge, with documentation and compiler-probe provenance changes only. Native CI and Linux CI qualify the final candidate; independent native archive reproduction executes the full native lane from manifest-verified source outside a Git checkout. The temporary QA workflow is not part of the release source.

Debug/release/full ASan retain 318 functions and 173 parameterized invocations; targeted TSan retains 32 functions. All 49 cap probes, strict-memory compilation, public consumers and distribution fault cases pass. Independent syntax: 287 evaluated successes plus 31 policy cases out of 318. Schema: 2300 evaluated successes plus 37 policy cases out of 2337. Policy exclusions are not evaluated successes. Native DocC covers 582 authored public symbols and named parameters, with four matching catalogues and no diagnostics.

Both Linux architectures retain complete coverage, safety and clean reproduction. The prior native coverage review meets the per-module 98% authored-line / 95% region targets without removing unused helpers. Execution percentages are not assertion completeness; branch/MC/DC counters are unavailable. Scoped WASI evidence is reused for byte-identical implementation/test inputs: Node full debug/release roots, Node/WasmKit affected QA and strict memory compilation. No new WASI sanitizer, independent WASI corpus or physical-device claim is made. Physical iPad remains deferred under the existing policy; earlier iPhone/device evidence retains its original source and scope. The 20 explicitly rooted schema-consumer cases do not establish downstream MCP conformance.

Accepted performance exception

The maintainer explicitly accepted a 1.2.1-specific performance exception for tag/draft preparation. The earlier diagnostic median +11.9833% exceeds the unchanged 10% review trigger and remains unresolved. A later authorized loaded-host comparison measured −1.6871% with no samples discarded and equal owned-work/logical-retention counters. Its host was busy; the further release readiness check also failed the idle criteria.

Retain the required correctness repair and disclose the measurement uncertainty. This is no intrinsic-improvement, no-regression or controlled-throughput claim. No cap, baseline or threshold was relaxed. Historical streaming reviews retain their separate baselines/dispositions. Logical retained bytes differ from RSS, and caller callbacks remain outside owned instruction quotas. Decision and scope.

Assets and support

Verify source, compiled DocC, reviewed public evidence and qualification receipts against SHA256SUMS; archive contents have accompanying or embedded manifests. An independent native SwiftPM consumer resolves and runs the exact version tag. Public assets exclude private maintainer records, personal device identifiers, credentials, LLVM objects/profiles and SDK-linked WASM binaries.

Online documentation follows main's later feature line; the attached four-catalog DocC archive matches this tag. Changelog · Support · Private reporting.

Published on 15 October 2026 following explicit maintainer authorization. The accepted performance exception and its measurement limitations remain unchanged. Attached qualification receipts retain their original preparation timestamps and states; the source, documentation and evidence assets are unchanged from the verified draft.

Swift-JSON 1.2.0 — Linux and WASI support

Swift-JSON 1.2.0 adds qualified Linux and full-language WebAssembly/WASI command support to the existing exact, resource-bounded JSON package. It retains the same four public products, strict semantics, offline schema engine and empty root dependency graph.

Platforms and compatibility

• Linux: Swift 6.4 on 64-bit Ubuntu 24.04/glibc, qualified on ARM64 and x86_64 with behavior, independent suites, Address/Leak Sanitizer, Thread Sanitizer and clean source reproduction. Other distributions, musl and 32-bit Linux are outside this qualification.
• WASI: full-language Swift 6.4, wasm32-unknown-wasip1, using the matching swift-6.4.0-RELEASE_wasm SDK. Command execution is qualified with WasmKit 0.3.1 and Node 26.5.0/V8. Browser integration, Embedded Swift, WASI threads, wasm64 and other host/SDK versions require separate qualification.
• Apple: Swift tools/compiler 6.4+, Swift language mode 6, and macOS/iOS/iPadOS 27+ remain the baseline. Existing mobile qualification and its physical-iPad deferral are preserved; this release adds no new physical-device claim.

.package(url: "https://github.com/ThorFuchs/Swift-JSON.git", from: "1.2.0")

Products remain JSON, JSONSchema, JSONStreaming and JSONPatch. JSONRegexRuntime stays private. Original code remains Apache-2.0 with all applicable upstream notices retained.

Changes

• Replace CryptoKit schema-resource hashing with an original, package-private portable SHA-256 implementation. Hashing participates in the active cumulative compilation budget, cancellation and logical scratch accounting. The nine packaged Draft 2020-12 resources retain their exact integrity pins; no dependency or alternative schema engine is introduced.
• Classify twelve cumulative quotas as checked UInt64 counters so finite defaults can exceed Int.max on wasm32. The other 37 metrics retain allocation/capacity guards. All 49 metric definitions, finite profile values and logical weights are unchanged. Synthetic boundary tests do not imply allocating or executing Int.max quantities of work.
• Check cumulative retired-report overflow before admitting work; caught owned failures remain terminal. Preserve native cancellation rendezvous and qualify cooperative WASI checkpoints after actual counted progress.
• Load schema resources beside the WASI command. Deploy Swift-JSON_JSONSchema.bundle alongside the executable, provide an absolute guest command path as argv[0], and preopen that directory at the matching guest path. Missing resources produce structured compilation errors. WASI deployment contract.
• Preserve exact bounded decimals, decoded Unicode-scalar identity, ordered objects, native value Codable, scoped reads, exact persistence, immutable offline plans, Patch and pull-stream semantics across the qualified hosts. Linux contract.

The frozen source changelog describes WASI under Unreleased and retains the already released 1.1.1 schema-builder correction there. These versioned notes bind the platform changes to 1.2.0 without changing the qualified commit or relabeling the 1.1.1 fix as new work.

Qualification

The annotated tag targets 25fb04f747e583209b4c4511abf39e11ef5b4f80. Its Native CI and Linux CI passed all seven qualification lanes, followed by documentation deployment. Debug, release and full ASAN execute 192 test functions and 173 parameterized invocations on each native/Linux architecture; TSan exercises six concurrency functions per safety lane. Strict memory-safety compilation passes.

The exact same public source bytes passed 65 WASI qualification commands: Node executes the full debug/release root suites and independent runner; both hosts execute 13 public consumer functions, all 49 cap outcomes, 20 explicitly rooted schema vectors, command parity and structured missing-resource cases. WasmKit does not claim the full independent/root-suite scope. WASI sanitizer instrumentation is unavailable in this pinned toolchain and is not counted as a sanitizer pass; native/Linux safety provides the shared-source sanitizer evidence.

Independent suites record syntax 318 observed / 287 evaluated successes / 31 policy cases, and schema 2,337 observed / 2,300 evaluated successes / 37 policy cases. Policy exclusions are separate from evaluated successes. Authored qualification includes 82 public semantic cases, nine budget/report cases and 4,396 deterministic malformed-input replays. Root tests include 31,824 regex differential cases, 18,853 Unicode normalization cases/94,265 comparisons and 874 format vectors. The downstream public consumer validates 20 explicitly selected definitions (eight valid, twelve ordinarily invalid), with two separate operational errors; it does not establish MCP conformance.

The attached public evidence preserves actual command exits, counts, input pins, source hashes, clean extracted native/Linux/WASI reproduction and an independently resolved remote-tag consumer. The source archive is reproducible and contains 820 source files plus its manifest. Four matching DocC catalogues contain 2,052 verified files, with 582/582 authored public declarations documented and ten executed README examples.

Performance and boundaries

The final native A/B/A/B comparison uses two runs per source, nine repetitions, three warmups and three invocations per sample over twelve identical workloads. Tiny exact parsing changes from 21.118 to 23.257 microseconds (+10.13%, +2.139 microseconds), crossing the unchanged 10% review trigger. The reviewed disposition retains checked cumulative report accounting and the measured validator fast path. Avoidable initial overhead was corrected before final qualification. The other eleven workloads stay below the trigger; root-array streaming changes +5.03% (1.018145 to 1.069311 seconds), with its 52-byte logical peak unchanged. All twelve logical peaks are unchanged.

Short-duration variation and host drift limit attribution; these measurements do not guarantee throughput or statistical equivalence. Earlier approximately +11% and +15.76% streaming reviews retain their separate baselines and dispositions. Logical retained bytes, allocated WASI linear-memory pages and host RSS are different measurements. Caller callbacks are outside owned instruction quotas, and cancellation checkpoints are not wall-clock preemption or host fuel limits. Node's WASI filesystem is not a security boundary for untrusted code.

SIMD/parallel batch experiments, E11 projection and E12 JSON text-sequence framing remain deferred. No precompiled SDK-linked WASM binaries are included in the release assets.

Assets and support

Verify the source archive, matching compiled DocC archive, public evidence archive and qualification receipt against SHA256SUMS. Source/evidence archives include exact file manifests; the DocC manifest accompanies its archive. Public assets exclude private maintainer records, personal device identifiers, credentials and build products.

Online documentation follows qualified main; the attached DocC archive matches this tag. Support · Private security reporting · Source changelog.

Swift-JSON 1.1.1

Swift-JSON 1.1.1 corrects cumulative accounting in JSONSchemaBuilder.object and clarifies the release documentation. It preserves the public API and default resource profiles from 1.1.0.

Fixes and compatibility

• Object construction and schema-document admission now share one finite cumulative budget in the schema-compilation domain. A 100-byte description under a 150-work-unit limit correctly fails instead of succeeding through separate phase budgets.
• Owned resource failures and cancellation remain terminal even if the builder callback catches them. Replacing or swapping the callback accumulator cannot reset the original operation's ledger.
• Schema compilation-work and plan-retention limits apply during construction as well as admission. Tight custom quotas that previously relied on a reset may now fail correctly. Public signatures, the 49 resource metrics and their default values are unchanged.
• README, API comments and DocC explain the shared-budget contract and the published 1.1 platform baseline. The frozen source changelog describes these changes under its Unreleased heading; these versioned notes bind that existing entry to 1.1.1 without changing the verified commit.

Swift tools/compiler 6.4+, Swift language mode 6, and macOS or iOS/iPadOS 27+ remain required. Four public products: JSON, JSONSchema, JSONStreaming and JSONPatch. JSONRegexRuntime remains private, root dependencies remain empty, and Apache-2.0 with all upstream notices is retained.

.package(url: "https://github.com/ThorFuchs/Swift-JSON.git", from: "1.1.1")

Qualification

The tag targets verified commit 653275373f0e69c7cfc303abf2882fc463e02bd3. Its post-merge native CI passed Native / native, Native / safety and Native / docs, followed by the existing documentation deployment. Debug, release and full ASAN each execute 184 test functions and 173 parameterized invocations; TSAN executes five concurrency functions. Strict memory-safety compilation, nine schema-builder regression cases, all 49 metric probes, ownership/reader compiler probes and public consumers pass.

The independent JSON corpus records 287 evaluated successes and 31 policy cases out of 318; the schema corpus records 2,300 evaluated successes and 37 policy cases out of 2,337. Policy cases are excluded from evaluated successes. Deterministic malformed-input replay covers 4,396 cases. The JSON/JSONSchema consumer retains 20 explicitly rooted instances (eight positive and 12 ordinary invalid), plus two separate operational errors; it does not establish downstream MCP conformance.

The attached qualification receipt and evidence archive retain exact source identity, clean archive reproduction/build/test, commands, toolchains, counts and an independently resolved 1.1.1 tag consumer. Four matching native DocC catalogues compile without diagnostics; coverage records 582 authored public symbols and ten compiled README examples.

The identical reviewed patch source passed iPhoneOS and iPhoneSimulator public-consumer builds, plus the explicit SwiftData shape compiler probe on macOS and both mobile SDKs. The patch's native lane exercises macOS public behavior and disk persistence. Earlier 1.1 mobile simulator and physical iPhone runtime qualification remains historical evidence, with no new patch-level physical-device run claimed. Physical iPad behavior, performance, memory and energy remain unmeasured, under the approved qualification policy; simulator results make no physical-device claim.

Performance disposition

The qualified idle-window A/B run compares the released 1.1.0 source with the reviewed patch tree. Construction median changes are +11.35% for one 100-byte description and +21.96% for a 64-member object with 256-byte strings. Both crossed the unchanged 10% review trigger and were reviewed and accepted for the required cumulative-budget and terminal-failure correction. No quota increase or faster path that weakens accounting was selected.

The experiment uses a native virtual Mac, A/B/B/A ordering, three warmups and nine samples per workload/process, with three consecutive ≥90% idle samples before and after each process and zero swapping. Background activity and baseline variation remain visible; this does not establish noise-free hardware or guaranteed throughput. The fixed-vector logical-retention overlap rises from 231 to 247 bytes (+6.93%); those bytes are distinct from process RSS. The historical streaming comparisons (approximately +11.0%, and the separate 1.1 integrated +15.76%) retain their existing dispositions. Caller callbacks are outside owned instruction quotas. SIMD, parallel batches, E11 projection and E12 text-sequence framing remain deferred.

Assets and support

Verify the source, compiled DocC, public evidence archive and qualification receipt against SHA256SUMS. Each archive includes or accompanies a file manifest. The evidence archive contains reviewed public CI, clean-build, tag-consumer and performance records; private maintainer handoffs, personal device identifiers and signing/build products are excluded.

Online documentation follows qualified main; the attached DocC archive matches this tag. Source changelog · Support · Private security reporting.

Swift-JSON 1.1.0

Swift-JSON 1.1.0 adds scoped access, exact persistence and Apple mobile support to the strict JSON model introduced in 1.0.

What changes

• Scoped typed reads: chain throwing String, JSONKey and Int brackets; distinguish absence from null; convert numbers with explicit fidelity; decode models under one cumulative meter. Cursors are synchronous and non-Sendable, invalidate on scope exit and release their root/source references.
• Native Codable conveniences: encode models directly into JSON values and decode them using the existing native strategies, without a Foundation serialization intermediate.
• Exact versioned persistence: JSONCodablePayload uses a fixed Version 1 envelope containing strict Base64 of a complete UTF-8 JSON document. It preserves exact decimals, decoded scalars, insertion order and admitted numeric lexemes. The qualified SwiftData example remains outside the core products and demonstrates disk reopening across three exited processes.
• Wide-object indexing: private exact-confirmed metadata accelerates wide-object construction and lookup, retains ordered members, and recognizes duplicates at the second key before its value. Growth, collisions and cancellation remain metered; small objects retain their scalar path.
• Apple platforms: macOS 27 and iOS/iPadOS 27 deployment minima, with corrected schema-resource packaging and SDK/simulator consumers.
• Correctness fixes: native ISO-8601 now includes calendar fields; strict Base64 rejects noncanonical unused padding bits; failed Base64 scratch is released from logical accounting without refunding work or terminal failures.

Compatibility and installation

Swift tools/compiler 6.4+, Swift language mode 6, and macOS or iOS/iPadOS 27+. Native qualification uses Apple Silicon with SDK 27.2. Four public products remain JSON, JSONSchema, JSONStreaming and JSONPatch; JSONRegexRuntime is private. Root package dependencies remain empty. Original code is Apache-2.0 with retained upstream notices.

.package(url: "https://github.com/ThorFuchs/Swift-JSON.git", from: "1.1.0")

Existing exact decimal, decoded-scalar key/text, ordered-object equality, strict UTF-8, offline schema-plan, staged Patch and stream-completion contracts remain. The ISO-8601 calendar correction can require explicit application migration for previously written time-only data. Package versions, payload format versions and application/SwiftData schemas are separate; the persistence envelope does not silently convert older storage formats. See the API and migration contract.

Qualification and limitations

The exact tagged commit passed post-merge Native / native, Native / safety and Native / docs, and the existing Pages deployment. The matching source archive is clean-extracted: its Git-free build/debug/release tests pass, and the full native lane passes after actual public Git metadata supplies the ownership probes’ required commit identity. Archive source bytes remain unchanged. Qualification retains 175 test functions, 173 parameterized invocations, full ASAN, five TSAN cases, strict memory-safety compilation, all 49 cap probes, pinned independent suites, four DocC catalogues, 582 authored public symbols and 10 compiled README examples. Corpus policy exclusions are listed separately from evaluated successes; ordinary schema invalidity remains distinct from operational errors. The public JSON/JSONSchema consumer retains 20 explicitly rooted frozen cases; it does not establish MCP server conformance.

Both mobile SDKs and iPhone/iPad simulator public behavior and three-process disk persistence are qualified, with unchanged-source physical iPhone evidence. Physical iPad behavior, performance, memory and energy are deferred and unmeasured, under the explicit 1.1 qualification policy. Simulator data is not a physical-device measurement.

The unchanged 10% performance review trigger and accepted dispositions remain: the historical stream comparison is approximately +11.0%; the separate matched 1.1 comparison is +15.76%. Wide-object gains include documented small-workload and spare-capacity costs. These are measured tradeoffs, without a package-wide speedup or hard RSS guarantee. Logical retained bytes differ from process RSS, and arbitrary caller callbacks are outside owned instruction quotas. See the measured disposition. SIMD, independent-work parallel batches, E11 projection and E12 text-sequence framing remain deferred.

Assets and support

Install through the SwiftPM tag. The source archive carries its own file manifest; the DocC archive preserves native catalogue filenames. The qualification JSON and evidence archive identify the source, environment, commands, counts, exclusions and limitations. Verify downloads against SHA256SUMS. Maintainer-private handoff bundles, device identifiers and build/signing outputs are excluded from these assets.

Online documentation tracks qualified main; the attached DocC archive matches this tag exactly. Changelog · Support · Private security reporting.

Swift-JSON 1.0.0

Swift-JSON 1.0.0 is the first stable release: exact JSON values, offline JSON Schema
validation, transactional patches and pull-driven streams for modern Swift.

Requirements and installation

Swift tools/compiler 6.4+, Swift language mode 6, and macOS/SDK 27+.
Native qualification covers Apple Silicon. The root package has no external
dependencies. Original contributions use Apache-2.0; upstream licenses and notices
are retained.

.package(url: "https://github.com/ThorFuchs/Swift-JSON.git", from: "1.0.0")

Choose any of the four public products: JSON, JSONSchema, JSONStreaming and
JSONPatch. JSONRegexRuntime remains package-private.

Included capabilities

• Exact bounded decimal numbers; decoded Unicode scalar identity for strings and
  keys; insertion-ordered objects with order-independent equality.
• One strict UTF-8 codec for complete documents and streams, native value-based
  Codable, RFC 6901 Pointer, presence and construction helpers, owned source
  documents, bounded diagnostics and public operation reports.
• Draft 2020-12 schema compilation/evaluation, explicit offline immutable registries
  and plans, annotations, raw declaration inspection and interruptible budgeted
  native regex. Ordinary invalidity remains distinct from operational errors.
• Staged RFC 6902 JSON Patch and RFC 7396 Merge Patch, including root removal distinct
  from JSON null.
• Pull events/values, strict NDJSON, provisional root-array elements with explicit
  completion, awaited sinks and cumulative finite budgets.

Qualification and boundaries

The public qualification receipt identifies the exact source commit, native CI
commands and outcomes, clean-extraction build/test proof, pinned independent suites,
all 49 finite resource caps, safety lanes and public consumers. Policy exclusions
are reported separately from evaluated outcomes. Compiled DocC catalogues accompany
the release; online documentation tracks
qualified main.

Default resource profiles bound charged owned work and logical retention. They are
initial policy, not hard process RSS or throughput guarantees; arbitrary caller
callback work is outside owned instruction quotas. Stream yields do not certify an
enclosing document until closing syntax, trailing whitespace and EOF are checked.

The existing performance review accepts a stream median of 1.07496 seconds versus
0.96849 seconds (approximately +11.0%), above the unchanged 10% review trigger.
This release preserves that disposition and makes no causal speedup claim. Scalar
scanning and immutable plan-local regex sharing remain selected. Projection and
RFC 7464 JSON text-sequence framing remain deferred.

The rooted JSON/JSONSchema consumer exercises 20 frozen vectors plus operational
failure cases. These results do not establish MCP server or protocol conformance.

Assets and support

Use SwiftPM's version tag for installation. The source archive carries an embedded
file manifest; the DocC archive preserves native catalogue filenames. Verify all
downloaded assets against SHA256SUMS.

Changelog ·
Support and maintenance ·
Private security reporting

Fixes target the latest published 1.x release with best-effort maintenance.