From 3f875ae96b579e7112f8629c04af3feedeb9a863 Mon Sep 17 00:00:00 2001 From: James Ross Date: Sun, 23 Aug 2026 03:52:52 -0700 Subject: [PATCH 01/30] feat: establish ReplaceRange Edict application boundary --- .gitignore | 3 + CHANGELOG.md | 4 + edict/replace-range/README.md | 42 ++++ edict/replace-range/edict.application.json | 20 ++ edict/replace-range/edict.lawpack.json | 207 ++++++++++++++++++ edict/replace-range/src/ReplaceRange.edict | 41 ++++ edict/replace-range/tests/build.sh | 52 +++++ .../vendor/jedit-text/adapter.cbor | Bin 0 -> 431 bytes .../vendor/jedit-text/adapter.sha256 | 1 + .../echo-operation-configuration.cbor | 1 + .../echo-operation-configuration.sha256 | 1 + .../jedit-text/edict.lawpack-output.json | 67 ++++++ .../vendor/jedit-text/exports.cbor | Bin 0 -> 2212 bytes .../vendor/jedit-text/exports.sha256 | 1 + .../vendor/jedit-text/manifest.cbor | Bin 0 -> 787 bytes .../vendor/jedit-text/manifest.sha256 | 1 + .../vendor/jedit-text/verifier-rules.cbor | 1 + .../vendor/jedit-text/verifier-rules.sha256 | 1 + 18 files changed, 443 insertions(+) create mode 100644 edict/replace-range/README.md create mode 100644 edict/replace-range/edict.application.json create mode 100644 edict/replace-range/edict.lawpack.json create mode 100644 edict/replace-range/src/ReplaceRange.edict create mode 100755 edict/replace-range/tests/build.sh create mode 100644 edict/replace-range/vendor/jedit-text/adapter.cbor create mode 100644 edict/replace-range/vendor/jedit-text/adapter.sha256 create mode 100644 edict/replace-range/vendor/jedit-text/echo-operation-configuration.cbor create mode 100644 edict/replace-range/vendor/jedit-text/echo-operation-configuration.sha256 create mode 100644 edict/replace-range/vendor/jedit-text/edict.lawpack-output.json create mode 100644 edict/replace-range/vendor/jedit-text/exports.cbor create mode 100644 edict/replace-range/vendor/jedit-text/exports.sha256 create mode 100644 edict/replace-range/vendor/jedit-text/manifest.cbor create mode 100644 edict/replace-range/vendor/jedit-text/manifest.sha256 create mode 100644 edict/replace-range/vendor/jedit-text/verifier-rules.cbor create mode 100644 edict/replace-range/vendor/jedit-text/verifier-rules.sha256 diff --git a/.gitignore b/.gitignore index 733790b0..ff1f05b4 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,9 @@ title-recordings/ .wesley-cache/ .jedit-cache/ .jedit/ +.build/ +.vendor.edict-lawpack-build.lock +.jedit-text.edict-lawpack-build.lock .obsidian/ .claude/ src/generated/jedit/structural-history-replace-text-range.wesley.generated.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index e9687470..9680ee4c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,10 @@ ## Unreleased +- Added the Jedit-owned `ReplaceRange.edict` application root and canonical + `jedit.text@1` lawpack publication. Its executable integration gate now proves + that real source reaches Edict's public Target IR boundary and fails closed + before package emission while generic Core `let` lowering remains unsupported. - Made `ReplaceRange` corroborate the selected Head/root byte extent and exact requested-range materialization before no-op classification, so truncated or absent retained roots fail with a typed malformed-rope obstruction. diff --git a/edict/replace-range/README.md b/edict/replace-range/README.md new file mode 100644 index 00000000..4c030195 --- /dev/null +++ b/edict/replace-range/README.md @@ -0,0 +1,42 @@ +# ReplaceRange Edict application + +This directory is the Jedit-owned application root for issue #296. It keeps +five artifact classes separate: + +- `edict.lawpack.json` is the reviewable `jedit.text@1` authoring input; +- `vendor/jedit-text/` is Edict's canonical published lawpack closure; +- `src/ReplaceRange.edict` is the application-owned source; +- `.build/` contains disposable provider and compiler outputs; +- `contracts/jedit/lawpacks/replace-range-v1/` remains the independent schema + and oracle corpus and is not executable input. + +## Current executable boundary + +The checked-in source is the first compiler-pressure slice, not a completed +text mutation. It binds bounded identity bytes, the selected basis, range, +replacement bytes, operation profile, budget, imported helper implementation, +and a pure conditional into Edict Core. It intentionally does not claim to +traverse or rewrite a rope yet. + +The public application build currently reaches Edict Target IR lowering and +fails closed because the selected generic target profile cannot lower the Core +`let` nodes emitted for the digest-bound helper and conditional. No package is +emitted and Echo is not invoked. That failure is the routing evidence required +by #296: the next owner is Edict's generic Core-to-Target-IR boundary, not Echo +and not a native Jedit planner. + +## Reproduce + +The build script requires exact local Edict and Echo checkouts: + +```bash +EDICT_REPO=/path/to/edict \ +ECHO_REPO=/path/to/echo \ + ./edict/replace-range/tests/build.sh +``` + +The script first republishes `jedit.text@1` through Edict's public lawpack +authoring boundary, then copies Echo's checked provider package into the +disposable application build tree and invokes Edict's public application build. +Until the generic lowering gap is implemented, it requires the stable +`TargetLoweringFailed` refusal and rejects accidental package emission. diff --git a/edict/replace-range/edict.application.json b/edict/replace-range/edict.application.json new file mode 100644 index 00000000..f3e59f82 --- /dev/null +++ b/edict/replace-range/edict.application.json @@ -0,0 +1,20 @@ +{ + "schema": "edict.application/v1", + "coordinate": "jedit.text.replace_range@1", + "sources": [ + "src/ReplaceRange.edict" + ], + "lawpacks": [ + { + "manifest": "vendor/jedit-text/manifest.cbor", + "exports": "vendor/jedit-text/exports.cbor", + "adapter": "vendor/jedit-text/adapter.cbor", + "targetConfiguration": "vendor/jedit-text/echo-operation-configuration.cbor" + } + ], + "target": { + "profile": "echo.dpo@1", + "providerPackage": ".build/echo-provider" + }, + "outputDirectory": ".build/application" +} diff --git a/edict/replace-range/edict.lawpack.json b/edict/replace-range/edict.lawpack.json new file mode 100644 index 00000000..81865aae --- /dev/null +++ b/edict/replace-range/edict.lawpack.json @@ -0,0 +1,207 @@ +{ + "schema": "edict.lawpack-build/v1", + "outputDirectory": "vendor/jedit-text", + "lawpack": { + "schema": "edict.lawpack-authoring/v1", + "id": "jedit.text", + "version": "1", + "acceptedCoreAbi": [ + "edict.core/v1" + ], + "dependencies": [], + "exportsCoordinate": "jedit.text.exports/v1", + "exports": { + "types": [ + { + "coordinate": "jedit.text@1.NodeId", + "definition": "Bytes" + }, + { + "coordinate": "jedit.text@1.ReplacementBytes", + "definition": "Bytes" + }, + { + "coordinate": "jedit.text@1.ObstructionDetail", + "definition": "String" + } + ], + "constants": [ + { + "coordinate": "jedit.text@1.maxCreatedLeaves", + "type": "U64", + "value": 4096 + }, + { + "coordinate": "jedit.text@1.maxCreatedBranches", + "type": "U64", + "value": 4096 + } + ], + "pureFunctions": [ + { + "source": "edict", + "coordinate": "jedit.text@1.maxCreatedLeafCount", + "typeParameters": [], + "parameterTypes": [], + "returnType": "U64", + "costTemplate": "jedit.text@1.replaceRangeBudget", + "determinismClass": "total", + "body": { + "params": [], + "body": { + "locals": [], + "bindings": [], + "result": { + "kind": "const", + "value": { + "kind": "int", + "width": "U64", + "value": 4096 + } + } + } + } + } + ], + "effects": [], + "obstructions": [ + { + "coordinate": "jedit.text@1.RangeOrderInvalid", + "authorityClass": "domainMappable", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.RangeOutOfBounds", + "authorityClass": "domainMappable", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.Utf8BoundaryInvalid", + "authorityClass": "domainMappable", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.NoOp", + "authorityClass": "domainMappable", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.BasisNotCanonical", + "authorityClass": "domainMappable", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.ArithmeticOverflow", + "authorityClass": "integrityFault", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.FactMissing", + "authorityClass": "resourceFault", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.FactMalformed", + "authorityClass": "integrityFault", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.ContentIdentityMismatch", + "authorityClass": "integrityFault", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.MalformedRope", + "authorityClass": "integrityFault", + "payloadSchema": "jedit.text@1.ObstructionDetail" + } + ], + "operationProfiles": { + "jedit.text@1.replaceRange": { + "opticTemplate": { + "opticKind": "affectReintegration", + "boundaryKind": "affect", + "supportPolicy": "jedit.text@1.basisBoundSupport", + "lossDisposition": "jedit.text@1.lossless", + "basisTemplate": "jedit.text@1.exactHeadBasis", + "apertureRequirement": { + "kind": "abstractFootprintObligation", + "reference": "jedit.text@1.replaceRangeFootprint" + } + }, + "effectPredicate": "jedit.text@1.replaceRangeEffects" + } + } + }, + "targetAdapters": [ + { + "coordinate": "jedit.text.echo-adapter/v1", + "output": "adapter.cbor", + "acceptedTargetProfile": { + "id": "echo.dpo@1", + "digest": "sha256:2e2494121aecf5e6a2d920f5fb85408825d394765fad41484c416397c920fb04" + }, + "acceptedTargetIr": { + "id": "echo.span-ir/v1", + "digest": "sha256:0057167e68f50c99dcce087b3e1cd677d17c5d1dc238bdb52d89469e1472fc2f" + }, + "operationProfiles": { + "jedit.text@1.replaceRange": { + "core": "continuum.profile.read-write/v1", + "semanticEffects": [], + "budgetObligation": "jedit.text@1.replaceRangeBudget", + "targetConfiguration": { + "local": "echo-config" + } + } + }, + "effectImplementations": {}, + "budgets": { + "jedit.text@1.replaceRangeBudget": { + "maxSteps": 1048576, + "maxAllocatedBytes": 16777216, + "maxOutputBytes": 8388608 + } + } + } + ], + "verifier": { + "class": "declarative", + "ruleset": { + "local": "verifier-rules" + } + }, + "compatibility": { + "id": "jedit.text.compatibility/v1", + "digest": "sha256:2adf83f798205f52636ad64ca45178f33a8e1cc663874f8a6113484c945e3052" + }, + "conformanceFixtureCorpus": { + "id": "jedit.text.ReplaceRange.oracle@1", + "digest": "sha256:b9b4707dd5e07897cbe7af36d88928401887e6af5d167d1a88a8d6181b4dbb0e" + }, + "localResources": [ + { + "name": "echo-config", + "coordinate": "jedit.text.echo-config/v1", + "output": "echo-operation-configuration.cbor", + "value": { + "apiVersion": "jedit.text.echo-config/v1", + "instructionProfile": "echo.dpo@1.generic-bounded-graph", + "operation": "jedit.text@1.replaceRange" + } + }, + { + "name": "verifier-rules", + "coordinate": "jedit.text.verifier-rules/v1", + "output": "verifier-rules.cbor", + "value": { + "schema": "jedit.text.schema@1", + "schemaDigest": "sha256:f49b0ff6c9c7010d3a72b46734d47832853f496739a083edc41dddec3431bac7", + "oracleIsExecutableInput": false, + "runtimeOntology": "generic-bounded-graph" + } + } + ] + }, + "dependencyBundles": [] +} diff --git a/edict/replace-range/src/ReplaceRange.edict b/edict/replace-range/src/ReplaceRange.edict new file mode 100644 index 00000000..cd317ee0 --- /dev/null +++ b/edict/replace-range/src/ReplaceRange.edict @@ -0,0 +1,41 @@ +package jedit.text.replace_range@1; + +use lawpack jedit.text@1 digest "sha256:0719a4161eaede5aa062f6cbd2e2ff74dee0bd961d0945449cd27ae2ef26f59a" as text; + +type ReplaceRangeInput = { + bufferId: Bytes, + basisHeadId: Bytes, + startByte: U64, + endByte: U64, + replacement: Bytes, +}; + +type ReplaceRangeBoundary = { + bufferId: Bytes, + basisHeadId: Bytes, + startByte: U64, + endByte: U64, + replacement: Bytes, + rangeIsEmpty: U32, + createdLeafCeiling: U64, +}; + +intent replaceRange(input: ReplaceRangeInput) returns ReplaceRangeBoundary + profile text.replaceRange + basis input.basisHeadId + budget <= text.replaceRangeBudget + where input.startByte <= input.endByte +{ + let createdLeafCeiling: U64 = text.maxCreatedLeafCount(); + let rangeIsEmpty = if input.startByte == input.endByte then 1u32 else 0u32; + + return { + bufferId: input.bufferId, + basisHeadId: input.basisHeadId, + startByte: input.startByte, + endByte: input.endByte, + replacement: input.replacement, + rangeIsEmpty, + createdLeafCeiling, + }; +} diff --git a/edict/replace-range/tests/build.sh b/edict/replace-range/tests/build.sh new file mode 100755 index 00000000..27f75ee6 --- /dev/null +++ b/edict/replace-range/tests/build.sh @@ -0,0 +1,52 @@ +#!/usr/bin/env bash +set -euo pipefail + +project_root=$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd) +application_root="$project_root/edict/replace-range" +edict_repo=${EDICT_REPO:?set EDICT_REPO to an exact Edict checkout} +echo_repo=${ECHO_REPO:?set ECHO_REPO to an exact Echo checkout} +edict_bin=${EDICT_BIN:-"$edict_repo/target/debug/edict"} +provider_source="$echo_repo/schemas/edict-provider/package/v1" + +test -x "$edict_bin" +test -f "$provider_source/provider-manifest.echo.json" +test -f "$provider_source/components/lowerer.echo-dpo.component.wasm" +test -f "$provider_source/components/verifier.echo-dpo.component.wasm" + +if find "$provider_source" -type l -print -quit | grep -q .; then + echo "provider package must not contain symlinks" >&2 + exit 1 +fi + +cd "$application_root" + +printf '%s\n' \ + '{"schema":"edict.compiler.settings/v1","type":"compilerSettings","operation":"build","lawpack":"edict.lawpack.json"}' \ + | "$edict_bin" + +rm -rf .build/echo-provider .build/application +mkdir -p .build/echo-provider +cp -RL "$provider_source/." .build/echo-provider/ + +if find .build/echo-provider -type l -print -quit | grep -q .; then + echo "copied provider package must not contain symlinks" >&2 + exit 1 +fi + +set +e +build_output=$( + printf '%s\n' \ + '{"schema":"edict.compiler.settings/v1","type":"compilerSettings","operation":"build","application":"edict.application.json"}' \ + | "$edict_bin" 2>&1 +) +build_status=$? +set -e + +printf '%s\n' "$build_output" +test "$build_status" -ne 0 +printf '%s\n' "$build_output" \ + | jq --exit-status --slurp \ + 'any(.[]; .type == "diagnostic" and .kind == "TargetLoweringFailed")' \ + >/dev/null +test ! -e .build/application/executable-operation-package.cbor +test ! -e .build/application/verification-report.cbor diff --git a/edict/replace-range/vendor/jedit-text/adapter.cbor b/edict/replace-range/vendor/jedit-text/adapter.cbor new file mode 100644 index 0000000000000000000000000000000000000000..c96488df0963dbf0b2283b73bd06eb953530e455 GIT binary patch literal 431 zcmaiwp-uxq5QZ0pMM5iz!1hQS&X zz#u>&afIMV9ggjt!4TAB{`@olH*=3%f%knes}4vGG3jI?LGm|wt%pKVM3~c7BXVdJ za6AB=V6(8?c2mgPgw|Ks0%JOKt&D6&%@e|)jTsvRZCfeBfl!q49Am5pRvx1B(&&6K zgm8)!j4bee9RyfHw>oSLjKvv}(fiKCQei+^`V;9+aN{tqaidAP6cof^^uc= zVX5($LU8ciI7Uu>Y|C?79VL?@?BBCJfeR1XF*=q>RuWD+Qv8OCkatZzumnp;jfG6m z(|PQ>u(rN&v|Rc4Jo|o-7su7d=da85>FeZbe)_aB|I&)5@72w>3=6!y)GAC-Q$gmh Fe*pW=s=)vN literal 0 HcmV?d00001 diff --git a/edict/replace-range/vendor/jedit-text/adapter.sha256 b/edict/replace-range/vendor/jedit-text/adapter.sha256 new file mode 100644 index 00000000..152492ee --- /dev/null +++ b/edict/replace-range/vendor/jedit-text/adapter.sha256 @@ -0,0 +1 @@ +sha256:4a4ead6b31d561c12d9abcd64b9e6cf518e4ee3d3d3770ae971559642fb02828 diff --git a/edict/replace-range/vendor/jedit-text/echo-operation-configuration.cbor b/edict/replace-range/vendor/jedit-text/echo-operation-configuration.cbor new file mode 100644 index 00000000..b2057f98 --- /dev/null +++ b/edict/replace-range/vendor/jedit-text/echo-operation-configuration.cbor @@ -0,0 +1 @@ +£ioperationxjedit.text@1.replaceRangejapiVersionxjedit.text.echo-config/v1rinstructionProfilex echo.dpo@1.generic-bounded-graph \ No newline at end of file diff --git a/edict/replace-range/vendor/jedit-text/echo-operation-configuration.sha256 b/edict/replace-range/vendor/jedit-text/echo-operation-configuration.sha256 new file mode 100644 index 00000000..2612bf63 --- /dev/null +++ b/edict/replace-range/vendor/jedit-text/echo-operation-configuration.sha256 @@ -0,0 +1 @@ +sha256:1ae7e97df9b46983591bc6cff08d537cd6a29c07f2cb2407d04f66f2e51b39de diff --git a/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json b/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json new file mode 100644 index 00000000..4f76b710 --- /dev/null +++ b/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json @@ -0,0 +1,67 @@ +{ + "schema": "edict.lawpack-output/v1", + "lawpackId": "jedit.text", + "lawpackVersion": "1", + "artifacts": [ + { + "path": "manifest.cbor", + "kind": "manifest", + "coordinate": "edict.lawpack/v1", + "digest": "sha256:0719a4161eaede5aa062f6cbd2e2ff74dee0bd961d0945449cd27ae2ef26f59a" + }, + { + "path": "manifest.sha256", + "kind": "manifestDigest", + "coordinate": "edict.lawpack/v1", + "digest": "sha256:0719a4161eaede5aa062f6cbd2e2ff74dee0bd961d0945449cd27ae2ef26f59a" + }, + { + "path": "exports.cbor", + "kind": "exports", + "coordinate": "jedit.text.exports/v1", + "digest": "sha256:2a4ef08bec9f2839aa69841a6458eabc037f1ea698fd1a68392aeb84d5b306be" + }, + { + "path": "exports.sha256", + "kind": "exportsDigest", + "coordinate": "jedit.text.exports/v1", + "digest": "sha256:2a4ef08bec9f2839aa69841a6458eabc037f1ea698fd1a68392aeb84d5b306be" + }, + { + "path": "echo-operation-configuration.cbor", + "kind": "localResource", + "coordinate": "jedit.text.echo-config/v1", + "digest": "sha256:1ae7e97df9b46983591bc6cff08d537cd6a29c07f2cb2407d04f66f2e51b39de" + }, + { + "path": "echo-operation-configuration.sha256", + "kind": "localResourceDigest", + "coordinate": "jedit.text.echo-config/v1", + "digest": "sha256:1ae7e97df9b46983591bc6cff08d537cd6a29c07f2cb2407d04f66f2e51b39de" + }, + { + "path": "verifier-rules.cbor", + "kind": "localResource", + "coordinate": "jedit.text.verifier-rules/v1", + "digest": "sha256:364fb4ff98ae64fcd8d793aae3d7cb133ff8a1ce661330cea47688b13a0a823f" + }, + { + "path": "verifier-rules.sha256", + "kind": "localResourceDigest", + "coordinate": "jedit.text.verifier-rules/v1", + "digest": "sha256:364fb4ff98ae64fcd8d793aae3d7cb133ff8a1ce661330cea47688b13a0a823f" + }, + { + "path": "adapter.cbor", + "kind": "adapter", + "coordinate": "jedit.text.echo-adapter/v1", + "digest": "sha256:4a4ead6b31d561c12d9abcd64b9e6cf518e4ee3d3d3770ae971559642fb02828" + }, + { + "path": "adapter.sha256", + "kind": "adapterDigest", + "coordinate": "jedit.text.echo-adapter/v1", + "digest": "sha256:4a4ead6b31d561c12d9abcd64b9e6cf518e4ee3d3d3770ae971559642fb02828" + } + ] +} diff --git a/edict/replace-range/vendor/jedit-text/exports.cbor b/edict/replace-range/vendor/jedit-text/exports.cbor new file mode 100644 index 0000000000000000000000000000000000000000..ab18a6b613d15e096bb3f507ba661ab3fe82ed6a GIT binary patch literal 2212 zcmcIlO>Yx15alOuq*Qzeaju}Wr3a`WDG?R4iPH85IQDGf;I+4&*>-aaaN}Q)NEJVm zv6ql_E0sgYWmnmF=FOWKzjqBZDFDCE#?m>jv=sz62Bm3>prUs#w@#dbBQ;i#X{$*) zo3|!>=1nfDx39Jjnt|1$B(e{M5fXB+6hj(0{4&SO7d!jAulLeKkCQ~*0g^9e06zp0 z+B7n`Q}WslV>#Qqdj~_vGLVE*EuBRYmhjtL1(Nc7ZwD@gDPiOOy$0PIRWq-)2X2G< z4B`^-AHh$ON|(VcFRUB^8n-MSf6SY>DapRDL+E-1{>XBbTIGe97$?*zr{TQm>02$a zqNI`YnkH={5Up~#(Dqmqg%}t}aBoa0;+E9STCTJT*9QAE>C`!8`w>w1$(jjYB)})G zTda*^I;56BjVF%U!aA#^Fl)n2x9~l$!6*mPvU>?WGwy0NU~LJ8VYNDz!i${W^>l%KMp9D}Q;k@vDNAwIW_hBq2P(Zi`=jSZI;1o1 zgJHq0(p%tb`-!^RD%B9kMtC6bAs(kT*g`Lq6u#lKP~n}k&tV=_6v&Y<7u;ztg8THm z%d`RfS#2aM(S(}iuHc)uDC%0rpP#q|D55p>p&oY3Xa+%aSp&m?tUizrf^IAlRGSGD zRD8!if>2Rhax9C&dFnZ%<>ZD(#57T3PwP|8IK)GZg~RCNWs*7k$=nbH)8!^ZA1+Gm zqkqq&hpc**oNtouI7bEhFvUHnHbpQ!F7)sB?!f3_WbA5#?)fnMFtv2%&8#14EB_5s CA8PUd literal 0 HcmV?d00001 diff --git a/edict/replace-range/vendor/jedit-text/exports.sha256 b/edict/replace-range/vendor/jedit-text/exports.sha256 new file mode 100644 index 00000000..41aa6fab --- /dev/null +++ b/edict/replace-range/vendor/jedit-text/exports.sha256 @@ -0,0 +1 @@ +sha256:2a4ef08bec9f2839aa69841a6458eabc037f1ea698fd1a68392aeb84d5b306be diff --git a/edict/replace-range/vendor/jedit-text/manifest.cbor b/edict/replace-range/vendor/jedit-text/manifest.cbor new file mode 100644 index 0000000000000000000000000000000000000000..dac00a5ab49fa14f63804e195860ade1c1416bea GIT binary patch literal 787 zcmZ3Ll$ny1m70=SqF0hyQIeioQIKC$QoIN#T#69Zg9_`H8K$LVrl%H{G^G`1BpR8T zMJQWK*{FTbE)Oy`=bu-((^s>~V;>`TKM8gaqD>E%K zwP;ala!z7#adrxbE=nxPEK5x)2?;)nuQQSdbY8aYF&nqsb+DIf>;3iOJbO!*Wtm3sUn^ zQuC5CQ;QpNlk;;6fX+$E%*iaN1Up3<$tftZ*j%D@zxn$Nh4`T4tZP0?0xLdS^~oGd zZujp>6!!3$5@!&USCUwio?7CVl2}jzbWr2s^h5{~Y?Ty}RjJ7t`MOX^Y&LoMt<5&P zns`um)}CwL^K!mQJb7npYhJK!x@csI{ss*Vp!bqfftI9%fNk_F0@;ucGF7j*ATduj zvk0514B=vR8DDv3-Z{rnZ6|ZB{9;Y4>>-Q2TXj3#=7|*j(Jw_cHJ~UzEi)$-WONqT z=#+wd2h0Sbr!qxI>dn_@i*71>{oU%&p?Y~rS^Qc@4&Wraj?eqLIBQEp;ha;jTqMM-H Date: Sun, 23 Aug 2026 04:27:26 -0700 Subject: [PATCH 02/30] test: advance ReplaceRange compiler boundary --- CHANGELOG.md | 8 +++++--- edict/replace-range/README.md | 24 ++++++++++++++++-------- edict/replace-range/tests/build.sh | 2 +- 3 files changed, 22 insertions(+), 12 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9680ee4c..bc7578c6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,9 +3,11 @@ ## Unreleased - Added the Jedit-owned `ReplaceRange.edict` application root and canonical - `jedit.text@1` lawpack publication. Its executable integration gate now proves - that real source reaches Edict's public Target IR boundary and fails closed - before package emission while generic Core `let` lowering remains unsupported. + `jedit.text@1` lawpack publication. With Edict #201, its executable integration + gate now proves that real source lowers into generic pure Target IR and reaches + Echo's provider-contract boundary, which refuses the new artifact family + before package emission. Rope mutation and end-to-end Jim execution remain + unimplemented. - Made `ReplaceRange` corroborate the selected Head/root byte extent and exact requested-range materialization before no-op classification, so truncated or absent retained roots fail with a typed malformed-rope obstruction. diff --git a/edict/replace-range/README.md b/edict/replace-range/README.md index 4c030195..e7300ad4 100644 --- a/edict/replace-range/README.md +++ b/edict/replace-range/README.md @@ -18,12 +18,18 @@ replacement bytes, operation profile, budget, imported helper implementation, and a pure conditional into Edict Core. It intentionally does not claim to traverse or rewrite a rope yet. -The public application build currently reaches Edict Target IR lowering and -fails closed because the selected generic target profile cannot lower the Core -`let` nodes emitted for the digest-bound helper and conditional. No package is -emitted and Echo is not invoked. That failure is the routing evidence required -by #296: the next owner is Edict's generic Core-to-Target-IR boundary, not Echo -and not a native Jedit planner. +With Edict #201, the public application build lowers those Core `let` nodes into +generic, source-ordered Target IR and independently verifies the compiler-owned +result projection. The exact Echo provider package then refuses the invocation +as `InvalidProviderInvocation` because its published adapter, target +configuration, Target IR, and result-projection contracts do not yet admit the +new generic artifact family. No executable operation package is emitted and no +Echo evaluator runs. + +That refusal is the current routing evidence required by #296: Edict now +preserves the bounded pure program without learning Jedit vocabulary, and the +next owner is Echo's generic provider package and execution profile. It is not +evidence that `ReplaceRange` mutates a rope or that Jim runs end to end. ## Reproduce @@ -38,5 +44,7 @@ ECHO_REPO=/path/to/echo \ The script first republishes `jedit.text@1` through Edict's public lawpack authoring boundary, then copies Echo's checked provider package into the disposable application build tree and invokes Edict's public application build. -Until the generic lowering gap is implemented, it requires the stable -`TargetLoweringFailed` refusal and rejects accidental package emission. +Against Edict #201 it requires the stable `InvalidProviderInvocation` refusal +and rejects accidental package emission. Once Echo admits this generic artifact +family, the gate must advance again rather than treating provider refusal as a +permanent success condition. diff --git a/edict/replace-range/tests/build.sh b/edict/replace-range/tests/build.sh index 27f75ee6..88ffaced 100755 --- a/edict/replace-range/tests/build.sh +++ b/edict/replace-range/tests/build.sh @@ -46,7 +46,7 @@ printf '%s\n' "$build_output" test "$build_status" -ne 0 printf '%s\n' "$build_output" \ | jq --exit-status --slurp \ - 'any(.[]; .type == "diagnostic" and .kind == "TargetLoweringFailed")' \ + 'any(.[]; .type == "diagnostic" and .kind == "InvalidProviderInvocation")' \ >/dev/null test ! -e .build/application/executable-operation-package.cbor test ! -e .build/application/verification-report.cbor From 629337d21c9708f515500b0a332c23bb13f8761e Mon Sep 17 00:00:00 2001 From: James Ross Date: Sun, 23 Aug 2026 05:05:03 -0700 Subject: [PATCH 03/30] feat: select Echo generic pure program profile --- CHANGELOG.md | 6 +++--- edict/replace-range/README.md | 16 +++++++++------- edict/replace-range/edict.lawpack.json | 7 +++---- edict/replace-range/src/ReplaceRange.edict | 2 +- edict/replace-range/tests/build.sh | 5 ++++- .../vendor/jedit-text/adapter.cbor | Bin 431 -> 446 bytes .../vendor/jedit-text/adapter.sha256 | 2 +- .../echo-operation-configuration.cbor | 2 +- .../echo-operation-configuration.sha256 | 2 +- .../vendor/jedit-text/edict.lawpack-output.json | 16 ++++++++-------- .../vendor/jedit-text/manifest.cbor | Bin 787 -> 787 bytes .../vendor/jedit-text/manifest.sha256 | 2 +- 12 files changed, 32 insertions(+), 28 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index bc7578c6..2a6c86a1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,9 +5,9 @@ - Added the Jedit-owned `ReplaceRange.edict` application root and canonical `jedit.text@1` lawpack publication. With Edict #201, its executable integration gate now proves that real source lowers into generic pure Target IR and reaches - Echo's provider-contract boundary, which refuses the new artifact family - before package emission. Rope mutation and end-to-end Jim execution remain - unimplemented. + Echo's checked lowerer through the exact generic pure target configuration. + The lowerer returns typed `UnsupportedSemantics` before package emission. + Rope mutation and end-to-end Jim execution remain unimplemented. - Made `ReplaceRange` corroborate the selected Head/root byte extent and exact requested-range materialization before no-op classification, so truncated or absent retained roots fail with a typed malformed-rope obstruction. diff --git a/edict/replace-range/README.md b/edict/replace-range/README.md index e7300ad4..82cb80ac 100644 --- a/edict/replace-range/README.md +++ b/edict/replace-range/README.md @@ -21,9 +21,10 @@ traverse or rewrite a rope yet. With Edict #201, the public application build lowers those Core `let` nodes into generic, source-ordered Target IR and independently verifies the compiler-owned result projection. The exact Echo provider package then refuses the invocation -as `InvalidProviderInvocation` because its published adapter, target -configuration, Target IR, and result-projection contracts do not yet admit the -new generic artifact family. No executable operation package is emitted and no +as `ProviderLowererRefused / UnsupportedSemantics`. Echo now admits the exact +zero-choice generic pure target configuration, so the request reaches the +checked lowerer; that lowerer does not yet implement the corresponding generic +executable package profile. No executable operation package is emitted and no Echo evaluator runs. That refusal is the current routing evidence required by #296: Edict now @@ -44,7 +45,8 @@ ECHO_REPO=/path/to/echo \ The script first republishes `jedit.text@1` through Edict's public lawpack authoring boundary, then copies Echo's checked provider package into the disposable application build tree and invokes Edict's public application build. -Against Edict #201 it requires the stable `InvalidProviderInvocation` refusal -and rejects accidental package emission. Once Echo admits this generic artifact -family, the gate must advance again rather than treating provider refusal as a -permanent success condition. +Against Edict #201 and Echo #724 it requires the stable +`ProviderLowererRefused / UnsupportedSemantics` refusal and rejects accidental +package emission. Once Echo implements the generic pure package profile, the +gate must advance again rather than treating provider refusal as a permanent +success condition. diff --git a/edict/replace-range/edict.lawpack.json b/edict/replace-range/edict.lawpack.json index 81865aae..363da346 100644 --- a/edict/replace-range/edict.lawpack.json +++ b/edict/replace-range/edict.lawpack.json @@ -182,12 +182,11 @@ "localResources": [ { "name": "echo-config", - "coordinate": "jedit.text.echo-config/v1", + "coordinate": "echo.operation-lowering-configuration/v1", "output": "echo-operation-configuration.cbor", "value": { - "apiVersion": "jedit.text.echo-config/v1", - "instructionProfile": "echo.dpo@1.generic-bounded-graph", - "operation": "jedit.text@1.replaceRange" + "apiVersion": "echo.operation-lowering-configuration/v1", + "programKind": "compiler-produced-bounded-pure/v1" } }, { diff --git a/edict/replace-range/src/ReplaceRange.edict b/edict/replace-range/src/ReplaceRange.edict index cd317ee0..6dc12a4a 100644 --- a/edict/replace-range/src/ReplaceRange.edict +++ b/edict/replace-range/src/ReplaceRange.edict @@ -1,6 +1,6 @@ package jedit.text.replace_range@1; -use lawpack jedit.text@1 digest "sha256:0719a4161eaede5aa062f6cbd2e2ff74dee0bd961d0945449cd27ae2ef26f59a" as text; +use lawpack jedit.text@1 digest "sha256:5c41ef4bec7f9f50b3ca3a5332969052f32745046200cfb2f89316d487e25197" as text; type ReplaceRangeInput = { bufferId: Bytes, diff --git a/edict/replace-range/tests/build.sh b/edict/replace-range/tests/build.sh index 88ffaced..72436a5f 100755 --- a/edict/replace-range/tests/build.sh +++ b/edict/replace-range/tests/build.sh @@ -46,7 +46,10 @@ printf '%s\n' "$build_output" test "$build_status" -ne 0 printf '%s\n' "$build_output" \ | jq --exit-status --slurp \ - 'any(.[]; .type == "diagnostic" and .kind == "InvalidProviderInvocation")' \ + 'any(.[]; + .type == "diagnostic" + and .kind == "ProviderLowererRefused" + and (.message | contains("UnsupportedSemantics")))' \ >/dev/null test ! -e .build/application/executable-operation-package.cbor test ! -e .build/application/verification-report.cbor diff --git a/edict/replace-range/vendor/jedit-text/adapter.cbor b/edict/replace-range/vendor/jedit-text/adapter.cbor index c96488df0963dbf0b2283b73bd06eb953530e455..99e3ce6283224b6b1bcd4fa3d52055c2d893d555 100644 GIT binary patch delta 121 zcmZ3_ypMT3#XMX@glC#?SDLQ+(EX7c45Io@?;W@cq$bV+S+Y-Md_ MZggREX>V?Gpb>5@_5c6? diff --git a/edict/replace-range/vendor/jedit-text/adapter.sha256 b/edict/replace-range/vendor/jedit-text/adapter.sha256 index 152492ee..4260e281 100644 --- a/edict/replace-range/vendor/jedit-text/adapter.sha256 +++ b/edict/replace-range/vendor/jedit-text/adapter.sha256 @@ -1 +1 @@ -sha256:4a4ead6b31d561c12d9abcd64b9e6cf518e4ee3d3d3770ae971559642fb02828 +sha256:b8d9f15ef18dc99691ab1e034ca40a8b8ac52a1bc1b27597284f1edbaf84f049 diff --git a/edict/replace-range/vendor/jedit-text/echo-operation-configuration.cbor b/edict/replace-range/vendor/jedit-text/echo-operation-configuration.cbor index b2057f98..ee60987a 100644 --- a/edict/replace-range/vendor/jedit-text/echo-operation-configuration.cbor +++ b/edict/replace-range/vendor/jedit-text/echo-operation-configuration.cbor @@ -1 +1 @@ -£ioperationxjedit.text@1.replaceRangejapiVersionxjedit.text.echo-config/v1rinstructionProfilex echo.dpo@1.generic-bounded-graph \ No newline at end of file +¢japiVersionx(echo.operation-lowering-configuration/v1kprogramKindx!compiler-produced-bounded-pure/v1 \ No newline at end of file diff --git a/edict/replace-range/vendor/jedit-text/echo-operation-configuration.sha256 b/edict/replace-range/vendor/jedit-text/echo-operation-configuration.sha256 index 2612bf63..a708943c 100644 --- a/edict/replace-range/vendor/jedit-text/echo-operation-configuration.sha256 +++ b/edict/replace-range/vendor/jedit-text/echo-operation-configuration.sha256 @@ -1 +1 @@ -sha256:1ae7e97df9b46983591bc6cff08d537cd6a29c07f2cb2407d04f66f2e51b39de +sha256:bcb811b2d00d9824a256a26e48c14401c87fff509f2f75deb2ba703003a3f6d4 diff --git a/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json b/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json index 4f76b710..f95011b6 100644 --- a/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json +++ b/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json @@ -7,13 +7,13 @@ "path": "manifest.cbor", "kind": "manifest", "coordinate": "edict.lawpack/v1", - "digest": "sha256:0719a4161eaede5aa062f6cbd2e2ff74dee0bd961d0945449cd27ae2ef26f59a" + "digest": "sha256:5c41ef4bec7f9f50b3ca3a5332969052f32745046200cfb2f89316d487e25197" }, { "path": "manifest.sha256", "kind": "manifestDigest", "coordinate": "edict.lawpack/v1", - "digest": "sha256:0719a4161eaede5aa062f6cbd2e2ff74dee0bd961d0945449cd27ae2ef26f59a" + "digest": "sha256:5c41ef4bec7f9f50b3ca3a5332969052f32745046200cfb2f89316d487e25197" }, { "path": "exports.cbor", @@ -30,14 +30,14 @@ { "path": "echo-operation-configuration.cbor", "kind": "localResource", - "coordinate": "jedit.text.echo-config/v1", - "digest": "sha256:1ae7e97df9b46983591bc6cff08d537cd6a29c07f2cb2407d04f66f2e51b39de" + "coordinate": "echo.operation-lowering-configuration/v1", + "digest": "sha256:bcb811b2d00d9824a256a26e48c14401c87fff509f2f75deb2ba703003a3f6d4" }, { "path": "echo-operation-configuration.sha256", "kind": "localResourceDigest", - "coordinate": "jedit.text.echo-config/v1", - "digest": "sha256:1ae7e97df9b46983591bc6cff08d537cd6a29c07f2cb2407d04f66f2e51b39de" + "coordinate": "echo.operation-lowering-configuration/v1", + "digest": "sha256:bcb811b2d00d9824a256a26e48c14401c87fff509f2f75deb2ba703003a3f6d4" }, { "path": "verifier-rules.cbor", @@ -55,13 +55,13 @@ "path": "adapter.cbor", "kind": "adapter", "coordinate": "jedit.text.echo-adapter/v1", - "digest": "sha256:4a4ead6b31d561c12d9abcd64b9e6cf518e4ee3d3d3770ae971559642fb02828" + "digest": "sha256:b8d9f15ef18dc99691ab1e034ca40a8b8ac52a1bc1b27597284f1edbaf84f049" }, { "path": "adapter.sha256", "kind": "adapterDigest", "coordinate": "jedit.text.echo-adapter/v1", - "digest": "sha256:4a4ead6b31d561c12d9abcd64b9e6cf518e4ee3d3d3770ae971559642fb02828" + "digest": "sha256:b8d9f15ef18dc99691ab1e034ca40a8b8ac52a1bc1b27597284f1edbaf84f049" } ] } diff --git a/edict/replace-range/vendor/jedit-text/manifest.cbor b/edict/replace-range/vendor/jedit-text/manifest.cbor index dac00a5ab49fa14f63804e195860ade1c1416bea..9acdcd3882ef72d06c4664f7a2d6886f595fba04 100644 GIT binary patch delta 45 zcmV+|0Mh@H29pM`w*ery+3{ZSjmeggs~!VPqza3Q#VQ-YvUQgzPafN^gz!nT*8w~M D?i&>m delta 45 zcmV+|0Mh@H29pM`w*eqZPOWP()nUOcn!MIao^16P Date: Sun, 23 Aug 2026 05:51:09 -0700 Subject: [PATCH 04/30] test: require verified ReplaceRange package --- CHANGELOG.md | 5 +- edict/replace-range/README.md | 32 +++++------ .../tests/assert-build-output.mjs | 54 +++++++++++++++++++ edict/replace-range/tests/build.sh | 25 ++------- 4 files changed, 78 insertions(+), 38 deletions(-) create mode 100644 edict/replace-range/tests/assert-build-output.mjs diff --git a/CHANGELOG.md b/CHANGELOG.md index 2a6c86a1..0df5095c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,8 +6,9 @@ `jedit.text@1` lawpack publication. With Edict #201, its executable integration gate now proves that real source lowers into generic pure Target IR and reaches Echo's checked lowerer through the exact generic pure target configuration. - The lowerer returns typed `UnsupportedSemantics` before package emission. - Rope mutation and end-to-end Jim execution remain unimplemented. + Echo's generic pure-program lowerer now emits the exact compiler-produced + package, and its structurally separate verifier independently accepts the + package relation. Runtime evaluation and rope mutation remain unimplemented. - Made `ReplaceRange` corroborate the selected Head/root byte extent and exact requested-range materialization before no-op classification, so truncated or absent retained roots fail with a typed malformed-rope obstruction. diff --git a/edict/replace-range/README.md b/edict/replace-range/README.md index 82cb80ac..0e096c35 100644 --- a/edict/replace-range/README.md +++ b/edict/replace-range/README.md @@ -20,17 +20,17 @@ traverse or rewrite a rope yet. With Edict #201, the public application build lowers those Core `let` nodes into generic, source-ordered Target IR and independently verifies the compiler-owned -result projection. The exact Echo provider package then refuses the invocation -as `ProviderLowererRefused / UnsupportedSemantics`. Echo now admits the exact -zero-choice generic pure target configuration, so the request reaches the -checked lowerer; that lowerer does not yet implement the corresponding generic -executable package profile. No executable operation package is emitted and no -Echo evaluator runs. - -That refusal is the current routing evidence required by #296: Edict now -preserves the bounded pure program without learning Jedit vocabulary, and the -next owner is Echo's generic provider package and execution profile. It is not -evidence that `ReplaceRange` mutates a rope or that Jim runs end to end. +result projection. Echo #724 now emits a distinct +`compiler-produced-bounded-pure/v1` executable package containing the exact +Core, lawpack exports, Target IR, and result projection. Echo's structurally +separate verifier independently reconstructs that package relation and emits an +accepted report. + +That accepted package is the current routing evidence required by #296: Edict +preserves the bounded pure program without learning Jedit vocabulary, and Echo +packages it without learning `ReplaceRange`. No Echo evaluator runs, no graph +or rope is mutated, and no Tick is settled. This is not evidence that +`ReplaceRange` mutates a rope or that Jim runs end to end. ## Reproduce @@ -45,8 +45,8 @@ ECHO_REPO=/path/to/echo \ The script first republishes `jedit.text@1` through Edict's public lawpack authoring boundary, then copies Echo's checked provider package into the disposable application build tree and invokes Edict's public application build. -Against Edict #201 and Echo #724 it requires the stable -`ProviderLowererRefused / UnsupportedSemantics` refusal and rejects accidental -package emission. Once Echo implements the generic pure package profile, the -gate must advance again rather than treating provider refusal as a permanent -success condition. +Against Edict #201 and Echo #724 it requires the generic pure package and an +exact accepted independent-verifier report. It also inspects the embedded +compiler artifacts and application coordinate. The gate must advance again +when Echo implements generic pure evaluation; package acceptance is not a +permanent substitute for runtime evidence. diff --git a/edict/replace-range/tests/assert-build-output.mjs b/edict/replace-range/tests/assert-build-output.mjs new file mode 100644 index 00000000..fb5f68dc --- /dev/null +++ b/edict/replace-range/tests/assert-build-output.mjs @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: Apache-2.0 OR LicenseRef-MIND-UCAL-1.0 +// © James Ross Ω FLYING•ROBOTS + +import assert from "node:assert/strict"; +import { readFile } from "node:fs/promises"; +import path from "node:path"; + +import { decode } from "cbor-x"; + +const [outputDirectory] = process.argv.slice(2); +assert.ok(outputDirectory, "pass the Edict application output directory"); + +const packageBytes = await readFile( + path.join(outputDirectory, "executable-operation-package.cbor"), +); +const reportBytes = await readFile( + path.join(outputDirectory, "verification-report.cbor"), +); +const executablePackage = decode(packageBytes); +const report = decode(reportBytes); +const program = decode(executablePackage.program); + +assert.equal(executablePackage.schema, "echo.operation-package/v1"); +assert.equal( + executablePackage.package_kind, + "compiler-produced-bounded-pure/v1", +); +assert.equal( + executablePackage.operation_coordinate, + "jedit.text.replace_range@1.replaceRange", +); +assert.equal(program.schema, "echo.compiler-produced-pure-program/v1"); +assert.equal(program.kind, "compiler-produced-bounded-pure/v1"); +assert.equal(program.intent, "replaceRange"); +for (const artifact of [ + "core_artifact", + "lawpack_exports_artifact", + "result_projection_artifact", + "target_ir_artifact", +]) { + assert.ok(Buffer.isBuffer(program[artifact]), `${artifact} must be retained`); + assert.ok(program[artifact].length > 0, `${artifact} must not be empty`); +} + +assert.equal( + report.apiVersion, + "echo.operation-package-verifier-report/v1", +); +assert.equal(report.outcome, "accepted"); +assert.equal(report.diagnosticBytes.length, 0); +assert.equal( + report.applicationResultProjection.id, + "jedit.text.replace_range@1.replaceRange", +); diff --git a/edict/replace-range/tests/build.sh b/edict/replace-range/tests/build.sh index 72436a5f..74a5c59e 100755 --- a/edict/replace-range/tests/build.sh +++ b/edict/replace-range/tests/build.sh @@ -33,23 +33,8 @@ if find .build/echo-provider -type l -print -quit | grep -q .; then exit 1 fi -set +e -build_output=$( - printf '%s\n' \ - '{"schema":"edict.compiler.settings/v1","type":"compilerSettings","operation":"build","application":"edict.application.json"}' \ - | "$edict_bin" 2>&1 -) -build_status=$? -set -e - -printf '%s\n' "$build_output" -test "$build_status" -ne 0 -printf '%s\n' "$build_output" \ - | jq --exit-status --slurp \ - 'any(.[]; - .type == "diagnostic" - and .kind == "ProviderLowererRefused" - and (.message | contains("UnsupportedSemantics")))' \ - >/dev/null -test ! -e .build/application/executable-operation-package.cbor -test ! -e .build/application/verification-report.cbor +printf '%s\n' \ + '{"schema":"edict.compiler.settings/v1","type":"compilerSettings","operation":"build","application":"edict.application.json"}' \ + | "$edict_bin" + +node tests/assert-build-output.mjs .build/application From 2283d3b4528c8bb27df5d1ed287552d0b12dba3f Mon Sep 17 00:00:00 2001 From: James Ross Date: Sun, 23 Aug 2026 15:34:07 -0700 Subject: [PATCH 05/30] test: lock ReplaceRange toolchain inputs --- CHANGELOG.md | 5 +- edict/replace-range/README.md | 23 +- edict/replace-range/edict.toolchain-lock.json | 28 ++ edict/replace-range/tests/build.sh | 35 +-- edict/replace-range/tests/package-chain.mjs | 252 ++++++++++++++++++ .../tests/proof-harness.spec.mjs | 195 ++++++++++++++ 6 files changed, 495 insertions(+), 43 deletions(-) create mode 100644 edict/replace-range/edict.toolchain-lock.json create mode 100644 edict/replace-range/tests/package-chain.mjs create mode 100644 edict/replace-range/tests/proof-harness.spec.mjs diff --git a/CHANGELOG.md b/CHANGELOG.md index 0df5095c..c36e2017 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,7 +8,10 @@ Echo's checked lowerer through the exact generic pure target configuration. Echo's generic pure-program lowerer now emits the exact compiler-produced package, and its structurally separate verifier independently accepts the - package relation. Runtime evaluation and rope mutation remain unimplemented. + package relation. The integration gate pins clean Edict and Echo revisions, + verifies the committed lawpack closure without repairing it, and rejects + authoritative-input mutation outside its disposable build root. Runtime + evaluation and rope mutation remain unimplemented. - Made `ReplaceRange` corroborate the selected Head/root byte extent and exact requested-range materialization before no-op classification, so truncated or absent retained roots fail with a typed malformed-rope obstruction. diff --git a/edict/replace-range/README.md b/edict/replace-range/README.md index 0e096c35..98aebc4d 100644 --- a/edict/replace-range/README.md +++ b/edict/replace-range/README.md @@ -42,11 +42,18 @@ ECHO_REPO=/path/to/echo \ ./edict/replace-range/tests/build.sh ``` -The script first republishes `jedit.text@1` through Edict's public lawpack -authoring boundary, then copies Echo's checked provider package into the -disposable application build tree and invokes Edict's public application build. -Against Edict #201 and Echo #724 it requires the generic pure package and an -exact accepted independent-verifier report. It also inspects the embedded -compiler artifacts and application coordinate. The gate must advance again -when Echo implements generic pure evaluation; package acceptance is not a -permanent substitute for runtime evidence. +`edict.toolchain-lock.json` pins the exact Edict commit and CLI release, Rust +toolchain, Echo commit, provider identity, provider manifest bytes, and lowerer +and verifier components. The script refuses non-Git roots, wrong commits, or +dirty checkouts before invoking either toolchain. + +The script verifies the committed `jedit.text@1` closure through Edict's public +lawpack `checkOnly` boundary. It never republishes or repairs that authoritative +tree. It then copies Echo's checked provider package into `.build/`, invokes +Edict's public application build, and requires the generic pure package and an +accepted independent-verifier report. Snapshots cover the application inputs +outside `.build/` plus every tracked Edict and Echo file; any content, identity, +or timestamp mutation fails the run. Only `.build/` is disposable output. + +The gate must advance again when Echo implements generic pure evaluation; +package acceptance is not a permanent substitute for runtime evidence. diff --git a/edict/replace-range/edict.toolchain-lock.json b/edict/replace-range/edict.toolchain-lock.json new file mode 100644 index 00000000..7900d330 --- /dev/null +++ b/edict/replace-range/edict.toolchain-lock.json @@ -0,0 +1,28 @@ +{ + "schema": "jedit.edict-toolchain-lock/v1", + "rust": { + "toolchain": "1.94.0", + "rustcVersion": "rustc 1.94.0 (4a4ef493e 2026-03-02)", + "cargoVersion": "cargo 1.94.0 (85eff7c80 2026-01-15)" + }, + "edict": { + "commit": "adc1bf6da7d90fd93f135eea47380a4c68758479", + "cliVersion": "0.11.0-alpha.1" + }, + "echo": { + "commit": "37dd65a0f9e6e40a4aa1303f82d0f0892eefb06c", + "provider": { + "coordinate": "echo.edict-provider@1", + "digest": "sha256:b888f0c64a53c68d18c2bd3212589cf2ed9da3fbd551a64a9006184db3dde71f", + "manifestSha256": "8bce11896166a7ef52ddd9d07a60cfdb426d57697ba16e266aee0cb0f188a4b2", + "lowerer": { + "coordinate": "echo.dpo.lowerer/component@1", + "sha256": "20fe92ce8d7bec67f772715cb1f0f3d9ac4f65fe382eff3952f3c368849419dd" + }, + "verifier": { + "coordinate": "echo.dpo.verifier/component@1", + "sha256": "58f9451831338fa39a73d53790fe839037f1a8a1fb5345ffefc334af3ec90413" + } + } + } +} diff --git a/edict/replace-range/tests/build.sh b/edict/replace-range/tests/build.sh index 74a5c59e..00009a3b 100755 --- a/edict/replace-range/tests/build.sh +++ b/edict/replace-range/tests/build.sh @@ -3,38 +3,5 @@ set -euo pipefail project_root=$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd) application_root="$project_root/edict/replace-range" -edict_repo=${EDICT_REPO:?set EDICT_REPO to an exact Edict checkout} -echo_repo=${ECHO_REPO:?set ECHO_REPO to an exact Echo checkout} -edict_bin=${EDICT_BIN:-"$edict_repo/target/debug/edict"} -provider_source="$echo_repo/schemas/edict-provider/package/v1" -test -x "$edict_bin" -test -f "$provider_source/provider-manifest.echo.json" -test -f "$provider_source/components/lowerer.echo-dpo.component.wasm" -test -f "$provider_source/components/verifier.echo-dpo.component.wasm" - -if find "$provider_source" -type l -print -quit | grep -q .; then - echo "provider package must not contain symlinks" >&2 - exit 1 -fi - -cd "$application_root" - -printf '%s\n' \ - '{"schema":"edict.compiler.settings/v1","type":"compilerSettings","operation":"build","lawpack":"edict.lawpack.json"}' \ - | "$edict_bin" - -rm -rf .build/echo-provider .build/application -mkdir -p .build/echo-provider -cp -RL "$provider_source/." .build/echo-provider/ - -if find .build/echo-provider -type l -print -quit | grep -q .; then - echo "copied provider package must not contain symlinks" >&2 - exit 1 -fi - -printf '%s\n' \ - '{"schema":"edict.compiler.settings/v1","type":"compilerSettings","operation":"build","application":"edict.application.json"}' \ - | "$edict_bin" - -node tests/assert-build-output.mjs .build/application +exec node "$application_root/tests/package-chain.mjs" diff --git a/edict/replace-range/tests/package-chain.mjs b/edict/replace-range/tests/package-chain.mjs new file mode 100644 index 00000000..3133466d --- /dev/null +++ b/edict/replace-range/tests/package-chain.mjs @@ -0,0 +1,252 @@ +// SPDX-License-Identifier: Apache-2.0 OR LicenseRef-MIND-UCAL-1.0 +// © James Ross Ω FLYING•ROBOTS + +import assert from "node:assert/strict"; +import { spawnSync } from "node:child_process"; +import { createHash } from "node:crypto"; +import { + cp, + lstat, + mkdir, + readFile, + readlink, + realpath, + readdir, + rm, +} from "node:fs/promises"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; + +const testsDirectory = path.dirname(fileURLToPath(import.meta.url)); +const applicationRoot = path.resolve(testsDirectory, ".."); +const projectRoot = path.resolve(applicationRoot, "../.."); +const lockPath = path.join(applicationRoot, "edict.toolchain-lock.json"); +const edictRepository = process.env.EDICT_REPO; +const echoRepository = process.env.ECHO_REPO; + +function run(command, arguments_, options = {}) { + const result = spawnSync(command, arguments_, { + cwd: options.cwd, + encoding: "utf8", + env: process.env, + input: options.input, + timeout: options.timeout ?? 120_000, + }); + if (options.emit !== false && result.stdout) { + process.stdout.write(result.stdout); + } + if (options.emit !== false && result.stderr) { + process.stderr.write(result.stderr); + } + if (result.error) { + throw result.error; + } + if (result.status !== 0) { + throw new Error(`${command} exited with status ${result.status}`); + } + return result.stdout.trim(); +} + +function git(repository, ...arguments_) { + return run("git", ["-C", repository, ...arguments_], { emit: false }); +} + +async function sha256(filePath) { + return createHash("sha256").update(await readFile(filePath)).digest("hex"); +} + +async function verifyGitCheckout(repository, expectedCommit, label) { + assert.ok(repository, `${label} repository path is required`); + const [requestedRoot, discoveredRoot] = await Promise.all([ + realpath(repository), + realpath(git(repository, "rev-parse", "--show-toplevel")), + ]); + assert.equal(discoveredRoot, requestedRoot, `${label} path must be the checkout root`); + assert.equal(git(repository, "rev-parse", "HEAD"), expectedCommit, `${label} commit mismatch`); + assert.equal( + git(repository, "status", "--porcelain=v1", "--untracked-files=all"), + "", + `${label} checkout must be clean`, + ); +} + +function providerArtifact(manifest, role) { + const matches = manifest.artifacts.filter((artifact) => artifact.role === role); + assert.equal(matches.length, 1, `provider must contain one ${role} artifact`); + return matches[0]; +} + +async function verifyProvider(lock) { + const providerRoot = path.join( + echoRepository, + "schemas", + "edict-provider", + "package", + "v1", + ); + await rejectSymlinks(providerRoot); + const manifestPath = path.join(providerRoot, "provider-manifest.echo.json"); + const manifest = JSON.parse(await readFile(manifestPath, "utf8")); + assert.equal(manifest.provider.coordinate, lock.coordinate); + assert.equal(manifest.provider.digest, lock.digest); + assert.equal(await sha256(manifestPath), lock.manifestSha256); + + for (const [role, fileName, expected] of [ + ["lowerer.echo-dpo", "lowerer.echo-dpo.component.wasm", lock.lowerer], + ["verifier.echo-dpo", "verifier.echo-dpo.component.wasm", lock.verifier], + ]) { + const artifact = providerArtifact(manifest, role); + assert.equal(artifact.resource.coordinate, expected.coordinate); + assert.equal(artifact.resource.digest, `sha256:${expected.sha256}`); + assert.equal(await sha256(path.join(providerRoot, "components", fileName)), expected.sha256); + } + return providerRoot; +} + +async function rejectSymlinks(root) { + for (const entry of await readdir(root, { withFileTypes: true })) { + const entryPath = path.join(root, entry.name); + assert.equal(entry.isSymbolicLink(), false, `symbolic link is forbidden: ${entryPath}`); + if (entry.isDirectory()) { + await rejectSymlinks(entryPath); + } + } +} + +async function collectDirectoryFiles(root, relative = "") { + const files = []; + const directory = path.join(root, relative); + for (const entry of await readdir(directory, { withFileTypes: true })) { + if (relative === "" && entry.name === ".build") { + continue; + } + const entryRelative = path.join(relative, entry.name); + if (entry.isDirectory()) { + files.push(...(await collectDirectoryFiles(root, entryRelative))); + } else { + files.push(entryRelative); + } + } + return files; +} + +function trackedFiles(repository) { + return git(repository, "ls-files", "-z") + .split("\0") + .filter(Boolean) + .sort(); +} + +async function snapshotFile(namespace, root, relative) { + const filePath = path.join(root, relative); + const metadata = await lstat(filePath, { bigint: true }); + const common = { + path: `${namespace}/${relative.split(path.sep).join("/")}`, + mode: metadata.mode.toString(), + size: metadata.size.toString(), + modifiedNanoseconds: metadata.mtimeNs.toString(), + inode: metadata.ino.toString(), + }; + if (metadata.isSymbolicLink()) { + return { ...common, kind: "symlink", target: await readlink(filePath) }; + } + if (metadata.isFile()) { + return { ...common, kind: "file", sha256: await sha256(filePath) }; + } + return { ...common, kind: "other" }; +} + +async function snapshotAuthoritativeInputs() { + const roots = [ + ["jedit", applicationRoot, (await collectDirectoryFiles(applicationRoot)).sort()], + ["edict", edictRepository, trackedFiles(edictRepository)], + ["echo", echoRepository, trackedFiles(echoRepository)], + ]; + const snapshot = []; + for (const [namespace, root, files] of roots) { + for (const relative of files) { + snapshot.push(await snapshotFile(namespace, root, relative)); + } + } + return snapshot; +} + +async function verifyVersions(lock) { + assert.equal(run("rustc", [`+${lock.rust.toolchain}`, "--version"]), lock.rust.rustcVersion); + assert.equal(run("cargo", [`+${lock.rust.toolchain}`, "--version"]), lock.rust.cargoVersion); + run( + "cargo", + [`+${lock.rust.toolchain}`, "build", "--locked", "-p", "edict-cli"], + { cwd: edictRepository }, + ); + const edictBinary = path.join(edictRepository, "target", "debug", "edict"); + const version = JSON.parse(run(edictBinary, ["--version"])); + assert.equal(version.version, lock.edict.cliVersion); + return edictBinary; +} + +async function build() { + const lock = JSON.parse(await readFile(lockPath, "utf8")); + assert.equal(lock.schema, "jedit.edict-toolchain-lock/v1"); + await verifyGitCheckout(edictRepository, lock.edict.commit, "Edict"); + await verifyGitCheckout(echoRepository, lock.echo.commit, "Echo"); + const providerSource = await verifyProvider(lock.echo.provider); + const before = await snapshotAuthoritativeInputs(); + let failure; + try { + const edictBinary = await verifyVersions(lock); + run(edictBinary, [], { + cwd: applicationRoot, + input: `${JSON.stringify({ + schema: "edict.compiler.settings/v1", + type: "compilerSettings", + operation: "build", + lawpack: "edict.lawpack.json", + checkOnly: true, + })}\n`, + }); + + const buildRoot = path.join(applicationRoot, ".build"); + const providerDestination = path.join(buildRoot, "echo-provider"); + const applicationOutput = path.join(buildRoot, "application"); + await rm(providerDestination, { recursive: true, force: true }); + await rm(applicationOutput, { recursive: true, force: true }); + await mkdir(providerDestination, { recursive: true }); + await cp(providerSource, providerDestination, { recursive: true }); + await rejectSymlinks(providerDestination); + + run(edictBinary, [], { + cwd: applicationRoot, + input: `${JSON.stringify({ + schema: "edict.compiler.settings/v1", + type: "compilerSettings", + operation: "build", + application: "edict.application.json", + })}\n`, + }); + run(process.execPath, [path.join(testsDirectory, "assert-build-output.mjs"), applicationOutput], { + cwd: applicationRoot, + }); + } catch (error) { + failure = error; + } + + const after = await snapshotAuthoritativeInputs(); + let mutationFailure; + try { + assert.deepEqual(after, before, "authoritative inputs changed during package-chain build"); + } catch (error) { + mutationFailure = error; + } + if (failure && mutationFailure) { + throw new AggregateError([failure, mutationFailure], "build failed and authoritative inputs changed"); + } + if (mutationFailure) { + throw mutationFailure; + } + if (failure) { + throw failure; + } +} + +await build(); diff --git a/edict/replace-range/tests/proof-harness.spec.mjs b/edict/replace-range/tests/proof-harness.spec.mjs new file mode 100644 index 00000000..b3fa1e45 --- /dev/null +++ b/edict/replace-range/tests/proof-harness.spec.mjs @@ -0,0 +1,195 @@ +// SPDX-License-Identifier: Apache-2.0 OR LicenseRef-MIND-UCAL-1.0 +// © James Ross Ω FLYING•ROBOTS + +import assert from "node:assert/strict"; +import { spawnSync } from "node:child_process"; +import { cp, mkdtemp, mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises"; +import os from "node:os"; +import path from "node:path"; +import test from "node:test"; +import { fileURLToPath } from "node:url"; + +import { decode, encode } from "cbor-x"; + +const testDirectory = path.dirname(fileURLToPath(import.meta.url)); +const applicationRoot = path.resolve(testDirectory, ".."); +const projectRoot = path.resolve(applicationRoot, "../.."); +const edictRepository = process.env.EDICT_REPO; +const echoRepository = process.env.ECHO_REPO; + +function requireToolchainEnvironment() { + assert.ok(edictRepository, "EDICT_REPO must name the exact Edict checkout"); + assert.ok(echoRepository, "ECHO_REPO must name the exact Echo checkout"); +} + +async function fixture() { + const root = await mkdtemp(path.join(os.tmpdir(), "jedit-replace-range-proof-")); + const fixtureProject = path.join(root, "jedit"); + const fixtureApplication = path.join(fixtureProject, "edict", "replace-range"); + await mkdir(path.dirname(fixtureApplication), { recursive: true }); + await cp(applicationRoot, fixtureApplication, { recursive: true }); + await symlink(path.join(projectRoot, "node_modules"), path.join(fixtureProject, "node_modules"), "dir"); + return { + root, + project: fixtureProject, + application: fixtureApplication, + async dispose() { + await rm(root, { recursive: true, force: true }); + }, + }; +} + +function runBuild(fixtureProject, overrides = {}) { + return spawnSync("bash", ["edict/replace-range/tests/build.sh"], { + cwd: fixtureProject, + encoding: "utf8", + env: { + ...process.env, + EDICT_REPO: edictRepository, + ECHO_REPO: echoRepository, + ...overrides, + }, + timeout: 120_000, + }); +} + +function assertCommandCompleted(result) { + assert.equal(result.error, undefined, result.error?.message); + assert.notEqual(result.status, null, `command terminated by ${result.signal}`); +} + +test("rejects_non_git_or_wrong_commit_toolchain_inputs", { timeout: 120_000 }, async () => { + requireToolchainEnvironment(); + const subject = await fixture(); + try { + const fakeEdict = path.join(subject.root, "fake-edict"); + const fakeEcho = path.join(subject.root, "fake-echo"); + const fakeEdictBinary = path.join(fakeEdict, "target", "debug", "edict"); + const providerSource = path.join( + echoRepository, + "schemas", + "edict-provider", + "package", + "v1", + ); + const fakeProvider = path.join( + fakeEcho, + "schemas", + "edict-provider", + "package", + "v1", + ); + await mkdir(path.dirname(fakeEdictBinary), { recursive: true }); + await mkdir(path.dirname(fakeProvider), { recursive: true }); + await symlink(path.join(edictRepository, "target", "debug", "edict"), fakeEdictBinary); + await cp(providerSource, fakeProvider, { recursive: true }); + + const result = runBuild(subject.project, { + EDICT_REPO: fakeEdict, + ECHO_REPO: fakeEcho, + }); + assertCommandCompleted(result); + assert.notEqual( + result.status, + 0, + "non-Git toolchain directories must be rejected before publication or application build", + ); + } finally { + await subject.dispose(); + } +}); + +test("lawpack_check_only_rejects_drift_without_repairing_it", { timeout: 120_000 }, async () => { + requireToolchainEnvironment(); + const subject = await fixture(); + try { + const digestPath = path.join( + subject.application, + "vendor", + "jedit-text", + "manifest.sha256", + ); + const corruptDigest = `sha256:${"0".repeat(64)}\n`; + await writeFile(digestPath, corruptDigest); + + const result = runBuild(subject.project); + assertCommandCompleted(result); + assert.notEqual(result.status, 0, "drift must fail instead of being repaired"); + assert.equal( + await readFile(digestPath, "utf8"), + corruptDigest, + "check-only validation must leave the drifted artifact untouched", + ); + } finally { + await subject.dispose(); + } +}); + +test( + "rejects_package_whose_recomputed_identity_differs_from_report_subject", + { timeout: 120_000 }, + async () => { + requireToolchainEnvironment(); + const subject = await fixture(); + try { + const build = runBuild(subject.project); + assertCommandCompleted(build); + assert.equal(build.status, 0, build.stderr); + + const outputDirectory = path.join(subject.application, ".build", "application"); + const packagePath = path.join(outputDirectory, "executable-operation-package.cbor"); + const executablePackage = decode(await readFile(packagePath)); + const program = decode(executablePackage.program); + const alteredCore = Buffer.from(program.core_artifact); + alteredCore[0] ^= 1; + program.core_artifact = alteredCore; + executablePackage.program = encode(program); + await writeFile(packagePath, encode(executablePackage)); + + const assertion = spawnSync( + process.execPath, + [path.join(subject.application, "tests", "assert-build-output.mjs"), outputDirectory], + { cwd: subject.project, encoding: "utf8", timeout: 30_000 }, + ); + assertCommandCompleted(assertion); + assert.notEqual( + assertion.status, + 0, + "a report for the original package must not authorize altered embedded Core bytes", + ); + } finally { + await subject.dispose(); + } + }, +); + +test("rejects_short_buffer_and_head_identities", { timeout: 120_000 }, async () => { + requireToolchainEnvironment(); + const subject = await fixture(); + try { + const build = runBuild(subject.project); + assertCommandCompleted(build); + assert.equal(build.status, 0, build.stderr); + + const packageBytes = await readFile( + path.join(subject.application, ".build", "application", "executable-operation-package.cbor"), + ); + const executablePackage = decode(packageBytes); + const program = decode(executablePackage.program); + const core = decode(program.core_artifact); + for (const typeName of [ + "ReplaceRangeInput.bufferId", + "ReplaceRangeInput.basisHeadId", + "ReplaceRangeBoundary.bufferId", + "ReplaceRangeBoundary.basisHeadId", + ]) { + assert.deepEqual( + core.types[typeName], + { kind: "Bytes", min: 32, max: 32 }, + `${typeName} must preserve the exact 32-byte identity contract in Core`, + ); + } + } finally { + await subject.dispose(); + } +}); From a8d4a527c42bc04b3260a402f34c03cf44fde569 Mon Sep 17 00:00:00 2001 From: James Ross Date: Sun, 23 Aug 2026 16:16:45 -0700 Subject: [PATCH 06/30] Bind ReplaceRange to exact text identities --- edict/replace-range/edict.lawpack.json | 10 +++++++++- edict/replace-range/edict.toolchain-lock.json | 10 +++++----- edict/replace-range/src/ReplaceRange.edict | 14 +++++++------- .../jedit-text/edict.lawpack-output.json | 8 ++++---- .../vendor/jedit-text/exports.cbor | Bin 2212 -> 2342 bytes .../vendor/jedit-text/exports.sha256 | 2 +- .../vendor/jedit-text/manifest.cbor | Bin 787 -> 787 bytes .../vendor/jedit-text/manifest.sha256 | 2 +- 8 files changed, 27 insertions(+), 19 deletions(-) diff --git a/edict/replace-range/edict.lawpack.json b/edict/replace-range/edict.lawpack.json index 363da346..13483ef6 100644 --- a/edict/replace-range/edict.lawpack.json +++ b/edict/replace-range/edict.lawpack.json @@ -14,7 +14,15 @@ "types": [ { "coordinate": "jedit.text@1.NodeId", - "definition": "Bytes" + "definition": "Bytes" + }, + { + "coordinate": "jedit.text@1.BufferId", + "definition": "jedit.text@1.NodeId" + }, + { + "coordinate": "jedit.text@1.HeadId", + "definition": "jedit.text@1.NodeId" }, { "coordinate": "jedit.text@1.ReplacementBytes", diff --git a/edict/replace-range/edict.toolchain-lock.json b/edict/replace-range/edict.toolchain-lock.json index 7900d330..b95983cb 100644 --- a/edict/replace-range/edict.toolchain-lock.json +++ b/edict/replace-range/edict.toolchain-lock.json @@ -6,18 +6,18 @@ "cargoVersion": "cargo 1.94.0 (85eff7c80 2026-01-15)" }, "edict": { - "commit": "adc1bf6da7d90fd93f135eea47380a4c68758479", + "commit": "68633c409474b9dffac4a33a674b2a3f29ad865c", "cliVersion": "0.11.0-alpha.1" }, "echo": { - "commit": "37dd65a0f9e6e40a4aa1303f82d0f0892eefb06c", + "commit": "ce032c8e07b2e3ffe82d97903a565521257cede6", "provider": { "coordinate": "echo.edict-provider@1", - "digest": "sha256:b888f0c64a53c68d18c2bd3212589cf2ed9da3fbd551a64a9006184db3dde71f", - "manifestSha256": "8bce11896166a7ef52ddd9d07a60cfdb426d57697ba16e266aee0cb0f188a4b2", + "digest": "sha256:319b2f44db2fdc953ab4dd4d7603a60db8c5951cc62a0ac2e6b41797eebcee92", + "manifestSha256": "b6687034723e965006b4ffbfe2b1848d4c173ad6528964d060954c75e14e7259", "lowerer": { "coordinate": "echo.dpo.lowerer/component@1", - "sha256": "20fe92ce8d7bec67f772715cb1f0f3d9ac4f65fe382eff3952f3c368849419dd" + "sha256": "7d00aa4d4ec63fb81dad318b0165010cd4451f33b3f939f90a0457caf54a46eb" }, "verifier": { "coordinate": "echo.dpo.verifier/component@1", diff --git a/edict/replace-range/src/ReplaceRange.edict b/edict/replace-range/src/ReplaceRange.edict index 6dc12a4a..0c77483d 100644 --- a/edict/replace-range/src/ReplaceRange.edict +++ b/edict/replace-range/src/ReplaceRange.edict @@ -1,21 +1,21 @@ package jedit.text.replace_range@1; -use lawpack jedit.text@1 digest "sha256:5c41ef4bec7f9f50b3ca3a5332969052f32745046200cfb2f89316d487e25197" as text; +use lawpack jedit.text@1 digest "sha256:5253f7c8682cfed88a34c660a610c30da6bd9924973fefd33a82c9915a4f09cf" as text; type ReplaceRangeInput = { - bufferId: Bytes, - basisHeadId: Bytes, + bufferId: text.BufferId, + basisHeadId: text.HeadId, startByte: U64, endByte: U64, - replacement: Bytes, + replacement: text.ReplacementBytes, }; type ReplaceRangeBoundary = { - bufferId: Bytes, - basisHeadId: Bytes, + bufferId: text.BufferId, + basisHeadId: text.HeadId, startByte: U64, endByte: U64, - replacement: Bytes, + replacement: text.ReplacementBytes, rangeIsEmpty: U32, createdLeafCeiling: U64, }; diff --git a/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json b/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json index f95011b6..0c5d525e 100644 --- a/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json +++ b/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json @@ -7,25 +7,25 @@ "path": "manifest.cbor", "kind": "manifest", "coordinate": "edict.lawpack/v1", - "digest": "sha256:5c41ef4bec7f9f50b3ca3a5332969052f32745046200cfb2f89316d487e25197" + "digest": "sha256:5253f7c8682cfed88a34c660a610c30da6bd9924973fefd33a82c9915a4f09cf" }, { "path": "manifest.sha256", "kind": "manifestDigest", "coordinate": "edict.lawpack/v1", - "digest": "sha256:5c41ef4bec7f9f50b3ca3a5332969052f32745046200cfb2f89316d487e25197" + "digest": "sha256:5253f7c8682cfed88a34c660a610c30da6bd9924973fefd33a82c9915a4f09cf" }, { "path": "exports.cbor", "kind": "exports", "coordinate": "jedit.text.exports/v1", - "digest": "sha256:2a4ef08bec9f2839aa69841a6458eabc037f1ea698fd1a68392aeb84d5b306be" + "digest": "sha256:ffa6529b8327ab49e7cf62016e940e5cabf90c5468d9d1efb0dcb3d7d6574c88" }, { "path": "exports.sha256", "kind": "exportsDigest", "coordinate": "jedit.text.exports/v1", - "digest": "sha256:2a4ef08bec9f2839aa69841a6458eabc037f1ea698fd1a68392aeb84d5b306be" + "digest": "sha256:ffa6529b8327ab49e7cf62016e940e5cabf90c5468d9d1efb0dcb3d7d6574c88" }, { "path": "echo-operation-configuration.cbor", diff --git a/edict/replace-range/vendor/jedit-text/exports.cbor b/edict/replace-range/vendor/jedit-text/exports.cbor index ab18a6b613d15e096bb3f507ba661ab3fe82ed6a..65bcda4a8cee4eb7fe8f3ee4237e28d580797495 100644 GIT binary patch delta 166 zcmZ1?xJ-y+S!zjTL27a9L=Nrxe5cBi)MA^|ip1m+TVo@;MOn%D`9&$2d5I;drCF&d znI(E9sTCy-hI&q=X=$lNo+()=scD&cnI)O|dBrFS{PI&$JyVbkK$Z7MO-w=8E{J3S KME^#|WDWqyH9rFY delta 40 wcmZ1`v_z0&S!zjTL27aHL=J8KT&K#C)MA_5#0pzuBfCYDvzVke-goB!04!DxeE!v^ B6}$id delta 43 zcmV+`0M!4J29pMmLLe$m@Qdu9C^@QWgc@X6>bwJg9;TT68fZBx>x9*_2EMUku>zDq B6IcKM diff --git a/edict/replace-range/vendor/jedit-text/manifest.sha256 b/edict/replace-range/vendor/jedit-text/manifest.sha256 index ca2740e4..b3292379 100644 --- a/edict/replace-range/vendor/jedit-text/manifest.sha256 +++ b/edict/replace-range/vendor/jedit-text/manifest.sha256 @@ -1 +1 @@ -sha256:5c41ef4bec7f9f50b3ca3a5332969052f32745046200cfb2f89316d487e25197 +sha256:5253f7c8682cfed88a34c660a610c30da6bd9924973fefd33a82c9915a4f09cf From d8af4e2227c6e6ba1b2a27f9d09b4f4fe5781ae0 Mon Sep 17 00:00:00 2001 From: James Ross Date: Sun, 23 Aug 2026 16:36:45 -0700 Subject: [PATCH 07/30] Verify the exact executable subject --- edict/replace-range/edict.toolchain-lock.json | 10 +-- .../tests/assert-build-output.mjs | 84 ++++++++++++++++++- package-lock.json | 1 + package.json | 1 + 4 files changed, 90 insertions(+), 6 deletions(-) diff --git a/edict/replace-range/edict.toolchain-lock.json b/edict/replace-range/edict.toolchain-lock.json index b95983cb..a0369e48 100644 --- a/edict/replace-range/edict.toolchain-lock.json +++ b/edict/replace-range/edict.toolchain-lock.json @@ -10,18 +10,18 @@ "cliVersion": "0.11.0-alpha.1" }, "echo": { - "commit": "ce032c8e07b2e3ffe82d97903a565521257cede6", + "commit": "27a56eb91964aeeea90d36c58585683b341a2dfc", "provider": { "coordinate": "echo.edict-provider@1", - "digest": "sha256:319b2f44db2fdc953ab4dd4d7603a60db8c5951cc62a0ac2e6b41797eebcee92", - "manifestSha256": "b6687034723e965006b4ffbfe2b1848d4c173ad6528964d060954c75e14e7259", + "digest": "sha256:a4e0d9e31ada5c8c14adfce05fdecb228e5b79545f3574a5e21e7db71ab3f307", + "manifestSha256": "205bdba71fd552316be59079d7509c592b1ac98af7197a119fe56ce12ea0a5f6", "lowerer": { "coordinate": "echo.dpo.lowerer/component@1", - "sha256": "7d00aa4d4ec63fb81dad318b0165010cd4451f33b3f939f90a0457caf54a46eb" + "sha256": "a4758f060122fba8c073841ccaa22bf0b8a742b495b76eb33c914eff3250dcf5" }, "verifier": { "coordinate": "echo.dpo.verifier/component@1", - "sha256": "58f9451831338fa39a73d53790fe839037f1a8a1fb5345ffefc334af3ec90413" + "sha256": "174cf8758815bf2b9f2ef575517aa6d144ed3f2d1995fc65d25a211b9dea82d9" } } } diff --git a/edict/replace-range/tests/assert-build-output.mjs b/edict/replace-range/tests/assert-build-output.mjs index fb5f68dc..4c66cd60 100644 --- a/edict/replace-range/tests/assert-build-output.mjs +++ b/edict/replace-range/tests/assert-build-output.mjs @@ -2,10 +2,26 @@ // © James Ross Ω FLYING•ROBOTS import assert from "node:assert/strict"; +import { createHash } from "node:crypto"; import { readFile } from "node:fs/promises"; import path from "node:path"; -import { decode } from "cbor-x"; +import { decode, encode } from "cbor-x"; + +function canonicalArtifactDigest(domain, canonicalArtifactBytes) { + const preimage = Buffer.concat([ + Buffer.from([0x83]), + Buffer.from(encode("edict.digest/v1")), + Buffer.from(encode(domain)), + Buffer.from(canonicalArtifactBytes), + ]); + return createHash("sha256").update(preimage).digest(); +} + +function assertResourceReference(reference, coordinate, digest) { + assert.equal(reference.id, coordinate); + assert.deepEqual(reference.digest, ["sha256", digest]); +} const [outputDirectory] = process.argv.slice(2); assert.ok(outputDirectory, "pass the Edict application output directory"); @@ -20,6 +36,16 @@ const executablePackage = decode(packageBytes); const report = decode(reportBytes); const program = decode(executablePackage.program); +const packageDigest = canonicalArtifactDigest( + "echo.operation-package/v1", + packageBytes, +); +assertResourceReference( + report.package, + "executable-operation-package.echo", + packageDigest, +); + assert.equal(executablePackage.schema, "echo.operation-package/v1"); assert.equal( executablePackage.package_kind, @@ -42,6 +68,31 @@ for (const artifact of [ assert.ok(program[artifact].length > 0, `${artifact} must not be empty`); } +const coreDigest = canonicalArtifactDigest( + "edict.core.module/v1", + program.core_artifact, +); +assert.deepEqual(executablePackage.semantic_closure.core_identity, coreDigest); +assert.deepEqual( + executablePackage.semantic_closure.canonical_meaning_identity, + coreDigest, +); + +const targetIrDigest = canonicalArtifactDigest( + "edict.target-ir.artifact/v1", + program.target_ir_artifact, +); +assert.deepEqual( + executablePackage.semantic_closure.target_ir_identity, + targetIrDigest, +); +assertResourceReference(report.targetIr, "echo.span-ir/v1", targetIrDigest); + +const resultProjectionDigest = canonicalArtifactDigest( + "edict.result-projection.artifact/v1", + program.result_projection_artifact, +); + assert.equal( report.apiVersion, "echo.operation-package-verifier-report/v1", @@ -52,3 +103,34 @@ assert.equal( report.applicationResultProjection.id, "jedit.text.replace_range@1.replaceRange", ); +assertResourceReference( + report.applicationResultProjection, + "jedit.text.replace_range@1.replaceRange", + resultProjectionDigest, +); + +assert.equal( + report.executableSubject.reference.id, + "echo.executable-subject/v1", +); +assert.ok( + Buffer.isBuffer(report.executableSubject.bytes), + "the verifier report must retain the executable subject bytes", +); +const executableSubjectDigest = canonicalArtifactDigest( + "echo.executable-subject/v1", + report.executableSubject.bytes, +); +assertResourceReference( + report.executableSubject.reference, + "echo.executable-subject/v1", + executableSubjectDigest, +); +const executableSubject = decode(report.executableSubject.bytes); +assert.equal(executableSubject.apiVersion, "echo.executable-subject/v1"); +assert.deepEqual(executableSubject.package, report.package); +assert.deepEqual(executableSubject.targetIr, report.targetIr); +assert.deepEqual( + executableSubject.applicationResultProjection, + report.applicationResultProjection, +); diff --git a/package-lock.json b/package-lock.json index 801e5a11..d76f6e89 100644 --- a/package-lock.json +++ b/package-lock.json @@ -22,6 +22,7 @@ "@flyingrobots/bijou-i18n-tools-node": "^7.0.0", "@flyingrobots/bijou-i18n-tools-xlsx": "^7.0.0", "@types/node": "^22.0.0", + "cbor-x": "^1.6.4", "semver": "^7.8.5", "tsx": "^4.22.4", "typescript": "^5.9.3" diff --git a/package.json b/package.json index d0490ecb..8161bb24 100644 --- a/package.json +++ b/package.json @@ -41,6 +41,7 @@ "@flyingrobots/bijou-i18n-tools-node": "^7.0.0", "@flyingrobots/bijou-i18n-tools-xlsx": "^7.0.0", "@types/node": "^22.0.0", + "cbor-x": "^1.6.4", "semver": "^7.8.5", "tsx": "^4.22.4", "typescript": "^5.9.3" From d6769cc1acca7527114d9ca88a0719997956ff75 Mon Sep 17 00:00:00 2001 From: James Ross Date: Sun, 23 Aug 2026 16:42:55 -0700 Subject: [PATCH 08/30] Require exact ReplaceRange package evidence --- .github/workflows/ci.yml | 76 +++++++- edict/replace-range/README.md | 26 ++- edict/replace-range/edict.build-lock.json | 106 +++++++++++ .../edict.executable-subject-lock.json | 20 +++ .../tests/assert-build-output.mjs | 165 +++++++++++++++++- .../tests/proof-harness.spec.mjs | 38 ++++ 6 files changed, 421 insertions(+), 10 deletions(-) create mode 100644 edict/replace-range/edict.build-lock.json create mode 100644 edict/replace-range/edict.executable-subject-lock.json diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index b8fc974e..09b79e4e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -168,9 +168,79 @@ jobs: - name: Run Echo release gate run: npm run release-gate:jedit-echo + edict-replace-range: + name: edict / replace-range package chain + runs-on: ubuntu-latest + timeout-minutes: 20 + + steps: + - name: Checkout Jedit + uses: actions/checkout@v6.0.2 + with: + path: jedit + + - name: Read pinned toolchain commits + id: toolchain + working-directory: jedit + run: | + node --input-type=module <<'NODE' >> "$GITHUB_OUTPUT" + import { readFileSync } from "node:fs"; + const lock = JSON.parse( + readFileSync("edict/replace-range/edict.toolchain-lock.json", "utf8"), + ); + console.log(`edict_commit=${lock.edict.commit}`); + console.log(`echo_commit=${lock.echo.commit}`); + console.log(`rust_toolchain=${lock.rust.toolchain}`); + NODE + + - name: Checkout pinned Edict + uses: actions/checkout@v6.0.2 + with: + repository: flyingrobots/edict + ref: ${{ steps.toolchain.outputs.edict_commit }} + path: edict + + - name: Checkout pinned Echo + uses: actions/checkout@v6.0.2 + with: + repository: flyingrobots/echo + ref: ${{ steps.toolchain.outputs.echo_commit }} + path: echo + + - name: Setup Node.js + uses: actions/setup-node@v6.4.0 + with: + node-version: 22 + cache: 'npm' + cache-dependency-path: jedit/package-lock.json + + - name: Setup pinned Rust + run: rustup toolchain install '${{ steps.toolchain.outputs.rust_toolchain }}' --profile minimal + + - name: Install Jedit dependencies + working-directory: jedit + run: npm ci + + - name: Verify exact package chain and adversarial regressions + working-directory: jedit + env: + EDICT_REPO: ${{ github.workspace }}/edict + ECHO_REPO: ${{ github.workspace }}/echo + run: node --test edict/replace-range/tests/proof-harness.spec.mjs + + - name: Verify authoritative checkouts remain clean + run: | + for repository in jedit edict echo; do + if [[ -n "$(git -C "$repository" status --porcelain=v1 --untracked-files=all)" ]]; then + echo "$repository changed during the package-chain gate" >&2 + git -C "$repository" status --short >&2 + exit 1 + fi + done + check: name: check - needs: [ plan, build, test-shards, quality, release-gate ] + needs: [ plan, build, test-shards, quality, release-gate, edict-replace-range ] if: always() runs-on: ubuntu-latest @@ -182,9 +252,10 @@ jobs: TEST_SHARDS_RESULT: ${{ needs.test-shards.result }} QUALITY_RESULT: ${{ needs.quality.result }} RELEASE_GATE_RESULT: ${{ needs.release-gate.result }} + EDICT_REPLACE_RANGE_RESULT: ${{ needs.edict-replace-range.result }} run: | failed=0 - for result in "$PLAN_RESULT" "$BUILD_RESULT" "$QUALITY_RESULT"; do + for result in "$PLAN_RESULT" "$BUILD_RESULT" "$QUALITY_RESULT" "$EDICT_REPLACE_RANGE_RESULT"; do if [[ "$result" != "success" ]]; then failed=1 fi @@ -205,5 +276,6 @@ jobs: echo "| test shards | $TEST_SHARDS_RESULT |" echo "| quality | $QUALITY_RESULT |" echo "| release gate | $RELEASE_GATE_RESULT |" + echo "| edict / replace-range package chain | $EDICT_REPLACE_RANGE_RESULT |" } >> "$GITHUB_STEP_SUMMARY" exit "$failed" diff --git a/edict/replace-range/README.md b/edict/replace-range/README.md index 98aebc4d..a063d07b 100644 --- a/edict/replace-range/README.md +++ b/edict/replace-range/README.md @@ -1,11 +1,16 @@ # ReplaceRange Edict application This directory is the Jedit-owned application root for issue #296. It keeps -five artifact classes separate: +the authored, built, and evidentiary artifact classes separate: - `edict.lawpack.json` is the reviewable `jedit.text@1` authoring input; - `vendor/jedit-text/` is Edict's canonical published lawpack closure; - `src/ReplaceRange.edict` is the application-owned source; +- `edict.toolchain-lock.json` pins the exact build implementations and + provider; +- `edict.build-lock.json` pins the exact source closure and emitted artifact + chain; +- `edict.executable-subject-lock.json` pins the verified executable meaning; - `.build/` contains disposable provider and compiler outputs; - `contracts/jedit/lawpacks/replace-range-v1/` remains the independent schema and oracle corpus and is not executable input. @@ -13,10 +18,10 @@ five artifact classes separate: ## Current executable boundary The checked-in source is the first compiler-pressure slice, not a completed -text mutation. It binds bounded identity bytes, the selected basis, range, -replacement bytes, operation profile, budget, imported helper implementation, -and a pure conditional into Edict Core. It intentionally does not claim to -traverse or rewrite a rope yet. +text mutation. It binds exact-length nominal identities, the selected basis, +range, replacement bytes, operation profile, budget, imported helper +implementation, and a pure conditional into Edict Core. It intentionally does +not claim to traverse or rewrite a rope yet. With Edict #201, the public application build lowers those Core `let` nodes into generic, source-ordered Target IR and independently verifies the compiler-owned @@ -24,7 +29,7 @@ result projection. Echo #724 now emits a distinct `compiler-produced-bounded-pure/v1` executable package containing the exact Core, lawpack exports, Target IR, and result projection. Echo's structurally separate verifier independently reconstructs that package relation and emits an -accepted report. +accepted report bound to retained canonical `echo.executable-subject/v1` bytes. That accepted package is the current routing evidence required by #296: Edict preserves the bounded pure program without learning Jedit vocabulary, and Echo @@ -47,6 +52,15 @@ toolchain, Echo commit, provider identity, provider manifest bytes, and lowerer and verifier components. The script refuses non-Git roots, wrong commits, or dirty checkouts before invoking either toolchain. +`edict.build-lock.json` binds the exact source and validation closure to the +Core, Target IR, result projection, executable package, verification report, +and executable-subject identities. `edict.executable-subject-lock.json` +separately records the subject identity and the exact package, Target IR, and +result-projection references it contains. The harness recomputes every digest +from emitted bytes and refuses a valid report paired with a substituted package. +The locks contain no self-referential Jedit commit; an exact PR head remains an +external review coordinate. + The script verifies the committed `jedit.text@1` closure through Edict's public lawpack `checkOnly` boundary. It never republishes or repairs that authoritative tree. It then copies Echo's checked provider package into `.build/`, invokes diff --git a/edict/replace-range/edict.build-lock.json b/edict/replace-range/edict.build-lock.json new file mode 100644 index 00000000..75296ccb --- /dev/null +++ b/edict/replace-range/edict.build-lock.json @@ -0,0 +1,106 @@ +{ + "schema": "jedit.edict-build-lock/v1", + "applicationCoordinate": "jedit.text.replace_range@1", + "operationCoordinate": "jedit.text.replace_range@1.replaceRange", + "toolchainLockSha256": "69c68a095278d10bc2215afc729dabcba937027da99938862cfb555b8bac9a93", + "sourceClosure": { + "schema": "jedit.edict-source-closure/v1", + "digest": "sha256:dfb61b22dba5616ed3259e49744534ea878aec6b053535c6793cd43e88e26a78", + "files": [ + { + "path": "edict.application.json", + "sha256": "3182577627cd1f88bf590f3a8481ef53476c83d783aa142182e7c65eb1f72f8b" + }, + { + "path": "edict.lawpack.json", + "sha256": "37e91e54ae54ed6852bcc736d0e49e93379321f55b77750b31b713bbb7f0e9d3" + }, + { + "path": "edict.toolchain-lock.json", + "sha256": "69c68a095278d10bc2215afc729dabcba937027da99938862cfb555b8bac9a93" + }, + { + "path": "src/ReplaceRange.edict", + "sha256": "7af4ee51415bb4391510c5e91a029838a425515abe172aad9c6805b2d70dd916" + }, + { + "path": "tests/assert-build-output.mjs", + "sha256": "a0e48f69ff7828fad421864bcf10ccfe830fa57264b2a95c25b979b0988d1235" + }, + { + "path": "tests/build.sh", + "sha256": "b5827a1e2a4b64b214406ee3d0cdc9499059922f9878649946c0358fbbd6ea6d" + }, + { + "path": "tests/package-chain.mjs", + "sha256": "3128f12beba257df3231681fcfc672e4fa4cb4436806e3d410ae577180e8afcf" + }, + { + "path": "tests/proof-harness.spec.mjs", + "sha256": "541b5599988ea66f85a807c7f249e7db488f7932ccf3765b94e7d12b1dc6c174" + }, + { + "path": "vendor/jedit-text/edict.lawpack-output.json", + "sha256": "2471666ac595570ea6f812aa613916e20d6f40fd0a99fafb35002be3f4fbcd74" + }, + { + "path": "vendor/jedit-text/exports.cbor", + "sha256": "dfee735fd0a7f714a401aa310973596e959672a11bcac5c7c1d289c9344a7a0d" + }, + { + "path": "vendor/jedit-text/exports.sha256", + "sha256": "3661e5416b155f803fa0ba888397e4f9b5c79b228ecda538b37b375d3a09791e" + }, + { + "path": "vendor/jedit-text/manifest.cbor", + "sha256": "dadfd41260b1e3449b9fc8c1e5f4c9523b6b819f36fcc1316b53b7aa943a7118" + }, + { + "path": "vendor/jedit-text/manifest.sha256", + "sha256": "0496d95c6a0c37e0395e20f7c5c063c0277b92353412b262e935d17d1141d31b" + } + ] + }, + "lawpackRelease": { + "coordinate": "jedit.text@1", + "digest": "sha256:5253f7c8682cfed88a34c660a610c30da6bd9924973fefd33a82c9915a4f09cf" + }, + "provider": { + "coordinate": "echo.edict-provider@1", + "digest": "sha256:a4e0d9e31ada5c8c14adfce05fdecb228e5b79545f3574a5e21e7db71ab3f307" + }, + "artifacts": { + "core": { + "coordinate": "jedit.text.replace_range@1", + "domain": "edict.core.module/v1", + "digest": "sha256:a2cec435e178b0f772508125a9c7c6a7a79adc05367cc37955e4a6aa7714c9ef" + }, + "targetIr": { + "coordinate": "echo.span-ir/v1", + "domain": "edict.target-ir.artifact/v1", + "digest": "sha256:84c1f9826285822f969fc287bc09af2afd63ca876f19f54e5c20ea2e7b424260" + }, + "resultProjection": { + "coordinate": "jedit.text.replace_range@1.replaceRange", + "domain": "edict.result-projection.artifact/v1", + "digest": "sha256:f804baa01c357e5ed54e86f752ea7f8201e454ad0b47c10813fde8c7dc2aeba6" + }, + "executablePackage": { + "coordinate": "executable-operation-package.echo", + "domain": "echo.operation-package/v1", + "digest": "sha256:6075cb3be2308d7a513a05637499ab130bb35296bbcf14064feb153c47612eb1", + "rawSha256": "5666555277c9f33a5c2bc3ec5f6859c8ee4005075bc1d6a457f12a384065a8f3" + }, + "verificationReport": { + "coordinate": "verifier-report.echo-operation", + "domain": "echo.operation-package-verifier-report/v1", + "digest": "sha256:410e10dfa931c57da3aaf64a50ef4b62a63217e97e6152cdc2a22a661685bfd9", + "rawSha256": "4038b28354fe8555a581fe6e87fec7edcd550e27bbe54693f997558b86da1a97" + }, + "executableSubject": { + "coordinate": "echo.executable-subject/v1", + "domain": "echo.executable-subject/v1", + "digest": "sha256:8e2bc64d4c98983c174df8e76c39d74869acb5713c59bc3c2a2af5a9c3083caf" + } + } +} diff --git a/edict/replace-range/edict.executable-subject-lock.json b/edict/replace-range/edict.executable-subject-lock.json new file mode 100644 index 00000000..cba2d22d --- /dev/null +++ b/edict/replace-range/edict.executable-subject-lock.json @@ -0,0 +1,20 @@ +{ + "schema": "jedit.edict-executable-subject-lock/v1", + "reference": { + "coordinate": "echo.executable-subject/v1", + "digest": "sha256:8e2bc64d4c98983c174df8e76c39d74869acb5713c59bc3c2a2af5a9c3083caf" + }, + "rawSha256": "7c7c4695a0029ff6fd45dea942652e2fd7f707464bb9e985ba9b70c4a6d3c849", + "package": { + "coordinate": "executable-operation-package.echo", + "digest": "sha256:6075cb3be2308d7a513a05637499ab130bb35296bbcf14064feb153c47612eb1" + }, + "targetIr": { + "coordinate": "echo.span-ir/v1", + "digest": "sha256:84c1f9826285822f969fc287bc09af2afd63ca876f19f54e5c20ea2e7b424260" + }, + "resultProjection": { + "coordinate": "jedit.text.replace_range@1.replaceRange", + "digest": "sha256:f804baa01c357e5ed54e86f752ea7f8201e454ad0b47c10813fde8c7dc2aeba6" + } +} diff --git a/edict/replace-range/tests/assert-build-output.mjs b/edict/replace-range/tests/assert-build-output.mjs index 4c66cd60..02757645 100644 --- a/edict/replace-range/tests/assert-build-output.mjs +++ b/edict/replace-range/tests/assert-build-output.mjs @@ -3,7 +3,7 @@ import assert from "node:assert/strict"; import { createHash } from "node:crypto"; -import { readFile } from "node:fs/promises"; +import { readFile, writeFile } from "node:fs/promises"; import path from "node:path"; import { decode, encode } from "cbor-x"; @@ -23,8 +23,63 @@ function assertResourceReference(reference, coordinate, digest) { assert.deepEqual(reference.digest, ["sha256", digest]); } -const [outputDirectory] = process.argv.slice(2); +const SOURCE_CLOSURE_PATHS = [ + "edict.application.json", + "edict.lawpack.json", + "edict.toolchain-lock.json", + "src/ReplaceRange.edict", + "tests/assert-build-output.mjs", + "tests/build.sh", + "tests/package-chain.mjs", + "tests/proof-harness.spec.mjs", + "vendor/jedit-text/edict.lawpack-output.json", + "vendor/jedit-text/exports.cbor", + "vendor/jedit-text/exports.sha256", + "vendor/jedit-text/manifest.cbor", + "vendor/jedit-text/manifest.sha256", +]; + +function sha256(bytes) { + return createHash("sha256").update(bytes).digest(); +} + +function lengthPrefix(length) { + const prefix = Buffer.alloc(8); + prefix.writeBigUInt64LE(BigInt(length)); + return prefix; +} + +async function sourceClosure(applicationRoot) { + const hasher = createHash("sha256"); + hasher.update("jedit.edict-source-closure/v1\0"); + const files = []; + for (const relative of SOURCE_CLOSURE_PATHS) { + const bytes = await readFile(path.join(applicationRoot, relative)); + const relativeBytes = Buffer.from(relative, "utf8"); + hasher.update(lengthPrefix(relativeBytes.length)); + hasher.update(relativeBytes); + hasher.update(lengthPrefix(bytes.length)); + hasher.update(bytes); + files.push({ path: relative, sha256: sha256(bytes).toString("hex") }); + } + return { + schema: "jedit.edict-source-closure/v1", + digest: `sha256:${hasher.digest("hex")}`, + files, + }; +} + +function digestText(bytes) { + return `sha256:${Buffer.from(bytes).toString("hex")}`; +} + +const [outputDirectory, mode] = process.argv.slice(2); assert.ok(outputDirectory, "pass the Edict application output directory"); +assert.ok( + mode === undefined || mode === "--write-locks", + "the only supported mode is --write-locks", +); +const applicationRoot = path.resolve(outputDirectory, "../.."); const packageBytes = await readFile( path.join(outputDirectory, "executable-operation-package.cbor"), @@ -72,6 +127,7 @@ const coreDigest = canonicalArtifactDigest( "edict.core.module/v1", program.core_artifact, ); +const coreArtifact = decode(program.core_artifact); assert.deepEqual(executablePackage.semantic_closure.core_identity, coreDigest); assert.deepEqual( executablePackage.semantic_closure.canonical_meaning_identity, @@ -134,3 +190,108 @@ assert.deepEqual( executableSubject.applicationResultProjection, report.applicationResultProjection, ); + +const toolchainLockBytes = await readFile( + path.join(applicationRoot, "edict.toolchain-lock.json"), +); +const toolchainLock = JSON.parse(toolchainLockBytes); +const lawpackReleaseDigest = ( + await readFile( + path.join(applicationRoot, "vendor", "jedit-text", "manifest.sha256"), + "utf8", + ) +).trim(); +const reportDigest = canonicalArtifactDigest( + "echo.operation-package-verifier-report/v1", + reportBytes, +); +const computedBuildLock = { + schema: "jedit.edict-build-lock/v1", + applicationCoordinate: coreArtifact.coordinate, + operationCoordinate: executablePackage.operation_coordinate, + toolchainLockSha256: sha256(toolchainLockBytes).toString("hex"), + sourceClosure: await sourceClosure(applicationRoot), + lawpackRelease: { + coordinate: executablePackage.semantic_closure.lawpack_coordinate, + digest: lawpackReleaseDigest, + }, + provider: { + coordinate: toolchainLock.echo.provider.coordinate, + digest: toolchainLock.echo.provider.digest, + }, + artifacts: { + core: { + coordinate: coreArtifact.coordinate, + domain: "edict.core.module/v1", + digest: digestText(coreDigest), + }, + targetIr: { + coordinate: report.targetIr.id, + domain: "edict.target-ir.artifact/v1", + digest: digestText(targetIrDigest), + }, + resultProjection: { + coordinate: report.applicationResultProjection.id, + domain: "edict.result-projection.artifact/v1", + digest: digestText(resultProjectionDigest), + }, + executablePackage: { + coordinate: report.package.id, + domain: "echo.operation-package/v1", + digest: digestText(packageDigest), + rawSha256: sha256(packageBytes).toString("hex"), + }, + verificationReport: { + coordinate: "verifier-report.echo-operation", + domain: "echo.operation-package-verifier-report/v1", + digest: digestText(reportDigest), + rawSha256: sha256(reportBytes).toString("hex"), + }, + executableSubject: { + coordinate: report.executableSubject.reference.id, + domain: "echo.executable-subject/v1", + digest: digestText(executableSubjectDigest), + }, + }, +}; +const computedSubjectLock = { + schema: "jedit.edict-executable-subject-lock/v1", + reference: { + coordinate: report.executableSubject.reference.id, + digest: digestText(executableSubjectDigest), + }, + rawSha256: sha256(report.executableSubject.bytes).toString("hex"), + package: { + coordinate: report.package.id, + digest: digestText(packageDigest), + }, + targetIr: { + coordinate: report.targetIr.id, + digest: digestText(targetIrDigest), + }, + resultProjection: { + coordinate: report.applicationResultProjection.id, + digest: digestText(resultProjectionDigest), + }, +}; + +const buildLockPath = path.join(applicationRoot, "edict.build-lock.json"); +const subjectLockPath = path.join( + applicationRoot, + "edict.executable-subject-lock.json", +); +if (mode === "--write-locks") { + await writeFile(buildLockPath, `${JSON.stringify(computedBuildLock, null, 2)}\n`); + await writeFile(subjectLockPath, `${JSON.stringify(computedSubjectLock, null, 2)}\n`); +} else { + assert.deepEqual( + JSON.parse(await readFile(buildLockPath, "utf8")), + computedBuildLock, + "the exact build closure differs from edict.build-lock.json", + ); + assert.deepEqual( + JSON.parse(await readFile(subjectLockPath, "utf8")), + computedSubjectLock, + "the executable subject differs from edict.executable-subject-lock.json", + ); +} diff --git a/edict/replace-range/tests/proof-harness.spec.mjs b/edict/replace-range/tests/proof-harness.spec.mjs index b3fa1e45..8ac3b7e3 100644 --- a/edict/replace-range/tests/proof-harness.spec.mjs +++ b/edict/replace-range/tests/proof-harness.spec.mjs @@ -193,3 +193,41 @@ test("rejects_short_buffer_and_head_identities", { timeout: 120_000 }, async () await subject.dispose(); } }); + +test("rejects_drifted_build_and_executable_subject_locks", { timeout: 120_000 }, async () => { + requireToolchainEnvironment(); + const subject = await fixture(); + try { + const lockPath = path.join(subject.application, "edict.build-lock.json"); + const lock = JSON.parse(await readFile(lockPath, "utf8")); + lock.artifacts.core.digest = `sha256:${"0".repeat(64)}`; + await writeFile(lockPath, `${JSON.stringify(lock, null, 2)}\n`); + + const build = runBuild(subject.project); + assertCommandCompleted(build); + assert.notEqual( + build.status, + 0, + "a changed exact-artifact expectation must fail the package-chain gate", + ); + } finally { + await subject.dispose(); + } +}); + +test("required_ci_executes_the_exact_package_chain", async () => { + const workflow = await readFile( + path.join(projectRoot, ".github", "workflows", "ci.yml"), + "utf8", + ); + assert.match(workflow, /^ edict-replace-range:\n/m); + assert.match(workflow, /name: edict \/ replace-range package chain/); + assert.match( + workflow, + /node --test edict\/replace-range\/tests\/proof-harness\.spec\.mjs/, + ); + assert.match( + workflow, + /needs: \[ plan, build, test-shards, quality, release-gate, edict-replace-range \]/, + ); +}); From a6673521699259abdd27be10f7c885b5c634a867 Mon Sep 17 00:00:00 2001 From: James Ross Date: Sun, 23 Aug 2026 19:50:47 -0700 Subject: [PATCH 09/30] Harden exact Edict package identity proof --- .github/workflows/ci.yml | 10 +- edict/replace-range/README.md | 30 ++- edict/replace-range/edict.build-lock.json | 94 +++++--- .../edict.executable-subject-lock.json | 8 +- edict/replace-range/edict.lawpack.json | 4 +- edict/replace-range/edict.toolchain-lock.json | 43 +++- edict/replace-range/src/ReplaceRange.edict | 2 +- .../tests/assert-build-output.mjs | 93 ++++---- edict/replace-range/tests/package-chain.mjs | 85 ++++++- .../tests/proof-harness.spec.mjs | 209 ++++++++++++++++-- .../tests/verification-evidence.mjs | 83 +++++++ .../jedit-text/edict.lawpack-output.json | 8 +- .../vendor/jedit-text/exports.cbor | Bin 2342 -> 2362 bytes .../vendor/jedit-text/exports.sha256 | 2 +- .../vendor/jedit-text/manifest.cbor | Bin 787 -> 787 bytes .../vendor/jedit-text/manifest.sha256 | 2 +- 16 files changed, 538 insertions(+), 135 deletions(-) create mode 100644 edict/replace-range/tests/verification-evidence.mjs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 09b79e4e..d90ea2c4 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -177,8 +177,15 @@ jobs: - name: Checkout Jedit uses: actions/checkout@v6.0.2 with: + ref: ${{ github.event.pull_request.head.sha || github.sha }} path: jedit + - name: Verify literal submitted head + working-directory: jedit + env: + EXPECTED_JEDIT_HEAD: ${{ github.event.pull_request.head.sha || github.sha }} + run: test "$(git rev-parse HEAD)" = "$EXPECTED_JEDIT_HEAD" + - name: Read pinned toolchain commits id: toolchain working-directory: jedit @@ -191,6 +198,7 @@ jobs: console.log(`edict_commit=${lock.edict.commit}`); console.log(`echo_commit=${lock.echo.commit}`); console.log(`rust_toolchain=${lock.rust.toolchain}`); + console.log(`node_version=${lock.validation.nodeVersion}`); NODE - name: Checkout pinned Edict @@ -210,7 +218,7 @@ jobs: - name: Setup Node.js uses: actions/setup-node@v6.4.0 with: - node-version: 22 + node-version: ${{ steps.toolchain.outputs.node_version }} cache: 'npm' cache-dependency-path: jedit/package-lock.json diff --git a/edict/replace-range/README.md b/edict/replace-range/README.md index a063d07b..da488a09 100644 --- a/edict/replace-range/README.md +++ b/edict/replace-range/README.md @@ -49,16 +49,24 @@ ECHO_REPO=/path/to/echo \ `edict.toolchain-lock.json` pins the exact Edict commit and CLI release, Rust toolchain, Echo commit, provider identity, provider manifest bytes, and lowerer -and verifier components. The script refuses non-Git roots, wrong commits, or -dirty checkouts before invoking either toolchain. +and verifier components. It also pins the Node and npm releases, the resolved +`cbor-x` package and integrity, and the package, lockfile, and CI invocation +bytes that perform validation. The script refuses non-Git roots, wrong commits, +dirty checkouts, or validation-environment drift before invoking either +toolchain. GitHub's package-chain job checks out and verifies the literal pull +request head; ordinary matrix jobs may separately exercise the synthetic merge. `edict.build-lock.json` binds the exact source and validation closure to the Core, Target IR, result projection, executable package, verification report, -and executable-subject identities. `edict.executable-subject-lock.json` -separately records the subject identity and the exact package, Target IR, and -result-projection references it contains. The harness recomputes every digest -from emitted bytes and refuses a valid report paired with a substituted package. -The locks contain no self-referential Jedit commit; an exact PR head remains an +and executable-subject identities. The raw Echo report remains a separately +identified artifact. A canonical-JSON Jedit evidence envelope binds that artifact +and subject to the exact provider release, verifier component, diagnostic ABI, +report ABI, and outcome; that verifier-specific envelope is the transitional +`VerificationReportId`. `edict.executable-subject-lock.json` separately records +the subject identity and the exact package, Target IR, and result-projection +references it contains. The harness recomputes every digest from emitted bytes +and refuses a valid report paired with a substituted package or verifier. The +locks contain no self-referential Jedit commit; an exact PR head remains an external review coordinate. The script verifies the committed `jedit.text@1` closure through Edict's public @@ -66,8 +74,12 @@ lawpack `checkOnly` boundary. It never republishes or repairs that authoritative tree. It then copies Echo's checked provider package into `.build/`, invokes Edict's public application build, and requires the generic pure package and an accepted independent-verifier report. Snapshots cover the application inputs -outside `.build/` plus every tracked Edict and Echo file; any content, identity, -or timestamp mutation fails the run. Only `.build/` is disposable output. +outside `.build/`, the pinned project validation files, and every tracked Edict +and Echo file; any content, identity, or timestamp mutation fails the run. Only +`.build/` is disposable output. Distinct nominal `BufferId` and `HeadId` +contracts retain the same exact 32-byte representation, while a negative +compiler witness proves that neither can cross the imported lawpack boundary as +the other. The gate must advance again when Echo implements generic pure evaluation; package acceptance is not a permanent substitute for runtime evidence. diff --git a/edict/replace-range/edict.build-lock.json b/edict/replace-range/edict.build-lock.json index 75296ccb..63a18344 100644 --- a/edict/replace-range/edict.build-lock.json +++ b/edict/replace-range/edict.build-lock.json @@ -2,83 +2,99 @@ "schema": "jedit.edict-build-lock/v1", "applicationCoordinate": "jedit.text.replace_range@1", "operationCoordinate": "jedit.text.replace_range@1.replaceRange", - "toolchainLockSha256": "69c68a095278d10bc2215afc729dabcba937027da99938862cfb555b8bac9a93", + "toolchainLockSha256": "3396bb91bea7e51d1e4b9f7385421d865d9e5a8f1c7ee1eaf330592143925fa0", "sourceClosure": { "schema": "jedit.edict-source-closure/v1", - "digest": "sha256:dfb61b22dba5616ed3259e49744534ea878aec6b053535c6793cd43e88e26a78", + "digest": "sha256:b6e247a612dd30b62db8b72d5063cbc29c762ffa91f8462fe57b1aadbdda521b", "files": [ { - "path": "edict.application.json", + "path": "application/edict.application.json", "sha256": "3182577627cd1f88bf590f3a8481ef53476c83d783aa142182e7c65eb1f72f8b" }, { - "path": "edict.lawpack.json", - "sha256": "37e91e54ae54ed6852bcc736d0e49e93379321f55b77750b31b713bbb7f0e9d3" + "path": "application/edict.lawpack.json", + "sha256": "150abd5971b40ed70d2b1a1765a1a690e120ad9e44239dae732dc54e6ae04f99" }, { - "path": "edict.toolchain-lock.json", - "sha256": "69c68a095278d10bc2215afc729dabcba937027da99938862cfb555b8bac9a93" + "path": "application/edict.toolchain-lock.json", + "sha256": "3396bb91bea7e51d1e4b9f7385421d865d9e5a8f1c7ee1eaf330592143925fa0" }, { - "path": "src/ReplaceRange.edict", - "sha256": "7af4ee51415bb4391510c5e91a029838a425515abe172aad9c6805b2d70dd916" + "path": "application/src/ReplaceRange.edict", + "sha256": "51797e77062585a9f59083ee8a1da3faaf486ef7691e1b62203369a9d9356ee0" }, { - "path": "tests/assert-build-output.mjs", - "sha256": "a0e48f69ff7828fad421864bcf10ccfe830fa57264b2a95c25b979b0988d1235" + "path": "application/tests/assert-build-output.mjs", + "sha256": "cc54e77a7a5923bb6496817b4822dfd38d5077501f6e12ab55129cf8cfcc86d9" }, { - "path": "tests/build.sh", + "path": "application/tests/build.sh", "sha256": "b5827a1e2a4b64b214406ee3d0cdc9499059922f9878649946c0358fbbd6ea6d" }, { - "path": "tests/package-chain.mjs", - "sha256": "3128f12beba257df3231681fcfc672e4fa4cb4436806e3d410ae577180e8afcf" + "path": "application/tests/package-chain.mjs", + "sha256": "28615de79aa645fa7c3a9cd098865e02af666fa86f49b251d5fe6c919329d141" }, { - "path": "tests/proof-harness.spec.mjs", - "sha256": "541b5599988ea66f85a807c7f249e7db488f7932ccf3765b94e7d12b1dc6c174" + "path": "application/tests/proof-harness.spec.mjs", + "sha256": "a60012f744cff26095a451fe74f984b41a48551e8b47d6f2e5d8e128e1dcd643" }, { - "path": "vendor/jedit-text/edict.lawpack-output.json", - "sha256": "2471666ac595570ea6f812aa613916e20d6f40fd0a99fafb35002be3f4fbcd74" + "path": "application/tests/verification-evidence.mjs", + "sha256": "3022f86f5c96d61f32ced3bec211d08ef7bbcdbc6e772cc61e2019eba0e42218" }, { - "path": "vendor/jedit-text/exports.cbor", - "sha256": "dfee735fd0a7f714a401aa310973596e959672a11bcac5c7c1d289c9344a7a0d" + "path": "application/vendor/jedit-text/edict.lawpack-output.json", + "sha256": "141c0000932ba19cff687e4173e40b0a38410f70bd511c9bc51f3fb3f73ee62b" }, { - "path": "vendor/jedit-text/exports.sha256", - "sha256": "3661e5416b155f803fa0ba888397e4f9b5c79b228ecda538b37b375d3a09791e" + "path": "application/vendor/jedit-text/exports.cbor", + "sha256": "cab9c575da49cb33289e45fc45afb9d7f05558dada734be7eb3acfbbabb1d4db" }, { - "path": "vendor/jedit-text/manifest.cbor", - "sha256": "dadfd41260b1e3449b9fc8c1e5f4c9523b6b819f36fcc1316b53b7aa943a7118" + "path": "application/vendor/jedit-text/exports.sha256", + "sha256": "9bb11d9f8153c18af53b484526d9980b05c27eb20aa97e7623d1bf1ed5a69aea" }, { - "path": "vendor/jedit-text/manifest.sha256", - "sha256": "0496d95c6a0c37e0395e20f7c5c063c0277b92353412b262e935d17d1141d31b" + "path": "application/vendor/jedit-text/manifest.cbor", + "sha256": "0323ed8e9510e473d329166d421dc7d8e1da353065c1cd2dee77e6313ba9bf91" + }, + { + "path": "application/vendor/jedit-text/manifest.sha256", + "sha256": "316cf602502a45cbab89b77b6344854edee750eaf1f0c8167da48d19ead75c22" + }, + { + "path": "project/.github/workflows/ci.yml", + "sha256": "d4100140562e160bd897f9af9fc5d4ee8d7ea9285ba5d0734c620a38cf2d2ea5" + }, + { + "path": "project/package.json", + "sha256": "735a70d8e48f118695529446780d547f8f200dcb0fa453099aa2241d820d9eb5" + }, + { + "path": "project/package-lock.json", + "sha256": "d39f4b39e262e55355315e0a38ad2d10953ae5f6cd48b9fe3a530a128afd01d2" } ] }, "lawpackRelease": { "coordinate": "jedit.text@1", - "digest": "sha256:5253f7c8682cfed88a34c660a610c30da6bd9924973fefd33a82c9915a4f09cf" + "digest": "sha256:95758c1605894672cc9069fde01bb8b6e11842b053102660c9cd4f4d6f34d64e" }, "provider": { "coordinate": "echo.edict-provider@1", - "digest": "sha256:a4e0d9e31ada5c8c14adfce05fdecb228e5b79545f3574a5e21e7db71ab3f307" + "digest": "sha256:b065242a81179df02cd450763c8266e866bbca959308f5198b791a919050e0c2" }, "artifacts": { "core": { "coordinate": "jedit.text.replace_range@1", "domain": "edict.core.module/v1", - "digest": "sha256:a2cec435e178b0f772508125a9c7c6a7a79adc05367cc37955e4a6aa7714c9ef" + "digest": "sha256:d965643ff78c4f321af538f086329fee53c22b21dc1de9e5f9914d6cb69e609f" }, "targetIr": { "coordinate": "echo.span-ir/v1", "domain": "edict.target-ir.artifact/v1", - "digest": "sha256:84c1f9826285822f969fc287bc09af2afd63ca876f19f54e5c20ea2e7b424260" + "digest": "sha256:8a5243fef0aea029df1b6a56eb65f199703e10143d5e0cec5b73603455284229" }, "resultProjection": { "coordinate": "jedit.text.replace_range@1.replaceRange", @@ -88,19 +104,25 @@ "executablePackage": { "coordinate": "executable-operation-package.echo", "domain": "echo.operation-package/v1", - "digest": "sha256:6075cb3be2308d7a513a05637499ab130bb35296bbcf14064feb153c47612eb1", - "rawSha256": "5666555277c9f33a5c2bc3ec5f6859c8ee4005075bc1d6a457f12a384065a8f3" + "digest": "sha256:9a9e26e10dabf9175889fb2ef50bd463dd08ea95e9a377e0a39eb4663acd409b", + "rawSha256": "f339cf8e52621df4a9b644c83770932df5c01c52e70d1bd271c0e6519cda2998" }, - "verificationReport": { + "verificationReportArtifact": { "coordinate": "verifier-report.echo-operation", "domain": "echo.operation-package-verifier-report/v1", - "digest": "sha256:410e10dfa931c57da3aaf64a50ef4b62a63217e97e6152cdc2a22a661685bfd9", - "rawSha256": "4038b28354fe8555a581fe6e87fec7edcd550e27bbe54693f997558b86da1a97" + "digest": "sha256:c8f1e52216f248022a884c822d577c479b3a68b0f5ad69f21db3288a00e474a1", + "rawSha256": "124cfca3449d19684a169a4fe62898dfb76124854d0f0ef57ea3ed9f606a4ce0" + }, + "verificationReport": { + "coordinate": "jedit.edict-verification-evidence/v1", + "domain": "jedit.edict-verification-evidence/v1", + "digest": "sha256:54f4bc09addabf3236478c891aa8ced4f13a2738e007f95c96f547b6b36dcd80", + "rawSha256": "6a6420061353e34a8a8db21025b9eeed7a0802c720b4e865e8f6218448f5be4e" }, "executableSubject": { "coordinate": "echo.executable-subject/v1", "domain": "echo.executable-subject/v1", - "digest": "sha256:8e2bc64d4c98983c174df8e76c39d74869acb5713c59bc3c2a2af5a9c3083caf" + "digest": "sha256:9738fc187d8507b64bc7c01a536c8eb2b99fb550380db878d49ebb7e130267aa" } } } diff --git a/edict/replace-range/edict.executable-subject-lock.json b/edict/replace-range/edict.executable-subject-lock.json index cba2d22d..d0605bb5 100644 --- a/edict/replace-range/edict.executable-subject-lock.json +++ b/edict/replace-range/edict.executable-subject-lock.json @@ -2,16 +2,16 @@ "schema": "jedit.edict-executable-subject-lock/v1", "reference": { "coordinate": "echo.executable-subject/v1", - "digest": "sha256:8e2bc64d4c98983c174df8e76c39d74869acb5713c59bc3c2a2af5a9c3083caf" + "digest": "sha256:9738fc187d8507b64bc7c01a536c8eb2b99fb550380db878d49ebb7e130267aa" }, - "rawSha256": "7c7c4695a0029ff6fd45dea942652e2fd7f707464bb9e985ba9b70c4a6d3c849", + "rawSha256": "46255257cc23601a10f2dd1fd5d7bc86fc4bb13612eb2b3ac5f633ded159aa88", "package": { "coordinate": "executable-operation-package.echo", - "digest": "sha256:6075cb3be2308d7a513a05637499ab130bb35296bbcf14064feb153c47612eb1" + "digest": "sha256:9a9e26e10dabf9175889fb2ef50bd463dd08ea95e9a377e0a39eb4663acd409b" }, "targetIr": { "coordinate": "echo.span-ir/v1", - "digest": "sha256:84c1f9826285822f969fc287bc09af2afd63ca876f19f54e5c20ea2e7b424260" + "digest": "sha256:8a5243fef0aea029df1b6a56eb65f199703e10143d5e0cec5b73603455284229" }, "resultProjection": { "coordinate": "jedit.text.replace_range@1.replaceRange", diff --git a/edict/replace-range/edict.lawpack.json b/edict/replace-range/edict.lawpack.json index 13483ef6..2652d166 100644 --- a/edict/replace-range/edict.lawpack.json +++ b/edict/replace-range/edict.lawpack.json @@ -18,11 +18,11 @@ }, { "coordinate": "jedit.text@1.BufferId", - "definition": "jedit.text@1.NodeId" + "definition": "Nominal" }, { "coordinate": "jedit.text@1.HeadId", - "definition": "jedit.text@1.NodeId" + "definition": "Nominal" }, { "coordinate": "jedit.text@1.ReplacementBytes", diff --git a/edict/replace-range/edict.toolchain-lock.json b/edict/replace-range/edict.toolchain-lock.json index a0369e48..110a908e 100644 --- a/edict/replace-range/edict.toolchain-lock.json +++ b/edict/replace-range/edict.toolchain-lock.json @@ -5,23 +5,54 @@ "rustcVersion": "rustc 1.94.0 (4a4ef493e 2026-03-02)", "cargoVersion": "cargo 1.94.0 (85eff7c80 2026-01-15)" }, + "validation": { + "nodeVersion": "22.23.1", + "processVersion": "v22.23.1", + "npmVersion": "10.9.8", + "cborX": { + "version": "1.6.4", + "integrity": "sha512-UGKHjp6RHC6QuZ2yy5LCKm7MojM4716DwoSaqwQpaH4DvZvbBTGcoDNTiG9Y2lByXZYFEs9WRkS5tLl96IrF1Q==" + }, + "files": [ + { + "path": "package.json", + "sha256": "735a70d8e48f118695529446780d547f8f200dcb0fa453099aa2241d820d9eb5" + }, + { + "path": "package-lock.json", + "sha256": "d39f4b39e262e55355315e0a38ad2d10953ae5f6cd48b9fe3a530a128afd01d2" + }, + { + "path": ".github/workflows/ci.yml", + "sha256": "d4100140562e160bd897f9af9fc5d4ee8d7ea9285ba5d0734c620a38cf2d2ea5" + } + ] + }, "edict": { - "commit": "68633c409474b9dffac4a33a674b2a3f29ad865c", + "commit": "39a796de04b3400f569880da06878da50d8ed0ee", "cliVersion": "0.11.0-alpha.1" }, "echo": { - "commit": "27a56eb91964aeeea90d36c58585683b341a2dfc", + "commit": "49e9efb68001dfd78563d18bac9359a87671e431", "provider": { "coordinate": "echo.edict-provider@1", - "digest": "sha256:a4e0d9e31ada5c8c14adfce05fdecb228e5b79545f3574a5e21e7db71ab3f307", - "manifestSha256": "205bdba71fd552316be59079d7509c592b1ac98af7197a119fe56ce12ea0a5f6", + "digest": "sha256:b065242a81179df02cd450763c8266e866bbca959308f5198b791a919050e0c2", + "manifestSha256": "c5b9fb2fe3a0dc4dad282621a97413225c555be0071f3502b3272952069d42dc", + "targetProfile": { + "coordinate": "echo.dpo@1", + "digest": "sha256:2e2494121aecf5e6a2d920f5fb85408825d394765fad41484c416397c920fb04" + }, "lowerer": { "coordinate": "echo.dpo.lowerer/component@1", - "sha256": "a4758f060122fba8c073841ccaa22bf0b8a742b495b76eb33c914eff3250dcf5" + "sha256": "e842063bd8d8ec12fff5b392a9d6bc646e2e3025c7a0c93726f53eed3cb5a0bf" }, "verifier": { "coordinate": "echo.dpo.verifier/component@1", - "sha256": "174cf8758815bf2b9f2ef575517aa6d144ed3f2d1995fc65d25a211b9dea82d9" + "sha256": "174cf8758815bf2b9f2ef575517aa6d144ed3f2d1995fc65d25a211b9dea82d9", + "contract": { + "coordinate": "echo.dpo.verifier/v1", + "digest": "sha256:ca96b190728de3d668072ec1bd37d24e5197e7bd9bd54f70966d8c566b9b67f2" + } } } } diff --git a/edict/replace-range/src/ReplaceRange.edict b/edict/replace-range/src/ReplaceRange.edict index 0c77483d..6079dbeb 100644 --- a/edict/replace-range/src/ReplaceRange.edict +++ b/edict/replace-range/src/ReplaceRange.edict @@ -1,6 +1,6 @@ package jedit.text.replace_range@1; -use lawpack jedit.text@1 digest "sha256:5253f7c8682cfed88a34c660a610c30da6bd9924973fefd33a82c9915a4f09cf" as text; +use lawpack jedit.text@1 digest "sha256:95758c1605894672cc9069fde01bb8b6e11842b053102660c9cd4f4d6f34d64e" as text; type ReplaceRangeInput = { bufferId: text.BufferId, diff --git a/edict/replace-range/tests/assert-build-output.mjs b/edict/replace-range/tests/assert-build-output.mjs index 02757645..fc0d14a6 100644 --- a/edict/replace-range/tests/assert-build-output.mjs +++ b/edict/replace-range/tests/assert-build-output.mjs @@ -6,37 +6,49 @@ import { createHash } from "node:crypto"; import { readFile, writeFile } from "node:fs/promises"; import path from "node:path"; -import { decode, encode } from "cbor-x"; +import { decode } from "cbor-x"; -function canonicalArtifactDigest(domain, canonicalArtifactBytes) { - const preimage = Buffer.concat([ - Buffer.from([0x83]), - Buffer.from(encode("edict.digest/v1")), - Buffer.from(encode(domain)), - Buffer.from(canonicalArtifactBytes), - ]); - return createHash("sha256").update(preimage).digest(); -} +import { + canonicalArtifactDigest, + digestText, + verificationEvidence, +} from "./verification-evidence.mjs"; function assertResourceReference(reference, coordinate, digest) { assert.equal(reference.id, coordinate); assert.deepEqual(reference.digest, ["sha256", digest]); } -const SOURCE_CLOSURE_PATHS = [ - "edict.application.json", - "edict.lawpack.json", - "edict.toolchain-lock.json", - "src/ReplaceRange.edict", - "tests/assert-build-output.mjs", - "tests/build.sh", - "tests/package-chain.mjs", - "tests/proof-harness.spec.mjs", - "vendor/jedit-text/edict.lawpack-output.json", - "vendor/jedit-text/exports.cbor", - "vendor/jedit-text/exports.sha256", - "vendor/jedit-text/manifest.cbor", - "vendor/jedit-text/manifest.sha256", +const SOURCE_CLOSURE_INPUTS = [ + ["application/edict.application.json", "edict.application.json"], + ["application/edict.lawpack.json", "edict.lawpack.json"], + ["application/edict.toolchain-lock.json", "edict.toolchain-lock.json"], + ["application/src/ReplaceRange.edict", "src/ReplaceRange.edict"], + ["application/tests/assert-build-output.mjs", "tests/assert-build-output.mjs"], + ["application/tests/build.sh", "tests/build.sh"], + ["application/tests/package-chain.mjs", "tests/package-chain.mjs"], + ["application/tests/proof-harness.spec.mjs", "tests/proof-harness.spec.mjs"], + [ + "application/tests/verification-evidence.mjs", + "tests/verification-evidence.mjs", + ], + [ + "application/vendor/jedit-text/edict.lawpack-output.json", + "vendor/jedit-text/edict.lawpack-output.json", + ], + ["application/vendor/jedit-text/exports.cbor", "vendor/jedit-text/exports.cbor"], + [ + "application/vendor/jedit-text/exports.sha256", + "vendor/jedit-text/exports.sha256", + ], + ["application/vendor/jedit-text/manifest.cbor", "vendor/jedit-text/manifest.cbor"], + [ + "application/vendor/jedit-text/manifest.sha256", + "vendor/jedit-text/manifest.sha256", + ], + ["project/.github/workflows/ci.yml", "../../.github/workflows/ci.yml"], + ["project/package.json", "../../package.json"], + ["project/package-lock.json", "../../package-lock.json"], ]; function sha256(bytes) { @@ -53,14 +65,14 @@ async function sourceClosure(applicationRoot) { const hasher = createHash("sha256"); hasher.update("jedit.edict-source-closure/v1\0"); const files = []; - for (const relative of SOURCE_CLOSURE_PATHS) { + for (const [identityPath, relative] of SOURCE_CLOSURE_INPUTS) { const bytes = await readFile(path.join(applicationRoot, relative)); - const relativeBytes = Buffer.from(relative, "utf8"); + const relativeBytes = Buffer.from(identityPath, "utf8"); hasher.update(lengthPrefix(relativeBytes.length)); hasher.update(relativeBytes); hasher.update(lengthPrefix(bytes.length)); hasher.update(bytes); - files.push({ path: relative, sha256: sha256(bytes).toString("hex") }); + files.push({ path: identityPath, sha256: sha256(bytes).toString("hex") }); } return { schema: "jedit.edict-source-closure/v1", @@ -69,10 +81,6 @@ async function sourceClosure(applicationRoot) { }; } -function digestText(bytes) { - return `sha256:${Buffer.from(bytes).toString("hex")}`; -} - const [outputDirectory, mode] = process.argv.slice(2); assert.ok(outputDirectory, "pass the Edict application output directory"); assert.ok( @@ -205,6 +213,21 @@ const reportDigest = canonicalArtifactDigest( "echo.operation-package-verifier-report/v1", reportBytes, ); +const reportArtifactId = { + coordinate: "verifier-report.echo-operation", + domain: "echo.operation-package-verifier-report/v1", + digest: digestText(reportDigest), + rawSha256: sha256(reportBytes).toString("hex"), +}; +const evidence = verificationEvidence({ + executableSubjectId: { + coordinate: report.executableSubject.reference.id, + digest: digestText(executableSubjectDigest), + }, + provider: toolchainLock.echo.provider, + reportArtifactId, + report, +}); const computedBuildLock = { schema: "jedit.edict-build-lock/v1", applicationCoordinate: coreArtifact.coordinate, @@ -241,12 +264,8 @@ const computedBuildLock = { digest: digestText(packageDigest), rawSha256: sha256(packageBytes).toString("hex"), }, - verificationReport: { - coordinate: "verifier-report.echo-operation", - domain: "echo.operation-package-verifier-report/v1", - digest: digestText(reportDigest), - rawSha256: sha256(reportBytes).toString("hex"), - }, + verificationReportArtifact: reportArtifactId, + verificationReport: evidence.identity, executableSubject: { coordinate: report.executableSubject.reference.id, domain: "echo.executable-subject/v1", diff --git a/edict/replace-range/tests/package-chain.mjs b/edict/replace-range/tests/package-chain.mjs index 3133466d..b5217985 100644 --- a/edict/replace-range/tests/package-chain.mjs +++ b/edict/replace-range/tests/package-chain.mjs @@ -17,6 +17,8 @@ import { import path from "node:path"; import { fileURLToPath } from "node:url"; +import { decode } from "cbor-x"; + const testsDirectory = path.dirname(fileURLToPath(import.meta.url)); const applicationRoot = path.resolve(testsDirectory, ".."); const projectRoot = path.resolve(applicationRoot, "../.."); @@ -98,8 +100,35 @@ async function verifyProvider(lock) { const artifact = providerArtifact(manifest, role); assert.equal(artifact.resource.coordinate, expected.coordinate); assert.equal(artifact.resource.digest, `sha256:${expected.sha256}`); - assert.equal(await sha256(path.join(providerRoot, "components", fileName)), expected.sha256); + assert.equal( + await sha256(path.join(providerRoot, "components", fileName)), + expected.sha256, + ); } + const targetProfileArtifact = providerArtifact( + manifest, + "target-profile.echo-dpo", + ); + assert.equal( + targetProfileArtifact.resource.coordinate, + lock.targetProfile.coordinate, + ); + assert.equal(targetProfileArtifact.resource.digest, lock.targetProfile.digest); + const targetProfile = decode( + await readFile( + path.join( + providerRoot, + "generated", + "primary", + "target-profile.echo-dpo.cbor", + ), + ), + ); + assert.equal(targetProfile.verifier.id, lock.verifier.contract.coordinate); + assert.equal( + `sha256:${Buffer.from(targetProfile.verifier.digest[1]).toString("hex")}`, + lock.verifier.contract.digest, + ); return providerRoot; } @@ -156,9 +185,14 @@ async function snapshotFile(namespace, root, relative) { return { ...common, kind: "other" }; } -async function snapshotAuthoritativeInputs() { +async function snapshotAuthoritativeInputs(lock) { const roots = [ ["jedit", applicationRoot, (await collectDirectoryFiles(applicationRoot)).sort()], + [ + "jedit-project", + projectRoot, + lock.validation.files.map((file) => file.path).sort(), + ], ["edict", edictRepository, trackedFiles(edictRepository)], ["echo", echoRepository, trackedFiles(echoRepository)], ]; @@ -172,8 +206,34 @@ async function snapshotAuthoritativeInputs() { } async function verifyVersions(lock) { - assert.equal(run("rustc", [`+${lock.rust.toolchain}`, "--version"]), lock.rust.rustcVersion); - assert.equal(run("cargo", [`+${lock.rust.toolchain}`, "--version"]), lock.rust.cargoVersion); + assert.equal(process.version, lock.validation.processVersion); + assert.equal(run("npm", ["--version"]), lock.validation.npmVersion); + const packageLock = JSON.parse( + await readFile(path.join(projectRoot, "package-lock.json")), + ); + assert.equal( + packageLock.packages["node_modules/cbor-x"].version, + lock.validation.cborX.version, + ); + assert.equal( + packageLock.packages["node_modules/cbor-x"].integrity, + lock.validation.cborX.integrity, + ); + for (const file of lock.validation.files) { + assert.equal( + await sha256(path.join(projectRoot, file.path)), + file.sha256, + `${file.path} differs from the validation-environment lock`, + ); + } + assert.equal( + run("rustc", [`+${lock.rust.toolchain}`, "--version"]), + lock.rust.rustcVersion, + ); + assert.equal( + run("cargo", [`+${lock.rust.toolchain}`, "--version"]), + lock.rust.cargoVersion, + ); run( "cargo", [`+${lock.rust.toolchain}`, "build", "--locked", "-p", "edict-cli"], @@ -191,7 +251,7 @@ async function build() { await verifyGitCheckout(edictRepository, lock.edict.commit, "Edict"); await verifyGitCheckout(echoRepository, lock.echo.commit, "Echo"); const providerSource = await verifyProvider(lock.echo.provider); - const before = await snapshotAuthoritativeInputs(); + const before = await snapshotAuthoritativeInputs(lock); let failure; try { const edictBinary = await verifyVersions(lock); @@ -224,14 +284,16 @@ async function build() { application: "edict.application.json", })}\n`, }); - run(process.execPath, [path.join(testsDirectory, "assert-build-output.mjs"), applicationOutput], { - cwd: applicationRoot, - }); + run( + process.execPath, + [path.join(testsDirectory, "assert-build-output.mjs"), applicationOutput], + { cwd: applicationRoot }, + ); } catch (error) { failure = error; } - const after = await snapshotAuthoritativeInputs(); + const after = await snapshotAuthoritativeInputs(lock); let mutationFailure; try { assert.deepEqual(after, before, "authoritative inputs changed during package-chain build"); @@ -239,7 +301,10 @@ async function build() { mutationFailure = error; } if (failure && mutationFailure) { - throw new AggregateError([failure, mutationFailure], "build failed and authoritative inputs changed"); + throw new AggregateError( + [failure, mutationFailure], + "build failed and authoritative inputs changed", + ); } if (mutationFailure) { throw mutationFailure; diff --git a/edict/replace-range/tests/proof-harness.spec.mjs b/edict/replace-range/tests/proof-harness.spec.mjs index 8ac3b7e3..c860a4c2 100644 --- a/edict/replace-range/tests/proof-harness.spec.mjs +++ b/edict/replace-range/tests/proof-harness.spec.mjs @@ -11,6 +11,8 @@ import { fileURLToPath } from "node:url"; import { decode, encode } from "cbor-x"; +import { verificationEvidence } from "./verification-evidence.mjs"; + const testDirectory = path.dirname(fileURLToPath(import.meta.url)); const applicationRoot = path.resolve(testDirectory, ".."); const projectRoot = path.resolve(applicationRoot, "../.."); @@ -28,7 +30,21 @@ async function fixture() { const fixtureApplication = path.join(fixtureProject, "edict", "replace-range"); await mkdir(path.dirname(fixtureApplication), { recursive: true }); await cp(applicationRoot, fixtureApplication, { recursive: true }); - await symlink(path.join(projectRoot, "node_modules"), path.join(fixtureProject, "node_modules"), "dir"); + await mkdir(path.join(fixtureProject, ".github", "workflows"), { + recursive: true, + }); + for (const relative of [ + ".github/workflows/ci.yml", + "package.json", + "package-lock.json", + ]) { + await cp(path.join(projectRoot, relative), path.join(fixtureProject, relative)); + } + await symlink( + path.join(projectRoot, "node_modules"), + path.join(fixtureProject, "node_modules"), + "dir", + ); return { root, project: fixtureProject, @@ -58,7 +74,7 @@ function assertCommandCompleted(result) { assert.notEqual(result.status, null, `command terminated by ${result.signal}`); } -test("rejects_non_git_or_wrong_commit_toolchain_inputs", { timeout: 120_000 }, async () => { +test("rejects_non_git_toolchain_inputs", { timeout: 120_000 }, async () => { requireToolchainEnvironment(); const subject = await fixture(); try { @@ -99,6 +115,23 @@ test("rejects_non_git_or_wrong_commit_toolchain_inputs", { timeout: 120_000 }, a } }); +test("rejects_wrong_commit_toolchain_inputs", { timeout: 120_000 }, async () => { + requireToolchainEnvironment(); + const subject = await fixture(); + try { + const lockPath = path.join(subject.application, "edict.toolchain-lock.json"); + const lock = JSON.parse(await readFile(lockPath, "utf8")); + lock.edict.commit = "0".repeat(40); + await writeFile(lockPath, `${JSON.stringify(lock, null, 2)}\n`); + + const result = runBuild(subject.project); + assertCommandCompleted(result); + assert.notEqual(result.status, 0, "a wrong Edict commit must be rejected"); + } finally { + await subject.dispose(); + } +}); + test("lawpack_check_only_rejects_drift_without_repairing_it", { timeout: 120_000 }, async () => { requireToolchainEnvironment(); const subject = await fixture(); @@ -163,37 +196,138 @@ test( }, ); -test("rejects_short_buffer_and_head_identities", { timeout: 120_000 }, async () => { +test( + "preserves_nominal_exact_length_buffer_and_head_identities", + { timeout: 120_000 }, + async () => { + requireToolchainEnvironment(); + const subject = await fixture(); + try { + const build = runBuild(subject.project); + assertCommandCompleted(build); + assert.equal(build.status, 0, build.stderr); + + const packageBytes = await readFile( + path.join( + subject.application, + ".build", + "application", + "executable-operation-package.cbor", + ), + ); + const executablePackage = decode(packageBytes); + const program = decode(executablePackage.program); + const core = decode(program.core_artifact); + for (const typeName of [ + "ReplaceRangeInput.bufferId", + "ReplaceRangeInput.basisHeadId", + "ReplaceRangeBoundary.bufferId", + "ReplaceRangeBoundary.basisHeadId", + ]) { + assert.deepEqual( + core.types[typeName], + { + kind: "Nominal", + contract: + typeName.endsWith("bufferId") + ? "jedit.text@1.BufferId" + : "jedit.text@1.HeadId", + representation: "Bytes", + }, + `${typeName} must preserve its nominal exact 32-byte contract in Core`, + ); + } + } finally { + await subject.dispose(); + } + }, +); + +test("rejects_buffer_id_head_id_substitution", { timeout: 120_000 }, async () => { requireToolchainEnvironment(); const subject = await fixture(); try { - const build = runBuild(subject.project); - assertCommandCompleted(build); - assert.equal(build.status, 0, build.stderr); + const sourcePath = path.join( + subject.application, + "src", + "ReplaceRange.edict", + ); + const source = await readFile(sourcePath, "utf8"); + const crossed = source + .replace("bufferId: input.bufferId,", "bufferId: input.basisHeadId,") + .replace("basisHeadId: input.basisHeadId,", "basisHeadId: input.bufferId,"); + assert.notEqual( + crossed, + source, + "the negative witness must cross the two identities", + ); + await writeFile(sourcePath, crossed); - const packageBytes = await readFile( - path.join(subject.application, ".build", "application", "executable-operation-package.cbor"), + const result = runBuild(subject.project); + assertCommandCompleted(result); + assert.notEqual(result.status, 0, "BufferId and HeadId must not be substitutable"); + assert.match( + `${result.stdout}\n${result.stderr}`, + /TypeMismatch/, + "the imported nominal boundary must reject the crossed assignment", ); - const executablePackage = decode(packageBytes); - const program = decode(executablePackage.program); - const core = decode(program.core_artifact); - for (const typeName of [ - "ReplaceRangeInput.bufferId", - "ReplaceRangeInput.basisHeadId", - "ReplaceRangeBoundary.bufferId", - "ReplaceRangeBoundary.basisHeadId", - ]) { - assert.deepEqual( - core.types[typeName], - { kind: "Bytes", min: 32, max: 32 }, - `${typeName} must preserve the exact 32-byte identity contract in Core`, - ); - } } finally { await subject.dispose(); } }); +test("verification_report_identity_is_verifier_specific", () => { + const common = { + executableSubjectId: { + coordinate: "echo.executable-subject/v1", + digest: `sha256:${"1".repeat(64)}`, + }, + reportArtifactId: { + coordinate: "verifier-report.echo-operation", + domain: "echo.operation-package-verifier-report/v1", + digest: `sha256:${"2".repeat(64)}`, + rawSha256: "3".repeat(64), + }, + report: { + apiVersion: "echo.operation-package-verifier-report/v1", + diagnosticAbi: { + id: "edict.diagnostics/v1", + digest: ["sha256", Buffer.alloc(32, 4)], + }, + outcome: "accepted", + }, + }; + const provider = { + coordinate: "echo.edict-provider@1", + digest: `sha256:${"5".repeat(64)}`, + verifier: { + coordinate: "echo.dpo.verifier/component@1", + sha256: "6".repeat(64), + contract: { + coordinate: "echo.dpo.verifier/v1", + digest: `sha256:${"8".repeat(64)}`, + }, + }, + targetProfile: { + coordinate: "echo.dpo@1", + digest: `sha256:${"9".repeat(64)}`, + }, + }; + const original = verificationEvidence({ ...common, provider }); + const changed = verificationEvidence({ + ...common, + provider: { + ...provider, + verifier: { ...provider.verifier, sha256: "7".repeat(64) }, + }, + }); + assert.notEqual( + original.identity.digest, + changed.identity.digest, + "different verifier identities must produce different VerificationReportIds", + ); +}); + test("rejects_drifted_build_and_executable_subject_locks", { timeout: 120_000 }, async () => { requireToolchainEnvironment(); const subject = await fixture(); @@ -215,6 +349,30 @@ test("rejects_drifted_build_and_executable_subject_locks", { timeout: 120_000 }, } }); +test("rejects_drifted_executable_subject_lock", { timeout: 120_000 }, async () => { + requireToolchainEnvironment(); + const subject = await fixture(); + try { + const lockPath = path.join( + subject.application, + "edict.executable-subject-lock.json", + ); + const lock = JSON.parse(await readFile(lockPath, "utf8")); + lock.reference.digest = `sha256:${"0".repeat(64)}`; + await writeFile(lockPath, `${JSON.stringify(lock, null, 2)}\n`); + + const build = runBuild(subject.project); + assertCommandCompleted(build); + assert.notEqual( + build.status, + 0, + "a changed executable-subject expectation must fail the package-chain gate", + ); + } finally { + await subject.dispose(); + } +}); + test("required_ci_executes_the_exact_package_chain", async () => { const workflow = await readFile( path.join(projectRoot, ".github", "workflows", "ci.yml"), @@ -226,6 +384,11 @@ test("required_ci_executes_the_exact_package_chain", async () => { workflow, /node --test edict\/replace-range\/tests\/proof-harness\.spec\.mjs/, ); + assert.match( + workflow, + /ref: \$\{\{ github\.event\.pull_request\.head\.sha \|\| github\.sha \}\}/, + ); + assert.match(workflow, /git rev-parse HEAD/); assert.match( workflow, /needs: \[ plan, build, test-shards, quality, release-gate, edict-replace-range \]/, diff --git a/edict/replace-range/tests/verification-evidence.mjs b/edict/replace-range/tests/verification-evidence.mjs new file mode 100644 index 00000000..2286e294 --- /dev/null +++ b/edict/replace-range/tests/verification-evidence.mjs @@ -0,0 +1,83 @@ +// SPDX-License-Identifier: Apache-2.0 OR LicenseRef-MIND-UCAL-1.0 +// © James Ross Ω FLYING•ROBOTS + +import { createHash } from "node:crypto"; + +import { encode } from "cbor-x"; + +export function canonicalArtifactDigest(domain, canonicalArtifactBytes) { + const preimage = Buffer.concat([ + Buffer.from([0x83]), + Buffer.from(encode("edict.digest/v1")), + Buffer.from(encode(domain)), + Buffer.from(canonicalArtifactBytes), + ]); + return createHash("sha256").update(preimage).digest(); +} + +export function digestText(bytes) { + return `sha256:${Buffer.from(bytes).toString("hex")}`; +} + +function canonicalJson(value) { + if (Array.isArray(value)) { + return value.map(canonicalJson); + } + if (value !== null && typeof value === "object") { + return Object.fromEntries( + Object.keys(value) + .sort() + .map((key) => [key, canonicalJson(value[key])]), + ); + } + return value; +} + +function resourceReference(reference) { + return { + coordinate: reference.id, + digest: digestText(reference.digest[1]), + }; +} + +export function verificationEvidence({ + executableSubjectId, + provider, + reportArtifactId, + report, +}) { + const envelope = { + apiVersion: "jedit.edict-verification-evidence/v1", + reportArtifact: reportArtifactId, + executableSubject: executableSubjectId, + providerRelease: { + coordinate: provider.coordinate, + digest: provider.digest, + }, + verifierComponent: { + coordinate: provider.verifier.coordinate, + digest: `sha256:${provider.verifier.sha256}`, + }, + verificationPolicy: { + apiVersion: "jedit.edict-verification-policy/v1", + verifierContract: provider.verifier.contract, + targetProfile: provider.targetProfile, + reportAbi: report.apiVersion, + diagnosticAbi: resourceReference(report.diagnosticAbi), + }, + outcome: report.outcome, + }; + const bytes = Buffer.from(JSON.stringify(canonicalJson(envelope)), "utf8"); + return { + envelope, + bytes, + identity: { + coordinate: "jedit.edict-verification-evidence/v1", + domain: "jedit.edict-verification-evidence/v1", + digest: digestText( + canonicalArtifactDigest("jedit.edict-verification-evidence/v1", bytes), + ), + rawSha256: createHash("sha256").update(bytes).digest("hex"), + }, + }; +} diff --git a/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json b/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json index 0c5d525e..59079533 100644 --- a/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json +++ b/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json @@ -7,25 +7,25 @@ "path": "manifest.cbor", "kind": "manifest", "coordinate": "edict.lawpack/v1", - "digest": "sha256:5253f7c8682cfed88a34c660a610c30da6bd9924973fefd33a82c9915a4f09cf" + "digest": "sha256:95758c1605894672cc9069fde01bb8b6e11842b053102660c9cd4f4d6f34d64e" }, { "path": "manifest.sha256", "kind": "manifestDigest", "coordinate": "edict.lawpack/v1", - "digest": "sha256:5253f7c8682cfed88a34c660a610c30da6bd9924973fefd33a82c9915a4f09cf" + "digest": "sha256:95758c1605894672cc9069fde01bb8b6e11842b053102660c9cd4f4d6f34d64e" }, { "path": "exports.cbor", "kind": "exports", "coordinate": "jedit.text.exports/v1", - "digest": "sha256:ffa6529b8327ab49e7cf62016e940e5cabf90c5468d9d1efb0dcb3d7d6574c88" + "digest": "sha256:cbbc79fd92f09f341a1fae221a2a869bb64e15c511af39333e0453cd87fe456a" }, { "path": "exports.sha256", "kind": "exportsDigest", "coordinate": "jedit.text.exports/v1", - "digest": "sha256:ffa6529b8327ab49e7cf62016e940e5cabf90c5468d9d1efb0dcb3d7d6574c88" + "digest": "sha256:cbbc79fd92f09f341a1fae221a2a869bb64e15c511af39333e0453cd87fe456a" }, { "path": "echo-operation-configuration.cbor", diff --git a/edict/replace-range/vendor/jedit-text/exports.cbor b/edict/replace-range/vendor/jedit-text/exports.cbor index 65bcda4a8cee4eb7fe8f3ee4237e28d580797495..80925499a5d53b13815dd48e3ed972c3deffd6cb 100644 GIT binary patch delta 50 ucmZ1`v`c700at~LUw&?8USf{T#6n?4yNNB@s6tG3iza6=NpHOG&H(_uA`w{t delta 60 ycmdlbv`lD1fk<&yYD#8_UP)?2iG!h@Uw%reXUfDrZBcCEize4GNpJk@&H(_X_!dh5 diff --git a/edict/replace-range/vendor/jedit-text/exports.sha256 b/edict/replace-range/vendor/jedit-text/exports.sha256 index 9542b30a..87a0814b 100644 --- a/edict/replace-range/vendor/jedit-text/exports.sha256 +++ b/edict/replace-range/vendor/jedit-text/exports.sha256 @@ -1 +1 @@ -sha256:ffa6529b8327ab49e7cf62016e940e5cabf90c5468d9d1efb0dcb3d7d6574c88 +sha256:cbbc79fd92f09f341a1fae221a2a869bb64e15c511af39333e0453cd87fe456a diff --git a/edict/replace-range/vendor/jedit-text/manifest.cbor b/edict/replace-range/vendor/jedit-text/manifest.cbor index 9049ed68091b5df76093e71bd90ddda5582adf66..7bbc2c452f94541ff049a5d8b88f272775da67f6 100644 GIT binary patch delta 43 zcmV+`0M!4J29pMmLLke$dHs^`pEMdDt|A&LhMTrd6~z&+IWs;4Q_Y9|MQX8Pu>zD; B5=#I8 delta 43 zcmV+`0M!4J29pMmLLmR9Qk#P(t4Zh2VgYWH4qU7G3{+^@(eJR_v)9&FOo*{!u>!v^ B6}$id diff --git a/edict/replace-range/vendor/jedit-text/manifest.sha256 b/edict/replace-range/vendor/jedit-text/manifest.sha256 index b3292379..be4e2d8b 100644 --- a/edict/replace-range/vendor/jedit-text/manifest.sha256 +++ b/edict/replace-range/vendor/jedit-text/manifest.sha256 @@ -1 +1 @@ -sha256:5253f7c8682cfed88a34c660a610c30da6bd9924973fefd33a82c9915a4f09cf +sha256:95758c1605894672cc9069fde01bb8b6e11842b053102660c9cd4f4d6f34d64e From a894c7c4c6d150c0fb210d2e0ca4c27bf518b4c7 Mon Sep 17 00:00:00 2001 From: James Ross Date: Mon, 7 Sep 2026 16:00:11 -0700 Subject: [PATCH 10/30] test(edict): refresh ReplaceRange proof against merged compiler --- edict/replace-range/README.md | 15 +++- edict/replace-range/edict.build-lock.json | 26 +++---- .../edict.executable-subject-lock.json | 8 +-- edict/replace-range/edict.toolchain-lock.json | 2 +- .../tests/proof-harness.spec.mjs | 70 ++++++++++++++----- 5 files changed, 82 insertions(+), 39 deletions(-) diff --git a/edict/replace-range/README.md b/edict/replace-range/README.md index da488a09..da52e958 100644 --- a/edict/replace-range/README.md +++ b/edict/replace-range/README.md @@ -23,14 +23,23 @@ range, replacement bytes, operation profile, budget, imported helper implementation, and a pure conditional into Edict Core. It intentionally does not claim to traverse or rewrite a rope yet. -With Edict #201, the public application build lowers those Core `let` nodes into -generic, source-ordered Target IR and independently verifies the compiler-owned -result projection. Echo #724 now emits a distinct +With the merged Edict #201, the public application build lowers those Core `let` +nodes into generic, source-ordered Target IR and independently verifies the compiler-owned +result projection. The pinned Echo #724 candidate emits a distinct `compiler-produced-bounded-pure/v1` executable package containing the exact Core, lawpack exports, Target IR, and result projection. Echo's structurally separate verifier independently reconstructs that package relation and emits an accepted report bound to retained canonical `echo.executable-subject/v1` bytes. +The compiler pin is Edict main `3f81f759e921a69b04fe8cf8e62e62f8f3dc7b7e`. +Core retains the imported nominal definitions and their shared exact-length +`NodeId` representation; record fields refer to those named definitions. +The nominal identity test follows that reference chain, and repeated public +builds must reproduce identical Core, Target, package, and verifier-report bytes. +The Echo provider remains pinned to the open #724 candidate +`49e9efb68001dfd78563d18bac9359a87671e431`; this evidence does not claim that +provider or this Jedit application has landed on its repository's main branch. + That accepted package is the current routing evidence required by #296: Edict preserves the bounded pure program without learning Jedit vocabulary, and Echo packages it without learning `ReplaceRange`. No Echo evaluator runs, no graph diff --git a/edict/replace-range/edict.build-lock.json b/edict/replace-range/edict.build-lock.json index 63a18344..a2948ddf 100644 --- a/edict/replace-range/edict.build-lock.json +++ b/edict/replace-range/edict.build-lock.json @@ -2,10 +2,10 @@ "schema": "jedit.edict-build-lock/v1", "applicationCoordinate": "jedit.text.replace_range@1", "operationCoordinate": "jedit.text.replace_range@1.replaceRange", - "toolchainLockSha256": "3396bb91bea7e51d1e4b9f7385421d865d9e5a8f1c7ee1eaf330592143925fa0", + "toolchainLockSha256": "980e7fc1041aa2606f712dfa19eb694dd61759b4b2c776db8a80567c94ed96b7", "sourceClosure": { "schema": "jedit.edict-source-closure/v1", - "digest": "sha256:b6e247a612dd30b62db8b72d5063cbc29c762ffa91f8462fe57b1aadbdda521b", + "digest": "sha256:81e4bcbaa4e2ca16b5641b59bceaf1a504fe1098a4a28c07b8112c17ea251cc1", "files": [ { "path": "application/edict.application.json", @@ -17,7 +17,7 @@ }, { "path": "application/edict.toolchain-lock.json", - "sha256": "3396bb91bea7e51d1e4b9f7385421d865d9e5a8f1c7ee1eaf330592143925fa0" + "sha256": "980e7fc1041aa2606f712dfa19eb694dd61759b4b2c776db8a80567c94ed96b7" }, { "path": "application/src/ReplaceRange.edict", @@ -37,7 +37,7 @@ }, { "path": "application/tests/proof-harness.spec.mjs", - "sha256": "a60012f744cff26095a451fe74f984b41a48551e8b47d6f2e5d8e128e1dcd643" + "sha256": "218b32e0c5deddd48cd11917d22fb69e70ab8677d4e85670e467e8f3b711b30b" }, { "path": "application/tests/verification-evidence.mjs", @@ -89,12 +89,12 @@ "core": { "coordinate": "jedit.text.replace_range@1", "domain": "edict.core.module/v1", - "digest": "sha256:d965643ff78c4f321af538f086329fee53c22b21dc1de9e5f9914d6cb69e609f" + "digest": "sha256:8150aeee1766bde5b2c416a3c9ef9dd4960bde140e9d1b190a966d00bbdf7787" }, "targetIr": { "coordinate": "echo.span-ir/v1", "domain": "edict.target-ir.artifact/v1", - "digest": "sha256:8a5243fef0aea029df1b6a56eb65f199703e10143d5e0cec5b73603455284229" + "digest": "sha256:2c18d7d5e7d3bf9689e66e7b04c07824641836f6e23ed8396099ca8e24e79ff9" }, "resultProjection": { "coordinate": "jedit.text.replace_range@1.replaceRange", @@ -104,25 +104,25 @@ "executablePackage": { "coordinate": "executable-operation-package.echo", "domain": "echo.operation-package/v1", - "digest": "sha256:9a9e26e10dabf9175889fb2ef50bd463dd08ea95e9a377e0a39eb4663acd409b", - "rawSha256": "f339cf8e52621df4a9b644c83770932df5c01c52e70d1bd271c0e6519cda2998" + "digest": "sha256:b9052d3c40878a9fcba7768be67c8dba50cf0f751682339dfcdd04155871415b", + "rawSha256": "1860ab8a6cb9a4bfd63a1db99d1c2bc00aa53dae52a9d1998295654379a95d85" }, "verificationReportArtifact": { "coordinate": "verifier-report.echo-operation", "domain": "echo.operation-package-verifier-report/v1", - "digest": "sha256:c8f1e52216f248022a884c822d577c479b3a68b0f5ad69f21db3288a00e474a1", - "rawSha256": "124cfca3449d19684a169a4fe62898dfb76124854d0f0ef57ea3ed9f606a4ce0" + "digest": "sha256:12afbc22ce618b4e40b712235191657f7451a9dfc397531bd0448fbde5f3ae5c", + "rawSha256": "d96e5d21eecbc1e5bbf6ce76ab438d55cc8e74f6843121d4ffb0f4343e648267" }, "verificationReport": { "coordinate": "jedit.edict-verification-evidence/v1", "domain": "jedit.edict-verification-evidence/v1", - "digest": "sha256:54f4bc09addabf3236478c891aa8ced4f13a2738e007f95c96f547b6b36dcd80", - "rawSha256": "6a6420061353e34a8a8db21025b9eeed7a0802c720b4e865e8f6218448f5be4e" + "digest": "sha256:ee2a9c8332640579d184c5bc16118e152490be8213dc0f23c955bab84fd08a18", + "rawSha256": "ab68a3e18ba9c83fb9988e5f7b9fc4e7a5b96a257218717ef4d66f7e2b8ba0e2" }, "executableSubject": { "coordinate": "echo.executable-subject/v1", "domain": "echo.executable-subject/v1", - "digest": "sha256:9738fc187d8507b64bc7c01a536c8eb2b99fb550380db878d49ebb7e130267aa" + "digest": "sha256:93d1c2ee6b9798648f2706ef6ffbb0c426afd886331d23d452605fbc3bcdaccb" } } } diff --git a/edict/replace-range/edict.executable-subject-lock.json b/edict/replace-range/edict.executable-subject-lock.json index d0605bb5..d4edbb3d 100644 --- a/edict/replace-range/edict.executable-subject-lock.json +++ b/edict/replace-range/edict.executable-subject-lock.json @@ -2,16 +2,16 @@ "schema": "jedit.edict-executable-subject-lock/v1", "reference": { "coordinate": "echo.executable-subject/v1", - "digest": "sha256:9738fc187d8507b64bc7c01a536c8eb2b99fb550380db878d49ebb7e130267aa" + "digest": "sha256:93d1c2ee6b9798648f2706ef6ffbb0c426afd886331d23d452605fbc3bcdaccb" }, - "rawSha256": "46255257cc23601a10f2dd1fd5d7bc86fc4bb13612eb2b3ac5f633ded159aa88", + "rawSha256": "b36bf152e5bd5693f02e6eb1a58e698e332830218cf306719f11529422e74486", "package": { "coordinate": "executable-operation-package.echo", - "digest": "sha256:9a9e26e10dabf9175889fb2ef50bd463dd08ea95e9a377e0a39eb4663acd409b" + "digest": "sha256:b9052d3c40878a9fcba7768be67c8dba50cf0f751682339dfcdd04155871415b" }, "targetIr": { "coordinate": "echo.span-ir/v1", - "digest": "sha256:8a5243fef0aea029df1b6a56eb65f199703e10143d5e0cec5b73603455284229" + "digest": "sha256:2c18d7d5e7d3bf9689e66e7b04c07824641836f6e23ed8396099ca8e24e79ff9" }, "resultProjection": { "coordinate": "jedit.text.replace_range@1.replaceRange", diff --git a/edict/replace-range/edict.toolchain-lock.json b/edict/replace-range/edict.toolchain-lock.json index 110a908e..ba974026 100644 --- a/edict/replace-range/edict.toolchain-lock.json +++ b/edict/replace-range/edict.toolchain-lock.json @@ -29,7 +29,7 @@ ] }, "edict": { - "commit": "39a796de04b3400f569880da06878da50d8ed0ee", + "commit": "3f81f759e921a69b04fe8cf8e62e62f8f3dc7b7e", "cliVersion": "0.11.0-alpha.1" }, "echo": { diff --git a/edict/replace-range/tests/proof-harness.spec.mjs b/edict/replace-range/tests/proof-harness.spec.mjs index c860a4c2..86ac1a63 100644 --- a/edict/replace-range/tests/proof-harness.spec.mjs +++ b/edict/replace-range/tests/proof-harness.spec.mjs @@ -218,24 +218,23 @@ test( const executablePackage = decode(packageBytes); const program = decode(executablePackage.program); const core = decode(program.core_artifact); - for (const typeName of [ - "ReplaceRangeInput.bufferId", - "ReplaceRangeInput.basisHeadId", - "ReplaceRangeBoundary.bufferId", - "ReplaceRangeBoundary.basisHeadId", - ]) { - assert.deepEqual( - core.types[typeName], - { - kind: "Nominal", - contract: - typeName.endsWith("bufferId") - ? "jedit.text@1.BufferId" - : "jedit.text@1.HeadId", - representation: "Bytes", - }, - `${typeName} must preserve its nominal exact 32-byte contract in Core`, - ); + for (const recordName of ["ReplaceRangeInput", "ReplaceRangeBoundary"]) { + const record = core.types[recordName]; + assert.equal(record.kind, "Record"); + for (const [field, contract] of [ + ["bufferId", "jedit.text@1.BufferId"], + ["basisHeadId", "jedit.text@1.HeadId"], + ]) { + assert.equal(record.fields[field], contract); + const nominal = core.types[record.fields[field]]; + assert.equal(nominal.kind, "Nominal"); + assert.equal(nominal.contract, contract); + assert.deepEqual( + core.types[nominal.representation], + { kind: "Bytes", min: 32, max: 32 }, + `${recordName}.${field} must resolve to its nominal exact 32-byte contract`, + ); + } } } finally { await subject.dispose(); @@ -243,6 +242,41 @@ test( }, ); +test("repeated_public_builds_preserve_core_and_package_bytes", { timeout: 120_000 }, async () => { + requireToolchainEnvironment(); + const subject = await fixture(); + try { + const outputDirectory = path.join(subject.application, ".build", "application"); + const readArtifacts = async () => { + const packageBytes = await readFile( + path.join(outputDirectory, "executable-operation-package.cbor"), + ); + const program = decode(decode(packageBytes).program); + return { + core: program.core_artifact, + targetIr: program.target_ir_artifact, + projection: program.result_projection_artifact, + package: packageBytes, + report: await readFile(path.join(outputDirectory, "verification-report.cbor")), + }; + }; + const first = runBuild(subject.project); + assertCommandCompleted(first); + assert.equal(first.status, 0, first.stderr); + const firstBytes = await readArtifacts(); + const second = runBuild(subject.project); + assertCommandCompleted(second); + assert.equal(second.status, 0, second.stderr); + assert.deepEqual( + await readArtifacts(), + firstBytes, + "every artifact must be byte-identical for the same source and closure", + ); + } finally { + await subject.dispose(); + } +}); + test("rejects_buffer_id_head_id_substitution", { timeout: 120_000 }, async () => { requireToolchainEnvironment(); const subject = await fixture(); From 83ab52a3744babb63c8ce15cd94d917012e364a2 Mon Sep 17 00:00:00 2001 From: James Ross Date: Fri, 18 Sep 2026 05:53:23 -0700 Subject: [PATCH 11/30] test(edict): execute fresh packages through generic Echo runtime --- .github/workflows/ci.yml | 11 +- edict/replace-range/README.md | 33 +- edict/replace-range/edict.build-lock.json | 26 +- edict/replace-range/edict.toolchain-lock.json | 2 +- .../tests/assert-build-output.mjs | 3 + edict/replace-range/tests/package-chain.mjs | 31 +- .../tests/proof-harness.spec.mjs | 25 +- edict/replace-range/tests/runtime/Cargo.lock | 786 ++++++++++++++++++ edict/replace-range/tests/runtime/Cargo.toml | 16 + .../tests/runtime/compiled_boundary.rs | 98 +++ 10 files changed, 1009 insertions(+), 22 deletions(-) create mode 100644 edict/replace-range/tests/runtime/Cargo.lock create mode 100644 edict/replace-range/tests/runtime/Cargo.toml create mode 100644 edict/replace-range/tests/runtime/compiled_boundary.rs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d90ea2c4..f93cb306 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -169,7 +169,7 @@ jobs: run: npm run release-gate:jedit-echo edict-replace-range: - name: edict / replace-range package chain + name: edict / replace-range package and pure runtime chain runs-on: ubuntu-latest timeout-minutes: 20 @@ -229,11 +229,18 @@ jobs: working-directory: jedit run: npm ci - - name: Verify exact package chain and adversarial regressions + - name: Compile the pinned test-only pure runtime host + working-directory: jedit + env: + CARGO_TARGET_DIR: ${{ github.workspace }}/runtime-target + run: cargo +${{ steps.toolchain.outputs.rust_toolchain }} test --locked --manifest-path edict/replace-range/tests/runtime/Cargo.toml --test compiled_boundary --no-run + + - name: Verify exact package and pure runtime chain with adversarial regressions working-directory: jedit env: EDICT_REPO: ${{ github.workspace }}/edict ECHO_REPO: ${{ github.workspace }}/echo + CARGO_TARGET_DIR: ${{ github.workspace }}/runtime-target run: node --test edict/replace-range/tests/proof-harness.spec.mjs - name: Verify authoritative checkouts remain clean diff --git a/edict/replace-range/README.md b/edict/replace-range/README.md index da52e958..8e17aeba 100644 --- a/edict/replace-range/README.md +++ b/edict/replace-range/README.md @@ -40,11 +40,20 @@ The Echo provider remains pinned to the open #724 candidate `49e9efb68001dfd78563d18bac9359a87671e431`; this evidence does not claim that provider or this Jedit application has landed on its repository's main branch. -That accepted package is the current routing evidence required by #296: Edict -preserves the bounded pure program without learning Jedit vocabulary, and Echo -packages it without learning `ReplaceRange`. No Echo evaluator runs, no graph -or rope is mutated, and no Tick is settled. This is not evidence that -`ReplaceRange` mutates a rope or that Jim runs end to end. +The application gate passes that accepted package unchanged to Echo's generic +pure evaluator at `8c725d699241a7e3adee482029031ff6bade25fa`, the open #726 +candidate. A separate test-only Rust host consumes the fresh public-build +output, not the fixture retained in Echo. It checks both conditional branches, +the imported helper result, exact projected bytes, deterministic repetition, +the reversed-range constraint, malformed identity bytes, and package-pin +substitution. Its dependencies and their full resolution are pinned in +`tests/runtime/Cargo.toml` and `Cargo.lock` and bound into the build closure. + +This is pure computation only. No graph or rope is mutated, no Tick is settled, +and no WAL or recovery evidence is produced. The test host enables Echo's +trusted-host API only in this standalone unpublished test crate. It is not a +production dependency or an alternate editor route. The authored rope algorithm +and generic stateful execution remain unfinished under #296. ## Reproduce @@ -53,6 +62,7 @@ The build script requires exact local Edict and Echo checkouts: ```bash EDICT_REPO=/path/to/edict \ ECHO_REPO=/path/to/echo \ +CARGO_TARGET_DIR=/path/to/disposable-runtime-build-cache \ ./edict/replace-range/tests/build.sh ``` @@ -85,10 +95,17 @@ Edict's public application build, and requires the generic pure package and an accepted independent-verifier report. Snapshots cover the application inputs outside `.build/`, the pinned project validation files, and every tracked Edict and Echo file; any content, identity, or timestamp mutation fails the run. Only -`.build/` is disposable output. Distinct nominal `BufferId` and `HeadId` +`.build/` is disposable output. `CARGO_TARGET_DIR` optionally selects a shared +disposable Cargo cache; otherwise runtime build output stays under `.build/`. +The runtime witness runs with `--locked` and must emit its completion marker +after all assertions pass, so a zero-test Cargo invocation cannot satisfy the +gate. The provider stays pinned to #724; the runtime is independently pinned +to #726. Neither is described as a released or installed product dependency. +Distinct nominal `BufferId` and `HeadId` contracts retain the same exact 32-byte representation, while a negative compiler witness proves that neither can cross the imported lawpack boundary as the other. -The gate must advance again when Echo implements generic pure evaluation; -package acceptance is not a permanent substitute for runtime evidence. +The next gate must exercise an authored rope consequence under generic Echo +stateful execution and compare it with the independent oracle. This pure +boundary witness is not a substitute for that evidence. diff --git a/edict/replace-range/edict.build-lock.json b/edict/replace-range/edict.build-lock.json index a2948ddf..5cfba4c3 100644 --- a/edict/replace-range/edict.build-lock.json +++ b/edict/replace-range/edict.build-lock.json @@ -2,10 +2,10 @@ "schema": "jedit.edict-build-lock/v1", "applicationCoordinate": "jedit.text.replace_range@1", "operationCoordinate": "jedit.text.replace_range@1.replaceRange", - "toolchainLockSha256": "980e7fc1041aa2606f712dfa19eb694dd61759b4b2c776db8a80567c94ed96b7", + "toolchainLockSha256": "5323f86f94f6b1ac5b1bb25c7104f703cc633ff3cc57df5caaa637a7a8455e75", "sourceClosure": { "schema": "jedit.edict-source-closure/v1", - "digest": "sha256:81e4bcbaa4e2ca16b5641b59bceaf1a504fe1098a4a28c07b8112c17ea251cc1", + "digest": "sha256:19017995722b8b038571f59b54cffb8929636a0115d148b266d51b6b769e7242", "files": [ { "path": "application/edict.application.json", @@ -17,7 +17,7 @@ }, { "path": "application/edict.toolchain-lock.json", - "sha256": "980e7fc1041aa2606f712dfa19eb694dd61759b4b2c776db8a80567c94ed96b7" + "sha256": "5323f86f94f6b1ac5b1bb25c7104f703cc633ff3cc57df5caaa637a7a8455e75" }, { "path": "application/src/ReplaceRange.edict", @@ -25,7 +25,7 @@ }, { "path": "application/tests/assert-build-output.mjs", - "sha256": "cc54e77a7a5923bb6496817b4822dfd38d5077501f6e12ab55129cf8cfcc86d9" + "sha256": "e862848d2e3fdc0acb10b0e31fef4c6481ba9ed94ce6fb28a090b30fb47f43a2" }, { "path": "application/tests/build.sh", @@ -33,11 +33,23 @@ }, { "path": "application/tests/package-chain.mjs", - "sha256": "28615de79aa645fa7c3a9cd098865e02af666fa86f49b251d5fe6c919329d141" + "sha256": "cdb4d2d9661960b0b5890bf5bbae8b07e4f82365378ddb4c36342e42fad05927" }, { "path": "application/tests/proof-harness.spec.mjs", - "sha256": "218b32e0c5deddd48cd11917d22fb69e70ab8677d4e85670e467e8f3b711b30b" + "sha256": "ada20b6786401dc629f141220ced5041bc694458821149f4197b0e69dc619fae" + }, + { + "path": "application/tests/runtime/Cargo.toml", + "sha256": "8cdf2a89e74d70388e872bbf30484053a639423c9b3c3934e99d67c3254fe53b" + }, + { + "path": "application/tests/runtime/Cargo.lock", + "sha256": "22699d9bfad35c2ecc1bcab2a6bf6b5eeb97cb596e0169ebd37cb18ab2f01b7c" + }, + { + "path": "application/tests/runtime/compiled_boundary.rs", + "sha256": "0bef519a74dbc9383dad7c1408d1fdaf962842c3f4df17bd3de58699154d818d" }, { "path": "application/tests/verification-evidence.mjs", @@ -65,7 +77,7 @@ }, { "path": "project/.github/workflows/ci.yml", - "sha256": "d4100140562e160bd897f9af9fc5d4ee8d7ea9285ba5d0734c620a38cf2d2ea5" + "sha256": "bc19286ef44ce7d8ba0fd8a3e39a8ec0313d07ed3084fbe15e25ef42d82bc8f1" }, { "path": "project/package.json", diff --git a/edict/replace-range/edict.toolchain-lock.json b/edict/replace-range/edict.toolchain-lock.json index ba974026..a3caa289 100644 --- a/edict/replace-range/edict.toolchain-lock.json +++ b/edict/replace-range/edict.toolchain-lock.json @@ -24,7 +24,7 @@ }, { "path": ".github/workflows/ci.yml", - "sha256": "d4100140562e160bd897f9af9fc5d4ee8d7ea9285ba5d0734c620a38cf2d2ea5" + "sha256": "bc19286ef44ce7d8ba0fd8a3e39a8ec0313d07ed3084fbe15e25ef42d82bc8f1" } ] }, diff --git a/edict/replace-range/tests/assert-build-output.mjs b/edict/replace-range/tests/assert-build-output.mjs index fc0d14a6..7eb4a87d 100644 --- a/edict/replace-range/tests/assert-build-output.mjs +++ b/edict/replace-range/tests/assert-build-output.mjs @@ -28,6 +28,9 @@ const SOURCE_CLOSURE_INPUTS = [ ["application/tests/build.sh", "tests/build.sh"], ["application/tests/package-chain.mjs", "tests/package-chain.mjs"], ["application/tests/proof-harness.spec.mjs", "tests/proof-harness.spec.mjs"], + ["application/tests/runtime/Cargo.toml", "tests/runtime/Cargo.toml"], + ["application/tests/runtime/Cargo.lock", "tests/runtime/Cargo.lock"], + ["application/tests/runtime/compiled_boundary.rs", "tests/runtime/compiled_boundary.rs"], [ "application/tests/verification-evidence.mjs", "tests/verification-evidence.mjs", diff --git a/edict/replace-range/tests/package-chain.mjs b/edict/replace-range/tests/package-chain.mjs index b5217985..4dc9657f 100644 --- a/edict/replace-range/tests/package-chain.mjs +++ b/edict/replace-range/tests/package-chain.mjs @@ -30,7 +30,7 @@ function run(command, arguments_, options = {}) { const result = spawnSync(command, arguments_, { cwd: options.cwd, encoding: "utf8", - env: process.env, + env: { ...process.env, ...options.env }, input: options.input, timeout: options.timeout ?? 120_000, }); @@ -289,6 +289,35 @@ async function build() { [path.join(testsDirectory, "assert-build-output.mjs"), applicationOutput], { cwd: applicationRoot }, ); + const buildLock = JSON.parse( + await readFile(path.join(applicationRoot, "edict.build-lock.json"), "utf8"), + ); + const runtimeOutput = run( + "cargo", + [ + `+${lock.rust.toolchain}`, "test", "--locked", "--manifest-path", + path.join(testsDirectory, "runtime", "Cargo.toml"), + "--test", "compiled_boundary", "freshly_compiled_boundary_executes", + "--", "--exact", "--nocapture", + ], + { + cwd: applicationRoot, + timeout: 600_000, + env: { + CARGO_TARGET_DIR: process.env.CARGO_TARGET_DIR + ?? path.join(buildRoot, "runtime-target"), + JEDIT_VERIFIED_PACKAGE: path.join( + applicationOutput, "executable-operation-package.cbor", + ), + JEDIT_VERIFIED_PACKAGE_PIN: + buildLock.artifacts.executablePackage.digest.slice("sha256:".length), + }, + }, + ); + assert.ok( + runtimeOutput.includes("JEDIT_EDICT_PURE_RUNTIME_OK"), + "runtime conformance witness did not execute", + ); } catch (error) { failure = error; } diff --git a/edict/replace-range/tests/proof-harness.spec.mjs b/edict/replace-range/tests/proof-harness.spec.mjs index 86ac1a63..ec9bb5e5 100644 --- a/edict/replace-range/tests/proof-harness.spec.mjs +++ b/edict/replace-range/tests/proof-harness.spec.mjs @@ -29,7 +29,10 @@ async function fixture() { const fixtureProject = path.join(root, "jedit"); const fixtureApplication = path.join(fixtureProject, "edict", "replace-range"); await mkdir(path.dirname(fixtureApplication), { recursive: true }); - await cp(applicationRoot, fixtureApplication, { recursive: true }); + await cp(applicationRoot, fixtureApplication, { + recursive: true, + filter: (source) => source !== path.join(applicationRoot, ".build"), + }); await mkdir(path.join(fixtureProject, ".github", "workflows"), { recursive: true, }); @@ -65,7 +68,7 @@ function runBuild(fixtureProject, overrides = {}) { ECHO_REPO: echoRepository, ...overrides, }, - timeout: 120_000, + timeout: 600_000, }); } @@ -242,6 +245,22 @@ test( }, ); +test("freshly_compiled_package_must_execute_in_echo", { timeout: 120_000 }, async () => { + requireToolchainEnvironment(); + const subject = await fixture(); + try { + const result = runBuild(subject.project); + assertCommandCompleted(result); + assert.equal(result.status, 0, result.stderr); + assert.ok( + result.stdout.includes("JEDIT_EDICT_PURE_RUNTIME_OK"), + "a verified package alone is insufficient: the runtime conformance test must execute", + ); + } finally { + await subject.dispose(); + } +}); + test("repeated_public_builds_preserve_core_and_package_bytes", { timeout: 120_000 }, async () => { requireToolchainEnvironment(); const subject = await fixture(); @@ -413,7 +432,7 @@ test("required_ci_executes_the_exact_package_chain", async () => { "utf8", ); assert.match(workflow, /^ edict-replace-range:\n/m); - assert.match(workflow, /name: edict \/ replace-range package chain/); + assert.match(workflow, /name: edict \/ replace-range package and pure runtime chain/); assert.match( workflow, /node --test edict\/replace-range\/tests\/proof-harness\.spec\.mjs/, diff --git a/edict/replace-range/tests/runtime/Cargo.lock b/edict/replace-range/tests/runtime/Cargo.lock new file mode 100644 index 00000000..3701589c --- /dev/null +++ b/edict/replace-range/tests/runtime/Cargo.lock @@ -0,0 +1,786 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "ambient-authority" +version = "0.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e9d4ee0d472d1cd2e28c97dfa124b3d8d992e10eb0a035f33f5d12e3a177ba3b" + +[[package]] +name = "arrayvec" +version = "0.7.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56" + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "bitflags" +version = "2.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06" + +[[package]] +name = "blake3" +version = "1.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d9e454fc11f76977dc803893aff6304ed33d6a26efae8696573bea74baa27ae" +dependencies = [ + "arrayvec", + "cc", + "cfg-if", + "constant_time_eq", + "cpufeatures 0.3.1", +] + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "bytemuck" +version = "1.25.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a1f896587b6f2c069c73d2f0913e2d590c3990285cd2f0b6aa02b786b4c679c" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "bytes" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04" + +[[package]] +name = "cap-fs-ext" +version = "4.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d78e5a3368ae89b7cb68186411452b4b9fac8b41be9c19bf3f47c2d2c8e36e6b" +dependencies = [ + "cap-primitives", + "cap-std", + "io-lifetimes 3.0.1", + "windows-sys 0.61.2", +] + +[[package]] +name = "cap-primitives" +version = "4.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b5f74729fd2f44701d1a8eb47e906cdb3ccd9ec0f02baad85a744b791940b18" +dependencies = [ + "ambient-authority", + "fs-set-times", + "io-extras", + "io-lifetimes 3.0.1", + "ipnet", + "maybe-owned", + "rustix", + "rustix-linux-procfs", + "windows-sys 0.61.2", + "winx", +] + +[[package]] +name = "cap-std" +version = "4.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7281235d6e96d3544ca18bba9049be92f4190f8d923e3caef1b5f66cfa752608" +dependencies = [ + "cap-primitives", + "io-extras", + "io-lifetimes 3.0.1", + "rustix", +] + +[[package]] +name = "cc" +version = "1.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3eb0f42d6c360dc3f8a821f6bf2fdea7f72bfd36b3076eb0e6d1e9e0752fff4" +dependencies = [ + "find-msvc-tools", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "ciborium" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" +dependencies = [ + "ciborium-io", + "ciborium-ll", + "serde", +] + +[[package]] +name = "ciborium-io" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" + +[[package]] +name = "ciborium-ll" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" +dependencies = [ + "ciborium-io", + "half", +] + +[[package]] +name = "constant_time_eq" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b" + +[[package]] +name = "cpufeatures" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" +dependencies = [ + "libc", +] + +[[package]] +name = "cpufeatures" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566" +dependencies = [ + "libc", +] + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "crypto-common" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" +dependencies = [ + "generic-array", + "typenum", +] + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer", + "crypto-common", +] + +[[package]] +name = "echo-edict-canonical" +version = "0.1.0" +source = "git+https://github.com/flyingrobots/echo?rev=8c725d699241a7e3adee482029031ff6bade25fa#8c725d699241a7e3adee482029031ff6bade25fa" +dependencies = [ + "hex", + "sha2", +] + +[[package]] +name = "echo-registry-api" +version = "0.1.0" +source = "git+https://github.com/flyingrobots/echo?rev=8c725d699241a7e3adee482029031ff6bade25fa#8c725d699241a7e3adee482029031ff6bade25fa" + +[[package]] +name = "echo-runtime-schema" +version = "0.1.0" +source = "git+https://github.com/flyingrobots/echo?rev=8c725d699241a7e3adee482029031ff6bade25fa#8c725d699241a7e3adee482029031ff6bade25fa" + +[[package]] +name = "echo-wasm-abi" +version = "0.1.0" +source = "git+https://github.com/flyingrobots/echo?rev=8c725d699241a7e3adee482029031ff6bade25fa#8c725d699241a7e3adee482029031ff6bade25fa" +dependencies = [ + "blake3", + "ciborium", + "echo-registry-api", + "half", + "serde", + "serde-value", + "thiserror 2.0.20", +] + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "find-msvc-tools" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e0f1c7c3a72c66fd80abe965175f7523475c0489a87d3ff9d6e8c87d87a9d2d" + +[[package]] +name = "fs-set-times" +version = "0.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94e7099f6313ecacbe1256e8ff9d617b75d1bcb16a6fddef94866d225a01a14a" +dependencies = [ + "io-lifetimes 2.0.4", + "rustix", + "windows-sys 0.59.0", +] + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "zerocopy", +] + +[[package]] +name = "hex" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" + +[[package]] +name = "io-extras" +version = "0.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20fd6de4ccfcc187e38bc21cfa543cb5a302cb86a8b114eb7f0bf0dc9f8ac00f" +dependencies = [ + "io-lifetimes 3.0.1", + "windows-sys 0.60.2", +] + +[[package]] +name = "io-lifetimes" +version = "2.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06432fb54d3be7964ecd3649233cddf80db2832f47fec34c01f65b3d9d774983" + +[[package]] +name = "io-lifetimes" +version = "3.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f0fb0570afe1fed943c5c3d4102d5358592d8625fda6a0007fdbe65a92fba96" + +[[package]] +name = "ipnet" +version = "2.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "791930b43c0d5973160d90a8f3894509f2b273430f5c5c73b668636d0287c5c0" + +[[package]] +name = "jedit-edict-runtime-conformance" +version = "0.0.0" +dependencies = [ + "echo-edict-canonical", + "warp-core", +] + +[[package]] +name = "libc" +version = "0.2.189" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2" + +[[package]] +name = "libm" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" + +[[package]] +name = "linux-raw-sys" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" + +[[package]] +name = "maybe-owned" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4facc753ae494aeb6e3c22f839b158aebd4f9270f55cd3c79906c45476c47ab4" + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "ordered-float" +version = "2.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68f19d67e5a2795c94e73e0bb1cc1a7edeb2e28efd39e2e1c9b7a40c1108b11c" +dependencies = [ + "num-traits", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rustc-hash" +version = "2.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d" + +[[package]] +name = "rustix" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "891efababe418670775f199f0d233d84843c227a0949a883ce15b37c78d6629d" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustix-linux-procfs" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2fc84bf7e9aa16c4f2c758f27412dc9841341e16aa682d9c7ac308fe3ee12056" +dependencies = [ + "once_cell", + "rustix", +] + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde-value" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3a1a3341211875ef120e117ea7fd5228530ae7e7036a779fdc9117be6b3282c" +dependencies = [ + "ordered-float", + "serde", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "sha2" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" +dependencies = [ + "cfg-if", + "cpufeatures 0.2.17", + "digest", +] + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f" +dependencies = [ + "thiserror-impl 2.0.20", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + +[[package]] +name = "typenum" +version = "1.20.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20" + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "warp-core" +version = "0.1.1" +source = "git+https://github.com/flyingrobots/echo?rev=8c725d699241a7e3adee482029031ff6bade25fa#8c725d699241a7e3adee482029031ff6bade25fa" +dependencies = [ + "blake3", + "bytemuck", + "bytes", + "cap-fs-ext", + "cap-std", + "echo-edict-canonical", + "echo-registry-api", + "echo-runtime-schema", + "echo-wasm-abi", + "hex", + "rustc-hash", + "sha2", + "thiserror 1.0.69", + "warp-math", +] + +[[package]] +name = "warp-math" +version = "0.1.0" +source = "git+https://github.com/flyingrobots/echo?rev=8c725d699241a7e3adee482029031ff6bade25fa#8c725d699241a7e3adee482029031ff6bade25fa" +dependencies = [ + "libm", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" +dependencies = [ + "windows-targets 0.53.5", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", + "windows_i686_gnullvm 0.52.6", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", +] + +[[package]] +name = "windows-targets" +version = "0.53.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3" +dependencies = [ + "windows-link", + "windows_aarch64_gnullvm 0.53.1", + "windows_aarch64_msvc 0.53.1", + "windows_i686_gnu 0.53.1", + "windows_i686_gnullvm 0.53.1", + "windows_i686_msvc 0.53.1", + "windows_x86_64_gnu 0.53.1", + "windows_x86_64_gnullvm 0.53.1", + "windows_x86_64_msvc 0.53.1", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_i686_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" + +[[package]] +name = "winx" +version = "0.36.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f3fd376f71958b862e7afb20cfe5a22830e1963462f3a17f49d82a6c1d1f42d" +dependencies = [ + "bitflags", + "windows-sys 0.59.0", +] + +[[package]] +name = "zerocopy" +version = "0.8.57" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d35102a9f36d089ccae9e4c6802bc118be4487b80aaffc0ab4e0cf5ce92d2873" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.57" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "146c01f5ab44258da43cf276c74a2763db2ff3969c9c652c3f2de07041d0b2bc" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] diff --git a/edict/replace-range/tests/runtime/Cargo.toml b/edict/replace-range/tests/runtime/Cargo.toml new file mode 100644 index 00000000..e8d8fd5d --- /dev/null +++ b/edict/replace-range/tests/runtime/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "jedit-edict-runtime-conformance" +version = "0.0.0" +edition = "2021" +publish = false + +# This standalone, test-only trusted host is never a product dependency. +[workspace] + +[dev-dependencies] +echo-edict-canonical = { git = "https://github.com/flyingrobots/echo", rev = "8c725d699241a7e3adee482029031ff6bade25fa" } +warp-core = { git = "https://github.com/flyingrobots/echo", rev = "8c725d699241a7e3adee482029031ff6bade25fa", features = ["trusted_runtime"] } + +[[test]] +name = "compiled_boundary" +path = "compiled_boundary.rs" diff --git a/edict/replace-range/tests/runtime/compiled_boundary.rs b/edict/replace-range/tests/runtime/compiled_boundary.rs new file mode 100644 index 00000000..8d229fb1 --- /dev/null +++ b/edict/replace-range/tests/runtime/compiled_boundary.rs @@ -0,0 +1,98 @@ +// SPDX-License-Identifier: Apache-2.0 OR LicenseRef-MIND-UCAL-1.0 +// © James Ross Ω FLYING•ROBOTS +//! Test-only trusted host. No native Jedit planner or product host is linked. + +use std::{env, fs}; + +use echo_edict_canonical::{encode_canonical_cbor_v1 as encode, CanonicalValueV1 as Value}; +use warp_core::edict_pure::{evaluate, EvaluationError, EvaluationLimits}; + +const ID_BYTES: usize = 32; +const MAX_PACKAGE_BYTES: usize = 32_768; +const MAX_INPUT_BYTES: usize = 2_097_152; +const MAX_STEPS: u64 = 10_000; +const MAX_ALLOCATED_BYTES: u64 = 16_777_216; +const MAX_OUTPUT_BYTES: u64 = 2_097_152; + +fn record(fields: impl IntoIterator) -> Value { + Value::Map( + fields + .into_iter() + .map(|(name, value)| (Value::Text(name.into()), value)) + .collect(), + ) +} + +fn input(start: u64, end: u64, buffer_id_size: usize) -> Vec { + encode(&record([ + ("bufferId", Value::Bytes(vec![1; buffer_id_size])), + ("basisHeadId", Value::Bytes(vec![2; ID_BYTES])), + ("startByte", Value::Integer(start.into())), + ("endByte", Value::Integer(end.into())), + ("replacement", Value::Bytes("λ\r\n".as_bytes().to_vec())), + ])) + .expect("canonical input") +} + +fn limits() -> EvaluationLimits { + EvaluationLimits { + max_package_bytes: MAX_PACKAGE_BYTES, + max_input_bytes: MAX_INPUT_BYTES, + max_steps: MAX_STEPS, + max_allocated_bytes: MAX_ALLOCATED_BYTES, + max_output_bytes: MAX_OUTPUT_BYTES, + } +} + +#[test] +fn freshly_compiled_boundary_executes() { + // The driver validates the separate verifier report and build locks before + // supplying this pin. This fixture alone does not establish authorization. + let package = fs::read(env::var("JEDIT_VERIFIED_PACKAGE").expect("package path")) + .expect("fresh compiler package"); + let pin_text = env::var("JEDIT_VERIFIED_PACKAGE_PIN").expect("verified package pin"); + assert_eq!(pin_text.len(), ID_BYTES * 2); + let mut pin = [0; ID_BYTES]; + for (index, byte) in pin.iter_mut().enumerate() { + *byte = u8::from_str_radix(&pin_text[index * 2..index * 2 + 2], 16) + .expect("hexadecimal package pin"); + } + + // Literal expectations catch a skipped helper, constant result, wrong + // branch, or changed field projection without reproducing the evaluator. + for (start, end, range_is_empty) in [(7, 7, 1), (7, 11, 0)] { + let supplied = input(start, end, ID_BYTES); + let result = evaluate(&package, pin, &supplied, limits()).expect("pure result"); + let expected = record([ + ("bufferId", Value::Bytes(vec![1; ID_BYTES])), + ("basisHeadId", Value::Bytes(vec![2; ID_BYTES])), + ("startByte", Value::Integer(start.into())), + ("endByte", Value::Integer(end.into())), + ("replacement", Value::Bytes("λ\r\n".as_bytes().to_vec())), + ("rangeIsEmpty", Value::Integer(range_is_empty)), + ("createdLeafCeiling", Value::Integer(4096)), + ]); + assert_eq!(result.output, encode(&expected).expect("expected result")); + assert_eq!( + result, + evaluate(&package, pin, &supplied, limits()).unwrap() + ); + assert!(result.steps > 0); + assert!(result.allocated_bytes > 0); + } + assert_eq!( + evaluate(&package, pin, &input(11, 7, ID_BYTES), limits()), + Err(EvaluationError::InputConstraintFailed("where.0".into())) + ); + assert_eq!( + evaluate(&package, pin, &input(7, 11, ID_BYTES - 1), limits()), + Err(EvaluationError::InvalidInput) + ); + pin[0] ^= 1; + assert_eq!( + evaluate(&package, pin, &input(7, 11, ID_BYTES), limits()), + Err(EvaluationError::PackageIdentityMismatch) + ); + // The driver requires this marker, so zero discovered tests cannot pass. + println!("JEDIT_EDICT_PURE_RUNTIME_OK"); +} From 19edb6fba94a8fea2dea63aa2f05cffc3e084f97 Mon Sep 17 00:00:00 2001 From: James Ross Date: Sat, 3 Oct 2026 18:05:15 -0700 Subject: [PATCH 12/30] test(edict): preserve the state-read ordering blocker witness --- CHANGELOG.md | 5 + .../state-read/Dockerfile | 18 ++ .../state-read/Dockerfile.dockerignore | 5 + .../replace-range-probes/state-read/README.md | 69 +++++ .../state-read/edict.application.json | 20 ++ .../state-read/edict.lawpack.json | 247 ++++++++++++++++++ edict/replace-range-probes/state-read/run.py | 82 ++++++ .../state-read/src/ReplaceRange.edict | 13 + 8 files changed, 459 insertions(+) create mode 100644 edict/replace-range-probes/state-read/Dockerfile create mode 100644 edict/replace-range-probes/state-read/Dockerfile.dockerignore create mode 100644 edict/replace-range-probes/state-read/README.md create mode 100644 edict/replace-range-probes/state-read/edict.application.json create mode 100644 edict/replace-range-probes/state-read/edict.lawpack.json create mode 100644 edict/replace-range-probes/state-read/run.py create mode 100644 edict/replace-range-probes/state-read/src/ReplaceRange.edict diff --git a/CHANGELOG.md b/CHANGELOG.md index c36e2017..504a575d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,11 @@ ## Unreleased +- Added a separate Docker-only state-read ordering probe for ReplaceRange. It + reproduces Edict's refusal of an effect-dependent basis guard and confirms + that removing the guard reaches an unsupported-provider refusal. This is + development evidence, not stateful execution; existing producer pins remain + unchanged. Ordered Target IR is tracked in flyingrobots/edict#218. - Added the Jedit-owned `ReplaceRange.edict` application root and canonical `jedit.text@1` lawpack publication. With Edict #201, its executable integration gate now proves that real source lowers into generic pure Target IR and reaches diff --git a/edict/replace-range-probes/state-read/Dockerfile b/edict/replace-range-probes/state-read/Dockerfile new file mode 100644 index 00000000..ea6f274b --- /dev/null +++ b/edict/replace-range-probes/state-read/Dockerfile @@ -0,0 +1,18 @@ +FROM rust:1.95.0-bookworm AS compiler +WORKDIR /edict +RUN git init && git remote add origin https://github.com/flyingrobots/edict.git \ + && git fetch --depth=1 origin 77f4a91080a6c2c875fe349da6fc6a64525947a2 \ + && git checkout --detach FETCH_HEAD \ + && cargo build --locked -p edict-cli + +FROM debian:bookworm-slim +RUN apt-get update && apt-get install -y --no-install-recommends \ + ca-certificates git python3 && rm -rf /var/lib/apt/lists/* +WORKDIR /echo +RUN git init && git remote add origin https://github.com/flyingrobots/echo.git \ + && git fetch --depth=1 origin 49e9efb68001dfd78563d18bac9359a87671e431 \ + && git checkout --detach FETCH_HEAD \ + && cp -R schemas/edict-provider/package/v1 /echo-provider +COPY --from=compiler /edict/target/debug/edict /usr/local/bin/edict +COPY edict/replace-range-probes/state-read /probe +CMD ["python3", "/probe/run.py"] diff --git a/edict/replace-range-probes/state-read/Dockerfile.dockerignore b/edict/replace-range-probes/state-read/Dockerfile.dockerignore new file mode 100644 index 00000000..681a3149 --- /dev/null +++ b/edict/replace-range-probes/state-read/Dockerfile.dockerignore @@ -0,0 +1,5 @@ +* +!edict/ +!edict/replace-range-probes/ +!edict/replace-range-probes/state-read/ +!edict/replace-range-probes/state-read/** diff --git a/edict/replace-range-probes/state-read/README.md b/edict/replace-range-probes/state-read/README.md new file mode 100644 index 00000000..da41a87d --- /dev/null +++ b/edict/replace-range-probes/state-read/README.md @@ -0,0 +1,69 @@ +# State-read ordering probe + +This is development evidence for [#296](https://github.com/flyingrobots/jedit/issues/296) +and [PR #302](https://github.com/flyingrobots/jedit/pull/302). It is not the +ReplaceRange implementation, an admitted operation, or a runtime capability. +The frozen application and producer pins under `edict/replace-range/` are +unchanged. + +ReplaceRange must read a buffer's canonical head and compare it with the +requested basis before accepting an edit. A caller-provided head is not proof +of current state. This deliberately small authored source asks for that +read-then-check sequence through a Jim-owned semantic effect. + +The lawpack proposes `readCanonicalHead(BufferId) -> HeadId`, with a typed +missing-fact obstruction. Its `snapshot-read-probe` target intrinsic is an +explicit placeholder: **Echo does not implement it**. The retained pure-provider +configuration is intentionally incompatible with stateful execution. This +fixture establishes a compiler boundary, not an agreed future read ABI, +footprint model, canonical fact decoder, or provider implementation. + +## Reproduce + +From the repository root, build and run without mounting a host repository: + +```sh +docker build -f edict/replace-range-probes/state-read/Dockerfile \ + -t jedit-state-read-boundary . +docker run --rm jedit-state-read-boundary +``` + +The image pins Edict to `77f4a91080a6c2c875fe349da6fc6a64525947a2` +and the existing Echo provider to +`49e9efb68001dfd78563d18bac9359a87671e431`. Both revisions are fetched inside +Docker. The harness copies inputs to disposable container storage and uses the +public lawpack/application JSONL build API; it constructs no Core, Target IR, +executable package, or native edit plan. + +Expected evidence: + +1. The complete lawpack builds, and its generated digest matches the authored + import. +2. The source with the basis guard rejects at `TargetLoweringFailed`, with + `obstruction_requirement_step_output_dependency`. +3. A control removes only that guard. It reaches the provider and rejects at + `ProviderLowererRefused`, with `UnsupportedSemantics`. +4. Neither refusal publishes application output artifacts. + +The harness prints `JEDIT_STATE_READ_BOUNDARY_CONFIRMED` when both boundaries +are observed. A passing harness therefore means the limitation is reproduced; +it does **not** mean state reads or ReplaceRange work. + +## Required follow-through + +[Edict #218](https://github.com/flyingrobots/edict/issues/218) owns the ordered +Target IR prerequisite exposed here. + +Edict currently separates pure bindings, requirements, and target steps. +Requirements are pre-step guards. Supporting this operation requires an +explicit ordering contract; deleting the rejection alone would lose the +read-before-check meaning. The compiler must preserve dependencies and reject +forward or fabricated references. Existing artifact identities and consumers +need a deliberate compatibility path. + +After that compiler contract exists, Echo still needs an independently verified, +generic snapshot-read and private staged-write execution path. Reads must share +the admitted application snapshot; an obstruction must not publish partial +edits. Jim owns canonical fact decoding, rope algorithms, identities, and typed +obstructions. Complete rope transformation, oracle agreement, footprints, +budgets, Tick/WAL/receipt, and recovery remain the acceptance criteria of #296. diff --git a/edict/replace-range-probes/state-read/edict.application.json b/edict/replace-range-probes/state-read/edict.application.json new file mode 100644 index 00000000..b081d60c --- /dev/null +++ b/edict/replace-range-probes/state-read/edict.application.json @@ -0,0 +1,20 @@ +{ + "schema": "edict.application/v1", + "coordinate": "jedit.text.replace_range@1", + "sources": [ + "src/ReplaceRange.edict" + ], + "lawpacks": [ + { + "manifest": "vendor/state-probe/manifest.cbor", + "exports": "vendor/state-probe/exports.cbor", + "adapter": "vendor/state-probe/adapter.cbor", + "targetConfiguration": "vendor/state-probe/echo-operation-configuration.cbor" + } + ], + "target": { + "profile": "echo.dpo@1", + "providerPackage": ".build/echo-provider" + }, + "outputDirectory": ".build/application" +} diff --git a/edict/replace-range-probes/state-read/edict.lawpack.json b/edict/replace-range-probes/state-read/edict.lawpack.json new file mode 100644 index 00000000..963fa1c5 --- /dev/null +++ b/edict/replace-range-probes/state-read/edict.lawpack.json @@ -0,0 +1,247 @@ +{ + "schema": "edict.lawpack-build/v1", + "outputDirectory": "vendor/state-probe", + "lawpack": { + "schema": "edict.lawpack-authoring/v1", + "id": "jedit.text", + "version": "1", + "acceptedCoreAbi": [ + "edict.core/v1" + ], + "dependencies": [], + "exportsCoordinate": "jedit.text.exports/v1", + "exports": { + "types": [ + { + "coordinate": "jedit.text@1.NodeId", + "definition": "Bytes" + }, + { + "coordinate": "jedit.text@1.BufferId", + "definition": "Nominal" + }, + { + "coordinate": "jedit.text@1.HeadId", + "definition": "Nominal" + }, + { + "coordinate": "jedit.text@1.ReplacementBytes", + "definition": "Bytes" + }, + { + "coordinate": "jedit.text@1.ObstructionDetail", + "definition": "String" + } + ], + "constants": [ + { + "coordinate": "jedit.text@1.maxCreatedLeaves", + "type": "U64", + "value": 4096 + }, + { + "coordinate": "jedit.text@1.maxCreatedBranches", + "type": "U64", + "value": 4096 + } + ], + "pureFunctions": [ + { + "source": "edict", + "coordinate": "jedit.text@1.maxCreatedLeafCount", + "typeParameters": [], + "parameterTypes": [], + "returnType": "U64", + "costTemplate": "jedit.text@1.replaceRangeBudget", + "determinismClass": "total", + "body": { + "params": [], + "body": { + "locals": [], + "bindings": [], + "result": { + "kind": "const", + "value": { + "kind": "int", + "width": "U64", + "value": 4096 + } + } + } + } + } + ], + "effects": [ + { + "coordinate": "jedit.text@1.readCanonicalHead", + "typeParameters": [], + "inputType": "jedit.text@1.BufferId", + "outputType": "jedit.text@1.HeadId", + "executionClass": "runtime", + "effectKindHint": "read", + "footprintObligation": "jedit.text@1.replaceRangeFootprint", + "costObligation": "jedit.text@1.replaceRangeBudget", + "effectFailures": { + "missing": { + "authorityClass": "resourceFault", + "payloadType": "jedit.text@1.BufferId" + } + }, + "guardSupport": true + } + ], + "obstructions": [ + { + "coordinate": "jedit.text@1.RangeOrderInvalid", + "authorityClass": "domainMappable", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.RangeOutOfBounds", + "authorityClass": "domainMappable", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.Utf8BoundaryInvalid", + "authorityClass": "domainMappable", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.NoOp", + "authorityClass": "domainMappable", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.BasisNotCanonical", + "authorityClass": "domainMappable", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.ArithmeticOverflow", + "authorityClass": "integrityFault", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.FactMissing", + "authorityClass": "resourceFault", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.FactMalformed", + "authorityClass": "integrityFault", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.ContentIdentityMismatch", + "authorityClass": "integrityFault", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.MalformedRope", + "authorityClass": "integrityFault", + "payloadSchema": "jedit.text@1.ObstructionDetail" + } + ], + "operationProfiles": { + "jedit.text@1.replaceRange": { + "opticTemplate": { + "opticKind": "affectReintegration", + "boundaryKind": "affect", + "supportPolicy": "jedit.text@1.basisBoundSupport", + "lossDisposition": "jedit.text@1.lossless", + "basisTemplate": "jedit.text@1.exactHeadBasis", + "apertureRequirement": { + "kind": "abstractFootprintObligation", + "reference": "jedit.text@1.replaceRangeFootprint" + } + }, + "effectPredicate": "jedit.text@1.replaceRangeEffects" + } + } + }, + "targetAdapters": [ + { + "coordinate": "jedit.text.echo-adapter/v1", + "output": "adapter.cbor", + "acceptedTargetProfile": { + "id": "echo.dpo@1", + "digest": "sha256:2e2494121aecf5e6a2d920f5fb85408825d394765fad41484c416397c920fb04" + }, + "acceptedTargetIr": { + "id": "echo.span-ir/v1", + "digest": "sha256:0057167e68f50c99dcce087b3e1cd677d17c5d1dc238bdb52d89469e1472fc2f" + }, + "operationProfiles": { + "jedit.text@1.replaceRange": { + "core": "continuum.profile.read-write/v1", + "semanticEffects": [ + "jedit.text@1.readCanonicalHead" + ], + "budgetObligation": "jedit.text@1.replaceRangeBudget", + "targetConfiguration": { + "local": "echo-config" + } + } + }, + "effectImplementations": { + "jedit.text@1.readCanonicalHead": { + "targetIntrinsic": "echo.dpo@1.snapshot-read-probe", + "targetConfiguration": { + "local": "echo-config" + }, + "writeClass": "read", + "footprintObligation": "jedit.text@1.replaceRangeFootprint", + "costObligation": "jedit.text@1.replaceRangeBudget", + "failureMappings": { + "missing": "echo.fact-missing/v1" + } + } + }, + "budgets": { + "jedit.text@1.replaceRangeBudget": { + "maxSteps": 1048576, + "maxAllocatedBytes": 16777216, + "maxOutputBytes": 8388608 + } + } + } + ], + "verifier": { + "class": "declarative", + "ruleset": { + "local": "verifier-rules" + } + }, + "compatibility": { + "id": "jedit.text.compatibility/v1", + "digest": "sha256:2adf83f798205f52636ad64ca45178f33a8e1cc663874f8a6113484c945e3052" + }, + "conformanceFixtureCorpus": { + "id": "jedit.text.ReplaceRange.oracle@1", + "digest": "sha256:b9b4707dd5e07897cbe7af36d88928401887e6af5d167d1a88a8d6181b4dbb0e" + }, + "localResources": [ + { + "name": "echo-config", + "coordinate": "echo.operation-lowering-configuration/v1", + "output": "echo-operation-configuration.cbor", + "value": { + "apiVersion": "echo.operation-lowering-configuration/v1", + "programKind": "compiler-produced-bounded-pure/v1" + } + }, + { + "name": "verifier-rules", + "coordinate": "jedit.text.verifier-rules/v1", + "output": "verifier-rules.cbor", + "value": { + "schema": "jedit.text.schema@1", + "schemaDigest": "sha256:f49b0ff6c9c7010d3a72b46734d47832853f496739a083edc41dddec3431bac7", + "oracleIsExecutableInput": false, + "runtimeOntology": "generic-bounded-graph" + } + } + ] + }, + "dependencyBundles": [] +} diff --git a/edict/replace-range-probes/state-read/run.py b/edict/replace-range-probes/state-read/run.py new file mode 100644 index 00000000..94087c6b --- /dev/null +++ b/edict/replace-range-probes/state-read/run.py @@ -0,0 +1,82 @@ +"""Docker-only public compiler witness; this does not execute a rope edit.""" + +import json +import os +from pathlib import Path +import shutil +import subprocess +import tempfile + + +GUARD = " require canonicalHead == input.basisHeadId else text.BasisNotCanonical;\n" + + +def build(binary, workspace, document): + request = { + "schema": "edict.compiler.settings/v1", + "type": "compilerSettings", + "operation": "build", + document: f"edict.{document}.json", + } + result = subprocess.run( + [binary], cwd=workspace, input=json.dumps(request) + "\n", + text=True, capture_output=True, timeout=120, check=False, + ) + events = [ + json.loads(line) + for stream in (result.stdout, result.stderr) + for line in stream.splitlines() + ] + return result, events + + +def expect_refusal(binary, workspace, kind, detail): + result, events = build(binary, workspace, "application") + diagnostics = [event for event in events if event.get("type") == "diagnostic"] + if result.returncode != 2 or len(diagnostics) != 1: + raise RuntimeError(f"Unexpected build result: {result}\n{events}") + diagnostic = diagnostics[0] + if diagnostic["kind"] != kind or detail not in diagnostic["message"]: + raise RuntimeError(f"Wrong failure boundary: {diagnostic}") + output = workspace / ".build/application" + if output.exists() and list(output.rglob("*")): + raise RuntimeError("Refused application published output artifacts") + print(json.dumps(diagnostic, sort_keys=True)) + + +def main(): + if not Path("/.dockerenv").is_file(): + raise RuntimeError("Run this witness in its COPY-based Docker image") + binary = os.environ.get("EDICT_BINARY", "/usr/local/bin/edict") + provider = Path(os.environ.get("ECHO_PROVIDER_DIR", "/echo-provider")) + source = Path(__file__).resolve().parent + with tempfile.TemporaryDirectory(prefix="jedit-state-read-") as scratch: + workspace = Path(scratch) / "application" + workspace.mkdir() + for document in ("edict.application.json", "edict.lawpack.json"): + shutil.copyfile(source / document, workspace / document) + shutil.copytree(source / "src", workspace / "src") + shutil.copytree(provider, workspace / ".build/echo-provider") + result, events = build(binary, workspace, "lawpack") + if result.returncode != 0 or events[-1].get("status") != "ok": + raise RuntimeError(f"Lawpack did not build: {result}\n{events}") + authored = workspace / "src/ReplaceRange.edict" + text = authored.read_text() + manifest_digest = (workspace / "vendor/state-probe/manifest.sha256").read_text().strip() + if f'digest "{manifest_digest}"' not in text or text.count(GUARD) != 1: + raise RuntimeError("Source does not bind the exact generated lawpack and guard") + expect_refusal( + binary, workspace, "TargetLoweringFailed", + "obstruction_requirement_step_output_dependency", + ) + # This control removes only the dependent guard. The proposed read is + # deliberately unsupported by the old provider; it must not execute. + authored.write_text(text.replace(GUARD, "")) + expect_refusal( + binary, workspace, "ProviderLowererRefused", "UnsupportedSemantics", + ) + print("JEDIT_STATE_READ_BOUNDARY_CONFIRMED") + + +if __name__ == "__main__": + main() diff --git a/edict/replace-range-probes/state-read/src/ReplaceRange.edict b/edict/replace-range-probes/state-read/src/ReplaceRange.edict new file mode 100644 index 00000000..c59342c7 --- /dev/null +++ b/edict/replace-range-probes/state-read/src/ReplaceRange.edict @@ -0,0 +1,13 @@ +package jedit.text.replace_range@1; +use lawpack jedit.text@1 digest "sha256:7d66e6d70629ab25602500ab5802c25114b3691d90e0858b98a3332ec088647c" as text; +type Input = {bufferId: text.BufferId, basisHeadId: text.HeadId}; +intent replaceRange(input: Input) returns text.HeadId + profile text.replaceRange + basis input.basisHeadId + budget <= text.replaceRangeBudget +{ + let canonicalHead: text.HeadId = text.readCanonicalHead(input.bufferId) + else { missing(id) => text.FactMissing }; + require canonicalHead == input.basisHeadId else text.BasisNotCanonical; + return canonicalHead; +} From 906ae8c7c9382997d08f0effb59b95ad2de50d96 Mon Sep 17 00:00:00 2001 From: James Ross Date: Sat, 3 Oct 2026 18:58:54 -0700 Subject: [PATCH 13/30] fix: honor Cargo executable output in Edict proof gate --- CHANGELOG.md | 4 ++++ docs/BEARING.md | 5 +++++ edict/replace-range/README.md | 10 +++++++++- edict/replace-range/edict.build-lock.json | 6 +++--- edict/replace-range/tests/package-chain.mjs | 16 +++++++++++++--- .../replace-range/tests/proof-harness.spec.mjs | 18 ++++++++++++++++-- 6 files changed, 50 insertions(+), 9 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 504a575d..e62fb8dc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,10 @@ ## Unreleased +- Fixed the Edict package-chain harness to use Cargo's reported executable path + when CI redirects build output with `CARGO_TARGET_DIR`. The regression compiles + and executes the real pinned package without a default-path compiler binary; + compiler, provider, evaluator, and application artifact identities are unchanged. - Added a separate Docker-only state-read ordering probe for ReplaceRange. It reproduces Edict's refusal of an effect-dependent basis guard and confirms that removing the guard reaches an unsupported-provider refusal. This is diff --git a/docs/BEARING.md b/docs/BEARING.md index 7be0f60b..fd96a38c 100644 --- a/docs/BEARING.md +++ b/docs/BEARING.md @@ -124,6 +124,11 @@ or support-policy logic. ## Immediate Roadmap +- [x] Make the pinned Edict package-chain harness discover Cargo's actual + executable when its output is redirected. Preserve producer pins and verify + the emitted pure package in Echo; this does not complete the authored rope + operation or its stateful runtime path. + 1. Keep the narrow create/replace/checkpoint/read corridor green against Echo-owned WAL, admission, scheduling, graph state, receipts, and restart recovery. diff --git a/edict/replace-range/README.md b/edict/replace-range/README.md index 8e17aeba..1132d682 100644 --- a/edict/replace-range/README.md +++ b/edict/replace-range/README.md @@ -57,7 +57,8 @@ and generic stateful execution remain unfinished under #296. ## Reproduce -The build script requires exact local Edict and Echo checkouts: +Run the build script inside Docker with copies of the exact Edict and Echo +checkouts. Do not mount host repositories or Git directories into the container: ```bash EDICT_REPO=/path/to/edict \ @@ -75,6 +76,13 @@ dirty checkouts, or validation-environment drift before invoking either toolchain. GitHub's package-chain job checks out and verifies the literal pull request head; ordinary matrix jobs may separately exercise the synthetic merge. +The harness takes the compiler executable path from Cargo's successful +`compiler-artifact` output. `CARGO_TARGET_DIR` may therefore point outside the +Edict checkout, as it does in CI; no pre-existing `target/debug/edict` is needed. +The runtime witness uses the same configured build cache. A regression runs the +full package chain against an isolated Edict checkout whose default binary path +is absent before and after execution. + `edict.build-lock.json` binds the exact source and validation closure to the Core, Target IR, result projection, executable package, verification report, and executable-subject identities. The raw Echo report remains a separately diff --git a/edict/replace-range/edict.build-lock.json b/edict/replace-range/edict.build-lock.json index 5cfba4c3..d2d43e57 100644 --- a/edict/replace-range/edict.build-lock.json +++ b/edict/replace-range/edict.build-lock.json @@ -5,7 +5,7 @@ "toolchainLockSha256": "5323f86f94f6b1ac5b1bb25c7104f703cc633ff3cc57df5caaa637a7a8455e75", "sourceClosure": { "schema": "jedit.edict-source-closure/v1", - "digest": "sha256:19017995722b8b038571f59b54cffb8929636a0115d148b266d51b6b769e7242", + "digest": "sha256:aa0e80326f1931a0abce94173fc5791c8e28f5021f732ed286117752d8387a8d", "files": [ { "path": "application/edict.application.json", @@ -33,11 +33,11 @@ }, { "path": "application/tests/package-chain.mjs", - "sha256": "cdb4d2d9661960b0b5890bf5bbae8b07e4f82365378ddb4c36342e42fad05927" + "sha256": "26f1bbc543a6e7fcb4bab3add0ed63e4fc7f7848df62b7a38f0e8da467dc33ef" }, { "path": "application/tests/proof-harness.spec.mjs", - "sha256": "ada20b6786401dc629f141220ced5041bc694458821149f4197b0e69dc619fae" + "sha256": "1a7c6f3433437d25196d89dc41a35c844ec52e423cf396aed93c80b422f28717" }, { "path": "application/tests/runtime/Cargo.toml", diff --git a/edict/replace-range/tests/package-chain.mjs b/edict/replace-range/tests/package-chain.mjs index 4dc9657f..6f03f41b 100644 --- a/edict/replace-range/tests/package-chain.mjs +++ b/edict/replace-range/tests/package-chain.mjs @@ -234,12 +234,22 @@ async function verifyVersions(lock) { run("cargo", [`+${lock.rust.toolchain}`, "--version"]), lock.rust.cargoVersion, ); - run( + const cargoOutput = run( "cargo", - [`+${lock.rust.toolchain}`, "build", "--locked", "-p", "edict-cli"], + [ + `+${lock.rust.toolchain}`, "build", "--locked", "-p", "edict-cli", + "--message-format=json-render-diagnostics", + ], { cwd: edictRepository }, ); - const edictBinary = path.join(edictRepository, "target", "debug", "edict"); + const compilerArtifacts = cargoOutput.split("\n") + .map((line) => JSON.parse(line)) + .filter((artifact) => artifact.reason === "compiler-artifact" + && artifact.target.name === "edict" + && artifact.target.kind.includes("bin") + && typeof artifact.executable === "string"); + assert.equal(compilerArtifacts.length, 1, "Cargo must emit one Edict executable"); + const edictBinary = compilerArtifacts[0].executable; const version = JSON.parse(run(edictBinary, ["--version"])); assert.equal(version.version, lock.edict.cliVersion); return edictBinary; diff --git a/edict/replace-range/tests/proof-harness.spec.mjs b/edict/replace-range/tests/proof-harness.spec.mjs index ec9bb5e5..e65a682b 100644 --- a/edict/replace-range/tests/proof-harness.spec.mjs +++ b/edict/replace-range/tests/proof-harness.spec.mjs @@ -3,7 +3,7 @@ import assert from "node:assert/strict"; import { spawnSync } from "node:child_process"; -import { cp, mkdtemp, mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises"; +import { access, cp, mkdtemp, mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises"; import os from "node:os"; import path from "node:path"; import test from "node:test"; @@ -249,9 +249,23 @@ test("freshly_compiled_package_must_execute_in_echo", { timeout: 120_000 }, asyn requireToolchainEnvironment(); const subject = await fixture(); try { - const result = runBuild(subject.project); + const isolatedEdict = path.join(subject.root, "edict"); + const clone = spawnSync("git", [ + "clone", "--quiet", "--no-hardlinks", edictRepository, isolatedEdict, + ], { encoding: "utf8" }); + assertCommandCompleted(clone); + assert.equal(clone.status, 0, clone.stderr); + const defaultBinary = path.join(isolatedEdict, "target", "debug", "edict"); + await assert.rejects(access(defaultBinary), { code: "ENOENT" }); + const result = runBuild(subject.project, { + EDICT_REPO: isolatedEdict, + CARGO_TARGET_DIR: path.resolve( + process.env.CARGO_TARGET_DIR ?? path.join(edictRepository, "target"), + ), + }); assertCommandCompleted(result); assert.equal(result.status, 0, result.stderr); + await assert.rejects(access(defaultBinary), { code: "ENOENT" }); assert.ok( result.stdout.includes("JEDIT_EDICT_PURE_RUNTIME_OK"), "a verified package alone is insufficient: the runtime conformance test must execute", From b1aeaaabd0c8911c31a506f5e273bd33ce9f31cc Mon Sep 17 00:00:00 2001 From: James Ross Date: Sat, 3 Oct 2026 20:14:41 -0700 Subject: [PATCH 14/30] test: publish authored basis and payload equality witnesses Build exact independent packages with unchanged compiler and provider pins. The isolated comparison sources are not current-state observations or admitted edits. Refs #296 and flyingrobots/echo#738. --- .../basis-identity/Dockerfile | 17 +++++++ .../basis-identity/Dockerfile.dockerignore | 4 ++ .../basis-identity/PayloadEquality.edict | 21 +++++++++ .../basis-identity/README.md | 44 +++++++++++++++++++ .../basis-identity/ReplaceRange.edict | 21 +++++++++ .../basis-identity/build.sh | 22 ++++++++++ 6 files changed, 129 insertions(+) create mode 100644 edict/replace-range-probes/basis-identity/Dockerfile create mode 100644 edict/replace-range-probes/basis-identity/Dockerfile.dockerignore create mode 100644 edict/replace-range-probes/basis-identity/PayloadEquality.edict create mode 100644 edict/replace-range-probes/basis-identity/README.md create mode 100644 edict/replace-range-probes/basis-identity/ReplaceRange.edict create mode 100644 edict/replace-range-probes/basis-identity/build.sh diff --git a/edict/replace-range-probes/basis-identity/Dockerfile b/edict/replace-range-probes/basis-identity/Dockerfile new file mode 100644 index 00000000..89aa2b5b --- /dev/null +++ b/edict/replace-range-probes/basis-identity/Dockerfile @@ -0,0 +1,17 @@ +# SPDX-License-Identifier: Apache-2.0 +# © James Ross Ω FLYING•ROBOTS +FROM rust:1.94.0-bookworm +WORKDIR /edict +RUN git init && git remote add origin https://github.com/flyingrobots/edict.git \ + && git fetch --depth=1 origin 3f81f759e921a69b04fe8cf8e62e62f8f3dc7b7e \ + && git archive FETCH_HEAD | tar -x +RUN cargo +1.94.0 build --locked -p edict-cli +WORKDIR /echo +RUN git init && git remote add origin https://github.com/flyingrobots/echo.git \ + && git fetch --depth=1 origin 49e9efb68001dfd78563d18bac9359a87671e431 \ + && git archive FETCH_HEAD schemas/edict-provider/package/v1 | tar -x +COPY edict/replace-range /application-source +COPY edict/replace-range-probes/basis-identity/ReplaceRange.edict /comparison-sources/ReplaceRange.edict +COPY edict/replace-range-probes/basis-identity/PayloadEquality.edict /comparison-sources/PayloadEquality.edict +COPY edict/replace-range-probes/basis-identity/build.sh /comparison-build.sh +CMD ["sh", "/comparison-build.sh"] diff --git a/edict/replace-range-probes/basis-identity/Dockerfile.dockerignore b/edict/replace-range-probes/basis-identity/Dockerfile.dockerignore new file mode 100644 index 00000000..faa5a665 --- /dev/null +++ b/edict/replace-range-probes/basis-identity/Dockerfile.dockerignore @@ -0,0 +1,4 @@ +**/.git +**/target +**/node_modules +**/.build diff --git a/edict/replace-range-probes/basis-identity/PayloadEquality.edict b/edict/replace-range-probes/basis-identity/PayloadEquality.edict new file mode 100644 index 00000000..d53e5032 --- /dev/null +++ b/edict/replace-range-probes/basis-identity/PayloadEquality.edict @@ -0,0 +1,21 @@ +package jedit.text.replace_range@1; + +use lawpack jedit.text@1 digest "sha256:95758c1605894672cc9069fde01bb8b6e11842b053102660c9cd4f4d6f34d64e" as text; + +type Input = { + basisPayload: text.ReplacementBytes, + observedPayload: text.ReplacementBytes, +}; + +type Comparison = { + samePayload: U32, +}; + +intent replaceRange(input: Input) returns Comparison + profile text.replaceRange + basis none + budget <= text.replaceRangeBudget +{ + let samePayload = if input.observedPayload == input.basisPayload then 1u32 else 0u32; + return { samePayload }; +} diff --git a/edict/replace-range-probes/basis-identity/README.md b/edict/replace-range-probes/basis-identity/README.md new file mode 100644 index 00000000..84dab882 --- /dev/null +++ b/edict/replace-range-probes/basis-identity/README.md @@ -0,0 +1,44 @@ +# Basis identity comparison witness + +These Jim-owned sources isolate byte equality required by ReplaceRange's +basis validation and content comparisons. They are conformance inputs for +[Echo #738](https://github.com/flyingrobots/echo/issues/738), not the completed +operation from [Jim #296](https://github.com/flyingrobots/jedit/issues/296). + +`ReplaceRange.edict` compares two `text.HeadId` values through their declared +32-byte representation. `PayloadEquality.edict` compares bounded variable +byte payloads, including empty values and unequal lengths, to exercise work +accounting. Both return an authored numeric branch result. An observed ID +supplied as input is **not** evidence of the graph's current head. Neither +source reads state, decodes a fact, grants authority, or admits an edit. + +## Build the exact packages + +From the repository root: + +```sh +docker build -f edict/replace-range-probes/basis-identity/Dockerfile \ + -t jim-byte-comparison . +docker run --name jim-byte-comparison-proof jim-byte-comparison +docker cp jim-byte-comparison-proof:/comparison-output +``` + +The COPY-based image builds the existing pinned compiler +`3f81f759e921a69b04fe8cf8e62e62f8f3dc7b7e` using Rust 1.94.0, fetches the +existing pinned provider `49e9efb68001dfd78563d18bac9359a87671e431`, and invokes +Edict's public JSONL application-build boundary. Each disposable application +copy retains the frozen application manifest and complete published lawpack; +only its source file changes. No host repository or Git directory is mounted. + +The success marker is `JIM_BYTE_COMPARISON_PACKAGES_BUILT`. Output contains +`head/` and `payload/`, each with the emitted executable package and its separate +accepted verification report. Echo's runtime tests must consume these exact +bytes, never construct a program from the schema or oracle. The frozen +`edict/replace-range/` application, runtime host, and producer locks are unchanged. + +The original evaluator at `8c725d699241a7e3adee482029031ff6bade25fa` refuses +byte equality as `UnsupportedProgram`. The Echo prerequisite adds bounded, +metered byte equality; it does not provide snapshot reads or make the full +ReplaceRange acceptance criteria complete. Generic fact reads, application-owned +codecs and rope semantics, admitted execution, independent oracle agreement, +Tick, receipts, WAL, and recovery remain required by #296. diff --git a/edict/replace-range-probes/basis-identity/ReplaceRange.edict b/edict/replace-range-probes/basis-identity/ReplaceRange.edict new file mode 100644 index 00000000..6fb7e6f2 --- /dev/null +++ b/edict/replace-range-probes/basis-identity/ReplaceRange.edict @@ -0,0 +1,21 @@ +package jedit.text.replace_range@1; + +use lawpack jedit.text@1 digest "sha256:95758c1605894672cc9069fde01bb8b6e11842b053102660c9cd4f4d6f34d64e" as text; + +type Input = { + basisHeadId: text.HeadId, + observedHeadId: text.HeadId, +}; + +type Comparison = { + sameHead: U32, +}; + +intent replaceRange(input: Input) returns Comparison + profile text.replaceRange + basis input.basisHeadId + budget <= text.replaceRangeBudget +{ + let sameHead = if input.observedHeadId == input.basisHeadId then 1u32 else 0u32; + return { sameHead }; +} diff --git a/edict/replace-range-probes/basis-identity/build.sh b/edict/replace-range-probes/basis-identity/build.sh new file mode 100644 index 00000000..39148e78 --- /dev/null +++ b/edict/replace-range-probes/basis-identity/build.sh @@ -0,0 +1,22 @@ +#!/bin/sh +# SPDX-License-Identifier: Apache-2.0 +# © James Ross Ω FLYING•ROBOTS +set -eu +[ -f /.dockerenv ] || { echo 'Run in the COPY-based Docker image' >&2; exit 1; } +mkdir /comparison-output +for comparison in head payload; do + case "$comparison" in + head) source_file=ReplaceRange.edict ;; + payload) source_file=PayloadEquality.edict ;; + esac + application="/comparison-$comparison" + mkdir "$application" + cp -R /application-source/. "$application/" + cp "/comparison-sources/$source_file" "$application/src/ReplaceRange.edict" + mkdir -p "$application/.build" + cp -R /echo/schemas/edict-provider/package/v1 "$application/.build/echo-provider" + cd "$application" + printf '%s\n' '{"schema":"edict.compiler.settings/v1","type":"compilerSettings","operation":"build","application":"edict.application.json"}' | /edict/target/debug/edict + cp -R .build/application "/comparison-output/$comparison" +done +printf '%s\n' 'JIM_BYTE_COMPARISON_PACKAGES_BUILT' From f694a741b3bc522b80a1f9b7c149284776f90802 Mon Sep 17 00:00:00 2001 From: James Ross Date: Sat, 3 Oct 2026 20:41:01 -0700 Subject: [PATCH 15/30] test: pin the raw atom read and guard provider boundary --- .../node-atom-read/Dockerfile | 24 +++ .../node-atom-read/Dockerfile.dockerignore | 5 + .../node-atom-read/README.md | 67 +++++++ .../node-atom-read/edict.application.json | 20 ++ .../node-atom-read/edict.lawpack.json | 183 ++++++++++++++++++ .../node-atom-read/run.py | 82 ++++++++ .../node-atom-read/src/ReplaceRange.edict | 18 ++ 7 files changed, 399 insertions(+) create mode 100644 edict/replace-range-probes/node-atom-read/Dockerfile create mode 100644 edict/replace-range-probes/node-atom-read/Dockerfile.dockerignore create mode 100644 edict/replace-range-probes/node-atom-read/README.md create mode 100644 edict/replace-range-probes/node-atom-read/edict.application.json create mode 100644 edict/replace-range-probes/node-atom-read/edict.lawpack.json create mode 100644 edict/replace-range-probes/node-atom-read/run.py create mode 100644 edict/replace-range-probes/node-atom-read/src/ReplaceRange.edict diff --git a/edict/replace-range-probes/node-atom-read/Dockerfile b/edict/replace-range-probes/node-atom-read/Dockerfile new file mode 100644 index 00000000..679dc849 --- /dev/null +++ b/edict/replace-range-probes/node-atom-read/Dockerfile @@ -0,0 +1,24 @@ +FROM rust:1.95.0-bookworm AS compiler +RUN apt-get update && apt-get install -y --no-install-recommends python3 \ + && rm -rf /var/lib/apt/lists/* +WORKDIR /edict +RUN git init && git remote add origin https://github.com/flyingrobots/edict.git \ + && git fetch --depth=1 origin 2405a550e93e1e97fff640caa44bbd0f65ffff3c \ + && git archive FETCH_HEAD | tar -x +RUN cargo build --locked -p edict-cli +WORKDIR /echo-source +RUN git init && git remote add origin https://github.com/flyingrobots/echo.git \ + && git fetch --depth=1 origin 49e9efb68001dfd78563d18bac9359a87671e431 \ + && git archive FETCH_HEAD schemas/edict-provider/package/v1 | tar -x + +FROM rust:1.90.0-bookworm AS provider +WORKDIR /echo +RUN git init && git remote add origin https://github.com/flyingrobots/echo.git \ + && git fetch --depth=1 origin 84ccbcec0640f2c7d0565464fd55655007689b42 \ + && git archive FETCH_HEAD | tar -x +RUN cargo run --locked -p echo-wesley-gen --example ordered_publication_witness -- /ordered-provider + +FROM compiler AS witness +COPY --from=provider /ordered-provider /ordered-provider +COPY edict/replace-range-probes/node-atom-read /probe +CMD ["python3", "/probe/run.py"] diff --git a/edict/replace-range-probes/node-atom-read/Dockerfile.dockerignore b/edict/replace-range-probes/node-atom-read/Dockerfile.dockerignore new file mode 100644 index 00000000..7c923dc8 --- /dev/null +++ b/edict/replace-range-probes/node-atom-read/Dockerfile.dockerignore @@ -0,0 +1,5 @@ +** +!edict/ +!edict/replace-range-probes/ +!edict/replace-range-probes/node-atom-read/ +!edict/replace-range-probes/node-atom-read/** diff --git a/edict/replace-range-probes/node-atom-read/README.md b/edict/replace-range-probes/node-atom-read/README.md new file mode 100644 index 00000000..2eb63885 --- /dev/null +++ b/edict/replace-range-probes/node-atom-read/README.md @@ -0,0 +1,67 @@ +# Node atom read and guard probe + +This is authored consumer evidence for +[Echo #740](https://github.com/flyingrobots/echo/issues/740), +[Jedit #296](https://github.com/flyingrobots/jedit/issues/296), and +[PR #302](https://github.com/flyingrobots/jedit/pull/302). It reproduces an +unsupported provider boundary. **It does not implement reads or ReplaceRange.** +The frozen application and producer pins under `edict/replace-range/` remain +unchanged. + +The source requests the opaque atom bytes at an explicit address, compares +them with expected bytes, then returns them. The proposed address contains +32-byte WARP, node, and expected atom-type IDs. Four named failure arms cover +missing data, wrong atom type, non-atom attachments, and the byte bound. The +exported type uses Edict's canonical `Record<...>` syntax with sorted fields. +The output is bounded to 1 MiB. + +`echo.dpo@1.node-atom-read` and its failure coordinates are **proposed** target +contracts. Echo does not implement them. The pure provider configuration is +retained deliberately to identify its refusal boundary; it must not be treated +as permission for stateful execution. The experimental `echo.span-ir/v2` +selection binds the pinned Edict CDDL bytes, not a released semantic profile. + +## Reproduce + +From the repository root, with no host repository mounted into Docker: + +```sh +docker build -f edict/replace-range-probes/node-atom-read/Dockerfile \ + -t jedit-node-atom-read-boundary . +docker run --rm jedit-node-atom-read-boundary +``` + +The Dockerfile fetches exact revisions: + +- Edict `2405a550e93e1e97fff640caa44bbd0f65ffff3c` supplies ordered Target IR. +- Echo `49e9efb68001dfd78563d18bac9359a87671e431` supplies the old provider control. +- Echo `84ccbcec0640f2c7d0565464fd55655007689b42` supplies the public generator + example that assembles and digest-admits an ordered-schema provider candidate. + +The witness uses the public lawpack/application JSONL build API. It checks: + +1. The lawpack builds and its generated digest equals the authored import. +2. The old provider refuses ordered IR at `InvalidProviderInvocation`, naming + `ArtifactSchemaMismatch` and `06-target-ir`. +3. Changing only the provider to the ordered-schema candidate reaches + `ProviderLowererRefused`, naming `UnsupportedSemantics` and + `core.echo-pure-operation`. +4. Neither refusal publishes application outputs; the authored body is unchanged. + +Success prints `JEDIT_NODE_ATOM_READ_PROVIDER_BOUNDARY_CONFIRMED`. That means +the limitation was reproduced, not that an executable read package was emitted. +The harness neither fabricates intermediate artifacts nor substitutes a native +read implementation. + +## What remains + +Echo #740 owns explicit read-capable provider configuration, independent +verification, real bounded evaluation over graph storage, basis/aperture +enforcement, ordered guards, typed failures, and deterministic accounting. +No ordinary caller-provided bytes may stand in for an authorized read view. + +Jim owns fact decoding. Its canonical Buffer head is a field inside an encoded +fact, not the entire atom payload. Returning raw bytes does not supply that head +without the application-owned decoding step. Rope operations, staged writes, +admission, oracle agreement, Tick/WAL/receipts, and recovery remain the parent +issues' requirements. diff --git a/edict/replace-range-probes/node-atom-read/edict.application.json b/edict/replace-range-probes/node-atom-read/edict.application.json new file mode 100644 index 00000000..9bad89fb --- /dev/null +++ b/edict/replace-range-probes/node-atom-read/edict.application.json @@ -0,0 +1,20 @@ +{ + "schema": "edict.application/v1", + "coordinate": "jedit.text.replace_range@1", + "sources": [ + "src/ReplaceRange.edict" + ], + "lawpacks": [ + { + "manifest": "vendor/atom-read/manifest.cbor", + "exports": "vendor/atom-read/exports.cbor", + "adapter": "vendor/atom-read/adapter.cbor", + "targetConfiguration": "vendor/atom-read/echo-operation-configuration.cbor" + } + ], + "target": { + "profile": "echo.dpo@1", + "providerPackage": ".build/echo-provider" + }, + "outputDirectory": ".build/application" +} diff --git a/edict/replace-range-probes/node-atom-read/edict.lawpack.json b/edict/replace-range-probes/node-atom-read/edict.lawpack.json new file mode 100644 index 00000000..d74d67de --- /dev/null +++ b/edict/replace-range-probes/node-atom-read/edict.lawpack.json @@ -0,0 +1,183 @@ +{ + "schema": "edict.lawpack-build/v1", + "outputDirectory": "vendor/atom-read", + "lawpack": { + "schema": "edict.lawpack-authoring/v1", + "id": "jedit.text", + "version": "1", + "acceptedCoreAbi": [ + "edict.core/v1" + ], + "dependencies": [], + "exportsCoordinate": "jedit.text.exports/v1", + "exports": { + "types": [ + { + "coordinate": "jedit.text@1.FactAddress", + "definition": "Record,typeId:Bytes,warpId:Bytes>" + }, + { + "coordinate": "jedit.text@1.FactBytes", + "definition": "Bytes" + }, + { + "coordinate": "jedit.text@1.ObstructionDetail", + "definition": "String" + } + ], + "constants": [], + "pureFunctions": [], + "effects": [ + { + "coordinate": "jedit.text@1.readFact", + "typeParameters": [], + "inputType": "jedit.text@1.FactAddress", + "outputType": "jedit.text@1.FactBytes", + "executionClass": "runtime", + "effectKindHint": "read", + "footprintObligation": "jedit.text@1.replaceRangeFootprint", + "costObligation": "jedit.text@1.replaceRangeBudget", + "effectFailures": { + "missing": { + "authorityClass": "resourceFault", + "payloadType": "jedit.text@1.FactAddress" + }, + "typeMismatch": { + "authorityClass": "integrityFault", + "payloadType": "jedit.text@1.FactAddress" + }, + "notAtom": { + "authorityClass": "integrityFault", + "payloadType": "jedit.text@1.FactAddress" + }, + "tooLarge": { + "authorityClass": "integrityFault", + "payloadType": "jedit.text@1.FactAddress" + } + }, + "guardSupport": true + } + ], + "obstructions": [ + { + "coordinate": "jedit.text@1.BasisNotCanonical", + "authorityClass": "domainMappable", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.FactMissing", + "authorityClass": "resourceFault", + "payloadSchema": "jedit.text@1.ObstructionDetail" + }, + { + "coordinate": "jedit.text@1.FactMalformed", + "authorityClass": "integrityFault", + "payloadSchema": "jedit.text@1.ObstructionDetail" + } + ], + "operationProfiles": { + "jedit.text@1.replaceRange": { + "opticTemplate": { + "opticKind": "affectReintegration", + "boundaryKind": "affect", + "supportPolicy": "jedit.text@1.basisBoundSupport", + "lossDisposition": "jedit.text@1.lossless", + "basisTemplate": "jedit.text@1.exactHeadBasis", + "apertureRequirement": { + "kind": "abstractFootprintObligation", + "reference": "jedit.text@1.replaceRangeFootprint" + } + }, + "effectPredicate": "jedit.text@1.replaceRangeEffects" + } + } + }, + "targetAdapters": [ + { + "coordinate": "jedit.text.echo-adapter/v1", + "output": "adapter.cbor", + "acceptedTargetProfile": { + "id": "echo.dpo@1", + "digest": "sha256:2e2494121aecf5e6a2d920f5fb85408825d394765fad41484c416397c920fb04" + }, + "acceptedTargetIr": { + "id": "echo.span-ir/v2", + "digest": "sha256:123e7f805dc5e831e88befec4cd49ec02c39858b6f3990da8a73b50c6086ae39" + }, + "operationProfiles": { + "jedit.text@1.replaceRange": { + "core": "continuum.profile.read-only/v1", + "semanticEffects": [ + "jedit.text@1.readFact" + ], + "budgetObligation": "jedit.text@1.replaceRangeBudget", + "targetConfiguration": { + "local": "echo-config" + } + } + }, + "effectImplementations": { + "jedit.text@1.readFact": { + "targetIntrinsic": "echo.dpo@1.node-atom-read", + "targetConfiguration": { + "local": "echo-config" + }, + "writeClass": "read", + "footprintObligation": "jedit.text@1.replaceRangeFootprint", + "costObligation": "jedit.text@1.replaceRangeBudget", + "failureMappings": { + "missing": "echo.atom-missing/v1", + "typeMismatch": "echo.atom-type-mismatch/v1", + "notAtom": "echo.atom-required/v1", + "tooLarge": "echo.atom-byte-bound-exceeded/v1" + } + } + }, + "budgets": { + "jedit.text@1.replaceRangeBudget": { + "maxSteps": 1048576, + "maxAllocatedBytes": 16777216, + "maxOutputBytes": 8388608 + } + } + } + ], + "verifier": { + "class": "declarative", + "ruleset": { + "local": "verifier-rules" + } + }, + "compatibility": { + "id": "jedit.text.compatibility/v1", + "digest": "sha256:2adf83f798205f52636ad64ca45178f33a8e1cc663874f8a6113484c945e3052" + }, + "conformanceFixtureCorpus": { + "id": "jedit.text.ReplaceRange.oracle@1", + "digest": "sha256:b9b4707dd5e07897cbe7af36d88928401887e6af5d167d1a88a8d6181b4dbb0e" + }, + "localResources": [ + { + "name": "echo-config", + "coordinate": "echo.operation-lowering-configuration/v1", + "output": "echo-operation-configuration.cbor", + "value": { + "apiVersion": "echo.operation-lowering-configuration/v1", + "programKind": "compiler-produced-bounded-pure/v1" + } + }, + { + "name": "verifier-rules", + "coordinate": "jedit.text.verifier-rules/v1", + "output": "verifier-rules.cbor", + "value": { + "schema": "jedit.text.schema@1", + "schemaDigest": "sha256:f49b0ff6c9c7010d3a72b46734d47832853f496739a083edc41dddec3431bac7", + "oracleIsExecutableInput": false, + "runtimeOntology": "generic-bounded-graph" + } + } + ] + }, + "dependencyBundles": [] +} diff --git a/edict/replace-range-probes/node-atom-read/run.py b/edict/replace-range-probes/node-atom-read/run.py new file mode 100644 index 00000000..12af67b7 --- /dev/null +++ b/edict/replace-range-probes/node-atom-read/run.py @@ -0,0 +1,82 @@ +"""Reproduce the raw atom read/guard boundary through the public Edict CLI.""" + +import hashlib +import json +from pathlib import Path +import shutil +import subprocess +import tempfile + + +def build(root, document, expected_kind=None, required_details=()): + request = { + "schema": "edict.compiler.settings/v1", + "type": "compilerSettings", + "operation": "build", + document: f"edict.{document}.json", + } + result = subprocess.run( + ["/edict/target/debug/edict"], cwd=root, + input=json.dumps(request) + "\n", text=True, capture_output=True, + timeout=120, check=False, + ) + events = [json.loads(line) for stream in (result.stdout, result.stderr) + for line in stream.splitlines()] + diagnostics = [event for event in events if event.get("type") == "diagnostic"] + statuses = [event for event in events if event.get("type") == "status"] + expected_code = 0 if expected_kind is None else 2 + if (result.returncode != expected_code or len(statuses) != 1 + or statuses[0].get("exitCode") != expected_code): + raise RuntimeError(f"Unexpected public build result: {result}") + if expected_kind is None: + if diagnostics: + raise RuntimeError(f"Lawpack build produced diagnostics: {diagnostics}") + elif (len(diagnostics) != 1 or diagnostics[0].get("kind") != expected_kind + or any(detail not in diagnostics[0].get("message", "") + for detail in required_details)): + raise RuntimeError(f"Unexpected refusal boundary: {diagnostics}") + if document == "application": + output = root / ".build/application" + if output.exists() and any(output.rglob("*")): + raise RuntimeError("Refused build published application artifacts") + for event in events: + print(json.dumps(event, sort_keys=True), flush=True) + + +def main(): + if not Path("/.dockerenv").is_file(): + raise RuntimeError("Run with the COPY-based node-atom-read Dockerfile") + source = Path("/probe") + definition = json.loads((source / "edict.lawpack.json").read_text()) + selection = definition["lawpack"]["targetAdapters"][0]["acceptedTargetIr"] + schema = Path("/edict/docs/abi/edict-target-ir.cddl").read_bytes() + if selection != { + "id": "echo.span-ir/v2", + "digest": "sha256:" + hashlib.sha256(schema).hexdigest(), + }: + raise RuntimeError("Probe does not select the pinned experimental IR contract") + with tempfile.TemporaryDirectory(prefix="jedit-atom-read-") as scratch: + root = Path(scratch) + for document in ("edict.lawpack.json", "edict.application.json"): + shutil.copyfile(source / document, root / document) + shutil.copytree(source / "src", root / "src") + build(root, "lawpack") + digest = (root / "vendor/atom-read/manifest.sha256").read_text().strip() + authored = (root / "src/ReplaceRange.edict").read_text() + if authored.count(f'digest "{digest}"') != 1: + raise RuntimeError("Authored lawpack import does not match generated bytes") + provider = root / ".build/echo-provider" + shutil.copytree("/echo-source/schemas/edict-provider/package/v1", provider) + build(root, "application", "InvalidProviderInvocation", + ("ArtifactSchemaMismatch", "06-target-ir")) + shutil.rmtree(provider) + shutil.copytree("/ordered-provider", provider) + build(root, "application", "ProviderLowererRefused", + ("UnsupportedSemantics", "core.echo-pure-operation")) + if (root / "src/ReplaceRange.edict").read_text() != authored: + raise RuntimeError("Witness changed the authored operation") + print("JEDIT_NODE_ATOM_READ_PROVIDER_BOUNDARY_CONFIRMED", flush=True) + + +if __name__ == "__main__": + main() diff --git a/edict/replace-range-probes/node-atom-read/src/ReplaceRange.edict b/edict/replace-range-probes/node-atom-read/src/ReplaceRange.edict new file mode 100644 index 00000000..dd33b7f7 --- /dev/null +++ b/edict/replace-range-probes/node-atom-read/src/ReplaceRange.edict @@ -0,0 +1,18 @@ +package jedit.text.replace_range@1; +use lawpack jedit.text@1 digest "sha256:add46dc12d57a1df57847d501092b2d91dceab011d8781a747ed39437b01737e" as text; +type Input = { address: text.FactAddress, expected: text.FactBytes }; +intent replaceRange(input: Input) returns text.FactBytes + profile text.replaceRange + basis input.address.nodeId + budget <= text.replaceRangeBudget +{ + let actual: text.FactBytes = text.readFact(input.address) + else { + missing(address) => text.FactMissing, + typeMismatch(address) => text.FactMalformed, + notAtom(address) => text.FactMalformed, + tooLarge(address) => text.FactMalformed, + }; + require actual == input.expected else text.BasisNotCanonical; + return actual; +} From 381cd4cdba3cb9be10070ec0ddd674d1d2646317 Mon Sep 17 00:00:00 2001 From: James Ross Date: Sun, 4 Oct 2026 16:40:38 -0700 Subject: [PATCH 16/30] test(edict): pin authored leaf byte-slice compiler pressure --- .../leaf-slice/LeafSlice.edict | 24 + .../replace-range-probes/leaf-slice/README.md | 100 ++++ .../leaf-slice/cases.json | 18 + .../leaf-slice/evidence/compiler-source.json | 446 ++++++++++++++++++ .../leaf-slice/evidence/public-build-red.json | 54 +++ edict/replace-range-probes/leaf-slice/run.py | 128 +++++ 6 files changed, 770 insertions(+) create mode 100644 edict/replace-range-probes/leaf-slice/LeafSlice.edict create mode 100644 edict/replace-range-probes/leaf-slice/README.md create mode 100644 edict/replace-range-probes/leaf-slice/cases.json create mode 100644 edict/replace-range-probes/leaf-slice/evidence/compiler-source.json create mode 100644 edict/replace-range-probes/leaf-slice/evidence/public-build-red.json create mode 100644 edict/replace-range-probes/leaf-slice/run.py diff --git a/edict/replace-range-probes/leaf-slice/LeafSlice.edict b/edict/replace-range-probes/leaf-slice/LeafSlice.edict new file mode 100644 index 00000000..63b51745 --- /dev/null +++ b/edict/replace-range-probes/leaf-slice/LeafSlice.edict @@ -0,0 +1,24 @@ +package jedit.text.replace_range@1; + +use lawpack jedit.text@1 digest "sha256:95758c1605894672cc9069fde01bb8b6e11842b053102660c9cd4f4d6f34d64e" as text; + +type Input = { + blobBytes: Bytes, + startByte: U64, + endByte: U64, +}; + +type LeafBytes = { + bytes: Bytes, +}; + +intent sliceLeaf(input: Input) returns LeafBytes + profile text.replaceRange + basis none + budget <= text.replaceRangeBudget + where input.startByte <= input.endByte, + input.endByte <= len(input.blobBytes) +{ + let bytes = slice(input.blobBytes, input.startByte, input.endByte); + return { bytes }; +} diff --git a/edict/replace-range-probes/leaf-slice/README.md b/edict/replace-range-probes/leaf-slice/README.md new file mode 100644 index 00000000..1c19b44a --- /dev/null +++ b/edict/replace-range-probes/leaf-slice/README.md @@ -0,0 +1,100 @@ +# Authored leaf-byte slicing pressure + +`LeafSlice.edict` isolates the byte extraction used by persistent leaf splitting +in [Jim #296](https://github.com/flyingrobots/jedit/issues/296). It is an authored +compiler input, not a completed rope operation or a native callback. + +The frozen [fact law](../../../contracts/jedit/lawpacks/replace-range-v1/text-schema-v1.json) +stores a leaf's `blob_id`, `byte_start`, and `byte_length`. The existing +[`locate_leaf_slice` and `make_leaf_slice`](../../../native/jedit-echo-host/src/rope/tree.rs) +first check absolute offsets, extract the half-open byte range, validate UTF-8, +and derive metrics. This source isolates extraction after absolute offsets have +been obtained. It does not decode facts, validate UTF-8, derive metrics, or +publish a new leaf. + +The proposed generic primitive is `slice(bytes, start, end)`. Offsets are U64; +the result retains the operand's maximum byte bound and drops any exact-length +refinement. The source requires `start <= end` and `end <= len(bytes)` before +evaluation. Invalid inputs must fail ordinary input constraints, without +clipping, truncation, wrapping, or a host panic. A slice inside a UTF-8 code +point is still a lawful byte slice; Jim's later UTF-8 validation owns rejection +as a text operation. + +[`cases.json`](cases.json) records literal future runtime expectations, including +empty, full, interior, binary, Unicode, invalid-range, and U64-limit inputs. +They are not claimed to have executed. The file is a conformance specification, never +an executable lawpack input or a substitute for the retained 40-case rope +oracle. + +## Current boundary + +Source inspection of Edict main `ac63fe679973e8119244471c124cde44dea5984f` +found no implementation of this primitive. Its closed Bytes prelude currently +provides comparison and length. Its source compiler also rejects Option types, +so the first capability uses explicit range proofs instead of relying on an +unavailable Option result. + +The [retained public-build result](evidence/public-build-red.json) uses the +already built experimental compiler `2405a550e93e1e97fff640caa44bbd0f65ffff3c`, +with the unchanged Echo provider from `49e9efb68001dfd78563d18bac9359a87671e431`. +It does **not** use or replace the frozen application's `3f81f759` compiler pin. +The witness checks all 440 copied compiler-source files against their Git blob +identities before and after execution and records the existing binary hash. +It reuses that binary; this run does not reproduce its compilation. + +| Authored input | Public build result | +| --- | --- | +| Frozen boundary source | Exit 0; executable package and separate verification report | +| Leaf source with only the `slice(...)` expression replaced by `input.blobBytes` | Exit 0; executable package and separate verification report | +| Exact `LeafSlice.edict` | Exit 2; `ApplicationCompilationFailed`, with `TypeCheck` / `UnresolvedFunction`: `pure helper \`slice\` has no compiler context fact`; no application artifacts | + +The primary source diagnostic covers bytes 521–575, the call at line 22. The +following unresolved-binding and return diagnostics are cascading failures. +The paired control proves the range constraints and output shape compile; the +new slice expression is the first missing source capability. Neither control +package was evaluated during this run. + +The first harness run incorrectly expected the guarded control to reach a +provider refusal. Its actual successful build disproved that expectation. The +harness assertion was corrected, with no source change, and the full paired +witness passed with `JIM_LEAF_SLICE_SOURCE_BOUNDARY_CONFIRMED`. + +The frozen `edict/replace-range/` application, lawpack closure, producer pins, +and artifact locks remain authoritative for the existing pure-boundary witness. +This development source imports the same published lawpack in an isolated copy. +It does not repin or regenerate that application. + +## Reproduction discipline + +Use copied inputs in the existing guarded project Docker worker. Do not build +another image or use the older probe Dockerfiles as the default recipe: those +historical recipes bake Cargo output into image layers. Reuse the compiler and +provider only after identifying their exact source/build coordinates; retain +outputs outside image layers in the project's bounded owned storage. Follow the +shared lease, disk, memory, process, and log limits before invocation. + +Copy this directory and the unchanged application root into the worker, then +run the following command inside the guarded lease. The compiler-source root +must contain the copied `2405a550` tree; the provider root must be the pinned +`49e9efb` package. Use a fresh `work-root` under the existing accounted directory. + +```sh +python3 "$PROBE_ROOT/run.py" \ + --compiler "$EDICT_BINARY" \ + --compiler-source "$EDICT_SOURCE" \ + --compiler-manifest "$PROBE_ROOT/evidence/compiler-source.json" \ + --application-source "$APPLICATION_SOURCE" \ + --provider-package "$PROVIDER_PACKAGE" \ + --work-root /tmp/echo-726-runtime/jim-leaf-slice-proof +``` + +The source manifest is a read-only export of `git ls-tree -r` at `2405a550`, +not a compiler input. Its retained formatting differs from the original run's +manifest, so its raw file digest differs; its commit, tree, 440 paths, and blob +identities are unchanged. Logs and an evidence JSON file remain under the work +root. The runner's log-size check supplements the mandatory external resource +guard; it is not a disk quota or permission to run without the guard. + +Passing this refusal witness identifies the compiler boundary. Accepted slice +compilation, independent verification, generic execution of the literal cases, +and complete rope acceptance remain separate gates. diff --git a/edict/replace-range-probes/leaf-slice/cases.json b/edict/replace-range-probes/leaf-slice/cases.json new file mode 100644 index 00000000..298fb677 --- /dev/null +++ b/edict/replace-range-probes/leaf-slice/cases.json @@ -0,0 +1,18 @@ +{ + "schema": "jedit.leaf-byte-slice-cases/v1", + "operation": "jedit.text.replace_range@1.sliceLeaf", + "cases": [ + {"name": "empty-blob", "blobHex": "", "startByte": "0", "endByte": "0", "bytesHex": ""}, + {"name": "full-blob", "blobHex": "61626364", "startByte": "0", "endByte": "4", "bytesHex": "61626364"}, + {"name": "interior", "blobHex": "61626364", "startByte": "1", "endByte": "3", "bytesHex": "6263"}, + {"name": "empty-interior", "blobHex": "61626364", "startByte": "2", "endByte": "2", "bytesHex": ""}, + {"name": "empty-at-end", "blobHex": "61626364", "startByte": "4", "endByte": "4", "bytesHex": ""}, + {"name": "binary-octets", "blobHex": "00017fff80", "startByte": "2", "endByte": "5", "bytesHex": "7fff80"}, + {"name": "unicode-codepoint", "blobHex": "61f09f98ba62", "startByte": "1", "endByte": "5", "bytesHex": "f09f98ba"}, + {"name": "inside-codepoint-remains-bytes", "blobHex": "61f09f98ba62", "startByte": "2", "endByte": "4", "bytesHex": "9f98"}, + {"name": "reversed", "blobHex": "61626364", "startByte": "3", "endByte": "2", "refusal": "input-constraint"}, + {"name": "end-past-blob", "blobHex": "61626364", "startByte": "1", "endByte": "5", "refusal": "input-constraint"}, + {"name": "both-past-blob", "blobHex": "61626364", "startByte": "5", "endByte": "5", "refusal": "input-constraint"}, + {"name": "u64-max", "blobHex": "61626364", "startByte": "0", "endByte": "18446744073709551615", "refusal": "input-constraint"} + ] +} diff --git a/edict/replace-range-probes/leaf-slice/evidence/compiler-source.json b/edict/replace-range-probes/leaf-slice/evidence/compiler-source.json new file mode 100644 index 00000000..d0b18a0d --- /dev/null +++ b/edict/replace-range-probes/leaf-slice/evidence/compiler-source.json @@ -0,0 +1,446 @@ +{ + "commit": "2405a550e93e1e97fff640caa44bbd0f65ffff3c", + "tree": "257d3e6aa10c2248fdbddaa8e9b3638866396169", + "files": [ + {"path":".cargo/config.toml","gitBlob":"5592118f6c54bf8b53b16848e04ece896dd56384"}, + {"path":".github/workflows/auto-release-tag.yml","gitBlob":"87404ceb685191afd496c93494b0bc61e2a59504"}, + {"path":".github/workflows/ci.yml","gitBlob":"c6c6a17f59b6b96db88e3d4b2775bc64b7fe01f3"}, + {"path":".github/workflows/release.yml","gitBlob":"2c612fc786998bfa5b11e76ae1185114a7cc535f"}, + {"path":".gitignore","gitBlob":"30d7faf0fc8b7f010f99280302d4ed269d5da9ba"}, + {"path":".markdownlint.json","gitBlob":"f3ec2c8dc2fbacc425154a2baedec50c7474aefa"}, + {"path":"AGENTS.md","gitBlob":"0c48a5794454cf84e20640994a372316efde7bb5"}, + {"path":"ARCHITECTURE.md","gitBlob":"5b513dd25028092e7e75c8974f1d5f3cc31889ed"}, + {"path":"CHANGELOG.md","gitBlob":"9cc14cfa4891c9ff5167c569bb80567e8f670e0d"}, + {"path":"CODE_OF_CONDUCT.md","gitBlob":"784cf2799bcf8d2a69db5f5781359ef7e18a05fc"}, + {"path":"CONTRIBUTING.md","gitBlob":"9676914060f734dc59eabd9075898dc8170d4d19"}, + {"path":"Cargo.lock","gitBlob":"bacb208de0583f182379af7b5e078d31b25e2ca5"}, + {"path":"Cargo.toml","gitBlob":"b2e7106eb78f79230c091492ef21b497bdc9ed19"}, + {"path":"EDICT.md","gitBlob":"35376134195082d506f0161ba7ecb97efa8b770a"}, + {"path":"LICENSE","gitBlob":"261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64"}, + {"path":"NOTICE","gitBlob":"c300687bdd9d931d1f257d291e1cb6ff9d7d3607"}, + {"path":"README.md","gitBlob":"0812ef9a0c4611bf655dfc67d2ecc3631af9a536"}, + {"path":"ROADMAP.md","gitBlob":"d0e0135780537afab1d1a3f53808b363b35a63f4"}, + {"path":"SECURITY.md","gitBlob":"0bcc4e7375442e1334405a2d046df316cee05cd5"}, + {"path":"crates/edict-cli/Cargo.toml","gitBlob":"e9d844553c395bd312f84e806eb5bac30c5c3a54"}, + {"path":"crates/edict-cli/src/application_build.rs","gitBlob":"9c56ae6b4dd4eef0b9fe6db40316e100b2ffa699"}, + {"path":"crates/edict-cli/src/lawpack_build.rs","gitBlob":"55e9579153f34a3d5b139141c9de6640808cd386"}, + {"path":"crates/edict-cli/src/lawpack_build_windows.rs","gitBlob":"f71d03b368ae83becc1608bbba11cd5f1afa4f07"}, + {"path":"crates/edict-cli/src/lib.rs","gitBlob":"60883af60cf4b441680952ecce7ef4fcbfeabb97"}, + {"path":"crates/edict-cli/src/main.rs","gitBlob":"0dd9776642c4090479322111e4164ee7049fb9d0"}, + {"path":"crates/edict-cli/tests/golden_cli.rs","gitBlob":"9897caad3bcc6fa8bb0f20a1d0e18032285b1fa7"}, + {"path":"crates/edict-cli/tests/jsonl_cli.rs","gitBlob":"9ed353ca27d073fc7da49d3800c81ba4c58edd5d"}, + {"path":"crates/edict-cli/tests/lawpack_authoring_cli.rs","gitBlob":"dd7d7bfebf0e051c77d894a55c0204d373b19c63"}, + {"path":"crates/edict-provider-host-wasmtime/Cargo.toml","gitBlob":"ebeeb941f09012293d9923fe0e6039b2761b328e"}, + {"path":"crates/edict-provider-host-wasmtime/src/conversion.rs","gitBlob":"62c3cd4a85eb156b8c9a405ef3ea4d8a09b80cc3"}, + {"path":"crates/edict-provider-host-wasmtime/src/invocation.rs","gitBlob":"a4d6680d289094afebc0f1063abccf706f8149db"}, + {"path":"crates/edict-provider-host-wasmtime/src/lib.rs","gitBlob":"353ea7394f265219ebdecad56a3070c9e7d2685c"}, + {"path":"crates/edict-provider-host-wasmtime/src/limits.rs","gitBlob":"9e4d12c1b606d2b180f732db17bfbc78f8e26e3a"}, + {"path":"crates/edict-provider-host-wasmtime/src/replay.rs","gitBlob":"b8fa7be7c7ee5039793dad4cd0fa6a4f14ce388e"}, + {"path":"crates/edict-provider-host-wasmtime/tests/invocation.rs","gitBlob":"7a59a3192852a80bc01221ebf3dd1c437bda9508"}, + {"path":"crates/edict-provider-host-wasmtime/tests/preflight.rs","gitBlob":"a295e7547b0294f0355a85d5b9b8d045c8fceefd"}, + {"path":"crates/edict-provider-schema/Cargo.toml","gitBlob":"0e74f58acdc054ecce192cb8341afeaddc40deb5"}, + {"path":"crates/edict-provider-schema/src/contract_pack.rs","gitBlob":"370480d9c606134dd08ee62ae29ef143941e2f54"}, + {"path":"crates/edict-provider-schema/src/lib.rs","gitBlob":"51f5bee8892c9fb2122cb20022edc4d414759ff7"}, + {"path":"crates/edict-provider-schema/src/recursive_dispatch.rs","gitBlob":"6d97565b96f941b359d16f7a1c201189968fbeff"}, + {"path":"crates/edict-provider-schema/src/schema_safety.rs","gitBlob":"a2f605f62a2bfedcb84b68e37db9ff84b1dc3b05"}, + {"path":"crates/edict-provider-schema/tests/authority_facts_abi.rs","gitBlob":"7dd4d0302805ceecffc2045cdb91e386f8e08517"}, + {"path":"crates/edict-provider-schema/tests/provider_contract_pack.rs","gitBlob":"a26be8054b39215048825dd8cae7e9bddcfe27c9"}, + {"path":"crates/edict-provider-schema/tests/registry.rs","gitBlob":"bdd13ec00e441aef9e67ba49f6592ecbc7dcb303"}, + {"path":"crates/edict-syntax/Cargo.toml","gitBlob":"f55bb23e528af78b1e97b52f9b72cbd876a44ba7"}, + {"path":"crates/edict-syntax/src/admission.rs","gitBlob":"471430dd13a617bac886fcd44afbf15263e7db3b"}, + {"path":"crates/edict-syntax/src/ast.rs","gitBlob":"2a5d208a53a82408f8a18d9a13ccb133ec6a7a2e"}, + {"path":"crates/edict-syntax/src/authority_facts.rs","gitBlob":"644de86d63983bdbfbf1279fdbf1dbdaecc151d5"}, + {"path":"crates/edict-syntax/src/canonical.rs","gitBlob":"6fb29d50ea4a55eb888a1b9600cdcb31713a6e20"}, + {"path":"crates/edict-syntax/src/compiler.rs","gitBlob":"7d2ef5f503aef28b6878467749200aea99843114"}, + {"path":"crates/edict-syntax/src/compiler/byte_length.rs","gitBlob":"0d8d6291064415baee9253d9fe1e11ad87945773"}, + {"path":"crates/edict-syntax/src/compiler/unsigned_subtraction.rs","gitBlob":"e714094b05f69559ec69f1b9b45fb054d06c1919"}, + {"path":"crates/edict-syntax/src/contract_bundle.rs","gitBlob":"9a31645f0e30879d019787e29c21c82eebf58129"}, + {"path":"crates/edict-syntax/src/core_ir.rs","gitBlob":"119d69b75914db1357030ccc5aecb90448fe8f24"}, + {"path":"crates/edict-syntax/src/highlight.rs","gitBlob":"28b3f7dcdfe8d4982bdcfb05759f769ccdbffc7f"}, + {"path":"crates/edict-syntax/src/lawpack.rs","gitBlob":"54f85bda48c960ad0b7bc316d332b379ab5b6ae0"}, + {"path":"crates/edict-syntax/src/lawpack_adapter.rs","gitBlob":"e425960e2437faa2f9eeb5d089ff507417d39586"}, + {"path":"crates/edict-syntax/src/lawpack_authoring.rs","gitBlob":"11ff578f458b8a4c8e4df75c0c616e37fa468d49"}, + {"path":"crates/edict-syntax/src/lib.rs","gitBlob":"7323475cc7f846e11c2d73f4c26a5e581b7e6157"}, + {"path":"crates/edict-syntax/src/lowerability.rs","gitBlob":"c6a1323fd6a79b0460b43aaf338956c3906a633e"}, + {"path":"crates/edict-syntax/src/parser.rs","gitBlob":"0b3650e3012e49023ccbb9cc9effe9b5b102f19d"}, + {"path":"crates/edict-syntax/src/provider.rs","gitBlob":"18fa661d880979c53dd335fb7e68d5445b638d4c"}, + {"path":"crates/edict-syntax/src/provider_invocation.rs","gitBlob":"2526168f0a6f2d1d9b6181b689ff43e203434122"}, + {"path":"crates/edict-syntax/src/provider_lowering.rs","gitBlob":"50a4e60b561127cb8c78e3f7c04c6bbaca068e52"}, + {"path":"crates/edict-syntax/src/result_projection.rs","gitBlob":"79ba246d4c58960fe368eaca4c7d135fe187832a"}, + {"path":"crates/edict-syntax/src/semantic.rs","gitBlob":"3314c1ac95904d2b3d92cd67a9d7babad5182123"}, + {"path":"crates/edict-syntax/src/target_ir.rs","gitBlob":"c6cac206a5e4342ebda323070d3dc18baf68a3ce"}, + {"path":"crates/edict-syntax/src/target_ir/byte_length.rs","gitBlob":"84e93d15c61936061323485a8408d3f1fbf95f55"}, + {"path":"crates/edict-syntax/src/target_ir/execution_order.rs","gitBlob":"e69a28805dc5e414a64afdaafee34161c217a044"}, + {"path":"crates/edict-syntax/src/target_ir/unsigned_subtraction.rs","gitBlob":"2170e31b98dfa7ab48a0441a2355e9824b3fcab6"}, + {"path":"crates/edict-syntax/src/target_profile.rs","gitBlob":"dd514f7380243e795f0655a78aecd06ee3fa2eda"}, + {"path":"crates/edict-syntax/src/target_profile_contract_resources.rs","gitBlob":"4efd22961c2fd7591440efd6087944ecaf21e991"}, + {"path":"crates/edict-syntax/src/token.rs","gitBlob":"2768586eea6d42d5df357c4cc62a011ee7f455de"}, + {"path":"crates/edict-syntax/tests/admission.rs","gitBlob":"57edbc320307c1d6daba85f03d8dc79558d7b849"}, + {"path":"crates/edict-syntax/tests/authority_facts.rs","gitBlob":"add9d272be6e8eb1cd6fdde2999a5fb452ecd852"}, + {"path":"crates/edict-syntax/tests/authority_facts_cbor.rs","gitBlob":"7359f047d9f731fee208efb5f69072b612d69547"}, + {"path":"crates/edict-syntax/tests/byte_length.rs","gitBlob":"032a62da58ae4ef933ef9dcd92d6510f627ff102"}, + {"path":"crates/edict-syntax/tests/canonical_encoding.rs","gitBlob":"e4c5d59a88f88193f522eb555359919f7034a264"}, + {"path":"crates/edict-syntax/tests/common/mod.rs","gitBlob":"89560bfacb3dab031485c2dfa30d7eb325966574"}, + {"path":"crates/edict-syntax/tests/compiler_spine.rs","gitBlob":"2237318cfc0d4209e8a629e45320e42a4b72dbef"}, + {"path":"crates/edict-syntax/tests/contract_bundle.rs","gitBlob":"e6a2948335a0efc86d8bbb2e9e2c3d634e53965a"}, + {"path":"crates/edict-syntax/tests/core_golden_fixtures.rs","gitBlob":"0e0e42d19b52dc0557902dad9e1b85f37edf53f8"}, + {"path":"crates/edict-syntax/tests/external_action_requests.rs","gitBlob":"3c07be4db0bfc49e67c2d7e1eda0ac0397987a37"}, + {"path":"crates/edict-syntax/tests/highlighting.rs","gitBlob":"17e6b9ba08c96f0efb6efd440590f0fc917316e2"}, + {"path":"crates/edict-syntax/tests/lawpack.rs","gitBlob":"a675999ed96309358c8552a9d32781b5eede20dc"}, + {"path":"crates/edict-syntax/tests/lawpack_authoring.rs","gitBlob":"3a905cbd6d7d2625bc1d7826a6f6f1e991efbab0"}, + {"path":"crates/edict-syntax/tests/lowerability.rs","gitBlob":"5cfa58f5cbc51cccc7f119caddc1c3fcbc2e4806"}, + {"path":"crates/edict-syntax/tests/operation_prerequisites.rs","gitBlob":"753659e1a6e7751c455b8518226fa0902157a745"}, + {"path":"crates/edict-syntax/tests/parse_control_flow.rs","gitBlob":"5245561866d8902c1fbd5ab21f2e34807d568e17"}, + {"path":"crates/edict-syntax/tests/parse_greeting.rs","gitBlob":"f214d0c17745b8203d562780caa8f37b71c1e62c"}, + {"path":"crates/edict-syntax/tests/parse_hello.rs","gitBlob":"bf7b1b065277188f4be8754eb11ace94298394ba"}, + {"path":"crates/edict-syntax/tests/parse_keywords.rs","gitBlob":"78d8a64d785136d42a32655afda3df240c54f884"}, + {"path":"crates/edict-syntax/tests/parse_loops.rs","gitBlob":"d9ece2fce96fd6835d080055f06955d139c7e0ce"}, + {"path":"crates/edict-syntax/tests/parse_negative.rs","gitBlob":"17fdb983b8250470368a8f19d3a7bd9680052548"}, + {"path":"crates/edict-syntax/tests/parse_review_regressions.rs","gitBlob":"560215cfe044a528e190aa1ea7670e52b9365bdf"}, + {"path":"crates/edict-syntax/tests/parse_variants.rs","gitBlob":"8849f68f5ca1e2b06d0f66496e59b20d1c0fd022"}, + {"path":"crates/edict-syntax/tests/provider.rs","gitBlob":"7e8a596109b1e1fd3f22b3a0ef82f4755f127291"}, + {"path":"crates/edict-syntax/tests/provider_invocation.rs","gitBlob":"402647dd6701be65a9e693fd3f5688f26d84988e"}, + {"path":"crates/edict-syntax/tests/provider_lowering.rs","gitBlob":"411c306f3ab641de9dc2f7aed229767eba9dbd72"}, + {"path":"crates/edict-syntax/tests/result_projection.rs","gitBlob":"a74dd2a419266cb77d846d83da27f726095660f1"}, + {"path":"crates/edict-syntax/tests/semantic_validation.rs","gitBlob":"a127988d178c00ed12a0a25f70df6b7fd5e6d931"}, + {"path":"crates/edict-syntax/tests/target_ir.rs","gitBlob":"928e1cf921dead0b559bd115bb6eef3faaddd37e"}, + {"path":"crates/edict-syntax/tests/target_ir/ordered.rs","gitBlob":"a1b05db81a97a43ec5a2dc2d9bcc9578bc286f30"}, + {"path":"crates/edict-syntax/tests/target_profile.rs","gitBlob":"42f1c907f6c60dea1e8a9b4558b56ffd0b3a59ab"}, + {"path":"crates/edict-syntax/tests/target_profile_contract_resources.rs","gitBlob":"270c180a12dc10fb7e208cc4dc1e202da82c85fb"}, + {"path":"crates/edict-syntax/tests/target_unsigned_subtraction.rs","gitBlob":"6884e55a45baa4f423056a10b6dea9f8b08fb60f"}, + {"path":"crates/edict-syntax/tests/unsigned_subtraction.rs","gitBlob":"b4b870cea63f440a52c949529077336a0b58b4ee"}, + {"path":"crates/edict/Cargo.toml","gitBlob":"525403f4f36db4040531e4dd747ec2398f9052cd"}, + {"path":"crates/edict/README.md","gitBlob":"a1ecf50bff3443d25a23fabfa6374d3f0a28ca82"}, + {"path":"crates/edict/src/lib.rs","gitBlob":"169d820759d6333f27a45ebb712bfcc4f0115107"}, + {"path":"crates/edict/tests/artifact_models.rs","gitBlob":"b923109c7195ce2c0071dc54179f0746b95329f0"}, + {"path":"crates/edict/tests/public_surface.rs","gitBlob":"a24c4bc9d9484f540da9b280790896701922968a"}, + {"path":"deny.toml","gitBlob":"e3f0f54060cead9a0d48b96ed86948d0909c4f78"}, + {"path":"docs/DESIGN_runtime-neutral-edict-sha-lock-assurance.md","gitBlob":"ea3badf78ebd19545147a93671fdb5f9af4a61ea"}, + {"path":"docs/GUIDE_edict-assurance-transparency.md","gitBlob":"100321157ec43055c45794f1c161b1e5281ba6b4"}, + {"path":"docs/README.md","gitBlob":"e21739b842be14d91a17f2508b1a1b629754af01"}, + {"path":"docs/REQUIREMENTS.md","gitBlob":"a00535b05e265bca945229debabd36e2e36016bf"}, + {"path":"docs/RETRO_phase1-parser.md","gitBlob":"5cfb7b85ca2f140fc58f9186c47e4635e94a1e6f"}, + {"path":"docs/SPEC_continuum-admission-v1.md","gitBlob":"0a74a0bfc642337d5d7a85133ce50a0a22caffbd"}, + {"path":"docs/SPEC_continuum-contract-bundle-v1.md","gitBlob":"65b36bb33a34beb1f246d1f97384631c83ca631e"}, + {"path":"docs/SPEC_edict-language-v1.md","gitBlob":"a8187fa158f8f510a364dc40e5fee2e7c390f675"}, + {"path":"docs/SPEC_edict-lawpack-abi-v1.md","gitBlob":"ea1d801f07ab3677f7a411a1f58a28feda589ec3"}, + {"path":"docs/SPEC_edict-target-profile-abi-v1.md","gitBlob":"91687bfe45565a21f5f93f6ce9eed84095268691"}, + {"path":"docs/TECHNICAL_EXPLANATION.md","gitBlob":"d88561c0552c0e75d1ecc2eef6f9afd003e99674"}, + {"path":"docs/abi/edict-authority-facts.cddl","gitBlob":"e9a6d8685706ae0d8dabda401655234161e94299"}, + {"path":"docs/abi/edict-common.cddl","gitBlob":"836c11b92425beb6d42b378c0defe6f02d144dd7"}, + {"path":"docs/abi/edict-core.cddl","gitBlob":"862f02939fcc3858b4a60cb75f9bf149eae8ffda"}, + {"path":"docs/abi/edict-lawpack-adapter.cddl","gitBlob":"8e887c2e196ba7502470ddb45dc7cfd10116ad6b"}, + {"path":"docs/abi/edict-lawpack.cddl","gitBlob":"96efd51d437ec785b108b51835e9e8bf87aeab51"}, + {"path":"docs/abi/edict-result-projection.cddl","gitBlob":"98b5c2e861e7e9b66b7481502287cb041f6e77e6"}, + {"path":"docs/abi/edict-target-ir.cddl","gitBlob":"98134f277ded1920a3a36e5e3946c51153f2e84d"}, + {"path":"docs/abi/edict-target-profile.cddl","gitBlob":"746ae03001310f3a83524e5332819dad1a4eea5a"}, + {"path":"docs/abi/edict-target-provider.wit","gitBlob":"0efa5903a52d38dc61e429619d86322c6c5f1fa0"}, + {"path":"docs/audit/2026-06-28_code-quality.md","gitBlob":"143cbf4f4491a76a6649e919c6edaba73f0bcf4b"}, + {"path":"docs/audit/2026-06-28_documentation-quality.md","gitBlob":"656b4fa8dea43306af1818f8622cafd72e82a370"}, + {"path":"docs/audit/2026-06-28_ship-readiness.md","gitBlob":"b9d34a8693564d0134f550092e7645e5d5137442"}, + {"path":"docs/design/authority-fact-governance.md","gitBlob":"8531061cf718c47ec791f5712b2f357d92adc9e4"}, + {"path":"docs/design/canonical-target-ir-v0.11.md","gitBlob":"a46acb84e3523b51e2348c776cfdb63a8b98107a"}, + {"path":"docs/design/contract-bundle-assembly-v0.11.md","gitBlob":"a364f8ade5445808f87cf0c63ab3484c03ad616a"}, + {"path":"docs/design/crate-scope-v0.11.md","gitBlob":"92fe92285d02465d84bbe82e29d051fdc461f3a6"}, + {"path":"docs/design/obstruction-strands-v0.md","gitBlob":"81f70fd688c12798cd23472a4e810191e61eabe2"}, + {"path":"docs/design/provider-artifact-pipeline-alpha.md","gitBlob":"60eefa7dc160aba986bcd1188b79610ff5e9f299"}, + {"path":"docs/design/schema-as-sot-codegen.md","gitBlob":"d818e0e3f1fafd1d3aba26cb37c739f3ebe69763"}, + {"path":"docs/design/v2-obligation-closure.md","gitBlob":"816d22d843a33c6f7e143da4cb45e80679609dc8"}, + {"path":"docs/releases/v0.1.0-alpha.1.md","gitBlob":"5dd96057ba7f109cf5e5acde16e29d18627f98d3"}, + {"path":"docs/releases/v0.10.0-alpha.1.md","gitBlob":"363c4e9ed6f5ea5758198c7124681b520098e583"}, + {"path":"docs/releases/v0.11.0-alpha.1.md","gitBlob":"4612dbb5a1aaf20710bdb199b658ded7ced4ebab"}, + {"path":"docs/releases/v0.2.0-alpha.1.md","gitBlob":"7302ef93ed5ff9b562d9cec92d49d85a6b789b27"}, + {"path":"docs/releases/v0.3.0-alpha.1.md","gitBlob":"bf023ba4ca2c38f0120c461781447d58fe239ae0"}, + {"path":"docs/releases/v0.4.0-alpha.1.md","gitBlob":"769500b59800c02c536b76b0eb850d06d6cd8f58"}, + {"path":"docs/releases/v0.5.0-alpha.1.md","gitBlob":"7c7354e89846ea816992aaf55d4ad04367d61a10"}, + {"path":"docs/releases/v0.6.0-alpha.1.md","gitBlob":"3f2a0edfc4bccd9f3c60a7443ef4f8cbcbac1971"}, + {"path":"docs/releases/v0.7.0-alpha.1.md","gitBlob":"57671d5ef5a6b9f16d1674e0a35ddeb86ff126a8"}, + {"path":"docs/releases/v0.8.0-alpha.1.md","gitBlob":"12f77bda185c54fbbd136bf0dc7292716ecdfa39"}, + {"path":"docs/releases/v0.9.0-alpha.1.md","gitBlob":"fa295fcf0967415bb052f238256919b32b3fe6ba"}, + {"path":"docs/schemas/edict.cli-check-result.v1.schema.json","gitBlob":"eef8cd11f07e06d68b7051efa60ae05f2cfd8a63"}, + {"path":"docs/schemas/edict.cli-diagnostic.v1.schema.json","gitBlob":"92a2151a76893c598a4191ed6cecd8a0e671613f"}, + {"path":"docs/schemas/edict.cli-event.v1.schema.json","gitBlob":"705d82a893c2ea91caa91ad6977a9be8646b47bb"}, + {"path":"docs/schemas/edict.cli-info.v1.schema.json","gitBlob":"2d9a0777b4190b56ff569625275d352d17363afa"}, + {"path":"docs/schemas/edict.compiler-input.v1.schema.json","gitBlob":"26da3ba0fe85fab4c826ad79f13968ce09c4f29b"}, + {"path":"docs/schemas/edict.compiler-settings.v1.schema.json","gitBlob":"a3e8ba469895b84ab81724da1075c73141a8dd0c"}, + {"path":"docs/schemas/edict.projection-core.v1.schema.json","gitBlob":"8c0afe3834256abd1e18efb5f31eae1c4bdf0374"}, + {"path":"docs/schemas/edict.projection-diagnostics.v1.schema.json","gitBlob":"28cfb0a67dff7b8f879122c74433158dc0a4e5df"}, + {"path":"docs/schemas/edict.projection-syntax.v1.schema.json","gitBlob":"a85f2e14f536863f5e7b107b1a9f3f10816e6234"}, + {"path":"docs/schemas/edict.projection-target-ir.v1.schema.json","gitBlob":"8bbb6495ad8800d775d1c08506e85351038d678a"}, + {"path":"docs/topics/README.md","gitBlob":"99b06d3124c71cb62dfe6faff7604c13063162a7"}, + {"path":"docs/topics/admission/README.md","gitBlob":"755dcba96c0a428eec18d58a529f3e26d57d118c"}, + {"path":"docs/topics/admission/test-plan.md","gitBlob":"68ee0a2d2502103285985bf862de9fadf2bac5a0"}, + {"path":"docs/topics/assurance/README.md","gitBlob":"cf382008f3d3094a5380a687abbf07538e07404d"}, + {"path":"docs/topics/assurance/test-plan.md","gitBlob":"0ea6c971924db763088577a0a52bbd30bfec814c"}, + {"path":"docs/topics/authority-facts/README.md","gitBlob":"c5589d2489d6e4a5729c0df2b2655ff281d8d88d"}, + {"path":"docs/topics/authority-facts/test-plan.md","gitBlob":"e3769edf8309347b23ffa2e8f0901e06feabd654"}, + {"path":"docs/topics/cli/README.md","gitBlob":"af38946c9ccae8da343877c3861b0f52b6076e1b"}, + {"path":"docs/topics/cli/test-plan.md","gitBlob":"d72d69ef1d340ffd7057a63dd7bc07e3dfb2c166"}, + {"path":"docs/topics/compiler-spine/README.md","gitBlob":"6cc754abfdced28d919d5ae9f9ec4d924afc16d7"}, + {"path":"docs/topics/compiler-spine/test-plan.md","gitBlob":"8a73925d919a6fb6ee62f713b1603c5f4fe9c179"}, + {"path":"docs/topics/contract-bundles/README.md","gitBlob":"2347499e8da9dd57bb1588faf67fe386c7a70c03"}, + {"path":"docs/topics/contract-bundles/test-plan.md","gitBlob":"3ae4c7362f90fa89081ab9ff2bf1c3db1a811874"}, + {"path":"docs/topics/core-ir/README.md","gitBlob":"a8759d0f26569a60590792aadc9ba28d8daea004"}, + {"path":"docs/topics/core-ir/canonical-encoding.md","gitBlob":"34927c69fb1de10b685294a155fc46bb4ac21628"}, + {"path":"docs/topics/core-ir/test-plan.md","gitBlob":"00d55085e24a6639b02558ea48af68beea97cb65"}, + {"path":"docs/topics/developer-tooling/README.md","gitBlob":"8648d3c1bdf4f6b774bc5fec71c71aa8c59b0ce8"}, + {"path":"docs/topics/developer-tooling/test-plan.md","gitBlob":"9240f717434dfbca08a6366e6d3ebafd4ef2c908"}, + {"path":"docs/topics/documentation/README.md","gitBlob":"34fa7f4db136c274a88b680f99619d657fda15d5"}, + {"path":"docs/topics/documentation/test-plan.md","gitBlob":"47964954fbf640211bc30b0dd361c44c9955c488"}, + {"path":"docs/topics/external-action-requests/README.md","gitBlob":"73aae64e1adb730c00b680d18aea76f64adc23cb"}, + {"path":"docs/topics/external-action-requests/test-plan.md","gitBlob":"438184fc13353250a0c0976e3c3cc8cba605fa00"}, + {"path":"docs/topics/fixtures/README.md","gitBlob":"c8b3b196109fb6d4e37d8ffa17635166010075fb"}, + {"path":"docs/topics/fixtures/test-plan.md","gitBlob":"624357dbc544d365835390d3d3c2f11015b7b82f"}, + {"path":"docs/topics/lawpack-authoring/README.md","gitBlob":"74bb25cc22e1f88cf4ee952b42313d919339113a"}, + {"path":"docs/topics/lawpack-authoring/test-plan.md","gitBlob":"d7ad2eacde45dbce3eeb2b1a22c6482134b841ba"}, + {"path":"docs/topics/lawpacks/README.md","gitBlob":"dedaa524dc55663a44bf8101241ab4b6d4755531"}, + {"path":"docs/topics/lawpacks/test-plan.md","gitBlob":"f8aa2c7ce40dad2665134956dc95d951d311808f"}, + {"path":"docs/topics/lowerability/README.md","gitBlob":"fb9519af3539d846dc5bf2915bf5ca86816e46f8"}, + {"path":"docs/topics/lowerability/test-plan.md","gitBlob":"e0fbff0799ba805c9531097d6b8aeea657e2b815"}, + {"path":"docs/topics/obstruction-strands/README.md","gitBlob":"a2930645065390cecff8008bfd48b7f034bfcd18"}, + {"path":"docs/topics/obstruction-strands/test-plan.md","gitBlob":"20c54ffcaa19930a5bc772a49a5f01119054be2d"}, + {"path":"docs/topics/providers/README.md","gitBlob":"8b5a07fb9c708b753861a4e156b866115f4d687b"}, + {"path":"docs/topics/providers/architecture.md","gitBlob":"664b38347ccaf37f298d6ac9f19d3423c0277f9e"}, + {"path":"docs/topics/providers/test-plan.md","gitBlob":"95c55f9e132ca6859fd9df70470973e678ed8d92"}, + {"path":"docs/topics/public-rust-api/README.md","gitBlob":"c64a1081b7f693b02bd2ea63329f2610bae9d84c"}, + {"path":"docs/topics/public-rust-api/test-plan.md","gitBlob":"4c3b9e9662afd9edb790ba2b5c57ed5e93df595c"}, + {"path":"docs/topics/release-process/README.md","gitBlob":"a474ab8b6a4a58c5c73334c9e677be7c20d1837c"}, + {"path":"docs/topics/release-process/policy.toml","gitBlob":"e40b4f4ec721ae61210ec1bb022a847bcb49fb4a"}, + {"path":"docs/topics/release-process/runbook.md","gitBlob":"0b6bd8ef44cbfe8c7cdc347273fa74b7c96c4823"}, + {"path":"docs/topics/release-process/test-plan.md","gitBlob":"61ecded1d2318d7dd74070cd1c6155f353c947e9"}, + {"path":"docs/topics/result-projections/README.md","gitBlob":"d5c2f85a7681a15dcdc3e35f992a389c50d13461"}, + {"path":"docs/topics/result-projections/test-plan.md","gitBlob":"9e69d58c88d6a9b7389334a78b994a3449721faa"}, + {"path":"docs/topics/review-process/README.md","gitBlob":"25190d37dc30110f75ba5d3a41494575ffecc1c3"}, + {"path":"docs/topics/review-process/policy.toml","gitBlob":"a826ba58aad2e509220b65aa8f96c290b600e094"}, + {"path":"docs/topics/review-process/test-plan.md","gitBlob":"f1a50aeae47913e4513a8149c1679d9a94c5ef21"}, + {"path":"docs/topics/rust-standards/README.md","gitBlob":"2fe29258705d117f4d10604a83fd832a8476e303"}, + {"path":"docs/topics/rust-standards/test-plan.md","gitBlob":"0e0d6b306cd2b58db07a7a5da6a752925fe58764"}, + {"path":"docs/topics/semantic-validation/README.md","gitBlob":"51cd9761755e7b5879069bf3774eeb487982ca97"}, + {"path":"docs/topics/semantic-validation/test-plan.md","gitBlob":"b43969d8eb0a884c1663ab761662f9622617bb3b"}, + {"path":"docs/topics/syntax/README.md","gitBlob":"b2a372bf41b1976567c61f400bf000f33abc20cc"}, + {"path":"docs/topics/syntax/test-plan.md","gitBlob":"a69efaf12dfe12661fca049b8790b37fa3fb3665"}, + {"path":"docs/topics/target-ir/README.md","gitBlob":"3970b7e10985a1f1f0628eb6066a09821bce2856"}, + {"path":"docs/topics/target-ir/test-plan.md","gitBlob":"c6bed244f422eb39b30b886bfc7bf44f54fad0e6"}, + {"path":"docs/topics/target-profiles/README.md","gitBlob":"6a88f4d732f8069855b2ed2cb9a8769a117b2f60"}, + {"path":"docs/topics/target-profiles/test-plan.md","gitBlob":"90084c3f3a1296745469cd86e9b5f2bc928825be"}, + {"path":"docs/topics/tests/README.md","gitBlob":"4ad079b6a9718e2a8446a6c67ff45735015bef84"}, + {"path":"docs/topics/tests/test-plan.md","gitBlob":"46bc0572d02a41e86f71c6d46baf5be611a462a6"}, + {"path":"docs/topics/v2-design/README.md","gitBlob":"b33a07599e43e660aa4def7f119ddd02df6a16de"}, + {"path":"docs/topics/v2-design/test-plan.md","gitBlob":"f17f96d381f81b20842393f70ff55b9597858b84"}, + {"path":"editors/README.md","gitBlob":"7a933576262bc58bac197f9264fdbf649dd5e696"}, + {"path":"editors/vscode/.vscodeignore","gitBlob":"f15b3142e4b8af11d580789a0c82acee3499f571"}, + {"path":"editors/vscode/README.md","gitBlob":"8b29840ae9ec8f618b7364022329f694d0ed9746"}, + {"path":"editors/vscode/language-configuration.json","gitBlob":"b7f583841649c9c437785edbfcb70ee24e495c79"}, + {"path":"editors/vscode/package.json","gitBlob":"cd9e391e7c9afb6f9393fcead118e0e55aadc839"}, + {"path":"editors/vscode/syntaxes/edict.tmLanguage.json","gitBlob":"5847d8edfdb32d822f0f3950f41d00c947982185"}, + {"path":"fixtures/README.md","gitBlob":"470e3e0fc3aa00654930ecdef892ee9df8a42c8d"}, + {"path":"fixtures/authority-facts/canonical/README.md","gitBlob":"28692ce70add5d4f2d4ff5318309c3353924caf9"}, + {"path":"fixtures/authority-facts/canonical/example-effectful.authority-facts.cbor","gitBlob":"fe2e59a8e2602e02c52094010a130db2637c5227"}, + {"path":"fixtures/authority-facts/canonical/example-effectful.authority-facts.json","gitBlob":"009faa5d2dc1dcf55cf284dcfd14c0b6405f3e0d"}, + {"path":"fixtures/authority-facts/canonical/example-effectful.authority-facts.sha256","gitBlob":"a3d68f0a3b3a586e85b6a84cbd884866e662951f"}, + {"path":"fixtures/bundle/assembly/bounded-hello.bundle-digests.txt","gitBlob":"da5402db7bd41dd88c6152b7799723561130c91e"}, + {"path":"fixtures/cli/01-source-ok/expected.stdout.jsonl","gitBlob":"e08ccf8fdedd3a73beef5d06c443a1bc60274ce1"}, + {"path":"fixtures/cli/01-source-ok/request.jsonl","gitBlob":"002fea597e6b93c8468d6972b73cc1344600fa87"}, + {"path":"fixtures/cli/02-source-parse-rejection/exit","gitBlob":"d00491fd7e5bb6fa28c517a0bb32b8b506539d4d"}, + {"path":"fixtures/cli/02-source-parse-rejection/expected.stderr.jsonl","gitBlob":"1077b73c9a7c02eae99f737bea7b6ff8c64d04da"}, + {"path":"fixtures/cli/02-source-parse-rejection/request.jsonl","gitBlob":"dce01f0466bd9384fc6f5cbe2845b6e0bd9a9cfd"}, + {"path":"fixtures/cli/03-source-semantic-rejection/exit","gitBlob":"d00491fd7e5bb6fa28c517a0bb32b8b506539d4d"}, + {"path":"fixtures/cli/03-source-semantic-rejection/expected.stderr.jsonl","gitBlob":"5ec447700da52d0b4ce1f75825eb9bffaed4884b"}, + {"path":"fixtures/cli/03-source-semantic-rejection/request.jsonl","gitBlob":"ddfd529e5448760387961febbd4ce013e49de435"}, + {"path":"fixtures/cli/04-cli-missing-settings/exit","gitBlob":"0cfbf08886fca9a91cb753ec8734c84fcbe52c9f"}, + {"path":"fixtures/cli/04-cli-missing-settings/expected.stderr.jsonl","gitBlob":"5060bd2fd773ba9ea3ea6db8c80b86a846bfadbd"}, + {"path":"fixtures/cli/04-cli-missing-settings/request.jsonl","gitBlob":"8eb12e58d427bd64ccfe339190e05bdccf4c8634"}, + {"path":"fixtures/cli/05-path-input-ok/expected.stdout.jsonl","gitBlob":"a05fc582efc41b6414e785167b5deeb7532088ef"}, + {"path":"fixtures/cli/05-path-input-ok/inputs/hello.edict","gitBlob":"39c53bb184a7c10de61da0c637b607eb1d7cc454"}, + {"path":"fixtures/cli/05-path-input-ok/request.jsonl","gitBlob":"18facaab79dc198134c535df389cba79efe7dce7"}, + {"path":"fixtures/cli/06-directory-expansion-ok/expected.stdout.jsonl","gitBlob":"ef59591526e2084ddf5057249bbc96ab660cf256"}, + {"path":"fixtures/cli/06-directory-expansion-ok/inputs/a.edict","gitBlob":"39c53bb184a7c10de61da0c637b607eb1d7cc454"}, + {"path":"fixtures/cli/06-directory-expansion-ok/inputs/ignore.txt","gitBlob":"ed34ae8da336ff94a67b6125fbd6be730c976d91"}, + {"path":"fixtures/cli/06-directory-expansion-ok/inputs/nested/b.edict","gitBlob":"39c53bb184a7c10de61da0c637b607eb1d7cc454"}, + {"path":"fixtures/cli/06-directory-expansion-ok/request.jsonl","gitBlob":"bd9aad14fe79caccacaa6d00ffd32b5e13b3551f"}, + {"path":"fixtures/cli/07-path-list-ok/expected.stdout.jsonl","gitBlob":"643ecb3e659c10cb98255ec1aced772778e76eb0"}, + {"path":"fixtures/cli/07-path-list-ok/inputs/first.edict","gitBlob":"39c53bb184a7c10de61da0c637b607eb1d7cc454"}, + {"path":"fixtures/cli/07-path-list-ok/inputs/second.edict","gitBlob":"39c53bb184a7c10de61da0c637b607eb1d7cc454"}, + {"path":"fixtures/cli/07-path-list-ok/request.jsonl","gitBlob":"f11265b02c5b7559ced4d975471a78b5bef3ee27"}, + {"path":"fixtures/cli/08-glob-expansion-ok/expected.stdout.jsonl","gitBlob":"90164a7fce6c51abdadef8f0586d2c56113d9712"}, + {"path":"fixtures/cli/08-glob-expansion-ok/inputs/x.edict","gitBlob":"39c53bb184a7c10de61da0c637b607eb1d7cc454"}, + {"path":"fixtures/cli/08-glob-expansion-ok/inputs/y.edict","gitBlob":"39c53bb184a7c10de61da0c637b607eb1d7cc454"}, + {"path":"fixtures/cli/08-glob-expansion-ok/request.jsonl","gitBlob":"9335acf3a008ab8fb9942b3e22d73c456ed3827e"}, + {"path":"fixtures/cli/09-shape-source-ok/expected.stdout.jsonl","gitBlob":"ac6f9259502ebfe484e1c07a5f53865888dd8207"}, + {"path":"fixtures/cli/09-shape-source-ok/request.jsonl","gitBlob":"64c75d9a7b40985bacf0e59a943a16e20419c602"}, + {"path":"fixtures/cli/10-input-extra-field/exit","gitBlob":"0cfbf08886fca9a91cb753ec8734c84fcbe52c9f"}, + {"path":"fixtures/cli/10-input-extra-field/expected.stderr.jsonl","gitBlob":"2f5a8fba093b71d15a5b37504ad0352191c8299c"}, + {"path":"fixtures/cli/10-input-extra-field/request.jsonl","gitBlob":"6052212c652d41f03144a7d3d4018b1cdd18cd09"}, + {"path":"fixtures/cli/11-input-hybrid-kind/exit","gitBlob":"0cfbf08886fca9a91cb753ec8734c84fcbe52c9f"}, + {"path":"fixtures/cli/11-input-hybrid-kind/expected.stderr.jsonl","gitBlob":"7b6d2ac0c8afbf5e3991498846c2fc4847ac9453"}, + {"path":"fixtures/cli/11-input-hybrid-kind/request.jsonl","gitBlob":"b893b640aa6631c77f2a889a807afa31632ac2db"}, + {"path":"fixtures/cli/12-input-too-large/env.json","gitBlob":"ab0c7f13fc6b22d61fc73da2f1787ff3aa298ecb"}, + {"path":"fixtures/cli/12-input-too-large/exit","gitBlob":"0cfbf08886fca9a91cb753ec8734c84fcbe52c9f"}, + {"path":"fixtures/cli/12-input-too-large/expected.stderr.jsonl","gitBlob":"ebda022d79c978d4ff511579512be2c642e3e902"}, + {"path":"fixtures/cli/12-input-too-large/request.jsonl","gitBlob":"1e2fbb102503356bbcc627f49a5b58590859f170"}, + {"path":"fixtures/cli/13-input-root-outside/allowed/.gitkeep","gitBlob":"8b137891791fe96927ad78e64b0aad7bded08bdc"}, + {"path":"fixtures/cli/13-input-root-outside/exit","gitBlob":"0cfbf08886fca9a91cb753ec8734c84fcbe52c9f"}, + {"path":"fixtures/cli/13-input-root-outside/expected.stderr.jsonl","gitBlob":"9c5b8567a755c9ea2ee6e0168bf96f429185f675"}, + {"path":"fixtures/cli/13-input-root-outside/outside/outside.edict","gitBlob":"44abebc15811c38cc266007484dd74ae10a26a4d"}, + {"path":"fixtures/cli/13-input-root-outside/request.jsonl","gitBlob":"116dbbb4b1a80938bc042e41747872cb6da161cd"}, + {"path":"fixtures/cli/README.md","gitBlob":"9388df4182fedec41c353e85cf9210e88906fa3d"}, + {"path":"fixtures/core/canonical/README.md","gitBlob":"d9a0ca79557c3623c0b843d9eff4808f94fd7b18"}, + {"path":"fixtures/core/canonical/bounded-hello.core.cbor","gitBlob":"a0ec54aa1a5e20624192091526445cfd803e6f0c"}, + {"path":"fixtures/core/canonical/bounded-hello.core.sha256","gitBlob":"86ba062c26a3ad3fd733ccd8c80d7faa7ed62d94"}, + {"path":"fixtures/core/canonical/statement-branch.core.hex","gitBlob":"c22760cace0e4d146a2fdc8d7c7b50c38497622a"}, + {"path":"fixtures/core/canonical/statement-branch.core.sha256","gitBlob":"0b62657b192232390479319f0a1c8f601020a58f"}, + {"path":"fixtures/core/canonical/workspace-snapshot.core.cbor","gitBlob":"58e4f724610861f5b61537bf386a87062e8a57a7"}, + {"path":"fixtures/core/canonical/workspace-snapshot.core.sha256","gitBlob":"4bcb3e0813cd3f4a7afc7cf311d846f1dfdd0a9d"}, + {"path":"fixtures/core/schema/accepted/core-fn-body-minimal.fields","gitBlob":"bef3ca412ab0ea97465b8658499ae5e05e1ec760"}, + {"path":"fixtures/core/schema/accepted/core-intent-minimal.fields","gitBlob":"268b28ce942fed4f139aafe5c7cd50c15a0ee640"}, + {"path":"fixtures/core/schema/accepted/core-module-minimal.fields","gitBlob":"249ff76349f936c9a5ff6cb65d81de8e80d53de8"}, + {"path":"fixtures/core/schema/rejected/core-fn-body-effect-node-field.fields","gitBlob":"9af8fa3540b25ec810936bc4dc82e26f6dd0dd48"}, + {"path":"fixtures/core/schema/rejected/core-intent-unknown-verified-mode.fields","gitBlob":"667ae032ee117f32c1bcbafd21393e406621f517"}, + {"path":"fixtures/core/schema/rejected/core-module-missing-intents.fields","gitBlob":"17f37c7ac4c199de4eace7f31e6a59b9a6d3a0f6"}, + {"path":"fixtures/core/schema/rejected/local-ref-missing-alpha-name.fields","gitBlob":"456a89528ffe74d892be40c9c9be4a078ff5c18a"}, + {"path":"fixtures/lang/bounds/bounded-hello.edict","gitBlob":"e3443a1d3b1c8f0e137ac698b621dd2f3afb673b"}, + {"path":"fixtures/lang/effects/conditional-blob.edict","gitBlob":"1e4f2ca6112f26d57ee4d20058666ec7cd693b75"}, + {"path":"fixtures/lang/effects/read-greeting.edict","gitBlob":"5e3838d1547be171e0a0384a7a200f52a2b9d139"}, + {"path":"fixtures/lang/external-actions/workspace-snapshot.edict","gitBlob":"e54b0fbccad2fd680505f3ee46ca28d39d7e776e"}, + {"path":"fixtures/lang/operations/explicit-basis-u64.edict","gitBlob":"444d8ca77b9827746df81885f0620dce2d1a3b73"}, + {"path":"fixtures/lang/tooling/highlight-smoke.edict","gitBlob":"8c2d91084be22e5e1594a42159992aca95c73612"}, + {"path":"fixtures/lang/types/color-match.edict","gitBlob":"dd98d6de677904f36d7601165a0094d92928e536"}, + {"path":"fixtures/lawpack/causal-cell/README.md","gitBlob":"52e8cc1e2af8aea86c1090a1b20b5f5ab3e07c06"}, + {"path":"fixtures/lawpack/causal-cell/adapter.cbor","gitBlob":"3b0c8b1b3a8591a322b6e785d9f963899319310c"}, + {"path":"fixtures/lawpack/causal-cell/adapter.sha256","gitBlob":"f8231bc941e1fbe02279865a82e183cbeeb0988a"}, + {"path":"fixtures/lawpack/causal-cell/echo-operation-configuration.cbor","gitBlob":"24527d30d0146b567fda157561ac6a2587cae919"}, + {"path":"fixtures/lawpack/causal-cell/echo-operation-configuration.sha256","gitBlob":"d293c8a14b1955a3e171703400c4df620c7871a1"}, + {"path":"fixtures/lawpack/causal-cell/exports.cbor","gitBlob":"384f4839adfe8e5b0f1aa848bfe2aeb1c3f640b6"}, + {"path":"fixtures/lawpack/causal-cell/exports.sha256","gitBlob":"4f836f6b03497338a1f8eacc55480cbe1a3b49e9"}, + {"path":"fixtures/lawpack/causal-cell/manifest.cbor","gitBlob":"b9311a236d7898861a0b90b1f30b852b35cef623"}, + {"path":"fixtures/lawpack/causal-cell/manifest.sha256","gitBlob":"685fd6a6c72fc3100d595d009b6198a81c731a40"}, + {"path":"fixtures/lawpack/hello-echo/README.md","gitBlob":"79f6612f1f5608a8f7dc4835e5470878cd27f96e"}, + {"path":"fixtures/lawpack/hello-echo/adapter.cbor","gitBlob":"24e2f546e2b97747b53462a72faaa1d5d85d62f1"}, + {"path":"fixtures/lawpack/hello-echo/adapter.sha256","gitBlob":"91df491028061e026ecaaeb4e1598e2ac369af44"}, + {"path":"fixtures/lawpack/hello-echo/create-greeting.core.cbor","gitBlob":"246b6135855c415def0bd89b275f0457752ee563"}, + {"path":"fixtures/lawpack/hello-echo/create-greeting.core.sha256","gitBlob":"9adc71605e0a275349161809614bd17de97d129c"}, + {"path":"fixtures/lawpack/hello-echo/create-greeting.edict","gitBlob":"825d50565230bd71d62bfbeb59d0399a89864b4c"}, + {"path":"fixtures/lawpack/hello-echo/create-greeting.result-projection.cbor","gitBlob":"981cba6e1c7ab6bdae6829116749c4796167e4e6"}, + {"path":"fixtures/lawpack/hello-echo/create-greeting.result-projection.sha256","gitBlob":"d55e4083771e1d9791f59cf87fd5cc5f1ea3b9f4"}, + {"path":"fixtures/lawpack/hello-echo/create-greeting.target-ir.cbor","gitBlob":"c8a934cefec17dbab0a43d9be9cebd2533268798"}, + {"path":"fixtures/lawpack/hello-echo/create-greeting.target-ir.sha256","gitBlob":"20186cbe9482e8a7df7c44fabec13ffd4efbcf36"}, + {"path":"fixtures/lawpack/hello-echo/echo-operation-configuration.cbor","gitBlob":"84838ab0d8627237232fa5a9b9fa39087bcc5f8a"}, + {"path":"fixtures/lawpack/hello-echo/echo-operation-configuration.sha256","gitBlob":"0898688f14067560dd22abd04b97f020071fd3e8"}, + {"path":"fixtures/lawpack/hello-echo/exports.cbor","gitBlob":"0e1220ceed9442a7b35870eeb02fcb65454d8c5c"}, + {"path":"fixtures/lawpack/hello-echo/exports.sha256","gitBlob":"e1f3e9223de9ce935bc7f60dda3cfa7d12d54fdc"}, + {"path":"fixtures/lawpack/hello-echo/manifest.cbor","gitBlob":"d715900f03ec454a0ad96e6710f52a46120d0b9d"}, + {"path":"fixtures/lawpack/hello-echo/manifest.sha256","gitBlob":"20171199b401cecace2dd74e18f3cc1d5c7ed3de"}, + {"path":"fixtures/lawpack/workspace-patch/README.md","gitBlob":"67cd35f2e0660aa7455de1c197ad821d5438679b"}, + {"path":"fixtures/lawpack/workspace-patch/adapter.cbor","gitBlob":"2d6f09a7e2fab381b97a05cfad1e692902e878c3"}, + {"path":"fixtures/lawpack/workspace-patch/adapter.sha256","gitBlob":"d44eb9675e126716e8a5ef3c53fd39ade49d76fb"}, + {"path":"fixtures/lawpack/workspace-patch/apply-validated-patch.core.cbor","gitBlob":"6a88c127e426288a3e51d4749d5c31d5b0cb60cb"}, + {"path":"fixtures/lawpack/workspace-patch/apply-validated-patch.core.sha256","gitBlob":"0204b6f1d8b346a67800a7738ee39df49e78571f"}, + {"path":"fixtures/lawpack/workspace-patch/apply-validated-patch.edict","gitBlob":"6e11a3d022a53a8fb2c20a77e35e29840f5fe086"}, + {"path":"fixtures/lawpack/workspace-patch/apply-validated-patch.target-ir.cbor","gitBlob":"a6124a995a3cdbb5d39cd0a6e046b329048703aa"}, + {"path":"fixtures/lawpack/workspace-patch/apply-validated-patch.target-ir.sha256","gitBlob":"f7ac419ce15b32d491e09bddbe7c75f8227f51d8"}, + {"path":"fixtures/lawpack/workspace-patch/exports.cbor","gitBlob":"3a6fd19dc8059b9fe1bde74fb1da61398b0e80cc"}, + {"path":"fixtures/lawpack/workspace-patch/exports.sha256","gitBlob":"b301dd883a31fffe324e9306ec90ae2b1ec44520"}, + {"path":"fixtures/lawpack/workspace-patch/input-schema.cbor","gitBlob":"3045d9b696864fefe111c3eb641b3b68532752d2"}, + {"path":"fixtures/lawpack/workspace-patch/input-schema.sha256","gitBlob":"9f1284b4f0a2c7f6dbe1915a6113cd13a9700cb8"}, + {"path":"fixtures/lawpack/workspace-patch/manifest.cbor","gitBlob":"77e56c7525f0e64ab191f0adfeac12b540c87848"}, + {"path":"fixtures/lawpack/workspace-patch/manifest.sha256","gitBlob":"8316978e68565f29a30a6978d33d907710185857"}, + {"path":"fixtures/lawpack/workspace-patch/reconciliation-law.cbor","gitBlob":"0736b75f81913fca7ac95c56ec45f66b95aea4cf"}, + {"path":"fixtures/lawpack/workspace-patch/reconciliation-law.sha256","gitBlob":"de31fc9fda59fa3c29397e5fc48db224e8e1fee7"}, + {"path":"fixtures/lawpack/workspace-patch/request-profile-configuration.cbor","gitBlob":"5e2870b2f562bafaa73a91a3fc192f5ed39257c7"}, + {"path":"fixtures/lawpack/workspace-patch/request-profile-configuration.sha256","gitBlob":"4345ae2e39ce3f4d9cfa6b0dddf4ce56d56c035c"}, + {"path":"fixtures/lawpack/workspace-patch/settlement-schema.cbor","gitBlob":"0a93ac19c51b341602eeba524769147e962d5d60"}, + {"path":"fixtures/lawpack/workspace-patch/settlement-schema.sha256","gitBlob":"f1bb3fb0313dd6815b4184345194949ec40fe9e1"}, + {"path":"fixtures/lawpack/workspace-snapshot/README.md","gitBlob":"996bd1d29b28769fff477084d9118d0833ca2970"}, + {"path":"fixtures/lawpack/workspace-snapshot/adapter.cbor","gitBlob":"9be4ea568b602b56269af505deb809989a3fa8b5"}, + {"path":"fixtures/lawpack/workspace-snapshot/adapter.sha256","gitBlob":"1e287be0a322e5444dea15fa14bcfc7cf12975c4"}, + {"path":"fixtures/lawpack/workspace-snapshot/exports.cbor","gitBlob":"33fe04db74775c191d4b7400e1fb2b6393c5a010"}, + {"path":"fixtures/lawpack/workspace-snapshot/exports.sha256","gitBlob":"e057cac7fc360e6599b7ddab88508aaf0f2f55f8"}, + {"path":"fixtures/lawpack/workspace-snapshot/input-schema.cbor","gitBlob":"49c849169946e44c8b5f300279dd085bd6b63aeb"}, + {"path":"fixtures/lawpack/workspace-snapshot/input-schema.sha256","gitBlob":"9dd7bb6e48192e90d19fc346d1705f736b1d85d7"}, + {"path":"fixtures/lawpack/workspace-snapshot/manifest.cbor","gitBlob":"d4e58e3d4646ca967170a6882f2a617cb8d81390"}, + {"path":"fixtures/lawpack/workspace-snapshot/manifest.sha256","gitBlob":"0edb311125a89a5816ee3fa0c9b700c9b3bcff3d"}, + {"path":"fixtures/lawpack/workspace-snapshot/observe-workspace.core.cbor","gitBlob":"a4b249dfb197f1a6b4adc06855f16e4305a1c798"}, + {"path":"fixtures/lawpack/workspace-snapshot/observe-workspace.core.sha256","gitBlob":"ea6b914d14907d9fd915058e579aff33c954da2c"}, + {"path":"fixtures/lawpack/workspace-snapshot/observe-workspace.edict","gitBlob":"c2c10f1ef1009796d67061b9722c4db9bb4e031b"}, + {"path":"fixtures/lawpack/workspace-snapshot/observe-workspace.target-ir.cbor","gitBlob":"bdab1b0c55a34360c7e9ab304af91fe2b1e4afce"}, + {"path":"fixtures/lawpack/workspace-snapshot/observe-workspace.target-ir.sha256","gitBlob":"7342aaa96221d6c8efa75ead2af5563791ccfeff"}, + {"path":"fixtures/lawpack/workspace-snapshot/reconciliation-law.cbor","gitBlob":"df55572b350002a3df98ccb3e72dd60c86b9aead"}, + {"path":"fixtures/lawpack/workspace-snapshot/reconciliation-law.sha256","gitBlob":"957cd04c78c130b07d2cad2fd7e07ae69978be57"}, + {"path":"fixtures/lawpack/workspace-snapshot/request-profile-configuration.cbor","gitBlob":"708f18918ee1703491a910df82e129e711a4cc46"}, + {"path":"fixtures/lawpack/workspace-snapshot/request-profile-configuration.sha256","gitBlob":"d9953d9dcaa41c98387226d1980f40b24d2bc3cb"}, + {"path":"fixtures/lawpack/workspace-snapshot/settlement-schema.cbor","gitBlob":"f01ad68531267666e6bf93bf30a37d5b311c1676"}, + {"path":"fixtures/lawpack/workspace-snapshot/settlement-schema.sha256","gitBlob":"06fcc0ee2b976a09b3017bd93132a3c51eb1317e"}, + {"path":"fixtures/obstruction-strands/v0/stale-basis/README.md","gitBlob":"25efbfa04e2e6104c5434f329128333e895e2b0a"}, + {"path":"fixtures/obstruction-strands/v0/stale-basis/source.edict","gitBlob":"e487b46e81220c50e6f928922dada29f3a21ca6a"}, + {"path":"fixtures/provider-contracts/v1/README.md","gitBlob":"447692907f9268ce3b6b78c43b7cbbb0417aeadf"}, + {"path":"fixtures/provider-contracts/v1/edict-provider-contracts.cddl","gitBlob":"07048aeeadb5062eabb89e995713cbc0893b7d7e"}, + {"path":"fixtures/provider-contracts/v1/manifest.json","gitBlob":"d2c8de5d61049e9f4182c630bf82b138f0f96792"}, + {"path":"fixtures/providers/README.md","gitBlob":"c26ee60a4930e3e0784c76cb855e48234a5c6b58"}, + {"path":"fixtures/providers/components/guests/Cargo.lock","gitBlob":"d7858ce7bc67deabb5ff352a24c85a7caa0ef4b0"}, + {"path":"fixtures/providers/components/guests/Cargo.toml","gitBlob":"450a24aed25dc73661b0ae8adfe2630dfecc9b07"}, + {"path":"fixtures/providers/components/guests/lowerer/Cargo.toml","gitBlob":"568aa137fa215b6b973fe31e12322530b393b9dc"}, + {"path":"fixtures/providers/components/guests/lowerer/src/lib.rs","gitBlob":"b39a8a0b18fe9ed7cb90277f793056434afa1318"}, + {"path":"fixtures/providers/components/guests/verifier/Cargo.toml","gitBlob":"f814f2c8c248bbf03389f5a0936f80cd4dada5b6"}, + {"path":"fixtures/providers/components/guests/verifier/src/lib.rs","gitBlob":"3f07ffdfd808ff95b206a2c08c2d481ccaf0e165"}, + {"path":"fixtures/providers/components/instantiation-failure-lowerer.component.wasm","gitBlob":"bd2d7c0d31798d7676aedab0bd0d289fc2053bef"}, + {"path":"fixtures/providers/components/instantiation-failure-lowerer.wat","gitBlob":"f6f5a70edb80d3a7fa1dee13b34ab5b8b44274d7"}, + {"path":"fixtures/providers/components/instantiation-fuel-lowerer.component.wasm","gitBlob":"0804d26d3ddb428682ca87ecad03cf0e05ef64af"}, + {"path":"fixtures/providers/components/instantiation-fuel-lowerer.wat","gitBlob":"80e972463ef593602d27c7d7cec78d87d22ff727"}, + {"path":"fixtures/providers/components/inventory.json","gitBlob":"45cf2e8e937a17a8ee05dfa8d68e94dcc155e129"}, + {"path":"fixtures/providers/components/lowerer.component.wasm","gitBlob":"6c1cf123a44284d15b7b1e90f1905ae94e65c158"}, + {"path":"fixtures/providers/components/malformed-lowerer.component.wasm","gitBlob":"be873af81100dc76ed1f3f1f818a41da45a38e4c"}, + {"path":"fixtures/providers/components/malformed-lowerer.wat","gitBlob":"1e7bfffe0a0baf230d9fb5766083f82198f4029c"}, + {"path":"fixtures/providers/components/verifier.component.wasm","gitBlob":"671adbe7931d0a9a5e0c78d459c244d37a135a69"}, + {"path":"fixtures/providers/echo-generated/provider-manifest.json","gitBlob":"22c8560e7ddecacd5da388e52d3935d7fc1474b9"}, + {"path":"fixtures/providers/echo-target-profile/README.md","gitBlob":"350c33dcda2d66d2d50e589c58db7c6d7b14a80b"}, + {"path":"fixtures/providers/echo-target-profile/generated/primary/target-profile.echo-dpo.cbor","gitBlob":"9fa43529b1021dfd8e3a33256c832d4eee6f4a47"}, + {"path":"fixtures/providers/wit/legacy-target-profile.wit","gitBlob":"ae7d6af764012b16bf06bfa260ccba98a7f04868"}, + {"path":"fixtures/target-ir/canonical/echo-effectful.target-ir.cbor","gitBlob":"727a80eb37319dbdbea40d7d9b4e37f0d93d8d84"}, + {"path":"fixtures/target-ir/canonical/echo-effectful.target-ir.sha256","gitBlob":"6d050bb46ac8981ea8e47c7a52371027b941fd89"}, + {"path":"fixtures/target-ir/canonical/gitwarp-append.target-ir.cbor","gitBlob":"89b46b138a7b90252a4397c0e8b622bceff10a33"}, + {"path":"fixtures/target-ir/canonical/gitwarp-append.target-ir.sha256","gitBlob":"a59a4ab9d46095d5be1797ed9e60fe841f821bce"}, + {"path":"fixtures/target-ir/canonical/workspace-snapshot.target-ir.cbor","gitBlob":"1854eeb549b3719fa2b0114867dbece6db1819d4"}, + {"path":"fixtures/target-ir/canonical/workspace-snapshot.target-ir.sha256","gitBlob":"4d0e501323d415ef9e64c0a3d25bdd57dabfc998"}, + {"path":"fixtures/target-profile/contract-resources/README.md","gitBlob":"32dcab1dd9376a4eed2c73bb1b1a29255fe3ea05"}, + {"path":"fixtures/target-profile/contract-resources/canonical-cbor.cbor","gitBlob":"4a95ba3bd9dff190ca5ec9c83262bfa6254a91d3"}, + {"path":"fixtures/target-profile/contract-resources/canonical-cbor.sha256","gitBlob":"2168df5d4bf77ed2347139dd7c45fd808df8ec7e"}, + {"path":"fixtures/target-profile/contract-resources/determinism.cbor","gitBlob":"09cd11c36048939961408550763c04fad8241557"}, + {"path":"fixtures/target-profile/contract-resources/determinism.sha256","gitBlob":"5376d6bfe23bea659463a7e3c56ad1e8afd4095f"}, + {"path":"fixtures/target-profile/contract-resources/diagnostics.cbor","gitBlob":"c47fa05f463e0da745fbcdf8daf94d70e134eb8d"}, + {"path":"fixtures/target-profile/contract-resources/diagnostics.sha256","gitBlob":"69613ec4014f27b23245e23fbf7c9447566516b2"}, + {"path":"fixtures/target-profile/contract-resources/fuel.cbor","gitBlob":"b5a3484ec5b2bf7343c2fcedc67bcb2b63a37104"}, + {"path":"fixtures/target-profile/contract-resources/fuel.sha256","gitBlob":"6ec1c830358ee35bb12bd04cc1a6edf47fb20997"}, + {"path":"fixtures/target-profile/contract-resources/wasm-component.cbor","gitBlob":"6344996c283e0d1c332ea3ce597ad4593882a3c5"}, + {"path":"fixtures/target-profile/contract-resources/wasm-component.sha256","gitBlob":"24bf3e552e4216d8258d2b85c8878af46a176c52"}, + {"path":"grammars/textmate/README.md","gitBlob":"fc116a669725d4e965d658234d32d779955d5dc8"}, + {"path":"grammars/textmate/edict.tmLanguage.json","gitBlob":"5847d8edfdb32d822f0f3950f41d00c947982185"}, + {"path":"grammars/tree-sitter-edict/README.md","gitBlob":"e2992a839d6719f1461db78c4e3f33d2e5ab0c09"}, + {"path":"grammars/tree-sitter-edict/grammar.js","gitBlob":"a82f5b9d9b78525f17a59272543fdcddd7a0da40"}, + {"path":"grammars/tree-sitter-edict/queries/highlights.scm","gitBlob":"0f46530b36996d13449901aed4e376a126577cba"}, + {"path":"grammars/tree-sitter-edict/src/grammar.json","gitBlob":"55df730a06b83c9f622e3ec17845fc9897c7d8c0"}, + {"path":"grammars/tree-sitter-edict/src/node-types.json","gitBlob":"520f6c4f7b30cd6892dd60faf6d76f3fbaa6a5c7"}, + {"path":"grammars/tree-sitter-edict/src/parser.c","gitBlob":"81cc4713cb5e05f9aa8dac16da202a864faefee6"}, + {"path":"grammars/tree-sitter-edict/src/tree_sitter/alloc.h","gitBlob":"1abdd1201578605b8d05a3001f01ebc0d58826d9"}, + {"path":"grammars/tree-sitter-edict/src/tree_sitter/array.h","gitBlob":"56fc8cd470996ded64a5452be25e26dbd2aa682a"}, + {"path":"grammars/tree-sitter-edict/src/tree_sitter/parser.h","gitBlob":"858107deb9e4a1ffcd2ed5e6ffe98a5fcab3e1f6"}, + {"path":"grammars/tree-sitter-edict/test/corpus/current-subset.txt","gitBlob":"732c5eda8e1bf95eef799476296a6ee061eb58eb"}, + {"path":"grammars/tree-sitter-edict/tree-sitter.json","gitBlob":"97d3fdd498a3bef509c8615d98b9560b527c03cb"}, + {"path":"scripts/consumer-witnesses/README.md","gitBlob":"262ba30223afa1a3782b17dd5272a02b40a541fb"}, + {"path":"scripts/consumer-witnesses/jedit-state-read.Dockerfile","gitBlob":"b76948f9b5d337f3681d645cceb56e32f8e9c69f"}, + {"path":"scripts/consumer-witnesses/jedit-state-read.Dockerfile.dockerignore","gitBlob":"ee41b3ca0a68fd5eb20e1b777b4b368fd8b44e63"}, + {"path":"scripts/consumer-witnesses/jedit-state-read.py","gitBlob":"26db295d4eabfc4e57813fc9bf17314c23350777"}, + {"path":"spec.lock.json","gitBlob":"ef8b02386e0f269a99c1d2121764f70b76e67620"}, + {"path":"xtask/Cargo.toml","gitBlob":"795c70a5172363bfcd55174b1bc76c9c131d21a3"}, + {"path":"xtask/src/contract_check.rs","gitBlob":"9e80393accf79936033972fde0f2aa2cf40f1be3"}, + {"path":"xtask/src/goldens.rs","gitBlob":"713f1f8266d9f6993684ae86db105fcd7d69ee2a"}, + {"path":"xtask/src/lawpack_goldens.rs","gitBlob":"c499e8581c73313794b83c261937144b3917850a"}, + {"path":"xtask/src/main.rs","gitBlob":"6c2c06038bb5ecdde60620071b200d8191dc116c"}, + {"path":"xtask/src/provider_components.rs","gitBlob":"ee9d6a1028f9fbfad879faab4b15a94b996ef6d4"}, + {"path":"xtask/src/provider_contract_pack.rs","gitBlob":"cf60d89892b7a57cc33300f273d2522a6e8f43f9"}, + {"path":"xtask/src/provider_dependencies.rs","gitBlob":"c4b0539ed593d2a2777d294090d2a891b13ae628"}, + {"path":"xtask/src/release_dates.rs","gitBlob":"1c6d7acb872f6d820eab3a30ca580e9c5cfba2ee"}, + {"path":"xtask/src/release_prep.rs","gitBlob":"01ed64ccbb28c9d1e908b7b800ff58076e5e1a2b"}, + {"path":"xtask/src/tests.rs","gitBlob":"9a3f6543c2dbae31d53e93d56f781e5d54f74f41"}, + {"path":"xtask/src/util.rs","gitBlob":"c1bf39e93460c43ffdcfd9a76e0424750cbb9dfd"} + ] +} diff --git a/edict/replace-range-probes/leaf-slice/evidence/public-build-red.json b/edict/replace-range-probes/leaf-slice/evidence/public-build-red.json new file mode 100644 index 00000000..1245f6c9 --- /dev/null +++ b/edict/replace-range-probes/leaf-slice/evidence/public-build-red.json @@ -0,0 +1,54 @@ +{ + "compiler": { + "commit": "2405a550e93e1e97fff640caa44bbd0f65ffff3c", + "tree": "257d3e6aa10c2248fdbddaa8e9b3638866396169", + "fileCount": 440, + "manifestSha256": "9cc2cb4f711ef4038091559587099bbe65d6c54c8316c3e373752d0783b25173", + "binarySha256": "3b082d61c8cd23b0f917efb55c4eebd54e75c0df5d31c72f90ad856853678bf5" + }, + "results": { + "baseline": { + "exitCode": 0, + "diagnostics": [], + "artifacts": [ + "executable-operation-package.cbor", + "verification-report.cbor" + ], + "sourceSha256": "51797e77062585a9f59083ee8a1da3faaf486ef7691e1b62203369a9d9356ee0", + "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61", + "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "guard-control": { + "exitCode": 0, + "diagnostics": [], + "artifacts": [ + "executable-operation-package.cbor", + "verification-report.cbor" + ], + "sourceSha256": "066f7f3858f31bfd2ddc8490470942ae56da2f9a461399a872f7f158b1bc9774", + "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61", + "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "slice": { + "exitCode": 2, + "diagnostics": [ + { + "command": "build", + "input": { + "kind": "stdin" + }, + "kind": "ApplicationCompilationFailed", + "message": "Edict application did not compile to Core: [CompilerError { stage: TypeCheck, kind: UnresolvedFunction, message: \"pure helper `slice` has no compiler context fact\", span: Span { start: 521, end: 575 } }, CompilerError { stage: TypeCheck, kind: UnresolvedType, message: \"record shorthand `bytes` has no typed binding\", span: Span { start: 588, end: 593 } }, CompilerError { stage: TypeCheck, kind: TypeMismatch, message: \"return value does not match declared output type\", span: Span { start: 291, end: 598 } }, CompilerError { stage: TypeCheck, kind: TypeMismatch, message: \"intent body must return a value\", span: Span { start: 291, end: 598 } }]", + "schema": "edict.cli.diagnostic/v1", + "severity": "error", + "stage": "cli", + "type": "diagnostic" + } + ], + "artifacts": [], + "sourceSha256": "81ffc0dae8c5d8900badf66b1ca4b8cac92378935702374785f2b20781e6934c", + "stdoutSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderrSha256": "6181544d23ab4e8bf02f3719bfbe9a86a9f851490995eb23983d55af61525e64" + } + } +} diff --git a/edict/replace-range-probes/leaf-slice/run.py b/edict/replace-range-probes/leaf-slice/run.py new file mode 100644 index 00000000..cee2b146 --- /dev/null +++ b/edict/replace-range-probes/leaf-slice/run.py @@ -0,0 +1,128 @@ +"""Exercise authored byte slicing at the public compiler build boundary.""" + +import argparse +import hashlib +import json +from pathlib import Path +import shutil +import subprocess + + +COMPILER_COMMIT = "2405a550e93e1e97fff640caa44bbd0f65ffff3c" +SOURCE_EXPRESSION = "slice(input.blobBytes, input.startByte, input.endByte)" +MAX_LOG_BYTES = 1024 * 1024 + + +def sha256(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def snapshot(root): + return {str(path.relative_to(root)): sha256(path) + for path in sorted(root.rglob("*")) if path.is_file()} + + +def verify_compiler_source(root, manifest_path): + manifest = json.loads(manifest_path.read_text()) + if manifest["commit"] != COMPILER_COMMIT: + raise RuntimeError("This RED witness requires the explicit experimental compiler pin") + for entry in manifest["files"]: + relative = Path(entry["path"]) + if relative.is_absolute() or ".." in relative.parts: + raise RuntimeError("Compiler source manifest contains an unsafe path") + data = (root / relative).read_bytes() + blob = hashlib.sha1(b"blob " + str(len(data)).encode() + b"\0" + data).hexdigest() + if blob != entry["gitBlob"]: + raise RuntimeError(f"Compiler source differs at {relative}") + return {"commit": manifest["commit"], "tree": manifest["tree"], + "fileCount": len(manifest["files"]), + "manifestSha256": sha256(manifest_path)} + + +def prepare(root, application_source, provider_source, source): + root.mkdir() + shutil.copy2(application_source / "edict.application.json", root) + shutil.copytree(application_source / "vendor", root / "vendor") + (root / "src").mkdir() + (root / "src/ReplaceRange.edict").write_bytes(source) + shutil.copytree(provider_source, root / ".build/echo-provider") + + +def build(root, compiler): + request = {"schema": "edict.compiler.settings/v1", "type": "compilerSettings", + "operation": "build", "application": "edict.application.json"} + stdout_path, stderr_path = root / "stdout.jsonl", root / "stderr.jsonl" + with stdout_path.open("wb") as stdout, stderr_path.open("wb") as stderr: + result = subprocess.run([str(compiler)], cwd=root, + input=(json.dumps(request) + "\n").encode(), + stdout=stdout, stderr=stderr, timeout=120, check=False) + events = [] + for path in (stdout_path, stderr_path): + if path.stat().st_size > MAX_LOG_BYTES: + raise RuntimeError("Compiler output exceeded witness log ceiling") + events.extend(json.loads(line) for line in path.read_text().splitlines()) + statuses = [event for event in events if event.get("type") == "status"] + if len(statuses) != 1 or statuses[0].get("exitCode") != result.returncode: + raise RuntimeError(f"Invalid compiler status stream: {events}") + diagnostics = [event for event in events if event.get("type") == "diagnostic"] + output = root / ".build/application" + artifacts = sorted(str(path.relative_to(output)) for path in output.rglob("*") + if path.is_file()) if output.exists() else [] + return {"exitCode": result.returncode, "diagnostics": diagnostics, + "artifacts": artifacts, "sourceSha256": sha256(root / "src/ReplaceRange.edict"), + "stdoutSha256": sha256(stdout_path), "stderrSha256": sha256(stderr_path)} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + for name in ("compiler", "compiler-source", "compiler-manifest", "application-source", + "provider-package", "work-root"): + parser.add_argument("--" + name, type=Path, required=True) + args = parser.parse_args() + if not Path("/.dockerenv").is_file(): + raise RuntimeError("Run only under the shared guarded Docker-worker lease") + if not args.work_root.is_relative_to(Path("/tmp/echo-726-runtime")): + raise RuntimeError("Work must stay inside the declared runtime-data accounting root") + args.work_root.mkdir() + compiler_identity = verify_compiler_source(args.compiler_source, args.compiler_manifest) + compiler_identity["binarySha256"] = sha256(args.compiler) + before = {"application": snapshot(args.application_source), + "provider": snapshot(args.provider_package)} + source = (Path(__file__).parent / "LeafSlice.edict").read_bytes() + if source.count(SOURCE_EXPRESSION.encode()) != 1: + raise RuntimeError("Expected one exact authored slice expression") + sources = { + "baseline": (args.application_source / "src/ReplaceRange.edict").read_bytes(), + "guard-control": source.replace(SOURCE_EXPRESSION.encode(), b"input.blobBytes"), + "slice": source, + } + evidence = {"compiler": compiler_identity, "results": {}} + for name, authored in sources.items(): + root = args.work_root / name + prepare(root, args.application_source, args.provider_package, authored) + evidence["results"][name] = build(root, args.compiler) + (args.work_root / "evidence.json").write_text(json.dumps(evidence, indent=2) + "\n") + for name, result in evidence["results"].items(): + print(json.dumps({"case": name, **result}, sort_keys=True), flush=True) + if before != {"application": snapshot(args.application_source), + "provider": snapshot(args.provider_package)}: + raise RuntimeError("Witness changed an authoritative input") + if compiler_identity["binarySha256"] != sha256(args.compiler): + raise RuntimeError("Compiler binary changed during the witness") + verify_compiler_source(args.compiler_source, args.compiler_manifest) + for name in ("baseline", "guard-control"): + result = evidence["results"][name] + if result["exitCode"] != 0 or result["diagnostics"] or not result["artifacts"]: + raise RuntimeError(f"{name} positive control did not build") + result = evidence["results"]["slice"] + if result["exitCode"] != 2 or result["artifacts"]: + raise RuntimeError("Slice must refuse without application artifacts") + refusal = evidence["results"]["slice"]["diagnostics"] + if (len(refusal) != 1 or refusal[0].get("kind") != "ApplicationCompilationFailed" + or "pure helper `slice` has no compiler context fact" not in refusal[0].get("message", "")): + raise RuntimeError("Slice did not produce the expected source refusal") + print("JIM_LEAF_SLICE_SOURCE_BOUNDARY_CONFIRMED", flush=True) + + +if __name__ == "__main__": + main() From 0cd880224fafcd1f26f78552e7b34ad170ae6a04 Mon Sep 17 00:00:00 2001 From: James Ross Date: Sun, 4 Oct 2026 17:00:37 -0700 Subject: [PATCH 17/30] test(edict): retain candidate leaf-slice package evidence --- .../replace-range-probes/leaf-slice/README.md | 52 +- .../executable-operation-package.cbor | Bin 0 -> 7586 bytes .../verification-report.cbor | Bin 0 -> 924 bytes .../evidence/candidate-compiler-source.json | 451 ++++++++++++++++++ .../evidence/candidate-report-inspection.json | 70 +++ .../evidence/public-build-candidate.json | 57 +++ edict/replace-range-probes/leaf-slice/run.py | 27 +- 7 files changed, 646 insertions(+), 11 deletions(-) create mode 100644 edict/replace-range-probes/leaf-slice/evidence/candidate-artifacts/executable-operation-package.cbor create mode 100644 edict/replace-range-probes/leaf-slice/evidence/candidate-artifacts/verification-report.cbor create mode 100644 edict/replace-range-probes/leaf-slice/evidence/candidate-compiler-source.json create mode 100644 edict/replace-range-probes/leaf-slice/evidence/candidate-report-inspection.json create mode 100644 edict/replace-range-probes/leaf-slice/evidence/public-build-candidate.json diff --git a/edict/replace-range-probes/leaf-slice/README.md b/edict/replace-range-probes/leaf-slice/README.md index 1c19b44a..23669ece 100644 --- a/edict/replace-range-probes/leaf-slice/README.md +++ b/edict/replace-range-probes/leaf-slice/README.md @@ -34,7 +34,7 @@ provides comparison and length. Its source compiler also rejects Option types, so the first capability uses explicit range proofs instead of relying on an unavailable Option result. -The [retained public-build result](evidence/public-build-red.json) uses the +The [retained public-build RED](evidence/public-build-red.json) uses the already built experimental compiler `2405a550e93e1e97fff640caa44bbd0f65ffff3c`, with the unchanged Echo provider from `49e9efb68001dfd78563d18bac9359a87671e431`. It does **not** use or replace the frozen application's `3f81f759` compiler pin. @@ -59,6 +59,42 @@ provider refusal. Its actual successful build disproved that expectation. The harness assertion was corrected, with no source change, and the full paired witness passed with `JIM_LEAF_SLICE_SOURCE_BOUNDARY_CONFIRMED`. +## Candidate public build + +With Edict [PR #221](https://github.com/flyingrobots/edict/pull/221) at +`0835f398336ce1c693b5531b262228cd909c0b4b`, the **unchanged** source passes the +public application-build boundary with the same frozen provider. Both controls +also pass. The [retained candidate result](evidence/public-build-candidate.json) +records all source and output hashes. The witness checks all 445 compiler-source +files and the existing compiler binary before and after the run. + +The actual boundary is further than initially expected: the frozen provider +produces the [executable package](evidence/candidate-artifacts/executable-operation-package.cbor) +and [verification report](evidence/candidate-artifacts/verification-report.cbor). +A separate read-only CBOR inspection observed `outcome: accepted`, zero diagnostic +bytes, the `jedit.text.replace_range@1.sliceLeaf` coordinate, and the explicit +`core.bytes.slice` call in both retained Core and Target. Its +[inspection summary](evidence/candidate-report-inspection.json) records those +observations. This is an inspection of the existing verifier's report, not a +new independent verification implementation or evidence of evaluator support. + +| Retained artifact | Raw SHA-256 | +| --- | --- | +| Executable package | `bfacd029cf2dc9247cbcee47d747eca3f8298c7184cac3866eb36f3ab55573c1` | +| Verification report | `943ac86ea20c40d68881cc8413b926f98ba2a4ee99408e3dcede4eead1e7bb86` | + +The first candidate harness expected a provider refusal, so it failed its own +assertion after recording the successful builds. That was a harness expectation +mismatch, not a compiler failure. A fresh run with the correct package-boundary +assertion passed with `JIM_LEAF_SLICE_PACKAGE_BOUNDARY_CONFIRMED` and reproduced +identical package/report bytes for all three sources. The original source RED +and both positive controls are preserved. + +No evaluator was invoked. In particular, none of the twelve literal cases has +executed, and the accepted report does not establish the runtime primitive's +availability, metering, refusals, or rope behavior. Those require a fresh +generic evaluator witness using the exact retained package. + The frozen `edict/replace-range/` application, lawpack closure, producer pins, and artifact locks remain authoritative for the existing pure-boundary witness. This development source imports the same published lawpack in an isolated copy. @@ -95,6 +131,14 @@ identities are unchanged. Logs and an evidence JSON file remain under the work root. The runner's log-size check supplements the mandatory external resource guard; it is not a disk quota or permission to run without the guard. -Passing this refusal witness identifies the compiler boundary. Accepted slice -compilation, independent verification, generic execution of the literal cases, -and complete rope acceptance remain separate gates. +For the candidate build, use the exact `0835f398` compiler source and existing +binary SHA-256 `a5ffea7b16b641448db4d5dc608bec1539211ab683df3ab78985e12bb1c2fd15`, +select `evidence/candidate-compiler-source.json`, and add `--boundary package`. +That manifest has the same formatting qualification as the RED manifest. +Keep the provider unchanged: its manifest SHA-256 is +`c5b9fb2fe3a0dc4dad282621a97413225c555be0071f3502b3272952069d42dc`. +The runner records its actual hash and refuses mutation during the run. + +The public source RED and candidate package construction are established. +Generic execution of the literal cases and complete rope acceptance remain +separate gates. diff --git a/edict/replace-range-probes/leaf-slice/evidence/candidate-artifacts/executable-operation-package.cbor b/edict/replace-range-probes/leaf-slice/evidence/candidate-artifacts/executable-operation-package.cbor new file mode 100644 index 0000000000000000000000000000000000000000..fd9fa8b0b41d8fb470c1120f27a8ab7e2b48e9e2 GIT binary patch literal 7586 zcmeHMZ)_Y#6~6#cQw2ntN^Np(8n<#IB;>1|CLy7A65pjJhT0d|Nt>j=F}M46Z!Wt# z>zP@5E&j+3M3jPn4{eYTLW-}o%iqveN-IQF6i}o#z?VX*N~oem>Zb}Jg?s=jlsB_` zcf0o0PV3m>L%!Uf-I;mw-n{pF@BQYdmM|*dl5jH^6_#T@a3U%5I(=fCAU51P)@}Qo z*_^n?vKwa26Vx-qyA0;~)B)a!ugt&zv$MBe?$TK@EGmyLRl}`KeudsgSsGW2oAm9@J{pGf;kyRcz||j7u>!ZE&!r z%hYtLU{aZr5X$}CmPu_8@}wmyWc$utN86tWzH{5!Z}sy(e4k$ZTiXlg-rSV`)yRfz zUwZkE#X+{?(vVikcF4H0ydBw3oM~Ec#w;^)q6Qu_K}^;3aKix!W5fyINt19}e7$Ct zi2%K$8tw@2VXn(mrVHDfyUTI#9b!O<6VHbI-8pSkN*upJhKLK$f%Cew1aO!^oam>v zGw9EzeOFClABJ}_;NwF>605edG?W;SFp9{wxpAkaB0o0-gHM)6snqmV*^PJtr3CX>m8 zn>dUH6kWMkPwR&`voLXoTMdTU*$V{@a9)A~)VYVPtI-QKmPh3lN4+z9St>8gdQYM?iL z)}n#Rbv(W?`_7fOr(bWsGIwhKqxZb}_*m%|eFq=xGk)-L``kyEz&;kUno)3=KyaR} z#LX18Xt?z9y0dCjII3)>7F#U$E$IAiU%P+zy5qOZzVYZr*8c1x|NQ79x2~UBbGoga zPWnG1)j8Q*yU?hg7LyQeiZv@isC&?6CcXL7ai@H0I&tEnnW?ec8^R89z^t0s%6XWR zna6Y~(E}m&+P(K}-Z3 zN8PMKVXa6)vlcy8Qn~QX)I!BFb_#)^OmYAup-y5YHX=E8ahgcLetxeFXbA&hpJFM6 zy{T?5bf>NOhbZrF-jGQg!n|E$%~rsg3oABkSjIrq7N5K|wbSP0JofO&;0WY98k-l7 z)sk}4N)D@@zsOBIMh{C(YGSuD;V@#3L_|<}^a7K3B#;$`W#UA^Awqajfi_5dEb$yj z$(?sfT5ceVR$g&MV#UNJhz@l2BhuQf1rk27!U~V3j%bJ#{T0(OeMosCs2F0hKs@GQ zL+h-V+_V?=p&L|OK*%kQ0Y|E0e0hQu>18X|>L*A#qp%C`LoRD)Cq49I0kbg@~` zgup_9iRK2qNDCy6#W=P@%M$4=qGW>AK$%EfC=PYNR79$rKz&^zjmnBiPis6_*LE1I zgzG8ORgF`B;Axl@Q%`GJb2=h7W40^Z#3AW~02?7{OnWLDYT6SK7RIS5D++WgaodGW zAQCvl#qa2JLAS6;NK9iy6HOI&R6ux=RSq)X-eIiA)Y6W@gglIPa1gM=bQHv7s>ao* zW%smrq-MFAFD5<34<1rmQqQncFx59EO*~SKq9BZfr~E!CYT9K!MqYhW zGgSZm9CoAv>2^#_!$_*Bc+y;gqX~M%KsCUM2DnHsQBhwYY)gsK#emAu8eCiv_^Q%4 z#E{URn3p#7G8$t?qEQSBFmZqip9x)Gq-zNE(g7g^K~@5d48sviq4Kw86T`bxJ4q_t z&zSTv4@=!Tgl$A6Jp_Zs^J3Ydw$_+M3Hnf-<4cl@7+uL#ABa+Un2orD5>g^qh^jK6 zSy-*P^{M(DMmAzZqQUCYA|9;h5iH2?x#CUY+k{q}Y2?MRbDBPpmAa=!lTIYK1sXf` zKudn18u6jZ&903TZABl6hTkR1&jc3LZPmCgXb>Gvd`nci#%m$3tSPOM0mud+B~CH& zN}9LP+?KEYMjDkgy{_3UguSqY#Ct?<#V-`U<<|@Tk`Yz>Pe<2Ac<-SR^Jx20l{bd7 zzHTWsrz~|%!|PL;L|Ce`NYGo&MNfbC;ID6b=EAvs+wc5w@2Q#I^XI=ZxO4VD!R}XI z@A%lm_a6_mN0lP9N^Iu%Gf&Oz8UOj&w~P6={`^|*;k(z5WlJw+cK-XGqwkz2x7-zG zje5#2xj-2&M?e2 zidGfd^JdSTJ$x=Z`j@^vwTUDDZTn^ZA6wS!`{BEvy!lH1y5irT`_rYc&8njg?%C6L zlMw#WVD03Ap6@*-*Y|$n`LFd{{q~-Vx2^lh3#Z;V_U6U4uYDN8I}{9aga!O;A^xx1 ozI^!$zx~YY!DILT=8I?DC*WNBiL2juxTGnqI3v->)GR_lUdU#FgsS=Km`!IhBF|div3^_VClWMm z=c%n8?k(qMe#$6GEJ{x;@hk#akPk9KuecyFPdBqjzswNBv}t`FyVy4#+h%VhH_x_p zneCxNHNK|Hf0bHXzNx|+ZXK1CSdbZ(T2u^lR)r?mFbrqvmZcVDre&rU=@z9H#!XiYk}T6# zTj%b){_k1FGm)M72>ni#C8@;@g^2JAE=|fxO)goKngo)GWb|7ybVFJS9MTBC=@vsg z2Mn_c>BNG9oXli!N(o9WF3l+kD9Q)<92iC5G^LUS4C@lTlGKV4Jz$LFBqpcE7bWJU zr#cww6$5pq`lKeNVI+iW)|a`SRx)VcFNylID>lQ@{(Ae%|4Hd@?|KN!)a%T7o>`Qd zmRgjWmkdd`cwC5Kbj9|s(=VJk&;4`yR+HtES!PVtp42H@a Date: Sun, 4 Oct 2026 17:56:54 -0700 Subject: [PATCH 18/30] test(edict): pin authored range-fragment assembly pressure --- .../replace-range-probes/leaf-slice/README.md | 35 +- .../range-assembly/README.md | 101 + .../range-assembly/RangeAssembly.edict | 21 + .../range-assembly/cases.json | 78 + .../evidence/assembly-stderr.jsonl | 2 + .../evidence/assembly-stdout.jsonl | 0 .../evidence/baseline-stderr.jsonl | 0 .../evidence/baseline-stdout.jsonl | 1 + .../evidence/compiler-source.json | 1790 +++++++++++++++++ .../evidence/first-control-stderr.jsonl | 0 .../evidence/first-control-stdout.jsonl | 1 + .../evidence/public-build-red.json | 79 + .../evidence/second-control-stderr.jsonl | 0 .../evidence/second-control-stdout.jsonl | 1 + .../range-assembly/run.py | 72 + 15 files changed, 2172 insertions(+), 9 deletions(-) create mode 100644 edict/replace-range-probes/range-assembly/README.md create mode 100644 edict/replace-range-probes/range-assembly/RangeAssembly.edict create mode 100644 edict/replace-range-probes/range-assembly/cases.json create mode 100644 edict/replace-range-probes/range-assembly/evidence/assembly-stderr.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/assembly-stdout.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/baseline-stderr.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/baseline-stdout.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/compiler-source.json create mode 100644 edict/replace-range-probes/range-assembly/evidence/first-control-stderr.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/first-control-stdout.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/public-build-red.json create mode 100644 edict/replace-range-probes/range-assembly/evidence/second-control-stderr.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/second-control-stdout.jsonl create mode 100644 edict/replace-range-probes/range-assembly/run.py diff --git a/edict/replace-range-probes/leaf-slice/README.md b/edict/replace-range-probes/leaf-slice/README.md index 23669ece..63cdda9f 100644 --- a/edict/replace-range-probes/leaf-slice/README.md +++ b/edict/replace-range-probes/leaf-slice/README.md @@ -20,9 +20,9 @@ clipping, truncation, wrapping, or a host panic. A slice inside a UTF-8 code point is still a lawful byte slice; Jim's later UTF-8 validation owns rejection as a text operation. -[`cases.json`](cases.json) records literal future runtime expectations, including +[`cases.json`](cases.json) records literal runtime expectations, including empty, full, interior, binary, Unicode, invalid-range, and U64-limit inputs. -They are not claimed to have executed. The file is a conformance specification, never +They were not executed by the public compiler witnesses below. The file is a conformance specification, never an executable lawpack input or a substitute for the retained 40-case rope oracle. @@ -90,16 +90,33 @@ assertion passed with `JIM_LEAF_SLICE_PACKAGE_BOUNDARY_CONFIRMED` and reproduced identical package/report bytes for all three sources. The original source RED and both positive controls are preserved. -No evaluator was invoked. In particular, none of the twelve literal cases has -executed, and the accepted report does not establish the runtime primitive's -availability, metering, refusals, or rope behavior. Those require a fresh -generic evaluator witness using the exact retained package. +No evaluator was invoked during these public-build runs. The accepted report +does not establish runtime availability, metering, refusals, or rope behavior. +The separate runtime witness below covers the byte primitive. The frozen `edict/replace-range/` application, lawpack closure, producer pins, and artifact locks remain authoritative for the existing pure-boundary witness. This development source imports the same published lawpack in an isolated copy. It does not repin or regenerate that application. +## Separate generic runtime witness + +[Echo PR #746](https://github.com/flyingrobots/echo/pull/746) at +`bf11732478067e43dda400bab94aa0f6d186b614` consumes the exact retained package +and report. Its evaluator RED failed on the first interior slice with +`UnsupportedProgram`. Generic `core.bytes.slice` support then passed all twelve +literal cases, plus malformed-artifact and exact-budget controls. A test-only +application-name renaming control preserves outputs and costs; no Jim name +selects runtime behavior. Those mutated test controls are not new compiler or +verifier artifacts. + +The runtime change passed 40 relevant integration tests, four evaluator unit +tests, strict Clippy/formatting, and 187 routing assertions in guarded Docker. +[The exact test source](https://github.com/flyingrobots/echo/blob/bf11732478067e43dda400bab94aa0f6d186b614/crates/warp-core/tests/edict_byte_slice_tests.rs) +retains literal outputs and bounds. This establishes that generic primitive on +the named candidate; it does not migrate Jim's frozen evaluator pin, complete +rope traversal, or admit an edit with Tick/WAL/receipt/recovery evidence. + ## Reproduction discipline Use copied inputs in the existing guarded project Docker worker. Do not build @@ -139,6 +156,6 @@ Keep the provider unchanged: its manifest SHA-256 is `c5b9fb2fe3a0dc4dad282621a97413225c555be0071f3502b3272952069d42dc`. The runner records its actual hash and refuses mutation during the run. -The public source RED and candidate package construction are established. -Generic execution of the literal cases and complete rope acceptance remain -separate gates. +The public source RED, candidate package construction, and separately named +generic runtime witness are established. Complete rope acceptance and an +explicit consumer migration remain separate gates. diff --git a/edict/replace-range-probes/range-assembly/README.md b/edict/replace-range-probes/range-assembly/README.md new file mode 100644 index 00000000..faa82a5b --- /dev/null +++ b/edict/replace-range-probes/range-assembly/README.md @@ -0,0 +1,101 @@ +# Authored range-fragment assembly pressure + +`RangeAssembly.edict` isolates one append step of Jim's native range reader: +[`plan_replace_with_reason`](../../../native/jedit-echo-host/src/rope/replace.rs) +reads current range bytes at line 176 and compares them with replacement bytes +for the no-op decision. [`read_range_bytes`](../../../native/jedit-echo-host/src/rope/window.rs) +at line 136 calls `collect_range`, which visits left before right and appends +each selected leaf slice with `output.extend_from_slice(slice)` at line 244. +These source coordinates are inspected at Jim `0cd880224fafcd1f26f78552e7b34ad170ae6a04`. + +The authored operation receives two already selected fragments and joins them +in order with `+`. Each fragment has an eight-byte probe aperture, making the +sixteen-byte summed output bound explicit and testable with literal data. +Those small apertures are specimen bounds, not the application's rope limits. +This is raw byte concatenation: it does not interpret UTF-8, classify no-op, +traverse nodes, prove range length, fold a collection, join tree references, +or publish facts. Those semantics remain Jim-owned authored work under +[Jim #296](https://github.com/flyingrobots/jedit/issues/296) and draft PR #302. + +[`cases.json`](cases.json) specifies ten literal outputs and two input-type +refusals. These are future runtime conformance expectations, not executed +results, executable lawpack input, or the full rope oracle. Empty input has +its literal identity result; reversed fragment order changes the expected +bytes; invalid UTF-8 stays bytes. The full-aperture case requires the sum of +both static bounds, not either operand's bound alone. + +## Compiler boundary + +Inspection of Edict `ac836e5c42a5c47b0dab30cfb0b09848cca73215` found source `+` +dispatched to `check_string_concat`, which rejects non-String operands. The +[public compiler probe](evidence/public-build-red.json) confirms the source +failure below. GitHub merge `0f38fce33c2b8c0cad7bd8aeba110a34c9166a2d` and this +compiler have the identical source tree `dadd4703a9905a37ff366c7134aea5cfe351e2fd`. +The witness explicitly names the built compiler, not a substituted frozen pin. + +Two controls replace only the addition expression with `input.firstFragment` +or `input.secondFragment`. They retain both input fields and the declared +sixteen-byte output bound, so their actual build outcomes distinguish missing +byte concatenation from basic field/projection/type-bound failures. The frozen +boundary application is a third positive control. + +| Input | Public result | +| --- | --- | +| Frozen boundary source | Exit 0, package and separate report | +| First-fragment-only control | Exit 0, package and separate report | +| Second-fragment-only control | Exit 0, package and separate report | +| Exact `RangeAssembly.edict` | Exit 2, `ApplicationCompilationFailed` with `TypeCheck/TypeMismatch`; no application artifacts | + +The primary diagnostic is `string concatenation requires string operands`, +covering source bytes 430–472 at line 19. Later shorthand/return diagnostics are +cascades. [Raw assembly diagnostics](evidence/assembly-stderr.jsonl) and all +control streams are retained unchanged. The successful paired witness ends with +`JIM_RANGE_ASSEMBLY_SOURCE_BOUNDARY_CONFIRMED`. No runtime case was executed. + +The guarded worker rebuilt Edict with Rust 1.95.0 from the verified 446-file +source manifest, reproducing binary SHA-256 +`a937e6f150f73fa20e9868c84adee0a8270cc62130d4aef18e5b891ec268fee2`. +The frozen provider remains Echo `49e9efb68001dfd78563d18bac9359a87671e431`, +manifest SHA-256 +`c5b9fb2fe3a0dc4dad282621a97413225c555be0071f3502b3272952069d42dc`. +Source, binary, application, and provider identities were checked before and +after the public builds. One earlier preflight stopped before compilation +because the preserved `/edict/target` symlink appeared as an untracked file; +its destination was verified as the existing shared target before proceeding. +That setup stop is not the source RED. + +The unchanged published lawpack provides the profile and budget. The frozen +application root, producer pins, closure, and artifact locks are authoritative +for their existing witness and are not migrated by this development source. + +## Reproduction discipline + +Use copied inputs, the existing compiler and frozen provider package, the +shared Docker worker and Cargo target, workstation git-locks admission, +native locks, and the mandatory fail-closed disk/process guard. Record exact +compiler source and binary identities before a build. Keep generated apps, +artifacts, and streams under the owned bounded runtime-data directory. Do not +use historical build-in-image recipes or create another image, worker, or +cache. The twelve runtime expectations require separate generic evaluator +execution after an actual public build succeeds. + +Copy both this directory and the unchanged sibling `leaf-slice/run.py`; the +runner reuses that file's public-build and identity helpers. Provide the frozen +application root and provider package as read-only copied inputs, then invoke +inside the admitted guarded worker: + +```sh +python3 "$PROBE_ROOT/range-assembly/run.py" \ + --compiler "$EDICT_BINARY" \ + --compiler-source "$EDICT_SOURCE" \ + --compiler-manifest "$PROBE_ROOT/range-assembly/evidence/compiler-source.json" \ + --application-source "$APPLICATION_SOURCE" \ + --provider-package "$PROVIDER_PACKAGE" \ + --work-root /tmp/echo-726-runtime/jim-range-assembly-proof +``` + +The source manifest is read-only provenance, not executable compiler input. +Use a fresh work-root; retain unique evidence and recycle only owned disposable +copies after export. The runner's stream-size check does not replace the external +disk/process guard. The retained result is a compiler refusal witness, not +byte-concatenation runtime support or complete `ReplaceRange` behavior. diff --git a/edict/replace-range-probes/range-assembly/RangeAssembly.edict b/edict/replace-range-probes/range-assembly/RangeAssembly.edict new file mode 100644 index 00000000..f8905c8a --- /dev/null +++ b/edict/replace-range-probes/range-assembly/RangeAssembly.edict @@ -0,0 +1,21 @@ +package jedit.text.replace_range@1; + +use lawpack jedit.text@1 digest "sha256:95758c1605894672cc9069fde01bb8b6e11842b053102660c9cd4f4d6f34d64e" as text; + +type Input = { + firstFragment: Bytes, + secondFragment: Bytes, +}; + +type RangeBytes = { + bytes: Bytes, +}; + +intent assembleRange(input: Input) returns RangeBytes + profile text.replaceRange + basis none + budget <= text.replaceRangeBudget +{ + let bytes = input.firstFragment + input.secondFragment; + return { bytes }; +} diff --git a/edict/replace-range-probes/range-assembly/cases.json b/edict/replace-range-probes/range-assembly/cases.json new file mode 100644 index 00000000..ee8bcf9a --- /dev/null +++ b/edict/replace-range-probes/range-assembly/cases.json @@ -0,0 +1,78 @@ +{ + "schema": "jedit.range-fragment-assembly-cases/v1", + "operation": "jedit.text.replace_range@1.assembleRange", + "cases": [ + { + "name": "both-empty", + "firstHex": "", + "secondHex": "", + "bytesHex": "" + }, + { + "name": "first-empty", + "firstHex": "", + "secondHex": "6162", + "bytesHex": "6162" + }, + { + "name": "second-empty", + "firstHex": "6162", + "secondHex": "", + "bytesHex": "6162" + }, + { + "name": "in-order", + "firstHex": "61626364", + "secondHex": "65666768", + "bytesHex": "6162636465666768" + }, + { + "name": "different-order", + "firstHex": "65666768", + "secondHex": "61626364", + "bytesHex": "6566676861626364" + }, + { + "name": "binary-octets", + "firstHex": "00ff", + "secondHex": "807f", + "bytesHex": "00ff807f" + }, + { + "name": "codepoint-fragments", + "firstHex": "f09f", + "secondHex": "98ba", + "bytesHex": "f09f98ba" + }, + { + "name": "incomplete-codepoint-remains-bytes", + "firstHex": "f0", + "secondHex": "9f", + "bytesHex": "f09f" + }, + { + "name": "full-apertures", + "firstHex": "0001020304050607", + "secondHex": "08090a0b0c0d0e0f", + "bytesHex": "000102030405060708090a0b0c0d0e0f" + }, + { + "name": "repeated-bytes-preserved", + "firstHex": "ff00ff", + "secondHex": "ff00ff", + "bytesHex": "ff00ffff00ff" + }, + { + "name": "first-over-bound", + "firstHex": "000102030405060708", + "secondHex": "", + "refusal": "input-type" + }, + { + "name": "second-over-bound", + "firstHex": "", + "secondHex": "000102030405060708", + "refusal": "input-type" + } + ] +} diff --git a/edict/replace-range-probes/range-assembly/evidence/assembly-stderr.jsonl b/edict/replace-range-probes/range-assembly/evidence/assembly-stderr.jsonl new file mode 100644 index 00000000..8ae2e3aa --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/assembly-stderr.jsonl @@ -0,0 +1,2 @@ +{"command":"build","input":{"kind":"stdin"},"kind":"ApplicationCompilationFailed","message":"Edict application did not compile to Core: [CompilerError { stage: TypeCheck, kind: TypeMismatch, message: \"string concatenation requires string operands\", span: Span { start: 430, end: 472 } }, CompilerError { stage: TypeCheck, kind: UnresolvedType, message: \"record shorthand `bytes` has no typed binding\", span: Span { start: 485, end: 490 } }, CompilerError { stage: TypeCheck, kind: TypeMismatch, message: \"return value does not match declared output type\", span: Span { start: 283, end: 495 } }, CompilerError { stage: TypeCheck, kind: TypeMismatch, message: \"intent body must return a value\", span: Span { start: 283, end: 495 } }]","schema":"edict.cli.diagnostic/v1","severity":"error","stage":"cli","type":"diagnostic"} +{"checked":0,"command":"build","errors":1,"exitCode":2,"schema":"edict.cli.event/v1","status":"error","type":"status"} diff --git a/edict/replace-range-probes/range-assembly/evidence/assembly-stdout.jsonl b/edict/replace-range-probes/range-assembly/evidence/assembly-stdout.jsonl new file mode 100644 index 00000000..e69de29b diff --git a/edict/replace-range-probes/range-assembly/evidence/baseline-stderr.jsonl b/edict/replace-range-probes/range-assembly/evidence/baseline-stderr.jsonl new file mode 100644 index 00000000..e69de29b diff --git a/edict/replace-range-probes/range-assembly/evidence/baseline-stdout.jsonl b/edict/replace-range-probes/range-assembly/evidence/baseline-stdout.jsonl new file mode 100644 index 00000000..a668538e --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/baseline-stdout.jsonl @@ -0,0 +1 @@ +{"checked":1,"command":"build","errors":0,"exitCode":0,"schema":"edict.cli.event/v1","status":"ok","type":"status"} diff --git a/edict/replace-range-probes/range-assembly/evidence/compiler-source.json b/edict/replace-range-probes/range-assembly/evidence/compiler-source.json new file mode 100644 index 00000000..ed4a8f2c --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/compiler-source.json @@ -0,0 +1,1790 @@ +{ + "commit": "ac836e5c42a5c47b0dab30cfb0b09848cca73215", + "tree": "dadd4703a9905a37ff366c7134aea5cfe351e2fd", + "files": [ + { + "path": ".cargo/config.toml", + "gitBlob": "5592118f6c54bf8b53b16848e04ece896dd56384" + }, + { + "path": ".github/workflows/auto-release-tag.yml", + "gitBlob": "87404ceb685191afd496c93494b0bc61e2a59504" + }, + { + "path": ".github/workflows/ci.yml", + "gitBlob": "c6c6a17f59b6b96db88e3d4b2775bc64b7fe01f3" + }, + { + "path": ".github/workflows/release.yml", + "gitBlob": "2c612fc786998bfa5b11e76ae1185114a7cc535f" + }, + { + "path": ".gitignore", + "gitBlob": "30d7faf0fc8b7f010f99280302d4ed269d5da9ba" + }, + { + "path": ".markdownlint.json", + "gitBlob": "f3ec2c8dc2fbacc425154a2baedec50c7474aefa" + }, + { + "path": "AGENTS.md", + "gitBlob": "0c48a5794454cf84e20640994a372316efde7bb5" + }, + { + "path": "ARCHITECTURE.md", + "gitBlob": "5b513dd25028092e7e75c8974f1d5f3cc31889ed" + }, + { + "path": "CHANGELOG.md", + "gitBlob": "10a05a5561d05b79d087c2b660271e08d799771b" + }, + { + "path": "CODE_OF_CONDUCT.md", + "gitBlob": "784cf2799bcf8d2a69db5f5781359ef7e18a05fc" + }, + { + "path": "CONTRIBUTING.md", + "gitBlob": "9676914060f734dc59eabd9075898dc8170d4d19" + }, + { + "path": "Cargo.lock", + "gitBlob": "bacb208de0583f182379af7b5e078d31b25e2ca5" + }, + { + "path": "Cargo.toml", + "gitBlob": "b2e7106eb78f79230c091492ef21b497bdc9ed19" + }, + { + "path": "EDICT.md", + "gitBlob": "35376134195082d506f0161ba7ecb97efa8b770a" + }, + { + "path": "LICENSE", + "gitBlob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "NOTICE", + "gitBlob": "c300687bdd9d931d1f257d291e1cb6ff9d7d3607" + }, + { + "path": "README.md", + "gitBlob": "0812ef9a0c4611bf655dfc67d2ecc3631af9a536" + }, + { + "path": "ROADMAP.md", + "gitBlob": "d0e0135780537afab1d1a3f53808b363b35a63f4" + }, + { + "path": "SECURITY.md", + "gitBlob": "0bcc4e7375442e1334405a2d046df316cee05cd5" + }, + { + "path": "crates/edict-cli/Cargo.toml", + "gitBlob": "e9d844553c395bd312f84e806eb5bac30c5c3a54" + }, + { + "path": "crates/edict-cli/src/application_build.rs", + "gitBlob": "9c56ae6b4dd4eef0b9fe6db40316e100b2ffa699" + }, + { + "path": "crates/edict-cli/src/lawpack_build.rs", + "gitBlob": "55e9579153f34a3d5b139141c9de6640808cd386" + }, + { + "path": "crates/edict-cli/src/lawpack_build_windows.rs", + "gitBlob": "f71d03b368ae83becc1608bbba11cd5f1afa4f07" + }, + { + "path": "crates/edict-cli/src/lib.rs", + "gitBlob": "60883af60cf4b441680952ecce7ef4fcbfeabb97" + }, + { + "path": "crates/edict-cli/src/main.rs", + "gitBlob": "0dd9776642c4090479322111e4164ee7049fb9d0" + }, + { + "path": "crates/edict-cli/tests/golden_cli.rs", + "gitBlob": "9897caad3bcc6fa8bb0f20a1d0e18032285b1fa7" + }, + { + "path": "crates/edict-cli/tests/jsonl_cli.rs", + "gitBlob": "9ed353ca27d073fc7da49d3800c81ba4c58edd5d" + }, + { + "path": "crates/edict-cli/tests/lawpack_authoring_cli.rs", + "gitBlob": "dd7d7bfebf0e051c77d894a55c0204d373b19c63" + }, + { + "path": "crates/edict-provider-host-wasmtime/Cargo.toml", + "gitBlob": "ebeeb941f09012293d9923fe0e6039b2761b328e" + }, + { + "path": "crates/edict-provider-host-wasmtime/src/conversion.rs", + "gitBlob": "62c3cd4a85eb156b8c9a405ef3ea4d8a09b80cc3" + }, + { + "path": "crates/edict-provider-host-wasmtime/src/invocation.rs", + "gitBlob": "a4d6680d289094afebc0f1063abccf706f8149db" + }, + { + "path": "crates/edict-provider-host-wasmtime/src/lib.rs", + "gitBlob": "353ea7394f265219ebdecad56a3070c9e7d2685c" + }, + { + "path": "crates/edict-provider-host-wasmtime/src/limits.rs", + "gitBlob": "9e4d12c1b606d2b180f732db17bfbc78f8e26e3a" + }, + { + "path": "crates/edict-provider-host-wasmtime/src/replay.rs", + "gitBlob": "b8fa7be7c7ee5039793dad4cd0fa6a4f14ce388e" + }, + { + "path": "crates/edict-provider-host-wasmtime/tests/invocation.rs", + "gitBlob": "7a59a3192852a80bc01221ebf3dd1c437bda9508" + }, + { + "path": "crates/edict-provider-host-wasmtime/tests/preflight.rs", + "gitBlob": "a295e7547b0294f0355a85d5b9b8d045c8fceefd" + }, + { + "path": "crates/edict-provider-schema/Cargo.toml", + "gitBlob": "0e74f58acdc054ecce192cb8341afeaddc40deb5" + }, + { + "path": "crates/edict-provider-schema/src/contract_pack.rs", + "gitBlob": "370480d9c606134dd08ee62ae29ef143941e2f54" + }, + { + "path": "crates/edict-provider-schema/src/lib.rs", + "gitBlob": "51f5bee8892c9fb2122cb20022edc4d414759ff7" + }, + { + "path": "crates/edict-provider-schema/src/recursive_dispatch.rs", + "gitBlob": "6d97565b96f941b359d16f7a1c201189968fbeff" + }, + { + "path": "crates/edict-provider-schema/src/schema_safety.rs", + "gitBlob": "a2f605f62a2bfedcb84b68e37db9ff84b1dc3b05" + }, + { + "path": "crates/edict-provider-schema/tests/authority_facts_abi.rs", + "gitBlob": "7dd4d0302805ceecffc2045cdb91e386f8e08517" + }, + { + "path": "crates/edict-provider-schema/tests/provider_contract_pack.rs", + "gitBlob": "a26be8054b39215048825dd8cae7e9bddcfe27c9" + }, + { + "path": "crates/edict-provider-schema/tests/registry.rs", + "gitBlob": "bdd13ec00e441aef9e67ba49f6592ecbc7dcb303" + }, + { + "path": "crates/edict-syntax/Cargo.toml", + "gitBlob": "f55bb23e528af78b1e97b52f9b72cbd876a44ba7" + }, + { + "path": "crates/edict-syntax/src/admission.rs", + "gitBlob": "471430dd13a617bac886fcd44afbf15263e7db3b" + }, + { + "path": "crates/edict-syntax/src/ast.rs", + "gitBlob": "2a5d208a53a82408f8a18d9a13ccb133ec6a7a2e" + }, + { + "path": "crates/edict-syntax/src/authority_facts.rs", + "gitBlob": "644de86d63983bdbfbf1279fdbf1dbdaecc151d5" + }, + { + "path": "crates/edict-syntax/src/canonical.rs", + "gitBlob": "6fb29d50ea4a55eb888a1b9600cdcb31713a6e20" + }, + { + "path": "crates/edict-syntax/src/compiler.rs", + "gitBlob": "ad3efd3e92c23a54a9a279cbfa22b108895af3fb" + }, + { + "path": "crates/edict-syntax/src/compiler/byte_length.rs", + "gitBlob": "0d8d6291064415baee9253d9fe1e11ad87945773" + }, + { + "path": "crates/edict-syntax/src/compiler/byte_slice.rs", + "gitBlob": "84385fffdf4e38e21285e1fde252e9185a3a76fa" + }, + { + "path": "crates/edict-syntax/src/compiler/unsigned_subtraction.rs", + "gitBlob": "c2ef2deda74afb52e4346076a310df341556e1c8" + }, + { + "path": "crates/edict-syntax/src/contract_bundle.rs", + "gitBlob": "9a31645f0e30879d019787e29c21c82eebf58129" + }, + { + "path": "crates/edict-syntax/src/core_ir.rs", + "gitBlob": "4c6f350b325d13a27947687dd1f4114edf6d548d" + }, + { + "path": "crates/edict-syntax/src/highlight.rs", + "gitBlob": "28b3f7dcdfe8d4982bdcfb05759f769ccdbffc7f" + }, + { + "path": "crates/edict-syntax/src/lawpack.rs", + "gitBlob": "54f85bda48c960ad0b7bc316d332b379ab5b6ae0" + }, + { + "path": "crates/edict-syntax/src/lawpack_adapter.rs", + "gitBlob": "e425960e2437faa2f9eeb5d089ff507417d39586" + }, + { + "path": "crates/edict-syntax/src/lawpack_authoring.rs", + "gitBlob": "11ff578f458b8a4c8e4df75c0c616e37fa468d49" + }, + { + "path": "crates/edict-syntax/src/lib.rs", + "gitBlob": "7323475cc7f846e11c2d73f4c26a5e581b7e6157" + }, + { + "path": "crates/edict-syntax/src/lowerability.rs", + "gitBlob": "c6a1323fd6a79b0460b43aaf338956c3906a633e" + }, + { + "path": "crates/edict-syntax/src/parser.rs", + "gitBlob": "0b3650e3012e49023ccbb9cc9effe9b5b102f19d" + }, + { + "path": "crates/edict-syntax/src/provider.rs", + "gitBlob": "18fa661d880979c53dd335fb7e68d5445b638d4c" + }, + { + "path": "crates/edict-syntax/src/provider_invocation.rs", + "gitBlob": "2526168f0a6f2d1d9b6181b689ff43e203434122" + }, + { + "path": "crates/edict-syntax/src/provider_lowering.rs", + "gitBlob": "50a4e60b561127cb8c78e3f7c04c6bbaca068e52" + }, + { + "path": "crates/edict-syntax/src/result_projection.rs", + "gitBlob": "79ba246d4c58960fe368eaca4c7d135fe187832a" + }, + { + "path": "crates/edict-syntax/src/semantic.rs", + "gitBlob": "76bd133ef5859bf7722d1987613f7fd84836ab62" + }, + { + "path": "crates/edict-syntax/src/target_ir.rs", + "gitBlob": "c322a874d8a2341ae46a99b1b62eb952f4a49dfe" + }, + { + "path": "crates/edict-syntax/src/target_ir/byte_length.rs", + "gitBlob": "972e6ffa943bc7a7a943d76f0af42b342e3d2aac" + }, + { + "path": "crates/edict-syntax/src/target_ir/byte_slice.rs", + "gitBlob": "62a1c0b9e84a331bb17ab78090cce6d8eb8da486" + }, + { + "path": "crates/edict-syntax/src/target_ir/execution_order.rs", + "gitBlob": "e69a28805dc5e414a64afdaafee34161c217a044" + }, + { + "path": "crates/edict-syntax/src/target_ir/totality.rs", + "gitBlob": "a4fb9573d59e1a4bb9d7c250402c5b7e1da0a8c3" + }, + { + "path": "crates/edict-syntax/src/target_ir/unsigned_subtraction.rs", + "gitBlob": "b83522bfe9a2b506413b4d306f4bc49f8b053f36" + }, + { + "path": "crates/edict-syntax/src/target_profile.rs", + "gitBlob": "dd514f7380243e795f0655a78aecd06ee3fa2eda" + }, + { + "path": "crates/edict-syntax/src/target_profile_contract_resources.rs", + "gitBlob": "4efd22961c2fd7591440efd6087944ecaf21e991" + }, + { + "path": "crates/edict-syntax/src/token.rs", + "gitBlob": "2768586eea6d42d5df357c4cc62a011ee7f455de" + }, + { + "path": "crates/edict-syntax/tests/admission.rs", + "gitBlob": "57edbc320307c1d6daba85f03d8dc79558d7b849" + }, + { + "path": "crates/edict-syntax/tests/authority_facts.rs", + "gitBlob": "add9d272be6e8eb1cd6fdde2999a5fb452ecd852" + }, + { + "path": "crates/edict-syntax/tests/authority_facts_cbor.rs", + "gitBlob": "7359f047d9f731fee208efb5f69072b612d69547" + }, + { + "path": "crates/edict-syntax/tests/byte_length.rs", + "gitBlob": "50945944e8c2223abcc6b1081322432bc540c017" + }, + { + "path": "crates/edict-syntax/tests/byte_slice.rs", + "gitBlob": "99aae98ac1637a95532cdd833463210bbaa5a5be" + }, + { + "path": "crates/edict-syntax/tests/canonical_encoding.rs", + "gitBlob": "e4c5d59a88f88193f522eb555359919f7034a264" + }, + { + "path": "crates/edict-syntax/tests/common/mod.rs", + "gitBlob": "89560bfacb3dab031485c2dfa30d7eb325966574" + }, + { + "path": "crates/edict-syntax/tests/compiler_spine.rs", + "gitBlob": "2237318cfc0d4209e8a629e45320e42a4b72dbef" + }, + { + "path": "crates/edict-syntax/tests/contract_bundle.rs", + "gitBlob": "e6a2948335a0efc86d8bbb2e9e2c3d634e53965a" + }, + { + "path": "crates/edict-syntax/tests/core_golden_fixtures.rs", + "gitBlob": "0e0e42d19b52dc0557902dad9e1b85f37edf53f8" + }, + { + "path": "crates/edict-syntax/tests/core_graph_depth.rs", + "gitBlob": "1d95462ad2426d29b5974e6bb56ab8c125a92837" + }, + { + "path": "crates/edict-syntax/tests/external_action_requests.rs", + "gitBlob": "20aac8c03325ea0cdab8f4f54660cb980b4667c4" + }, + { + "path": "crates/edict-syntax/tests/highlighting.rs", + "gitBlob": "17e6b9ba08c96f0efb6efd440590f0fc917316e2" + }, + { + "path": "crates/edict-syntax/tests/lawpack.rs", + "gitBlob": "a675999ed96309358c8552a9d32781b5eede20dc" + }, + { + "path": "crates/edict-syntax/tests/lawpack_authoring.rs", + "gitBlob": "3a905cbd6d7d2625bc1d7826a6f6f1e991efbab0" + }, + { + "path": "crates/edict-syntax/tests/lowerability.rs", + "gitBlob": "5cfa58f5cbc51cccc7f119caddc1c3fcbc2e4806" + }, + { + "path": "crates/edict-syntax/tests/operation_prerequisites.rs", + "gitBlob": "753659e1a6e7751c455b8518226fa0902157a745" + }, + { + "path": "crates/edict-syntax/tests/parse_control_flow.rs", + "gitBlob": "5245561866d8902c1fbd5ab21f2e34807d568e17" + }, + { + "path": "crates/edict-syntax/tests/parse_greeting.rs", + "gitBlob": "f214d0c17745b8203d562780caa8f37b71c1e62c" + }, + { + "path": "crates/edict-syntax/tests/parse_hello.rs", + "gitBlob": "bf7b1b065277188f4be8754eb11ace94298394ba" + }, + { + "path": "crates/edict-syntax/tests/parse_keywords.rs", + "gitBlob": "78d8a64d785136d42a32655afda3df240c54f884" + }, + { + "path": "crates/edict-syntax/tests/parse_loops.rs", + "gitBlob": "d9ece2fce96fd6835d080055f06955d139c7e0ce" + }, + { + "path": "crates/edict-syntax/tests/parse_negative.rs", + "gitBlob": "17fdb983b8250470368a8f19d3a7bd9680052548" + }, + { + "path": "crates/edict-syntax/tests/parse_review_regressions.rs", + "gitBlob": "560215cfe044a528e190aa1ea7670e52b9365bdf" + }, + { + "path": "crates/edict-syntax/tests/parse_variants.rs", + "gitBlob": "8849f68f5ca1e2b06d0f66496e59b20d1c0fd022" + }, + { + "path": "crates/edict-syntax/tests/provider.rs", + "gitBlob": "7e8a596109b1e1fd3f22b3a0ef82f4755f127291" + }, + { + "path": "crates/edict-syntax/tests/provider_invocation.rs", + "gitBlob": "402647dd6701be65a9e693fd3f5688f26d84988e" + }, + { + "path": "crates/edict-syntax/tests/provider_lowering.rs", + "gitBlob": "411c306f3ab641de9dc2f7aed229767eba9dbd72" + }, + { + "path": "crates/edict-syntax/tests/result_projection.rs", + "gitBlob": "a74dd2a419266cb77d846d83da27f726095660f1" + }, + { + "path": "crates/edict-syntax/tests/semantic_validation.rs", + "gitBlob": "a127988d178c00ed12a0a25f70df6b7fd5e6d931" + }, + { + "path": "crates/edict-syntax/tests/target_ir.rs", + "gitBlob": "928e1cf921dead0b559bd115bb6eef3faaddd37e" + }, + { + "path": "crates/edict-syntax/tests/target_ir/ordered.rs", + "gitBlob": "a1b05db81a97a43ec5a2dc2d9bcc9578bc286f30" + }, + { + "path": "crates/edict-syntax/tests/target_profile.rs", + "gitBlob": "42f1c907f6c60dea1e8a9b4558b56ffd0b3a59ab" + }, + { + "path": "crates/edict-syntax/tests/target_profile_contract_resources.rs", + "gitBlob": "270c180a12dc10fb7e208cc4dc1e202da82c85fb" + }, + { + "path": "crates/edict-syntax/tests/target_unsigned_subtraction.rs", + "gitBlob": "e30d91f896afda48eb3cf11617bccf1f9d160e32" + }, + { + "path": "crates/edict-syntax/tests/unsigned_subtraction.rs", + "gitBlob": "fbd24482fdad4c8ceb4df41302b33595ada337ec" + }, + { + "path": "crates/edict/Cargo.toml", + "gitBlob": "525403f4f36db4040531e4dd747ec2398f9052cd" + }, + { + "path": "crates/edict/README.md", + "gitBlob": "a1ecf50bff3443d25a23fabfa6374d3f0a28ca82" + }, + { + "path": "crates/edict/src/lib.rs", + "gitBlob": "169d820759d6333f27a45ebb712bfcc4f0115107" + }, + { + "path": "crates/edict/tests/artifact_models.rs", + "gitBlob": "b923109c7195ce2c0071dc54179f0746b95329f0" + }, + { + "path": "crates/edict/tests/public_surface.rs", + "gitBlob": "a24c4bc9d9484f540da9b280790896701922968a" + }, + { + "path": "deny.toml", + "gitBlob": "e3f0f54060cead9a0d48b96ed86948d0909c4f78" + }, + { + "path": "docs/DESIGN_runtime-neutral-edict-sha-lock-assurance.md", + "gitBlob": "ea3badf78ebd19545147a93671fdb5f9af4a61ea" + }, + { + "path": "docs/GUIDE_edict-assurance-transparency.md", + "gitBlob": "100321157ec43055c45794f1c161b1e5281ba6b4" + }, + { + "path": "docs/README.md", + "gitBlob": "e21739b842be14d91a17f2508b1a1b629754af01" + }, + { + "path": "docs/REQUIREMENTS.md", + "gitBlob": "52d98fecd60eb04ce55105ae2eb33997248698cb" + }, + { + "path": "docs/RETRO_phase1-parser.md", + "gitBlob": "5cfb7b85ca2f140fc58f9186c47e4635e94a1e6f" + }, + { + "path": "docs/SPEC_continuum-admission-v1.md", + "gitBlob": "0a74a0bfc642337d5d7a85133ce50a0a22caffbd" + }, + { + "path": "docs/SPEC_continuum-contract-bundle-v1.md", + "gitBlob": "65b36bb33a34beb1f246d1f97384631c83ca631e" + }, + { + "path": "docs/SPEC_edict-language-v1.md", + "gitBlob": "37ac2382f6ed09b314e64cce819a4de8c6fb7321" + }, + { + "path": "docs/SPEC_edict-lawpack-abi-v1.md", + "gitBlob": "ea1d801f07ab3677f7a411a1f58a28feda589ec3" + }, + { + "path": "docs/SPEC_edict-target-profile-abi-v1.md", + "gitBlob": "91687bfe45565a21f5f93f6ce9eed84095268691" + }, + { + "path": "docs/TECHNICAL_EXPLANATION.md", + "gitBlob": "d88561c0552c0e75d1ecc2eef6f9afd003e99674" + }, + { + "path": "docs/abi/edict-authority-facts.cddl", + "gitBlob": "e9a6d8685706ae0d8dabda401655234161e94299" + }, + { + "path": "docs/abi/edict-common.cddl", + "gitBlob": "836c11b92425beb6d42b378c0defe6f02d144dd7" + }, + { + "path": "docs/abi/edict-core.cddl", + "gitBlob": "862f02939fcc3858b4a60cb75f9bf149eae8ffda" + }, + { + "path": "docs/abi/edict-lawpack-adapter.cddl", + "gitBlob": "8e887c2e196ba7502470ddb45dc7cfd10116ad6b" + }, + { + "path": "docs/abi/edict-lawpack.cddl", + "gitBlob": "96efd51d437ec785b108b51835e9e8bf87aeab51" + }, + { + "path": "docs/abi/edict-result-projection.cddl", + "gitBlob": "98b5c2e861e7e9b66b7481502287cb041f6e77e6" + }, + { + "path": "docs/abi/edict-target-ir.cddl", + "gitBlob": "98134f277ded1920a3a36e5e3946c51153f2e84d" + }, + { + "path": "docs/abi/edict-target-profile.cddl", + "gitBlob": "746ae03001310f3a83524e5332819dad1a4eea5a" + }, + { + "path": "docs/abi/edict-target-provider.wit", + "gitBlob": "0efa5903a52d38dc61e429619d86322c6c5f1fa0" + }, + { + "path": "docs/audit/2026-06-28_code-quality.md", + "gitBlob": "143cbf4f4491a76a6649e919c6edaba73f0bcf4b" + }, + { + "path": "docs/audit/2026-06-28_documentation-quality.md", + "gitBlob": "656b4fa8dea43306af1818f8622cafd72e82a370" + }, + { + "path": "docs/audit/2026-06-28_ship-readiness.md", + "gitBlob": "b9d34a8693564d0134f550092e7645e5d5137442" + }, + { + "path": "docs/design/authority-fact-governance.md", + "gitBlob": "8531061cf718c47ec791f5712b2f357d92adc9e4" + }, + { + "path": "docs/design/canonical-target-ir-v0.11.md", + "gitBlob": "a46acb84e3523b51e2348c776cfdb63a8b98107a" + }, + { + "path": "docs/design/contract-bundle-assembly-v0.11.md", + "gitBlob": "a364f8ade5445808f87cf0c63ab3484c03ad616a" + }, + { + "path": "docs/design/crate-scope-v0.11.md", + "gitBlob": "92fe92285d02465d84bbe82e29d051fdc461f3a6" + }, + { + "path": "docs/design/obstruction-strands-v0.md", + "gitBlob": "81f70fd688c12798cd23472a4e810191e61eabe2" + }, + { + "path": "docs/design/provider-artifact-pipeline-alpha.md", + "gitBlob": "60eefa7dc160aba986bcd1188b79610ff5e9f299" + }, + { + "path": "docs/design/schema-as-sot-codegen.md", + "gitBlob": "d818e0e3f1fafd1d3aba26cb37c739f3ebe69763" + }, + { + "path": "docs/design/v2-obligation-closure.md", + "gitBlob": "816d22d843a33c6f7e143da4cb45e80679609dc8" + }, + { + "path": "docs/releases/v0.1.0-alpha.1.md", + "gitBlob": "5dd96057ba7f109cf5e5acde16e29d18627f98d3" + }, + { + "path": "docs/releases/v0.10.0-alpha.1.md", + "gitBlob": "363c4e9ed6f5ea5758198c7124681b520098e583" + }, + { + "path": "docs/releases/v0.11.0-alpha.1.md", + "gitBlob": "4612dbb5a1aaf20710bdb199b658ded7ced4ebab" + }, + { + "path": "docs/releases/v0.2.0-alpha.1.md", + "gitBlob": "7302ef93ed5ff9b562d9cec92d49d85a6b789b27" + }, + { + "path": "docs/releases/v0.3.0-alpha.1.md", + "gitBlob": "bf023ba4ca2c38f0120c461781447d58fe239ae0" + }, + { + "path": "docs/releases/v0.4.0-alpha.1.md", + "gitBlob": "769500b59800c02c536b76b0eb850d06d6cd8f58" + }, + { + "path": "docs/releases/v0.5.0-alpha.1.md", + "gitBlob": "7c7354e89846ea816992aaf55d4ad04367d61a10" + }, + { + "path": "docs/releases/v0.6.0-alpha.1.md", + "gitBlob": "3f2a0edfc4bccd9f3c60a7443ef4f8cbcbac1971" + }, + { + "path": "docs/releases/v0.7.0-alpha.1.md", + "gitBlob": "57671d5ef5a6b9f16d1674e0a35ddeb86ff126a8" + }, + { + "path": "docs/releases/v0.8.0-alpha.1.md", + "gitBlob": "12f77bda185c54fbbd136bf0dc7292716ecdfa39" + }, + { + "path": "docs/releases/v0.9.0-alpha.1.md", + "gitBlob": "fa295fcf0967415bb052f238256919b32b3fe6ba" + }, + { + "path": "docs/schemas/edict.cli-check-result.v1.schema.json", + "gitBlob": "eef8cd11f07e06d68b7051efa60ae05f2cfd8a63" + }, + { + "path": "docs/schemas/edict.cli-diagnostic.v1.schema.json", + "gitBlob": "92a2151a76893c598a4191ed6cecd8a0e671613f" + }, + { + "path": "docs/schemas/edict.cli-event.v1.schema.json", + "gitBlob": "705d82a893c2ea91caa91ad6977a9be8646b47bb" + }, + { + "path": "docs/schemas/edict.cli-info.v1.schema.json", + "gitBlob": "2d9a0777b4190b56ff569625275d352d17363afa" + }, + { + "path": "docs/schemas/edict.compiler-input.v1.schema.json", + "gitBlob": "26da3ba0fe85fab4c826ad79f13968ce09c4f29b" + }, + { + "path": "docs/schemas/edict.compiler-settings.v1.schema.json", + "gitBlob": "a3e8ba469895b84ab81724da1075c73141a8dd0c" + }, + { + "path": "docs/schemas/edict.projection-core.v1.schema.json", + "gitBlob": "8c0afe3834256abd1e18efb5f31eae1c4bdf0374" + }, + { + "path": "docs/schemas/edict.projection-diagnostics.v1.schema.json", + "gitBlob": "28cfb0a67dff7b8f879122c74433158dc0a4e5df" + }, + { + "path": "docs/schemas/edict.projection-syntax.v1.schema.json", + "gitBlob": "a85f2e14f536863f5e7b107b1a9f3f10816e6234" + }, + { + "path": "docs/schemas/edict.projection-target-ir.v1.schema.json", + "gitBlob": "8bbb6495ad8800d775d1c08506e85351038d678a" + }, + { + "path": "docs/topics/README.md", + "gitBlob": "99b06d3124c71cb62dfe6faff7604c13063162a7" + }, + { + "path": "docs/topics/admission/README.md", + "gitBlob": "755dcba96c0a428eec18d58a529f3e26d57d118c" + }, + { + "path": "docs/topics/admission/test-plan.md", + "gitBlob": "68ee0a2d2502103285985bf862de9fadf2bac5a0" + }, + { + "path": "docs/topics/assurance/README.md", + "gitBlob": "cf382008f3d3094a5380a687abbf07538e07404d" + }, + { + "path": "docs/topics/assurance/test-plan.md", + "gitBlob": "0ea6c971924db763088577a0a52bbd30bfec814c" + }, + { + "path": "docs/topics/authority-facts/README.md", + "gitBlob": "c5589d2489d6e4a5729c0df2b2655ff281d8d88d" + }, + { + "path": "docs/topics/authority-facts/test-plan.md", + "gitBlob": "e3769edf8309347b23ffa2e8f0901e06feabd654" + }, + { + "path": "docs/topics/cli/README.md", + "gitBlob": "af38946c9ccae8da343877c3861b0f52b6076e1b" + }, + { + "path": "docs/topics/cli/test-plan.md", + "gitBlob": "d72d69ef1d340ffd7057a63dd7bc07e3dfb2c166" + }, + { + "path": "docs/topics/compiler-spine/README.md", + "gitBlob": "39e64c586dd8b217b72d481e533f28a7049b3b0d" + }, + { + "path": "docs/topics/compiler-spine/test-plan.md", + "gitBlob": "73e31cad62f0915a06bf2c6fb40f216e96ea05a7" + }, + { + "path": "docs/topics/contract-bundles/README.md", + "gitBlob": "2347499e8da9dd57bb1588faf67fe386c7a70c03" + }, + { + "path": "docs/topics/contract-bundles/test-plan.md", + "gitBlob": "3ae4c7362f90fa89081ab9ff2bf1c3db1a811874" + }, + { + "path": "docs/topics/core-ir/README.md", + "gitBlob": "d747a18d1f53de2b29473ada7a06b819c77cd162" + }, + { + "path": "docs/topics/core-ir/canonical-encoding.md", + "gitBlob": "34927c69fb1de10b685294a155fc46bb4ac21628" + }, + { + "path": "docs/topics/core-ir/test-plan.md", + "gitBlob": "0f80304a4dd6b160c78674b73605bdbbb7e11066" + }, + { + "path": "docs/topics/developer-tooling/README.md", + "gitBlob": "8648d3c1bdf4f6b774bc5fec71c71aa8c59b0ce8" + }, + { + "path": "docs/topics/developer-tooling/test-plan.md", + "gitBlob": "9240f717434dfbca08a6366e6d3ebafd4ef2c908" + }, + { + "path": "docs/topics/documentation/README.md", + "gitBlob": "34fa7f4db136c274a88b680f99619d657fda15d5" + }, + { + "path": "docs/topics/documentation/test-plan.md", + "gitBlob": "47964954fbf640211bc30b0dd361c44c9955c488" + }, + { + "path": "docs/topics/external-action-requests/README.md", + "gitBlob": "45bc73e469919d3eff6e7eddbe9baa0383c7d91b" + }, + { + "path": "docs/topics/external-action-requests/test-plan.md", + "gitBlob": "38e7e53827d223c031d414f4ecd63720eb78eae0" + }, + { + "path": "docs/topics/fixtures/README.md", + "gitBlob": "c8b3b196109fb6d4e37d8ffa17635166010075fb" + }, + { + "path": "docs/topics/fixtures/test-plan.md", + "gitBlob": "624357dbc544d365835390d3d3c2f11015b7b82f" + }, + { + "path": "docs/topics/lawpack-authoring/README.md", + "gitBlob": "74bb25cc22e1f88cf4ee952b42313d919339113a" + }, + { + "path": "docs/topics/lawpack-authoring/test-plan.md", + "gitBlob": "d7ad2eacde45dbce3eeb2b1a22c6482134b841ba" + }, + { + "path": "docs/topics/lawpacks/README.md", + "gitBlob": "dedaa524dc55663a44bf8101241ab4b6d4755531" + }, + { + "path": "docs/topics/lawpacks/test-plan.md", + "gitBlob": "f8aa2c7ce40dad2665134956dc95d951d311808f" + }, + { + "path": "docs/topics/lowerability/README.md", + "gitBlob": "fb9519af3539d846dc5bf2915bf5ca86816e46f8" + }, + { + "path": "docs/topics/lowerability/test-plan.md", + "gitBlob": "e0fbff0799ba805c9531097d6b8aeea657e2b815" + }, + { + "path": "docs/topics/obstruction-strands/README.md", + "gitBlob": "a2930645065390cecff8008bfd48b7f034bfcd18" + }, + { + "path": "docs/topics/obstruction-strands/test-plan.md", + "gitBlob": "20c54ffcaa19930a5bc772a49a5f01119054be2d" + }, + { + "path": "docs/topics/providers/README.md", + "gitBlob": "8b5a07fb9c708b753861a4e156b866115f4d687b" + }, + { + "path": "docs/topics/providers/architecture.md", + "gitBlob": "664b38347ccaf37f298d6ac9f19d3423c0277f9e" + }, + { + "path": "docs/topics/providers/test-plan.md", + "gitBlob": "95c55f9e132ca6859fd9df70470973e678ed8d92" + }, + { + "path": "docs/topics/public-rust-api/README.md", + "gitBlob": "c64a1081b7f693b02bd2ea63329f2610bae9d84c" + }, + { + "path": "docs/topics/public-rust-api/test-plan.md", + "gitBlob": "4c3b9e9662afd9edb790ba2b5c57ed5e93df595c" + }, + { + "path": "docs/topics/release-process/README.md", + "gitBlob": "a474ab8b6a4a58c5c73334c9e677be7c20d1837c" + }, + { + "path": "docs/topics/release-process/policy.toml", + "gitBlob": "e40b4f4ec721ae61210ec1bb022a847bcb49fb4a" + }, + { + "path": "docs/topics/release-process/runbook.md", + "gitBlob": "0b6bd8ef44cbfe8c7cdc347273fa74b7c96c4823" + }, + { + "path": "docs/topics/release-process/test-plan.md", + "gitBlob": "61ecded1d2318d7dd74070cd1c6155f353c947e9" + }, + { + "path": "docs/topics/result-projections/README.md", + "gitBlob": "d5c2f85a7681a15dcdc3e35f992a389c50d13461" + }, + { + "path": "docs/topics/result-projections/test-plan.md", + "gitBlob": "9e69d58c88d6a9b7389334a78b994a3449721faa" + }, + { + "path": "docs/topics/review-process/README.md", + "gitBlob": "25190d37dc30110f75ba5d3a41494575ffecc1c3" + }, + { + "path": "docs/topics/review-process/policy.toml", + "gitBlob": "a826ba58aad2e509220b65aa8f96c290b600e094" + }, + { + "path": "docs/topics/review-process/test-plan.md", + "gitBlob": "f1a50aeae47913e4513a8149c1679d9a94c5ef21" + }, + { + "path": "docs/topics/rust-standards/README.md", + "gitBlob": "2fe29258705d117f4d10604a83fd832a8476e303" + }, + { + "path": "docs/topics/rust-standards/test-plan.md", + "gitBlob": "0e0d6b306cd2b58db07a7a5da6a752925fe58764" + }, + { + "path": "docs/topics/semantic-validation/README.md", + "gitBlob": "51cd9761755e7b5879069bf3774eeb487982ca97" + }, + { + "path": "docs/topics/semantic-validation/test-plan.md", + "gitBlob": "b43969d8eb0a884c1663ab761662f9622617bb3b" + }, + { + "path": "docs/topics/syntax/README.md", + "gitBlob": "b2a372bf41b1976567c61f400bf000f33abc20cc" + }, + { + "path": "docs/topics/syntax/test-plan.md", + "gitBlob": "a69efaf12dfe12661fca049b8790b37fa3fb3665" + }, + { + "path": "docs/topics/target-ir/README.md", + "gitBlob": "be30d1e24fda30aaa891ab03d53c2b8e287d9833" + }, + { + "path": "docs/topics/target-ir/test-plan.md", + "gitBlob": "cc94ae24fb452521c21f55db52a5c3e9ba09c424" + }, + { + "path": "docs/topics/target-profiles/README.md", + "gitBlob": "6a88f4d732f8069855b2ed2cb9a8769a117b2f60" + }, + { + "path": "docs/topics/target-profiles/test-plan.md", + "gitBlob": "90084c3f3a1296745469cd86e9b5f2bc928825be" + }, + { + "path": "docs/topics/tests/README.md", + "gitBlob": "4ad079b6a9718e2a8446a6c67ff45735015bef84" + }, + { + "path": "docs/topics/tests/test-plan.md", + "gitBlob": "46bc0572d02a41e86f71c6d46baf5be611a462a6" + }, + { + "path": "docs/topics/v2-design/README.md", + "gitBlob": "b33a07599e43e660aa4def7f119ddd02df6a16de" + }, + { + "path": "docs/topics/v2-design/test-plan.md", + "gitBlob": "f17f96d381f81b20842393f70ff55b9597858b84" + }, + { + "path": "editors/README.md", + "gitBlob": "7a933576262bc58bac197f9264fdbf649dd5e696" + }, + { + "path": "editors/vscode/.vscodeignore", + "gitBlob": "f15b3142e4b8af11d580789a0c82acee3499f571" + }, + { + "path": "editors/vscode/README.md", + "gitBlob": "8b29840ae9ec8f618b7364022329f694d0ed9746" + }, + { + "path": "editors/vscode/language-configuration.json", + "gitBlob": "b7f583841649c9c437785edbfcb70ee24e495c79" + }, + { + "path": "editors/vscode/package.json", + "gitBlob": "cd9e391e7c9afb6f9393fcead118e0e55aadc839" + }, + { + "path": "editors/vscode/syntaxes/edict.tmLanguage.json", + "gitBlob": "5847d8edfdb32d822f0f3950f41d00c947982185" + }, + { + "path": "fixtures/README.md", + "gitBlob": "470e3e0fc3aa00654930ecdef892ee9df8a42c8d" + }, + { + "path": "fixtures/authority-facts/canonical/README.md", + "gitBlob": "28692ce70add5d4f2d4ff5318309c3353924caf9" + }, + { + "path": "fixtures/authority-facts/canonical/example-effectful.authority-facts.cbor", + "gitBlob": "fe2e59a8e2602e02c52094010a130db2637c5227" + }, + { + "path": "fixtures/authority-facts/canonical/example-effectful.authority-facts.json", + "gitBlob": "009faa5d2dc1dcf55cf284dcfd14c0b6405f3e0d" + }, + { + "path": "fixtures/authority-facts/canonical/example-effectful.authority-facts.sha256", + "gitBlob": "a3d68f0a3b3a586e85b6a84cbd884866e662951f" + }, + { + "path": "fixtures/bundle/assembly/bounded-hello.bundle-digests.txt", + "gitBlob": "da5402db7bd41dd88c6152b7799723561130c91e" + }, + { + "path": "fixtures/cli/01-source-ok/expected.stdout.jsonl", + "gitBlob": "e08ccf8fdedd3a73beef5d06c443a1bc60274ce1" + }, + { + "path": "fixtures/cli/01-source-ok/request.jsonl", + "gitBlob": "002fea597e6b93c8468d6972b73cc1344600fa87" + }, + { + "path": "fixtures/cli/02-source-parse-rejection/exit", + "gitBlob": "d00491fd7e5bb6fa28c517a0bb32b8b506539d4d" + }, + { + "path": "fixtures/cli/02-source-parse-rejection/expected.stderr.jsonl", + "gitBlob": "1077b73c9a7c02eae99f737bea7b6ff8c64d04da" + }, + { + "path": "fixtures/cli/02-source-parse-rejection/request.jsonl", + "gitBlob": "dce01f0466bd9384fc6f5cbe2845b6e0bd9a9cfd" + }, + { + "path": "fixtures/cli/03-source-semantic-rejection/exit", + "gitBlob": "d00491fd7e5bb6fa28c517a0bb32b8b506539d4d" + }, + { + "path": "fixtures/cli/03-source-semantic-rejection/expected.stderr.jsonl", + "gitBlob": "5ec447700da52d0b4ce1f75825eb9bffaed4884b" + }, + { + "path": "fixtures/cli/03-source-semantic-rejection/request.jsonl", + "gitBlob": "ddfd529e5448760387961febbd4ce013e49de435" + }, + { + "path": "fixtures/cli/04-cli-missing-settings/exit", + "gitBlob": "0cfbf08886fca9a91cb753ec8734c84fcbe52c9f" + }, + { + "path": "fixtures/cli/04-cli-missing-settings/expected.stderr.jsonl", + "gitBlob": "5060bd2fd773ba9ea3ea6db8c80b86a846bfadbd" + }, + { + "path": "fixtures/cli/04-cli-missing-settings/request.jsonl", + "gitBlob": "8eb12e58d427bd64ccfe339190e05bdccf4c8634" + }, + { + "path": "fixtures/cli/05-path-input-ok/expected.stdout.jsonl", + "gitBlob": "a05fc582efc41b6414e785167b5deeb7532088ef" + }, + { + "path": "fixtures/cli/05-path-input-ok/inputs/hello.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/05-path-input-ok/request.jsonl", + "gitBlob": "18facaab79dc198134c535df389cba79efe7dce7" + }, + { + "path": "fixtures/cli/06-directory-expansion-ok/expected.stdout.jsonl", + "gitBlob": "ef59591526e2084ddf5057249bbc96ab660cf256" + }, + { + "path": "fixtures/cli/06-directory-expansion-ok/inputs/a.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/06-directory-expansion-ok/inputs/ignore.txt", + "gitBlob": "ed34ae8da336ff94a67b6125fbd6be730c976d91" + }, + { + "path": "fixtures/cli/06-directory-expansion-ok/inputs/nested/b.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/06-directory-expansion-ok/request.jsonl", + "gitBlob": "bd9aad14fe79caccacaa6d00ffd32b5e13b3551f" + }, + { + "path": "fixtures/cli/07-path-list-ok/expected.stdout.jsonl", + "gitBlob": "643ecb3e659c10cb98255ec1aced772778e76eb0" + }, + { + "path": "fixtures/cli/07-path-list-ok/inputs/first.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/07-path-list-ok/inputs/second.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/07-path-list-ok/request.jsonl", + "gitBlob": "f11265b02c5b7559ced4d975471a78b5bef3ee27" + }, + { + "path": "fixtures/cli/08-glob-expansion-ok/expected.stdout.jsonl", + "gitBlob": "90164a7fce6c51abdadef8f0586d2c56113d9712" + }, + { + "path": "fixtures/cli/08-glob-expansion-ok/inputs/x.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/08-glob-expansion-ok/inputs/y.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/08-glob-expansion-ok/request.jsonl", + "gitBlob": "9335acf3a008ab8fb9942b3e22d73c456ed3827e" + }, + { + "path": "fixtures/cli/09-shape-source-ok/expected.stdout.jsonl", + "gitBlob": "ac6f9259502ebfe484e1c07a5f53865888dd8207" + }, + { + "path": "fixtures/cli/09-shape-source-ok/request.jsonl", + "gitBlob": "64c75d9a7b40985bacf0e59a943a16e20419c602" + }, + { + "path": "fixtures/cli/10-input-extra-field/exit", + "gitBlob": "0cfbf08886fca9a91cb753ec8734c84fcbe52c9f" + }, + { + "path": "fixtures/cli/10-input-extra-field/expected.stderr.jsonl", + "gitBlob": "2f5a8fba093b71d15a5b37504ad0352191c8299c" + }, + { + "path": "fixtures/cli/10-input-extra-field/request.jsonl", + "gitBlob": "6052212c652d41f03144a7d3d4018b1cdd18cd09" + }, + { + "path": "fixtures/cli/11-input-hybrid-kind/exit", + "gitBlob": "0cfbf08886fca9a91cb753ec8734c84fcbe52c9f" + }, + { + "path": "fixtures/cli/11-input-hybrid-kind/expected.stderr.jsonl", + "gitBlob": "7b6d2ac0c8afbf5e3991498846c2fc4847ac9453" + }, + { + "path": "fixtures/cli/11-input-hybrid-kind/request.jsonl", + "gitBlob": "b893b640aa6631c77f2a889a807afa31632ac2db" + }, + { + "path": "fixtures/cli/12-input-too-large/env.json", + "gitBlob": "ab0c7f13fc6b22d61fc73da2f1787ff3aa298ecb" + }, + { + "path": "fixtures/cli/12-input-too-large/exit", + "gitBlob": "0cfbf08886fca9a91cb753ec8734c84fcbe52c9f" + }, + { + "path": "fixtures/cli/12-input-too-large/expected.stderr.jsonl", + "gitBlob": "ebda022d79c978d4ff511579512be2c642e3e902" + }, + { + "path": "fixtures/cli/12-input-too-large/request.jsonl", + "gitBlob": "1e2fbb102503356bbcc627f49a5b58590859f170" + }, + { + "path": "fixtures/cli/13-input-root-outside/allowed/.gitkeep", + "gitBlob": "8b137891791fe96927ad78e64b0aad7bded08bdc" + }, + { + "path": "fixtures/cli/13-input-root-outside/exit", + "gitBlob": "0cfbf08886fca9a91cb753ec8734c84fcbe52c9f" + }, + { + "path": "fixtures/cli/13-input-root-outside/expected.stderr.jsonl", + "gitBlob": "9c5b8567a755c9ea2ee6e0168bf96f429185f675" + }, + { + "path": "fixtures/cli/13-input-root-outside/outside/outside.edict", + "gitBlob": "44abebc15811c38cc266007484dd74ae10a26a4d" + }, + { + "path": "fixtures/cli/13-input-root-outside/request.jsonl", + "gitBlob": "116dbbb4b1a80938bc042e41747872cb6da161cd" + }, + { + "path": "fixtures/cli/README.md", + "gitBlob": "9388df4182fedec41c353e85cf9210e88906fa3d" + }, + { + "path": "fixtures/core/canonical/README.md", + "gitBlob": "d9a0ca79557c3623c0b843d9eff4808f94fd7b18" + }, + { + "path": "fixtures/core/canonical/bounded-hello.core.cbor", + "gitBlob": "a0ec54aa1a5e20624192091526445cfd803e6f0c" + }, + { + "path": "fixtures/core/canonical/bounded-hello.core.sha256", + "gitBlob": "86ba062c26a3ad3fd733ccd8c80d7faa7ed62d94" + }, + { + "path": "fixtures/core/canonical/statement-branch.core.hex", + "gitBlob": "c22760cace0e4d146a2fdc8d7c7b50c38497622a" + }, + { + "path": "fixtures/core/canonical/statement-branch.core.sha256", + "gitBlob": "0b62657b192232390479319f0a1c8f601020a58f" + }, + { + "path": "fixtures/core/canonical/workspace-snapshot.core.cbor", + "gitBlob": "58e4f724610861f5b61537bf386a87062e8a57a7" + }, + { + "path": "fixtures/core/canonical/workspace-snapshot.core.sha256", + "gitBlob": "4bcb3e0813cd3f4a7afc7cf311d846f1dfdd0a9d" + }, + { + "path": "fixtures/core/schema/accepted/core-fn-body-minimal.fields", + "gitBlob": "bef3ca412ab0ea97465b8658499ae5e05e1ec760" + }, + { + "path": "fixtures/core/schema/accepted/core-intent-minimal.fields", + "gitBlob": "268b28ce942fed4f139aafe5c7cd50c15a0ee640" + }, + { + "path": "fixtures/core/schema/accepted/core-module-minimal.fields", + "gitBlob": "249ff76349f936c9a5ff6cb65d81de8e80d53de8" + }, + { + "path": "fixtures/core/schema/rejected/core-fn-body-effect-node-field.fields", + "gitBlob": "9af8fa3540b25ec810936bc4dc82e26f6dd0dd48" + }, + { + "path": "fixtures/core/schema/rejected/core-intent-unknown-verified-mode.fields", + "gitBlob": "667ae032ee117f32c1bcbafd21393e406621f517" + }, + { + "path": "fixtures/core/schema/rejected/core-module-missing-intents.fields", + "gitBlob": "17f37c7ac4c199de4eace7f31e6a59b9a6d3a0f6" + }, + { + "path": "fixtures/core/schema/rejected/local-ref-missing-alpha-name.fields", + "gitBlob": "456a89528ffe74d892be40c9c9be4a078ff5c18a" + }, + { + "path": "fixtures/lang/bounds/bounded-hello.edict", + "gitBlob": "e3443a1d3b1c8f0e137ac698b621dd2f3afb673b" + }, + { + "path": "fixtures/lang/effects/conditional-blob.edict", + "gitBlob": "1e4f2ca6112f26d57ee4d20058666ec7cd693b75" + }, + { + "path": "fixtures/lang/effects/read-greeting.edict", + "gitBlob": "5e3838d1547be171e0a0384a7a200f52a2b9d139" + }, + { + "path": "fixtures/lang/external-actions/workspace-snapshot.edict", + "gitBlob": "e54b0fbccad2fd680505f3ee46ca28d39d7e776e" + }, + { + "path": "fixtures/lang/operations/explicit-basis-u64.edict", + "gitBlob": "444d8ca77b9827746df81885f0620dce2d1a3b73" + }, + { + "path": "fixtures/lang/tooling/highlight-smoke.edict", + "gitBlob": "8c2d91084be22e5e1594a42159992aca95c73612" + }, + { + "path": "fixtures/lang/types/color-match.edict", + "gitBlob": "dd98d6de677904f36d7601165a0094d92928e536" + }, + { + "path": "fixtures/lawpack/causal-cell/README.md", + "gitBlob": "52e8cc1e2af8aea86c1090a1b20b5f5ab3e07c06" + }, + { + "path": "fixtures/lawpack/causal-cell/adapter.cbor", + "gitBlob": "3b0c8b1b3a8591a322b6e785d9f963899319310c" + }, + { + "path": "fixtures/lawpack/causal-cell/adapter.sha256", + "gitBlob": "f8231bc941e1fbe02279865a82e183cbeeb0988a" + }, + { + "path": "fixtures/lawpack/causal-cell/echo-operation-configuration.cbor", + "gitBlob": "24527d30d0146b567fda157561ac6a2587cae919" + }, + { + "path": "fixtures/lawpack/causal-cell/echo-operation-configuration.sha256", + "gitBlob": "d293c8a14b1955a3e171703400c4df620c7871a1" + }, + { + "path": "fixtures/lawpack/causal-cell/exports.cbor", + "gitBlob": "384f4839adfe8e5b0f1aa848bfe2aeb1c3f640b6" + }, + { + "path": "fixtures/lawpack/causal-cell/exports.sha256", + "gitBlob": "4f836f6b03497338a1f8eacc55480cbe1a3b49e9" + }, + { + "path": "fixtures/lawpack/causal-cell/manifest.cbor", + "gitBlob": "b9311a236d7898861a0b90b1f30b852b35cef623" + }, + { + "path": "fixtures/lawpack/causal-cell/manifest.sha256", + "gitBlob": "685fd6a6c72fc3100d595d009b6198a81c731a40" + }, + { + "path": "fixtures/lawpack/hello-echo/README.md", + "gitBlob": "79f6612f1f5608a8f7dc4835e5470878cd27f96e" + }, + { + "path": "fixtures/lawpack/hello-echo/adapter.cbor", + "gitBlob": "24e2f546e2b97747b53462a72faaa1d5d85d62f1" + }, + { + "path": "fixtures/lawpack/hello-echo/adapter.sha256", + "gitBlob": "91df491028061e026ecaaeb4e1598e2ac369af44" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.core.cbor", + "gitBlob": "246b6135855c415def0bd89b275f0457752ee563" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.core.sha256", + "gitBlob": "9adc71605e0a275349161809614bd17de97d129c" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.edict", + "gitBlob": "825d50565230bd71d62bfbeb59d0399a89864b4c" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.result-projection.cbor", + "gitBlob": "981cba6e1c7ab6bdae6829116749c4796167e4e6" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.result-projection.sha256", + "gitBlob": "d55e4083771e1d9791f59cf87fd5cc5f1ea3b9f4" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.target-ir.cbor", + "gitBlob": "c8a934cefec17dbab0a43d9be9cebd2533268798" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.target-ir.sha256", + "gitBlob": "20186cbe9482e8a7df7c44fabec13ffd4efbcf36" + }, + { + "path": "fixtures/lawpack/hello-echo/echo-operation-configuration.cbor", + "gitBlob": "84838ab0d8627237232fa5a9b9fa39087bcc5f8a" + }, + { + "path": "fixtures/lawpack/hello-echo/echo-operation-configuration.sha256", + "gitBlob": "0898688f14067560dd22abd04b97f020071fd3e8" + }, + { + "path": "fixtures/lawpack/hello-echo/exports.cbor", + "gitBlob": "0e1220ceed9442a7b35870eeb02fcb65454d8c5c" + }, + { + "path": "fixtures/lawpack/hello-echo/exports.sha256", + "gitBlob": "e1f3e9223de9ce935bc7f60dda3cfa7d12d54fdc" + }, + { + "path": "fixtures/lawpack/hello-echo/manifest.cbor", + "gitBlob": "d715900f03ec454a0ad96e6710f52a46120d0b9d" + }, + { + "path": "fixtures/lawpack/hello-echo/manifest.sha256", + "gitBlob": "20171199b401cecace2dd74e18f3cc1d5c7ed3de" + }, + { + "path": "fixtures/lawpack/workspace-patch/README.md", + "gitBlob": "67cd35f2e0660aa7455de1c197ad821d5438679b" + }, + { + "path": "fixtures/lawpack/workspace-patch/adapter.cbor", + "gitBlob": "2d6f09a7e2fab381b97a05cfad1e692902e878c3" + }, + { + "path": "fixtures/lawpack/workspace-patch/adapter.sha256", + "gitBlob": "d44eb9675e126716e8a5ef3c53fd39ade49d76fb" + }, + { + "path": "fixtures/lawpack/workspace-patch/apply-validated-patch.core.cbor", + "gitBlob": "6a88c127e426288a3e51d4749d5c31d5b0cb60cb" + }, + { + "path": "fixtures/lawpack/workspace-patch/apply-validated-patch.core.sha256", + "gitBlob": "0204b6f1d8b346a67800a7738ee39df49e78571f" + }, + { + "path": "fixtures/lawpack/workspace-patch/apply-validated-patch.edict", + "gitBlob": "6e11a3d022a53a8fb2c20a77e35e29840f5fe086" + }, + { + "path": "fixtures/lawpack/workspace-patch/apply-validated-patch.target-ir.cbor", + "gitBlob": "a6124a995a3cdbb5d39cd0a6e046b329048703aa" + }, + { + "path": "fixtures/lawpack/workspace-patch/apply-validated-patch.target-ir.sha256", + "gitBlob": "f7ac419ce15b32d491e09bddbe7c75f8227f51d8" + }, + { + "path": "fixtures/lawpack/workspace-patch/exports.cbor", + "gitBlob": "3a6fd19dc8059b9fe1bde74fb1da61398b0e80cc" + }, + { + "path": "fixtures/lawpack/workspace-patch/exports.sha256", + "gitBlob": "b301dd883a31fffe324e9306ec90ae2b1ec44520" + }, + { + "path": "fixtures/lawpack/workspace-patch/input-schema.cbor", + "gitBlob": "3045d9b696864fefe111c3eb641b3b68532752d2" + }, + { + "path": "fixtures/lawpack/workspace-patch/input-schema.sha256", + "gitBlob": "9f1284b4f0a2c7f6dbe1915a6113cd13a9700cb8" + }, + { + "path": "fixtures/lawpack/workspace-patch/manifest.cbor", + "gitBlob": "77e56c7525f0e64ab191f0adfeac12b540c87848" + }, + { + "path": "fixtures/lawpack/workspace-patch/manifest.sha256", + "gitBlob": "8316978e68565f29a30a6978d33d907710185857" + }, + { + "path": "fixtures/lawpack/workspace-patch/reconciliation-law.cbor", + "gitBlob": "0736b75f81913fca7ac95c56ec45f66b95aea4cf" + }, + { + "path": "fixtures/lawpack/workspace-patch/reconciliation-law.sha256", + "gitBlob": "de31fc9fda59fa3c29397e5fc48db224e8e1fee7" + }, + { + "path": "fixtures/lawpack/workspace-patch/request-profile-configuration.cbor", + "gitBlob": "5e2870b2f562bafaa73a91a3fc192f5ed39257c7" + }, + { + "path": "fixtures/lawpack/workspace-patch/request-profile-configuration.sha256", + "gitBlob": "4345ae2e39ce3f4d9cfa6b0dddf4ce56d56c035c" + }, + { + "path": "fixtures/lawpack/workspace-patch/settlement-schema.cbor", + "gitBlob": "0a93ac19c51b341602eeba524769147e962d5d60" + }, + { + "path": "fixtures/lawpack/workspace-patch/settlement-schema.sha256", + "gitBlob": "f1bb3fb0313dd6815b4184345194949ec40fe9e1" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/README.md", + "gitBlob": "996bd1d29b28769fff477084d9118d0833ca2970" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/adapter.cbor", + "gitBlob": "9be4ea568b602b56269af505deb809989a3fa8b5" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/adapter.sha256", + "gitBlob": "1e287be0a322e5444dea15fa14bcfc7cf12975c4" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/exports.cbor", + "gitBlob": "33fe04db74775c191d4b7400e1fb2b6393c5a010" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/exports.sha256", + "gitBlob": "e057cac7fc360e6599b7ddab88508aaf0f2f55f8" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/input-schema.cbor", + "gitBlob": "49c849169946e44c8b5f300279dd085bd6b63aeb" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/input-schema.sha256", + "gitBlob": "9dd7bb6e48192e90d19fc346d1705f736b1d85d7" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/manifest.cbor", + "gitBlob": "d4e58e3d4646ca967170a6882f2a617cb8d81390" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/manifest.sha256", + "gitBlob": "0edb311125a89a5816ee3fa0c9b700c9b3bcff3d" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/observe-workspace.core.cbor", + "gitBlob": "a4b249dfb197f1a6b4adc06855f16e4305a1c798" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/observe-workspace.core.sha256", + "gitBlob": "ea6b914d14907d9fd915058e579aff33c954da2c" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/observe-workspace.edict", + "gitBlob": "c2c10f1ef1009796d67061b9722c4db9bb4e031b" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/observe-workspace.target-ir.cbor", + "gitBlob": "bdab1b0c55a34360c7e9ab304af91fe2b1e4afce" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/observe-workspace.target-ir.sha256", + "gitBlob": "7342aaa96221d6c8efa75ead2af5563791ccfeff" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/reconciliation-law.cbor", + "gitBlob": "df55572b350002a3df98ccb3e72dd60c86b9aead" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/reconciliation-law.sha256", + "gitBlob": "957cd04c78c130b07d2cad2fd7e07ae69978be57" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/request-profile-configuration.cbor", + "gitBlob": "708f18918ee1703491a910df82e129e711a4cc46" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/request-profile-configuration.sha256", + "gitBlob": "d9953d9dcaa41c98387226d1980f40b24d2bc3cb" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/settlement-schema.cbor", + "gitBlob": "f01ad68531267666e6bf93bf30a37d5b311c1676" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/settlement-schema.sha256", + "gitBlob": "06fcc0ee2b976a09b3017bd93132a3c51eb1317e" + }, + { + "path": "fixtures/obstruction-strands/v0/stale-basis/README.md", + "gitBlob": "25efbfa04e2e6104c5434f329128333e895e2b0a" + }, + { + "path": "fixtures/obstruction-strands/v0/stale-basis/source.edict", + "gitBlob": "e487b46e81220c50e6f928922dada29f3a21ca6a" + }, + { + "path": "fixtures/provider-contracts/v1/README.md", + "gitBlob": "447692907f9268ce3b6b78c43b7cbbb0417aeadf" + }, + { + "path": "fixtures/provider-contracts/v1/edict-provider-contracts.cddl", + "gitBlob": "07048aeeadb5062eabb89e995713cbc0893b7d7e" + }, + { + "path": "fixtures/provider-contracts/v1/manifest.json", + "gitBlob": "d2c8de5d61049e9f4182c630bf82b138f0f96792" + }, + { + "path": "fixtures/providers/README.md", + "gitBlob": "c26ee60a4930e3e0784c76cb855e48234a5c6b58" + }, + { + "path": "fixtures/providers/components/guests/Cargo.lock", + "gitBlob": "d7858ce7bc67deabb5ff352a24c85a7caa0ef4b0" + }, + { + "path": "fixtures/providers/components/guests/Cargo.toml", + "gitBlob": "450a24aed25dc73661b0ae8adfe2630dfecc9b07" + }, + { + "path": "fixtures/providers/components/guests/lowerer/Cargo.toml", + "gitBlob": "568aa137fa215b6b973fe31e12322530b393b9dc" + }, + { + "path": "fixtures/providers/components/guests/lowerer/src/lib.rs", + "gitBlob": "b39a8a0b18fe9ed7cb90277f793056434afa1318" + }, + { + "path": "fixtures/providers/components/guests/verifier/Cargo.toml", + "gitBlob": "f814f2c8c248bbf03389f5a0936f80cd4dada5b6" + }, + { + "path": "fixtures/providers/components/guests/verifier/src/lib.rs", + "gitBlob": "3f07ffdfd808ff95b206a2c08c2d481ccaf0e165" + }, + { + "path": "fixtures/providers/components/instantiation-failure-lowerer.component.wasm", + "gitBlob": "bd2d7c0d31798d7676aedab0bd0d289fc2053bef" + }, + { + "path": "fixtures/providers/components/instantiation-failure-lowerer.wat", + "gitBlob": "f6f5a70edb80d3a7fa1dee13b34ab5b8b44274d7" + }, + { + "path": "fixtures/providers/components/instantiation-fuel-lowerer.component.wasm", + "gitBlob": "0804d26d3ddb428682ca87ecad03cf0e05ef64af" + }, + { + "path": "fixtures/providers/components/instantiation-fuel-lowerer.wat", + "gitBlob": "80e972463ef593602d27c7d7cec78d87d22ff727" + }, + { + "path": "fixtures/providers/components/inventory.json", + "gitBlob": "45cf2e8e937a17a8ee05dfa8d68e94dcc155e129" + }, + { + "path": "fixtures/providers/components/lowerer.component.wasm", + "gitBlob": "6c1cf123a44284d15b7b1e90f1905ae94e65c158" + }, + { + "path": "fixtures/providers/components/malformed-lowerer.component.wasm", + "gitBlob": "be873af81100dc76ed1f3f1f818a41da45a38e4c" + }, + { + "path": "fixtures/providers/components/malformed-lowerer.wat", + "gitBlob": "1e7bfffe0a0baf230d9fb5766083f82198f4029c" + }, + { + "path": "fixtures/providers/components/verifier.component.wasm", + "gitBlob": "671adbe7931d0a9a5e0c78d459c244d37a135a69" + }, + { + "path": "fixtures/providers/echo-generated/provider-manifest.json", + "gitBlob": "22c8560e7ddecacd5da388e52d3935d7fc1474b9" + }, + { + "path": "fixtures/providers/echo-target-profile/README.md", + "gitBlob": "350c33dcda2d66d2d50e589c58db7c6d7b14a80b" + }, + { + "path": "fixtures/providers/echo-target-profile/generated/primary/target-profile.echo-dpo.cbor", + "gitBlob": "9fa43529b1021dfd8e3a33256c832d4eee6f4a47" + }, + { + "path": "fixtures/providers/wit/legacy-target-profile.wit", + "gitBlob": "ae7d6af764012b16bf06bfa260ccba98a7f04868" + }, + { + "path": "fixtures/target-ir/canonical/echo-effectful.target-ir.cbor", + "gitBlob": "727a80eb37319dbdbea40d7d9b4e37f0d93d8d84" + }, + { + "path": "fixtures/target-ir/canonical/echo-effectful.target-ir.sha256", + "gitBlob": "6d050bb46ac8981ea8e47c7a52371027b941fd89" + }, + { + "path": "fixtures/target-ir/canonical/gitwarp-append.target-ir.cbor", + "gitBlob": "89b46b138a7b90252a4397c0e8b622bceff10a33" + }, + { + "path": "fixtures/target-ir/canonical/gitwarp-append.target-ir.sha256", + "gitBlob": "a59a4ab9d46095d5be1797ed9e60fe841f821bce" + }, + { + "path": "fixtures/target-ir/canonical/workspace-snapshot.target-ir.cbor", + "gitBlob": "1854eeb549b3719fa2b0114867dbece6db1819d4" + }, + { + "path": "fixtures/target-ir/canonical/workspace-snapshot.target-ir.sha256", + "gitBlob": "4d0e501323d415ef9e64c0a3d25bdd57dabfc998" + }, + { + "path": "fixtures/target-profile/contract-resources/README.md", + "gitBlob": "32dcab1dd9376a4eed2c73bb1b1a29255fe3ea05" + }, + { + "path": "fixtures/target-profile/contract-resources/canonical-cbor.cbor", + "gitBlob": "4a95ba3bd9dff190ca5ec9c83262bfa6254a91d3" + }, + { + "path": "fixtures/target-profile/contract-resources/canonical-cbor.sha256", + "gitBlob": "2168df5d4bf77ed2347139dd7c45fd808df8ec7e" + }, + { + "path": "fixtures/target-profile/contract-resources/determinism.cbor", + "gitBlob": "09cd11c36048939961408550763c04fad8241557" + }, + { + "path": "fixtures/target-profile/contract-resources/determinism.sha256", + "gitBlob": "5376d6bfe23bea659463a7e3c56ad1e8afd4095f" + }, + { + "path": "fixtures/target-profile/contract-resources/diagnostics.cbor", + "gitBlob": "c47fa05f463e0da745fbcdf8daf94d70e134eb8d" + }, + { + "path": "fixtures/target-profile/contract-resources/diagnostics.sha256", + "gitBlob": "69613ec4014f27b23245e23fbf7c9447566516b2" + }, + { + "path": "fixtures/target-profile/contract-resources/fuel.cbor", + "gitBlob": "b5a3484ec5b2bf7343c2fcedc67bcb2b63a37104" + }, + { + "path": "fixtures/target-profile/contract-resources/fuel.sha256", + "gitBlob": "6ec1c830358ee35bb12bd04cc1a6edf47fb20997" + }, + { + "path": "fixtures/target-profile/contract-resources/wasm-component.cbor", + "gitBlob": "6344996c283e0d1c332ea3ce597ad4593882a3c5" + }, + { + "path": "fixtures/target-profile/contract-resources/wasm-component.sha256", + "gitBlob": "24bf3e552e4216d8258d2b85c8878af46a176c52" + }, + { + "path": "grammars/textmate/README.md", + "gitBlob": "fc116a669725d4e965d658234d32d779955d5dc8" + }, + { + "path": "grammars/textmate/edict.tmLanguage.json", + "gitBlob": "5847d8edfdb32d822f0f3950f41d00c947982185" + }, + { + "path": "grammars/tree-sitter-edict/README.md", + "gitBlob": "e2992a839d6719f1461db78c4e3f33d2e5ab0c09" + }, + { + "path": "grammars/tree-sitter-edict/grammar.js", + "gitBlob": "a82f5b9d9b78525f17a59272543fdcddd7a0da40" + }, + { + "path": "grammars/tree-sitter-edict/queries/highlights.scm", + "gitBlob": "0f46530b36996d13449901aed4e376a126577cba" + }, + { + "path": "grammars/tree-sitter-edict/src/grammar.json", + "gitBlob": "55df730a06b83c9f622e3ec17845fc9897c7d8c0" + }, + { + "path": "grammars/tree-sitter-edict/src/node-types.json", + "gitBlob": "520f6c4f7b30cd6892dd60faf6d76f3fbaa6a5c7" + }, + { + "path": "grammars/tree-sitter-edict/src/parser.c", + "gitBlob": "81cc4713cb5e05f9aa8dac16da202a864faefee6" + }, + { + "path": "grammars/tree-sitter-edict/src/tree_sitter/alloc.h", + "gitBlob": "1abdd1201578605b8d05a3001f01ebc0d58826d9" + }, + { + "path": "grammars/tree-sitter-edict/src/tree_sitter/array.h", + "gitBlob": "56fc8cd470996ded64a5452be25e26dbd2aa682a" + }, + { + "path": "grammars/tree-sitter-edict/src/tree_sitter/parser.h", + "gitBlob": "858107deb9e4a1ffcd2ed5e6ffe98a5fcab3e1f6" + }, + { + "path": "grammars/tree-sitter-edict/test/corpus/current-subset.txt", + "gitBlob": "732c5eda8e1bf95eef799476296a6ee061eb58eb" + }, + { + "path": "grammars/tree-sitter-edict/tree-sitter.json", + "gitBlob": "97d3fdd498a3bef509c8615d98b9560b527c03cb" + }, + { + "path": "scripts/consumer-witnesses/README.md", + "gitBlob": "2b7d2b9d81f9598fd8df232b3a76bef106ff7ef2" + }, + { + "path": "scripts/consumer-witnesses/jedit-state-read.Dockerfile", + "gitBlob": "7462059be67686090d0097b24b9d14bfbbd4c6f7" + }, + { + "path": "scripts/consumer-witnesses/jedit-state-read.Dockerfile.dockerignore", + "gitBlob": "ee41b3ca0a68fd5eb20e1b777b4b368fd8b44e63" + }, + { + "path": "scripts/consumer-witnesses/jedit-state-read.py", + "gitBlob": "26db295d4eabfc4e57813fc9bf17314c23350777" + }, + { + "path": "scripts/consumer-witnesses/run-jedit-state-read.sh", + "gitBlob": "18cd72bbbdfb17a5ea30a7821d47035071556d10" + }, + { + "path": "spec.lock.json", + "gitBlob": "ef8b02386e0f269a99c1d2121764f70b76e67620" + }, + { + "path": "xtask/Cargo.toml", + "gitBlob": "795c70a5172363bfcd55174b1bc76c9c131d21a3" + }, + { + "path": "xtask/src/contract_check.rs", + "gitBlob": "9e80393accf79936033972fde0f2aa2cf40f1be3" + }, + { + "path": "xtask/src/goldens.rs", + "gitBlob": "713f1f8266d9f6993684ae86db105fcd7d69ee2a" + }, + { + "path": "xtask/src/lawpack_goldens.rs", + "gitBlob": "c499e8581c73313794b83c261937144b3917850a" + }, + { + "path": "xtask/src/main.rs", + "gitBlob": "6c2c06038bb5ecdde60620071b200d8191dc116c" + }, + { + "path": "xtask/src/provider_components.rs", + "gitBlob": "ee9d6a1028f9fbfad879faab4b15a94b996ef6d4" + }, + { + "path": "xtask/src/provider_contract_pack.rs", + "gitBlob": "cf60d89892b7a57cc33300f273d2522a6e8f43f9" + }, + { + "path": "xtask/src/provider_dependencies.rs", + "gitBlob": "c4b0539ed593d2a2777d294090d2a891b13ae628" + }, + { + "path": "xtask/src/release_dates.rs", + "gitBlob": "1c6d7acb872f6d820eab3a30ca580e9c5cfba2ee" + }, + { + "path": "xtask/src/release_prep.rs", + "gitBlob": "01ed64ccbb28c9d1e908b7b800ff58076e5e1a2b" + }, + { + "path": "xtask/src/tests.rs", + "gitBlob": "9a3f6543c2dbae31d53e93d56f781e5d54f74f41" + }, + { + "path": "xtask/src/util.rs", + "gitBlob": "c1bf39e93460c43ffdcfd9a76e0424750cbb9dfd" + } + ] +} diff --git a/edict/replace-range-probes/range-assembly/evidence/first-control-stderr.jsonl b/edict/replace-range-probes/range-assembly/evidence/first-control-stderr.jsonl new file mode 100644 index 00000000..e69de29b diff --git a/edict/replace-range-probes/range-assembly/evidence/first-control-stdout.jsonl b/edict/replace-range-probes/range-assembly/evidence/first-control-stdout.jsonl new file mode 100644 index 00000000..a668538e --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/first-control-stdout.jsonl @@ -0,0 +1 @@ +{"checked":1,"command":"build","errors":0,"exitCode":0,"schema":"edict.cli.event/v1","status":"ok","type":"status"} diff --git a/edict/replace-range-probes/range-assembly/evidence/public-build-red.json b/edict/replace-range-probes/range-assembly/evidence/public-build-red.json new file mode 100644 index 00000000..33b9c136 --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/public-build-red.json @@ -0,0 +1,79 @@ +{ + "compiler": { + "commit": "ac836e5c42a5c47b0dab30cfb0b09848cca73215", + "tree": "dadd4703a9905a37ff366c7134aea5cfe351e2fd", + "fileCount": 446, + "manifestSha256": "1cf9cdb1a3bfacab2dfa515f7a07188c984ba0770399ee6ec3ef473b9383781e", + "binarySha256": "a937e6f150f73fa20e9868c84adee0a8270cc62130d4aef18e5b891ec268fee2" + }, + "providerManifestSha256": "c5b9fb2fe3a0dc4dad282621a97413225c555be0071f3502b3272952069d42dc", + "results": { + "baseline": { + "exitCode": 0, + "diagnostics": [], + "artifacts": [ + "executable-operation-package.cbor", + "verification-report.cbor" + ], + "sourceSha256": "51797e77062585a9f59083ee8a1da3faaf486ef7691e1b62203369a9d9356ee0", + "artifactSha256": { + "executable-operation-package.cbor": "1860ab8a6cb9a4bfd63a1db99d1c2bc00aa53dae52a9d1998295654379a95d85", + "verification-report.cbor": "d96e5d21eecbc1e5bbf6ce76ab438d55cc8e74f6843121d4ffb0f4343e648267" + }, + "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61", + "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "first-control": { + "exitCode": 0, + "diagnostics": [], + "artifacts": [ + "executable-operation-package.cbor", + "verification-report.cbor" + ], + "sourceSha256": "fa207e40f734fce99c581efbc5159a276c95e7b399d3acce854829ace05c6d2e", + "artifactSha256": { + "executable-operation-package.cbor": "d950cebad1bb978e24dfa736efab302eb0f5c96135cb32f27ad8781d6ace6b51", + "verification-report.cbor": "412fb923e3dbd3f070624446ae953920058e08eda5fdc94f201d9b475842c803" + }, + "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61", + "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "second-control": { + "exitCode": 0, + "diagnostics": [], + "artifacts": [ + "executable-operation-package.cbor", + "verification-report.cbor" + ], + "sourceSha256": "b7bdfce283a977bf2a04ec95d278138a9fbcaeb3e5eedefb909b6d617b1cf8c0", + "artifactSha256": { + "executable-operation-package.cbor": "e75c18f7265ea8fd7390e2e2d4ff49047323e99a07602d80442659d636fd61f4", + "verification-report.cbor": "463a47e58e00390937c565413305b4ec553928b86aae2979fbcbf631b55961d9" + }, + "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61", + "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "assembly": { + "exitCode": 2, + "diagnostics": [ + { + "command": "build", + "input": { + "kind": "stdin" + }, + "kind": "ApplicationCompilationFailed", + "message": "Edict application did not compile to Core: [CompilerError { stage: TypeCheck, kind: TypeMismatch, message: \"string concatenation requires string operands\", span: Span { start: 430, end: 472 } }, CompilerError { stage: TypeCheck, kind: UnresolvedType, message: \"record shorthand `bytes` has no typed binding\", span: Span { start: 485, end: 490 } }, CompilerError { stage: TypeCheck, kind: TypeMismatch, message: \"return value does not match declared output type\", span: Span { start: 283, end: 495 } }, CompilerError { stage: TypeCheck, kind: TypeMismatch, message: \"intent body must return a value\", span: Span { start: 283, end: 495 } }]", + "schema": "edict.cli.diagnostic/v1", + "severity": "error", + "stage": "cli", + "type": "diagnostic" + } + ], + "artifacts": [], + "sourceSha256": "8e8d2703759fb30cb49b73650ba8ddfd637d68b33b86145661bfca3033c968fc", + "artifactSha256": {}, + "stdoutSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderrSha256": "dfa643796ce3ecbca02f70ede806e6c50566456b3126747e3b496f6f35250d14" + } + } +} diff --git a/edict/replace-range-probes/range-assembly/evidence/second-control-stderr.jsonl b/edict/replace-range-probes/range-assembly/evidence/second-control-stderr.jsonl new file mode 100644 index 00000000..e69de29b diff --git a/edict/replace-range-probes/range-assembly/evidence/second-control-stdout.jsonl b/edict/replace-range-probes/range-assembly/evidence/second-control-stdout.jsonl new file mode 100644 index 00000000..a668538e --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/second-control-stdout.jsonl @@ -0,0 +1 @@ +{"checked":1,"command":"build","errors":0,"exitCode":0,"schema":"edict.cli.event/v1","status":"ok","type":"status"} diff --git a/edict/replace-range-probes/range-assembly/run.py b/edict/replace-range-probes/range-assembly/run.py new file mode 100644 index 00000000..adca6c7f --- /dev/null +++ b/edict/replace-range-probes/range-assembly/run.py @@ -0,0 +1,72 @@ +"""Exercise authored range-fragment assembly at Edict's public build boundary.""" + +import argparse +import json +from pathlib import Path +import runpy + + +COMPILER_COMMIT = "ac836e5c42a5c47b0dab30cfb0b09848cca73215" +SOURCE_EXPRESSION = b"input.firstFragment + input.secondFragment" + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + for name in ("compiler", "compiler-source", "compiler-manifest", "application-source", + "provider-package", "work-root"): + parser.add_argument("--" + name, type=Path, required=True) + args = parser.parse_args() + if not Path("/.dockerenv").is_file(): + raise RuntimeError("Run only under shared git-locks admission and the guarded Docker lease") + if not args.work_root.resolve().is_relative_to(Path("/tmp/echo-726-runtime")): + raise RuntimeError("Work must stay inside the declared runtime-data accounting root") + # Reuse the existing public-build orchestration without changing its specimen or pins. + common = runpy.run_path(str(Path(__file__).parent.parent / "leaf-slice/run.py")) + sha256, snapshot = common["sha256"], common["snapshot"] + verify = common["verify_compiler_source"] + args.work_root.mkdir() + compiler = verify(args.compiler_source, args.compiler_manifest, COMPILER_COMMIT) + compiler["binarySha256"] = sha256(args.compiler) + before = {"application": snapshot(args.application_source), + "provider": snapshot(args.provider_package)} + source = (Path(__file__).parent / "RangeAssembly.edict").read_bytes() + if source.count(SOURCE_EXPRESSION) != 1: + raise RuntimeError("Expected one exact authored fragment addition") + sources = { + "baseline": (args.application_source / "src/ReplaceRange.edict").read_bytes(), + "first-control": source.replace(SOURCE_EXPRESSION, b"input.firstFragment"), + "second-control": source.replace(SOURCE_EXPRESSION, b"input.secondFragment"), + "assembly": source, + } + evidence = {"compiler": compiler, + "providerManifestSha256": sha256(args.provider_package / "provider-manifest.echo.json"), + "results": {}} + for name, authored in sources.items(): + root = args.work_root / name + common["prepare"](root, args.application_source, args.provider_package, authored) + evidence["results"][name] = common["build"](root, args.compiler) + (args.work_root / "evidence.json").write_text(json.dumps(evidence, indent=2) + "\n") + for name, result in evidence["results"].items(): + print(json.dumps({"case": name, **result}, sort_keys=True), flush=True) + if before != {"application": snapshot(args.application_source), + "provider": snapshot(args.provider_package)}: + raise RuntimeError("Witness changed an authoritative input") + if compiler["binarySha256"] != sha256(args.compiler): + raise RuntimeError("Compiler binary changed during witness") + verify(args.compiler_source, args.compiler_manifest, COMPILER_COMMIT) + for name in ("baseline", "first-control", "second-control"): + result = evidence["results"][name] + if result["exitCode"] != 0 or result["diagnostics"] or not result["artifacts"]: + raise RuntimeError(f"{name} positive control did not build") + result = evidence["results"]["assembly"] + if result["exitCode"] != 2 or result["artifacts"]: + raise RuntimeError("Assembly must refuse without application artifacts") + refusal = result["diagnostics"] + if (len(refusal) != 1 or refusal[0].get("kind") != "ApplicationCompilationFailed" + or "string concatenation requires string operands" not in refusal[0].get("message", "")): + raise RuntimeError("Assembly did not produce the expected source refusal") + print("JIM_RANGE_ASSEMBLY_SOURCE_BOUNDARY_CONFIRMED", flush=True) + + +if __name__ == "__main__": + main() From 327ac11c71cc5a9a33c5552be7a6db533bf88f5d Mon Sep 17 00:00:00 2001 From: James Ross Date: Sun, 4 Oct 2026 18:30:05 -0700 Subject: [PATCH 19/30] test: retain range assembly candidate package evidence --- .../range-assembly/README.md | 52 +- .../executable-operation-package.cbor | Bin 0 -> 6055 bytes .../application/verification-report.cbor | 3 + .../evidence/candidate/assembly/stderr.jsonl | 0 .../evidence/candidate/assembly/stdout.jsonl | 1 + .../executable-operation-package.cbor | Bin 0 -> 9969 bytes .../application/verification-report.cbor | 1 + .../evidence/candidate/baseline/stderr.jsonl | 0 .../evidence/candidate/baseline/stdout.jsonl | 1 + .../candidate/compiler-source-sha256.json | 454 +++++ .../evidence/candidate/compiler-source.json | 1802 +++++++++++++++++ .../executable-operation-package.cbor | Bin 0 -> 5656 bytes .../application/verification-report.cbor | Bin 0 -> 932 bytes .../candidate/first-control/stderr.jsonl | 0 .../candidate/first-control/stdout.jsonl | 1 + .../candidate/git-locks-receipt.jsonl | 2 + .../evidence/candidate/guard.log | 5 + .../evidence/candidate/guard.result.json | 10 + .../portable-git-locks-receipt.jsonl | 2 + .../evidence/candidate/portable-guard.log | 5 + .../candidate/portable-guard.result.json | 10 + .../candidate/portable-public-build.json | 72 + .../evidence/candidate/public-build.json | 75 + .../executable-operation-package.cbor | Bin 0 -> 5658 bytes .../application/verification-report.cbor | 1 + .../candidate/second-control/stderr.jsonl | 0 .../candidate/second-control/stdout.jsonl | 1 + .../range-assembly/run.py | 13 +- 28 files changed, 2507 insertions(+), 4 deletions(-) create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/assembly/application/executable-operation-package.cbor create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/assembly/application/verification-report.cbor create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/assembly/stderr.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/assembly/stdout.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/baseline/application/executable-operation-package.cbor create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/baseline/application/verification-report.cbor create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/baseline/stderr.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/baseline/stdout.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/compiler-source-sha256.json create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/compiler-source.json create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/first-control/application/executable-operation-package.cbor create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/first-control/application/verification-report.cbor create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/first-control/stderr.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/first-control/stdout.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/git-locks-receipt.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/guard.log create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/guard.result.json create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/portable-git-locks-receipt.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/portable-guard.log create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/portable-guard.result.json create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/portable-public-build.json create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/public-build.json create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/second-control/application/executable-operation-package.cbor create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/second-control/application/verification-report.cbor create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/second-control/stderr.jsonl create mode 100644 edict/replace-range-probes/range-assembly/evidence/candidate/second-control/stdout.jsonl diff --git a/edict/replace-range-probes/range-assembly/README.md b/edict/replace-range-probes/range-assembly/README.md index faa82a5b..4d4d97bf 100644 --- a/edict/replace-range-probes/range-assembly/README.md +++ b/edict/replace-range-probes/range-assembly/README.md @@ -68,6 +68,47 @@ The unchanged published lawpack provides the profile and budget. The frozen application root, producer pins, closure, and artifact locks are authoritative for their existing witness and are not migrated by this development source. +## Candidate package boundary + +The unchanged authored source and all three controls also built with +[Edict's bounded-byte concatenation candidate](https://github.com/flyingrobots/edict/issues/222) +`01dc5abb9a8a74f8fd8b0e0a6d1041d0adb86d6e`. The +[retained public result](evidence/candidate/public-build.json) records exit 0, +no diagnostics, and an executable package plus separate verification report +for each source. This advances the source/compiler/package boundary; it does +not execute byte concatenation or any of the twelve runtime expectations. + +The candidate's 449 tracked source files and Git identity were verified before +and after the builds against the [original SHA-256 manifest](evidence/candidate/compiler-source-sha256.json). +Its tree is `74e571125a1da6ac5b2eac80944e343811708d51`; CLI SHA-256 is +`e2700698829b03f437c66425ed9878b002ef7a34ac183a39bac4eaf6a758cc6d`. +The [portable Git-blob manifest](evidence/candidate/compiler-source.json) +derives from the same exact commit and was checked against that original +manifest. The frozen provider manifest remains `c5b9fb2fe3a0dc4dad282621a97413225c555be0071f3502b3272952069d42dc`. + +Exact assembly artifacts are retained unchanged: + +- [Executable package](evidence/candidate/assembly/application/executable-operation-package.cbor): + SHA-256 `e889d4680435139fe76f45762f0529c090afcf3d73ef7d17f787d44a49bda534`. +- [Verification report](evidence/candidate/assembly/application/verification-report.cbor): + SHA-256 `7eec90854e0663aa2346ec5005ff7d05eeb50fc2229b32b407dda3cfa0280077`. + +The candidate directory also retains each control's package/report, all raw +compiler streams, the [guard output](evidence/candidate/guard.log), +[completion measurements](evidence/candidate/guard.result.json), and the +unchanged admission/release event records. The original RED above is preserved. +The application manifest, producer pins, source closure, and artifact locks remain unchanged. +The [portable runner replay](evidence/candidate/portable-public-build.json) +reproduced all four complete public result records, including identical source, +stream, package and report hashes. Its [guard log](evidence/candidate/portable-guard.log) +ends with `JIM_RANGE_ASSEMBLY_PACKAGE_BOUNDARY_CONFIRMED`; the +[completion receipt](evidence/candidate/portable-guard.result.json) records exit 0. +This checks the checked-in harness's package mode without replacing the +original observational replay. + +Full traversal, no-op classification, rope consequences and admitted execution +remain open under #296. + ## Reproduction discipline Use copied inputs, the existing compiler and frozen provider package, the @@ -77,7 +118,7 @@ compiler source and binary identities before a build. Keep generated apps, artifacts, and streams under the owned bounded runtime-data directory. Do not use historical build-in-image recipes or create another image, worker, or cache. The twelve runtime expectations require separate generic evaluator -execution after an actual public build succeeds. +execution of the successfully built candidate package. Copy both this directory and the unchanged sibling `leaf-slice/run.py`; the runner reuses that file's public-build and identity helpers. Provide the frozen @@ -94,8 +135,15 @@ python3 "$PROBE_ROOT/range-assembly/run.py" \ --work-root /tmp/echo-726-runtime/jim-range-assembly-proof ``` +The default `--boundary source` preserves the original RED assertion and its +compiler identity. To reproduce the candidate package witness, use the exact +candidate compiler binary/source, add `--boundary package`, and select +`evidence/candidate/compiler-source.json` as the compiler manifest. Both modes +retain the same source and controls; package mode requires the actual package +and separate report without claiming runtime support. + The source manifest is read-only provenance, not executable compiler input. Use a fresh work-root; retain unique evidence and recycle only owned disposable copies after export. The runner's stream-size check does not replace the external -disk/process guard. The retained result is a compiler refusal witness, not +disk/process guard. The retained results establish their named compiler boundaries, not byte-concatenation runtime support or complete `ReplaceRange` behavior. diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/assembly/application/executable-operation-package.cbor b/edict/replace-range-probes/range-assembly/evidence/candidate/assembly/application/executable-operation-package.cbor new file mode 100644 index 0000000000000000000000000000000000000000..27b2086448eab18545dd2ae3bb9f32264b647ab5 GIT binary patch literal 6055 zcmeHLZ)_Y#6~90$wID%=qBc1v#2`1S0AK7hO%ocYxx3WZwDv`IQq>Z0ncJP+o6GFZ zdS=$%Q%mJUL_iB_KQu)`RBFz}2|*-Ck zygRlVySRoge7U>bo0&K7&3nK1`^_mwSas~7Xg#*-tiS@yktEFT4v=*Sxp>P&uN!dY za^#JzecuWD5b^Ek0~YfFLNV`#zwFS$c6W`1z75|&$kiN&_!9flLqcG$M)3&pUEDUc zS(}=_hMKEZRK{Qp&te=`5tqb4mK?j`J2O}|11ws2&<{e{(tB}6FbuODhhS=pmgf*I zWIso)2j*$1DY4iE-u3O+?F$&`+YA2J(EHP)7h3i>uBnB*bh+N`yItZ1j7xF2WpV7Z zYQ&}uY!g|KIFfsM9hH$IS@N*fnN1r?Jm$EDlfWDHg>NPaqoNXKln?ab()A zA%XR-reRkYUKV<66}qT1-C=>_fFcW5xjLFXy#*aqf@n}j!^p$93+DA`3z#ws(fFs1 zGuEGGtp8h9=NzNnl?~gYj{3lOTxCr`pH~6S+d{IgTraA~82Mm4xHZUY;=3wfu68#G znR(`Ec-$^Ms>jh^5cK6n`mI~$ScJ4)20U8^Nxsgez+3VtbL5z)LR&m*92QD7@V4uu zS6X3#UbW18AvuCP7gJK5*}W=%1Pi%^ zRW+-{u2=i>IzH-t{wK|uGxxQAaCXb7(@(ptzn(0b%^8gU(E@NbD#8}GQ#Q@;#f4ESz(J(aZT+L4TBJoZd6zuum0JMO$| zyRoC_{l-F-8nmL&QX$!kB_cGl5*w8qh=C@Nz~goUjdidEbw!|+2nmU&7?+|L)`9KY zV$fT^I+rl2nEpMC^qcQIVHs}p>tQ9lF|rb z#mr{NEhPH^>Fm%35pS-r!{f#g4YNwHVm_LOR6>G?VJ6GSXFdV`yJB|DEG$AA)IAK4 zTbaNdDDdR+3@cXSs?_R7z-WzJT4%(zAAo9z2muATEQ=lxC5`Lz4Q9w4WRW(AsKYqW z!DX5Buj6Ew;Uq9)rJV9RZf`cG~n5bLdNsy{Q?ZAMXQ7E|6|bBOu#UJ!vgP^~DTe zpc>%B13b7NAfmlM)M1#?WI*+34KAJt1I0AivQGCiCIjfhQp=^N1F5D5U@-f>QlrGx9<#VX z?*sVIaUdwLM_ z?uiV!N0V#9>Jsk-{hBV6s)a!o!*vUR60Bj&@;K@LMc>7Dy>{wU>%hYw`QwGPQQm6z{;G!&G#NKDdok~!j)DLRTh~oBz6j1t z-&FR-KYh=(ue|vB_sX~Syiq)I=@Xy5O4r;$wtWA+-yXm4j%eco)6=MAs=tuv6{r+B zn{U;0Xtd;nn@ny|p!(G9O=h=?$;2o>%V1TZ&zXJo%>Hxv@t+lUPB#zytK)R(ZyQ(L z^W`@_eDjt5n<{@e`{PSdhtq~2*tf62Cu97=(DaeLyB>d3zPs=C=N{R0?XjH~Z@KAf z=a2q&?A41m{`{Rd+MqC*14h8-0_K0S`Jv07{O-q242<3Vtxuitj^T5ihpv6*hnFw@ M{;AOyFMoXE-zw#M%>V!Z literal 0 HcmV?d00001 diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/assembly/application/verification-report.cbor b/edict/replace-range-probes/range-assembly/evidence/candidate/assembly/application/verification-report.cbor new file mode 100644 index 00000000..6f3a5a61 --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/assembly/application/verification-report.cbor @@ -0,0 +1,3 @@ +¨goutcomehacceptedgpackage¢bidx!executable-operation-package.echofdigest‚fsha256X íH +3*_„÷B^F« ̨†È @àH[ˆû¡æàA_htargetIr¢bidoecho.span-ir/v1fdigest‚fsha256X è•|ø‹x`ç&9 ¤ðh~ÇHÌ¢ô¸`$7®³japiVersionx)echo.operation-package-verifier-report/v1mdiagnosticAbi¢bidtedict.diagnostics/v1fdigest‚fsha256X (ýr©‚#9‚ÊL)Û±²Ô0b9g«;m¹×þæhæ¹odiagnosticBytes@qexecutableSubject¢ebytesYR¤gpackage¢bidx!executable-operation-package.echofdigest‚fsha256X íH +3*_„÷B^F« ̨†È @àH[ˆû¡æàA_htargetIr¢bidoecho.span-ir/v1fdigest‚fsha256X è•|ø‹x`ç&9 ¤ðh~ÇHÌ¢ô¸`$7®³japiVersionxecho.executable-subject/v1xapplicationResultProjection¢bidx(jedit.text.replace_range@1.assembleRangefdigest‚fsha256X ¸{¡ò„(²0è_FPº8â2‚šÕŽŠkü¿å••ireference¢bidxecho.executable-subject/v1fdigest‚fsha256X cøžv­UÏìGÒÌmŠÛrY`HùŠ}t'ÙƒR`gèòxapplicationResultProjection¢bidx(jedit.text.replace_range@1.assembleRangefdigest‚fsha256X ¸{¡ò„(²0è_FPº8â2‚šÕŽŠkü¿å•• \ No newline at end of file diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/assembly/stderr.jsonl b/edict/replace-range-probes/range-assembly/evidence/candidate/assembly/stderr.jsonl new file mode 100644 index 00000000..e69de29b diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/assembly/stdout.jsonl b/edict/replace-range-probes/range-assembly/evidence/candidate/assembly/stdout.jsonl new file mode 100644 index 00000000..a668538e --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/assembly/stdout.jsonl @@ -0,0 +1 @@ +{"checked":1,"command":"build","errors":0,"exitCode":0,"schema":"edict.cli.event/v1","status":"ok","type":"status"} diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/baseline/application/executable-operation-package.cbor b/edict/replace-range-probes/range-assembly/evidence/candidate/baseline/application/executable-operation-package.cbor new file mode 100644 index 0000000000000000000000000000000000000000..8e13c184fa2cc9236342fe6b3dc82bc496d8a0e7 GIT binary patch literal 9969 zcmeHNZ)_Y#6~B~LYAJ%KLaF~W#DEEvs4sS$h6e03_9Z5U+Gp$pB~W^u+nv1|dv|BO zGi$F^QQ3j0v{b-{HV8z8;%okZM2kQQl}eRJluBtRAeE*dq0$!B{esGe5F`|Z@@8iD zcGf(Je&FPB%%?oej*ky(Li=4W;Iq;!YZ${6)3OM* zO?Iq=U9)$JV`KmJZRKKMS=jG4gHdb}p5-{?yE?MH(Nn@W=!pl96%iwBFGgm+$x`Fh zv$1GV4lFR-m>LjSCf*2Xtk(33G`2KI9pWOpY*3f`u)tbFUC`uX2GZo7q=yVr6VEqL zJ*yb7pA9VrC}?Pr+OV{S>yGOc8;1O;TE08+Uhtjmi$l}T_BbA&GWK_F^$i~*j?H^8 zvT~T%#4U-vt-Ym-c)9lAW%zlCjh+=QZ_2FCWHf)5h~rV8vzb}2+?p*C)7DRmWs(wR z{E)@UXzQKZ541cUJi6hAhx`2BewSQ+z4@6_Z#4A&Y-IiB`_I0VAE4XL52}M>qe*c$ zOX`NPqp3S~!YopAs)AiO9PE&Cf?;EhCy*WBCt<@&Y+A}O4P@Jv_=9oSqT7{)rQ|eM z!$IL?arJt{zp&8I`d7n}i$elTvwA zY>01ojqU7+wzG3jVH(At!l z&Sb{nS&uDp58yxbcwHuw2^)Mo9uP?7`M7Qw@~H)tNw`ViYT^cglZBE(Jc1mK%(h9N za8aO)B9D9t`wU7QM_>e=6{d+7iPd4#;)fg8B^*??eO&B!!ZVimz<@>J@a0+SC!-v{vCI`1b# zbF+VLxp?XDu5W(g<;NxpKkeCjPml4vvn`jdrwj;WKwC!6rVQfOY&qhnfcXN^S4Vn{ zD%34dmJn7ClPxfOX6UJRZnd6!>*vpJsGR-B6MsB%^J^de;1kV_??2*Xp8f0OLp+h4 zt76r98p4KXWd$5cYEMIWpNaVC!?PNMtVP+5ioECoR-`VKShfp?Kmd1lZr!O*txZ*G zlf&C04!J9VsX$FB4mc$$ZG~d7|0h99u%MbuU#$#qdv{0sw!7~9^!AiR;YU(7=ZjEg z1%`0RZp;y}HA!@Y`@lDL2~j|k?u15yg@G@hCXzmcgC~g2n1NI|sBwKp+k|;mgP?@o zoWN{}$(vG^CX;)C3xw7QvuR>Hd!(Z4O)pYr@VswAAHszah?u}aPT3ThBdPva$}$}6Tlz2bp*wZniCuBA>#)E0e#E5j_CIVoF3v#Mbf@%rhSzFvO@B5d4e z5$)BeVwtv}v4R}n1|qIZQY(5$Ovi{Mn#!i0=roP`mPYCSW*zFm z&5MmXPUO!ofD0Issc9I9N^zeg$7L6zMynWLsR528HDdu`b4ry210qMu;Nq~r6G&r- z+QgWemo}vs8DmG(C<*|K?Iz5lOyY|)h7d1pXi75#Y#BHi4<}Gx62sxgQkLk8?xU1@ zkcYV}R>Ni_k{$$u>hpZjCMCIIsuJ{2+v^QdCj_s5$_m0tO_&>bkjO z@s|Tlim6kB#is(%U_sjfAcNrzM%M3w9er_ASmq}- zZc(!51w(xbQ6Uga3zC_YG`c5#s`V9$;#(9+q(deP3()gdOnUS}Q0ZP=!xaow#GO>% z-#|-TCcy(OOBGWPq2-4Og=ET7A2j&!l!S9n6^j~^o(R38;ni2(e);r~hv(b}u0IpD znho3k_2$k$?YRH@FMhlA?H~O+kU^rL5|C!hTh7ku*E`P~Yy8UGv-dUpA%FYa7Y{sm z#{BY2WU}%1UEWOCWW*@0;9vxBp`^`TYV{BilYmiB-&ASSH|3o1uid@vhcEo|*STBU z-|abc{@#Z!*|&6(Ezf`Gx$)E2g&S*3PrRbV@oZFiLd@gU<5oz9hRZ!~lTn)j!l-DE zXvQv8?}ts*Qba`Td9yD)z3)`h_$xg-DpULa)BIHLI~&*C{eyQub<@SZ8}onr#qZ9C z%~qUCz-;yLlcxOiK;_WxuJ1g;Z|=VRmk)Mb{??9j8*cpZGlyS0_{O;#UVR@9ZxhMY whhPtXYpDOr<_9i(^~~o^>^=C|U)}e#^Ef`$GIseJFJ3tJ=8=&XE_{CCzjiZ*CjbBd literal 0 HcmV?d00001 diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/baseline/application/verification-report.cbor b/edict/replace-range-probes/range-assembly/evidence/candidate/baseline/application/verification-report.cbor new file mode 100644 index 00000000..c34f2faf --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/baseline/application/verification-report.cbor @@ -0,0 +1 @@ +¨goutcomehacceptedgpackage¢bidx!executable-operation-package.echofdigest‚fsha256X ¹-<@‡ŠŸË§v‹æ|ºPÏu‚3üÝXqA[htargetIr¢bidoecho.span-ir/v1fdigest‚fsha256X ,×ÕçÓ¿–‰æn{Àx$d6öâ>Ø9`™ÊŽ$çŸùjapiVersionx)echo.operation-package-verifier-report/v1mdiagnosticAbi¢bidtedict.diagnostics/v1fdigest‚fsha256X (ýr©‚#9‚ÊL)Û±²Ô0b9g«;m¹×þæhæ¹odiagnosticBytes@qexecutableSubject¢ebytesYQ¤gpackage¢bidx!executable-operation-package.echofdigest‚fsha256X ¹-<@‡ŠŸË§v‹æ|ºPÏu‚3üÝXqA[htargetIr¢bidoecho.span-ir/v1fdigest‚fsha256X ,×ÕçÓ¿–‰æn{Àx$d6öâ>Ø9`™ÊŽ$çŸùjapiVersionxecho.executable-subject/v1xapplicationResultProjection¢bidx'jedit.text.replace_range@1.replaceRangefdigest‚fsha256X øº 5~^ÕN†÷Rê‚äT­ GÁýèÇÜ*ë¦ireference¢bidxecho.executable-subject/v1fdigest‚fsha256X “ÑÂîk—˜d'ïoû°Ä&¯Ø†3#ÔR`_¼;ͬËxapplicationResultProjection¢bidx'jedit.text.replace_range@1.replaceRangefdigest‚fsha256X øº 5~^ÕN†÷Rê‚äT­ GÁýèÇÜ*ë¦ \ No newline at end of file diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/baseline/stderr.jsonl b/edict/replace-range-probes/range-assembly/evidence/candidate/baseline/stderr.jsonl new file mode 100644 index 00000000..e69de29b diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/baseline/stdout.jsonl b/edict/replace-range-probes/range-assembly/evidence/candidate/baseline/stdout.jsonl new file mode 100644 index 00000000..a668538e --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/baseline/stdout.jsonl @@ -0,0 +1 @@ +{"checked":1,"command":"build","errors":0,"exitCode":0,"schema":"edict.cli.event/v1","status":"ok","type":"status"} diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/compiler-source-sha256.json b/edict/replace-range-probes/range-assembly/evidence/candidate/compiler-source-sha256.json new file mode 100644 index 00000000..9bc9f80a --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/compiler-source-sha256.json @@ -0,0 +1,454 @@ +{ + "revision": "01dc5abb9a8a74f8fd8b0e0a6d1041d0adb86d6e", + "files": { + ".cargo/config.toml": "c185a2b859850d94af015a9672c1568e1ef73b12612d820f596ef967b835f637", + ".github/workflows/auto-release-tag.yml": "8f9769cc8ebd110cd9887562368b17b7cf640ea70487ab9e329b5efa4ad34aea", + ".github/workflows/ci.yml": "21fb0536c7ceb84136baa7f60e636df7f59739943c1a67692a789ee4598d19e1", + ".github/workflows/release.yml": "eece9419c92837bc90bb645ed00c19b4c4d7e05e9737b9dddb4bf4e750903eb7", + ".gitignore": "4a2b3d736804960e55dba16b8e00bc85084195608e4b9b3877859e745f4ddca1", + ".markdownlint.json": "d56624af462cadbbd8f8b2cfebec943cd2a34fe82c3f7eb517f3d63bb3d21a7e", + "AGENTS.md": "c43bd85432ee58d57041a389533c9531d26267af3e260346cf53a75932bd5c50", + "ARCHITECTURE.md": "7b476013a54a2b0ca2faf9b8c41a28d8042bd66999b385dea90e7fc1f6bab116", + "CHANGELOG.md": "35c1e5fb285701a09f0cf6794b4becf9b446a274287c7d7051ffa12023f3bfba", + "CODE_OF_CONDUCT.md": "46e5940b4f1f0f259b1c0ca3c5aa73e2804ea916370f70dff742f4978020e810", + "CONTRIBUTING.md": "cbf1a4cbab1891a55f86baf7aba1726aa496fe0d54e6ec91c3c5c66981242527", + "Cargo.lock": "668623d1ad8e50c2e2dd28fabacefccf852d8f234b1029bdf72943b0a7e47eaf", + "Cargo.toml": "59e341299663a5c63c48cf2752c25e4cfce724c1ead492258569d8261f4ab731", + "EDICT.md": "8117c4c7dc611490e3913afadd9e7dab9353fb6eb0ab1c35eac345bcaf7546c6", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE": "7acbac1eec94174678c6517ec3d0c087774176afe7ecc10dad13f006437d33da", + "README.md": "e94fb534ff7ce849c2e10ac7ea527b89dda9b2ead35e1ce7b582b1d077a52e27", + "ROADMAP.md": "12657f335e177d42c7f424657ff02488e4856568028ed7dc3b0adc99745da7bc", + "SECURITY.md": "b9f33ffbdc334812c53a7ab91c5ee20174fab455de5cf8b06adc151c57d46386", + "crates/edict-cli/Cargo.toml": "97bd5d56fb3d5a8b9ae92e10a33e1ee2a91ed4f7b07567e997cc4c074e0a6057", + "crates/edict-cli/src/application_build.rs": "0f3684e93fe79949e5bf7cee1f94e1f5044841b689ba7a8c1f963847a78179d7", + "crates/edict-cli/src/lawpack_build.rs": "ec63d3fef595ae4f9267e01fc1fa729e8b0f283e8c8f850dd26ee837bbeb7348", + "crates/edict-cli/src/lawpack_build_windows.rs": "f8df381586aeeb0ae9809cccff1fe00249b13117b681583fe16124017aada96c", + "crates/edict-cli/src/lib.rs": "5861d6e444dbb0c0583c5ce265ff0262915600978162bc9c15e5ca35ae42cbc0", + "crates/edict-cli/src/main.rs": "3605ed96c2c23b0a49108a466dc3622af1164c45702ddcc6de1714bda033c1a7", + "crates/edict-cli/tests/golden_cli.rs": "601ce4fbe45719fb465c3ba53f15745a3d6f6a4fb70c901b4edaf76b1ace6b1e", + "crates/edict-cli/tests/jsonl_cli.rs": "9b6b84b2c5c95c90148d3b370b84b95901a76332d64e75288e3f4a7c8e77336f", + "crates/edict-cli/tests/lawpack_authoring_cli.rs": "00a7a4c68262fcafdde1e4284c3f0f46bb5f5e508eefff42a2ae4b0cc49dc690", + "crates/edict-provider-host-wasmtime/Cargo.toml": "1c32708d174e52a50f26705907042a0912d393781d9f4fb3a04f31c4656eef90", + "crates/edict-provider-host-wasmtime/src/conversion.rs": "3cdf3773fd80ec49e34ff162212df79c0f0b41e4a9747e8cb3ab9e3fbde2c2d1", + "crates/edict-provider-host-wasmtime/src/invocation.rs": "517cd7631a172a948cdb86a69a91f43c43b4b2752939272e2ede05ddab36ff54", + "crates/edict-provider-host-wasmtime/src/lib.rs": "87dab846338d6e53e47ba6d818a6b7c8b321537c62cc4970076b89851b18f3aa", + "crates/edict-provider-host-wasmtime/src/limits.rs": "b8395e16dde588f75375e6ff635650aa25607ae63c024f0d05eae46c561bfb19", + "crates/edict-provider-host-wasmtime/src/replay.rs": "91d55f288cc84021bee48a1b10581c2bedcd56c95c7bf071a627a9a38b68940b", + "crates/edict-provider-host-wasmtime/tests/invocation.rs": "18fb18970d51ec3e105bfc9a3907044962e88681a6d7971b3e56e0480c278845", + "crates/edict-provider-host-wasmtime/tests/preflight.rs": "3de8dffbbcc26c3efa06aa7e8a9d281d874ea1365269552caf46d3d54ce18dee", + "crates/edict-provider-schema/Cargo.toml": "04e9de090fe8a0ef20237b3c0dac6a846fc04653399b49c45934cae64dbc444d", + "crates/edict-provider-schema/src/contract_pack.rs": "4ba5aa93fa6c82a0df6f82708cffbe7f1ea0690f1cb315ad9ea76318e87af8e5", + "crates/edict-provider-schema/src/lib.rs": "77391e3c7e0785c771f4dbb5c1618934fba82940b11dfafa5148dc4fa9b1b742", + "crates/edict-provider-schema/src/recursive_dispatch.rs": "2aff6c1350b3c93d7f5c75377462c860b44c5aaaa390e21e0ad3e58f255adf14", + "crates/edict-provider-schema/src/schema_safety.rs": "715d59a014750e4785c6127b73d301f92a3f2e59e63e296adc94315c92810702", + "crates/edict-provider-schema/tests/authority_facts_abi.rs": "877a5487f2c6e38cb2dc358cf66cbd40975076da2ce628ef0642e99971c7c7a3", + "crates/edict-provider-schema/tests/provider_contract_pack.rs": "2c45670654fd3171f75c935e0bcc2bcabf07d3c4d021145d52b45d735e942094", + "crates/edict-provider-schema/tests/registry.rs": "dc774cfc6f4f09af239831ae116f4cb55b764d8a863f121cde9762eb8e72b37b", + "crates/edict-syntax/Cargo.toml": "12058f9ae36c1b2ab78d683f56eb1e41af8c8185dcbf3c993ef097acd097283d", + "crates/edict-syntax/src/admission.rs": "5cd08a9c05a5c9be22d9720b137d25dec019efdf23c41289010e5f107cb93f45", + "crates/edict-syntax/src/ast.rs": "27770c7eda15838e99f7b790727b7d3a1ad93a22804b3d50054fdbc9eb95d827", + "crates/edict-syntax/src/authority_facts.rs": "3beea380b1f617a452e7a66e508ebdaa1262ede41c60381cfb96c2544f50de13", + "crates/edict-syntax/src/canonical.rs": "f0e1e60b272ff1b623aa6e018f8e3d1def4c90d1f0f66b0aba82d5ab2397ce42", + "crates/edict-syntax/src/compiler.rs": "0f1a1f9e14b7eb910838e08dfc6e67f71184b708d082a0bfaef9334f6e5a5f67", + "crates/edict-syntax/src/compiler/byte_concat.rs": "2f608fcd0c7f797f587cc0efb356be06437cfb372feb1d8b4516840d2e261ef4", + "crates/edict-syntax/src/compiler/byte_length.rs": "088b3a62ee8debd9512758ab2d670abcb5b0f04f9dacfe130b70a65567af1421", + "crates/edict-syntax/src/compiler/byte_slice.rs": "375297492ff393f6d132034c24c34aaa86e81d615f7b0a7c0d54ed9196fe7749", + "crates/edict-syntax/src/compiler/unsigned_subtraction.rs": "89f0b8275549e639a133b7466125811d7205ab320ab0ba6f1e30d11f5015c925", + "crates/edict-syntax/src/contract_bundle.rs": "4796496d79f7a3d9fb17afed1d79e54873007b84fe690706af66e127dd1c33f7", + "crates/edict-syntax/src/core_ir.rs": "0426224018a6990b60217739250f6f60232badd76df420e83d35bc7ee99cf533", + "crates/edict-syntax/src/highlight.rs": "98d63bbc547c44f01e7f6e665071c707352e94e6a1da9427db6ca9bd34c64c1a", + "crates/edict-syntax/src/lawpack.rs": "f85fb5b23be638f87cbc13ab9dcd63cecbfd3c6c8546f0c681eabb0a747a6d14", + "crates/edict-syntax/src/lawpack_adapter.rs": "3e535a54e09d14f204347e8e6c5d76fbde421fdd83d0f81ab96aa34254778261", + "crates/edict-syntax/src/lawpack_authoring.rs": "d841eb54a05de902dec2d5c051bc6bb1fc63fb860bd90c329d6d651c6defa864", + "crates/edict-syntax/src/lib.rs": "a61378d8f1747d2cad3b08999fed72f39643acbea262cafee993ff0a8cf95cca", + "crates/edict-syntax/src/lowerability.rs": "bbe4a2c194fdbf3ecaac891a0283bc565c29a50da7b88add56a84bf7f8d38612", + "crates/edict-syntax/src/parser.rs": "7000c9597582f9d4e40acd35c22c9a3ae11c60f98e06ca87166faa5674044c4d", + "crates/edict-syntax/src/provider.rs": "1664029ea4a946ef4583a89679936e6b617af4cb7f85ddf172d6d021e15f53dc", + "crates/edict-syntax/src/provider_invocation.rs": "41705963f052c64fbca5223d932c50f81bf475758a45ec60ce43388039b72420", + "crates/edict-syntax/src/provider_lowering.rs": "2d9db78159a0fed1edd39293eb245a9af723991654d5ee8b2b9b4bedb4ce3829", + "crates/edict-syntax/src/result_projection.rs": "3ebc8d04690127e713a3068adda28eadaa273e00efdb3b25c3d493aa9c31e3e9", + "crates/edict-syntax/src/semantic.rs": "c62ab97f2f23cdc90373b3e7b96d897776fbecf4f2a05a5e0cbcabf6a4521402", + "crates/edict-syntax/src/target_ir.rs": "f3efc95f75ab5a4cb85020a8ada65e7de224829c66ad44f18570ca4d015100ff", + "crates/edict-syntax/src/target_ir/byte_concat.rs": "212f25d55f29609a4f27990c3c8b635a88234908aee96a895079c31826a9e480", + "crates/edict-syntax/src/target_ir/byte_length.rs": "eccde25dc6bc2afa0bbe94ae295fe808853cb0020afd9c5b26601f2fb81f0339", + "crates/edict-syntax/src/target_ir/byte_slice.rs": "aa670da555ab42224fc1a5771589a9a4e08c62eea2707a7a8bcc932432d59da6", + "crates/edict-syntax/src/target_ir/execution_order.rs": "36351597b015491712c1cc2a3372a9d9a67c76c94d7f162aa04fadcbfde48495", + "crates/edict-syntax/src/target_ir/totality.rs": "b838eb8eb45bb8fe4f44a939e68b628ece8eb7be8de24c054c9ae162236abe07", + "crates/edict-syntax/src/target_ir/unsigned_subtraction.rs": "61263d52c0aa531f43a7962c673a7178d9325ea92ef37a159ad0979cf2b287e0", + "crates/edict-syntax/src/target_profile.rs": "904baf82f4f1a59287eef88e5f6cc5f14f6f5426be01625840c5bc5557d28775", + "crates/edict-syntax/src/target_profile_contract_resources.rs": "4307121aafc4081a744ae9a51457cddc2ac7a020bd528513a41c8a815825867d", + "crates/edict-syntax/src/token.rs": "fd89e2f658c1e4b1c4f3135ad377898755296343e899b12260a0880519e00f66", + "crates/edict-syntax/tests/admission.rs": "1bcea2e01578ccbcda98751a995dfa52d013ee10caa612f41e450ba713376f3b", + "crates/edict-syntax/tests/authority_facts.rs": "d3ccb5d407694ef040c8f6e8de4cac37d0c6c2a26ae29261b10cd754c01a9be3", + "crates/edict-syntax/tests/authority_facts_cbor.rs": "07fafcb7e611b260b4040098dfeaf6d1f1ca172ec2726f4eb084fd4c503070fb", + "crates/edict-syntax/tests/byte_concat.rs": "830ee7cd2bee0e2235a9b2dcd6af968a8e88fb9b3f7af34d5b26163a294e90fc", + "crates/edict-syntax/tests/byte_length.rs": "4ee3ff7844377d59f3461b20bbf8fb1e44824faba8a3768c901eba9ffe4f1694", + "crates/edict-syntax/tests/byte_slice.rs": "d479160e1fc462223fddc60ee2faf504487231480ff68a136cb5597535170e4d", + "crates/edict-syntax/tests/canonical_encoding.rs": "2e81d33a525c01708f0329e0117128fd9d969b785dbd6539919ef9179a251d9b", + "crates/edict-syntax/tests/common/mod.rs": "e4ab06daed846140ea87e5b5bc53094bec8e9121d63e209fa2f9cc7f8c8c56e4", + "crates/edict-syntax/tests/compiler_spine.rs": "bb27dcfce0c09a713b4841dd25276b2e5eb6cfefbf6612678c32b40e4c1169f2", + "crates/edict-syntax/tests/contract_bundle.rs": "652e4270f9ff90cb207a5e52d2863ea3077e1cb8e6ab753603a2784614da2985", + "crates/edict-syntax/tests/core_golden_fixtures.rs": "65bd63e543bbb9a6c9f9ea494d16690231355410e5dc9fce331ea5fa8667252c", + "crates/edict-syntax/tests/core_graph_depth.rs": "1ac9a0bbb6df7ef4a084a4b352384f397724bc2c105057de85c6c568d5158d92", + "crates/edict-syntax/tests/external_action_requests.rs": "351b65ef2e335120513e2f525c33c4b5ffc4920b5df71615a299c40c6dda981d", + "crates/edict-syntax/tests/highlighting.rs": "4a66ba0da9b05e10665230ad3f1151f07b5990a51a1b33a07ba2c408c49a67c0", + "crates/edict-syntax/tests/lawpack.rs": "06eb48d7e28a04eff94d2726f725209e980d04240bc6fa181f13cbefb838535e", + "crates/edict-syntax/tests/lawpack_authoring.rs": "0eabfad59ac99d18b50a5efa7f2c9bc763dbd1cb593719b568b2747947b8f18a", + "crates/edict-syntax/tests/lowerability.rs": "25654daf28c4543551fbc698c177a8b36a2b23ebe3792d51f59fca64a3a6dd5c", + "crates/edict-syntax/tests/operation_prerequisites.rs": "5d1762ded6d5132b72aba8973e45b1d1c13918fcc7a3bb9841432d4d5b5461dc", + "crates/edict-syntax/tests/parse_control_flow.rs": "5568c5d9616830cec8905811672738dd373e981b96e6f2fa7059ab9b2b125da9", + "crates/edict-syntax/tests/parse_greeting.rs": "12892d5a25393afcd7a3d13addb840c2ef478e96ea0896690c4bfdcdb08cf7cc", + "crates/edict-syntax/tests/parse_hello.rs": "3ff047d05d54f03538e4448427756c577adf19bb1d6b016ea885c2453f3ee9b4", + "crates/edict-syntax/tests/parse_keywords.rs": "e9bcd4f76a6254fa5bd2c38dad65818540fad013e8e1de4056ab8ef9136fc859", + "crates/edict-syntax/tests/parse_loops.rs": "909e08d646a6cf85f6cd9bc0a46ff6bf87c7d3fd0e67b5198313b8e46093ea9f", + "crates/edict-syntax/tests/parse_negative.rs": "3f6d3417192c7bac2da4117827e37024ee78af4766f906c93a49fb68be018901", + "crates/edict-syntax/tests/parse_review_regressions.rs": "5c2e5b24f64f72e8c5f0faad2e0bf87810b7e7c4d07a5f065d528bb2fff98974", + "crates/edict-syntax/tests/parse_variants.rs": "91a011215e0a058cc99546930f9f0dbb0eab5763f6efebc1bc3c3a3ba0071500", + "crates/edict-syntax/tests/provider.rs": "cf23cf7eaa0e7e5225220333091db869e4041f9362724e1bf436067cb0005d75", + "crates/edict-syntax/tests/provider_invocation.rs": "2bcd5c801ddc2c9104db7dd5f59375b7c34a28a70f0f3a24331c78b3123cc5b4", + "crates/edict-syntax/tests/provider_lowering.rs": "5db0737afd40d8d405dc49dc68d9190a91feaba02cff827c8e7c7587626d49fd", + "crates/edict-syntax/tests/result_projection.rs": "fb1a22dba15c177d8b65aae4ad46173c0345e84b9f87ba92d3c725bf6f901601", + "crates/edict-syntax/tests/semantic_validation.rs": "8176193d9abc9bab7cf36bf026059a64cfc95cb7d7126b0862ddd1336ee2f1ab", + "crates/edict-syntax/tests/target_ir.rs": "293d463a72a0770383fe43fa332cfa67d537ca3dc87ab1d9020f41960ccdb820", + "crates/edict-syntax/tests/target_ir/ordered.rs": "db4e7eb38ad4d2e04a5a63b94d6c21e8c2fd901a88f4c40a1130a1c1eb94f61b", + "crates/edict-syntax/tests/target_profile.rs": "78c360c9f16b97698338a9759cdfc60d61b700d6a486be7547b428d1cfdd525a", + "crates/edict-syntax/tests/target_profile_contract_resources.rs": "07947308744e307877bc1cc91bfd69c24f4d6752e1c8091fd31e68fc6b121211", + "crates/edict-syntax/tests/target_unsigned_subtraction.rs": "3905adb9dadfe23e93343bded17445b16a783771929d776c5e0fb4a166461c72", + "crates/edict-syntax/tests/unsigned_subtraction.rs": "4a33ebb4cfc854a16cff8f9eeb1465d871857d9dc9ce60604acc192a5f254627", + "crates/edict/Cargo.toml": "7ef565369c0108d463d9804fc494298cc80a5833aa26273bbf9abad328e342ef", + "crates/edict/README.md": "a4c923bf99c34bf42775286c73de35a8bf023e9105ff3f6827c67a0cde2193c5", + "crates/edict/src/lib.rs": "29962d09fd96bee5b9b7059a46732a7d8e965716185c1efc383ab68720b5b973", + "crates/edict/tests/artifact_models.rs": "4c635858a21e4e939f0c41c17da8ef874379191c13141ccb862b15ba6e9d3814", + "crates/edict/tests/public_surface.rs": "b6b2f9aa3c48be671ebb452ec5ee14d59c29b55184ee274f85b50f7477d77e6d", + "deny.toml": "b140f4619f9705b58bbdd9f82a82e3ca2c3c410545b2087940751e6a407ef6dd", + "docs/DESIGN_runtime-neutral-edict-sha-lock-assurance.md": "ec8cd6cb513a259458d932d0ed684a1773759ed4dbe2d5f3e561addc9b92b2ae", + "docs/GUIDE_edict-assurance-transparency.md": "30e26b75cfc7f4873ba0679a60c6611ce80cf5b206787488115630a3c49505f0", + "docs/README.md": "1d45afb7244c51e06130ca222b150d8777c4d93e79b05562dec111f1a359d79a", + "docs/REQUIREMENTS.md": "be8ca1f6c7f45f0d495d97e7a1e889a7f05fbd97a09515923eb34be80b1079b3", + "docs/RETRO_phase1-parser.md": "f88d661fc50ac6c62595d4db73214ba92adf180e59d6dbc3ce8a7c353a62946d", + "docs/SPEC_continuum-admission-v1.md": "32eaa3ae802b47c041cd5b289a9ce59cb5456a971b803794a2d0913a3a08295d", + "docs/SPEC_continuum-contract-bundle-v1.md": "01a899ce5b2b901b5b5dd8e7794ea4540926bef6eeade03775111f3fd0773ede", + "docs/SPEC_edict-language-v1.md": "a3e1f99eaf97e59628d59719db3921c4814814144b66211c6ea9bcf5e95489d2", + "docs/SPEC_edict-lawpack-abi-v1.md": "a2a1816167df73365f309228012abf33374861afb857ce71538a4ff760b83831", + "docs/SPEC_edict-target-profile-abi-v1.md": "b659e8139469ebb94ccb93cfac1300591e6ad5e02142bd0bbe6fc3f6d8af5d01", + "docs/TECHNICAL_EXPLANATION.md": "25b837b0639c340d871f86e4e6830c2572f6dffb7a405e12620cf6db014ac1f0", + "docs/abi/edict-authority-facts.cddl": "1b01189e5e95c583f5c07820b1572bb00ad75d87b9246079ff039e4897a49595", + "docs/abi/edict-common.cddl": "cce1c85f1a64e0b87098781cf606c5f251d09e1a851c50386fee6ef09b7844a1", + "docs/abi/edict-core.cddl": "07cf44011a58ecb29e849e81a3f2e33712299d06f5060bfab4737be48d22ac13", + "docs/abi/edict-lawpack-adapter.cddl": "3db613aa72379b50ad5ccd931e791fc2b6334e3c3ae4d4385ded0eda607948ca", + "docs/abi/edict-lawpack.cddl": "2e42f18af14089b5d3faaf2eef76b1412f828ca77dfd5df5c22fcf7abd222fb8", + "docs/abi/edict-result-projection.cddl": "5194be961826186ad678d8962e1453334b162d44c1eee443fed3079395554df4", + "docs/abi/edict-target-ir.cddl": "123e7f805dc5e831e88befec4cd49ec02c39858b6f3990da8a73b50c6086ae39", + "docs/abi/edict-target-profile.cddl": "a465b1214232de00029b8d6fa11747dc187f43c4901511e358adc45f04d54d7b", + "docs/abi/edict-target-provider.wit": "2971fe44def7e51d5271dfc0f04f3088aa58754cffdc847681a587605aac749e", + "docs/audit/2026-06-28_code-quality.md": "de796db9655ba262a27d940ff5aae9bdfce1e5932e913cfcd88b1c2fc012b9e4", + "docs/audit/2026-06-28_documentation-quality.md": "583d5f7ed077ae1dc7d76c675a35956a687e81d94490d942991532b8e84410a5", + "docs/audit/2026-06-28_ship-readiness.md": "a236c18ef7f1051ff68dcce11d4f5a2e4d31cc2be2d4ffc95afb03494d5d3204", + "docs/design/authority-fact-governance.md": "27fa454182a1366b2a85d467b323201ccf6e7ad0b0fd72c60af768ec4c0ce192", + "docs/design/canonical-target-ir-v0.11.md": "19bd1166f6d236946b0b98800c7a4000f862a395bab8273906360bc03c23f4d3", + "docs/design/contract-bundle-assembly-v0.11.md": "62752f8a85b2eec0ee27e65fd3fae7b895d5eca70856386dde69fbcc608ae736", + "docs/design/crate-scope-v0.11.md": "fbe735625d79951f7dfa1d500595d5257e48b4f89d67b8030a29cd791d6b59bf", + "docs/design/obstruction-strands-v0.md": "33bee298c20b64b09fdf6a09f9de369abb17a5a840993c2e1c624c5c7ea73b2b", + "docs/design/provider-artifact-pipeline-alpha.md": "d03b04b3b54be6f030336eed0745d7bdf7a3fdb27e46ae2715a1a2ce1c929e44", + "docs/design/schema-as-sot-codegen.md": "92072da960c24424784fdcc3c8a437d5ac7bdd9391d249af22c89db05a6bdf0c", + "docs/design/v2-obligation-closure.md": "8e0927734597a64f30451831f3a3aeda661242b3622de3d81b8a9cec723b5bfd", + "docs/releases/v0.1.0-alpha.1.md": "45edbd919f16d6a8e83364f6932b230e5021a4fe22efa4637a07411ed6c0fdb5", + "docs/releases/v0.10.0-alpha.1.md": "a5e587e70ed7b5c061153c98cd3712811518d9f5a4d6a9cd7fb3a4a83afffb42", + "docs/releases/v0.11.0-alpha.1.md": "52d21f35a92db8bc3cea9f065a93ef27db19a38ee2d54ae707a9e96b843e5f55", + "docs/releases/v0.2.0-alpha.1.md": "7bf1f65a05f647155ec5e649f40128da16dbf9073dc1e50416127470366644ae", + "docs/releases/v0.3.0-alpha.1.md": "9b4feca3ec64332a613b21bb9d712c09b1d2a516bec2e5a44add9532a76672ec", + "docs/releases/v0.4.0-alpha.1.md": "55bacd3162c6ff5ff82bf8a2823ab10d118d7371ed5299d7351ffe916d55394a", + "docs/releases/v0.5.0-alpha.1.md": "fd8585076e7b8bdb9c3ab863785a4c8a7febe9547e06def7c29f97fd239aa5a8", + "docs/releases/v0.6.0-alpha.1.md": "b8827f5c16c65b09bf13c9d2fb9354e969d52f668d3cd7681f488e2f135dd2a5", + "docs/releases/v0.7.0-alpha.1.md": "25848f2d35e31dd685553fd2b5e6cdd651be8864e49c902c73e1833b5287506e", + "docs/releases/v0.8.0-alpha.1.md": "c3c98f5461b74d72f83fdf2d65bf5fbdb54dad18825bbbb3cdf364769d395aa2", + "docs/releases/v0.9.0-alpha.1.md": "f41dadaa36ed8e48ca9a4ae5ae68e6898ca2a3eee2e677a5995448295eda5063", + "docs/schemas/edict.cli-check-result.v1.schema.json": "36547692662d017c57f2812598c19e64da3f19410ccb9e6c14386ae8714d0972", + "docs/schemas/edict.cli-diagnostic.v1.schema.json": "918d72cdf5356930959ccd590034653fc735b1b9aad9a4891d91c739420d4cb7", + "docs/schemas/edict.cli-event.v1.schema.json": "7294ae819dfd5e657f0ec677f5c945520c9e4e7c929b81a73c9cf79b49ff3767", + "docs/schemas/edict.cli-info.v1.schema.json": "8ccd6fa256b9cf5c7448480e884b202d2ed7eee2a427ad7f7f64cda3f79d847d", + "docs/schemas/edict.compiler-input.v1.schema.json": "478995c3d92ec08ad3a5d3ec8441592bfd87d5918ce6e5c023d7a658f19499f4", + "docs/schemas/edict.compiler-settings.v1.schema.json": "8dc2c56e77feedbbb407b653c838939ac7b31eb758b4964bb85a5a6c4febfd4f", + "docs/schemas/edict.projection-core.v1.schema.json": "3bb8ba3316e3ecd16513715fe0d0832b140aad98a20a7b4a44a698981f9c942d", + "docs/schemas/edict.projection-diagnostics.v1.schema.json": "5ef5f91600829158b74768f48e1dfe85b433313197c7db21f36e4e514052a4db", + "docs/schemas/edict.projection-syntax.v1.schema.json": "b235d88786554f2cec390193ae961b4579cc08a7379e0330070dcd46667ad655", + "docs/schemas/edict.projection-target-ir.v1.schema.json": "adcdff6d97e228dccb59219a8ad65da376208984201e9a23e257601f9ee51545", + "docs/topics/README.md": "f8b9d8b6cff5df545180d31d307295507db3d6fe61c6591af1bd9007995ed384", + "docs/topics/admission/README.md": "4d4dd43243a8ebe9b93bdaa9da3cbc22ef0e740039ac9319cd49777866c86a43", + "docs/topics/admission/test-plan.md": "ca413dbccca92fb5526502127034d51d815d141234172b82428bf167aaf9b056", + "docs/topics/assurance/README.md": "a9f4d173dad1bd5bf6d904166da7dcbbe57a02792d4f11b3bb5eff8c55a768f4", + "docs/topics/assurance/test-plan.md": "a80bb51c7c3492037c71a74ac865c96da03b95f39cc382da15261ae210a3f584", + "docs/topics/authority-facts/README.md": "499dd2e23d6f934cc8c443bafe9c580fb2196c87f7e5030fe8742528fd769e20", + "docs/topics/authority-facts/test-plan.md": "1acb5c38dfe610ab3660313b1fd19eae32f45fbd9896190f1474a212bcf7ca9f", + "docs/topics/cli/README.md": "72a05856737cb6f22285966fdde3e59d1770d43d45e155d41a41202f6b525525", + "docs/topics/cli/test-plan.md": "fc012a6cc4421053d606bed6ea6a083f9ffdd6bfc479483d1f315de25c1d2867", + "docs/topics/compiler-spine/README.md": "c0a1d9f9323d77365af089bcc3bbcc46d6aa9f020e087ea7d545af52f9104df1", + "docs/topics/compiler-spine/test-plan.md": "99c33b257107884c1b77b964682eb16cb4f44ced10dc3c77fc2b173d3c530ada", + "docs/topics/contract-bundles/README.md": "1f083c59ec1bf06350b0e3553cc359f48cbfe96a5fe112376ad853c2057a673e", + "docs/topics/contract-bundles/test-plan.md": "90c6bdd9dfd353ac6b884c8a77892aca88bc3da054f9fb7261b9e066a7effcc9", + "docs/topics/core-ir/README.md": "fafc02e14a18b4c93f2a2f598256227a11e2847161be6cd9c474cf39461ef632", + "docs/topics/core-ir/canonical-encoding.md": "0e798dda2d8ca6e30c5b8a03c0d891cd0828b32fab77ec7fd765bf4c4ed41368", + "docs/topics/core-ir/test-plan.md": "d61b97ebfbfeb04e83ac9533b78c819580d3fa1c15300ac00b13c64f4382e2c9", + "docs/topics/developer-tooling/README.md": "982186d3f43a9e2fcd107b997212a2783c2894f20c8c3e72ee602a575bc2b627", + "docs/topics/developer-tooling/test-plan.md": "ec2f8f8d708d9c4da72e718ae5ab21f982de1bfaf5ed0ec3a11f91ab24625094", + "docs/topics/documentation/README.md": "37e6fb6bf67035459646e8ae03a9aad74a8e2ee97f746aae2e852dd05da1a1e5", + "docs/topics/documentation/test-plan.md": "e6a75f6160f27f7aea8f224ab830bbf05298f9241ff90f6c3311d989e82fc45e", + "docs/topics/external-action-requests/README.md": "0dade9953c656da44dd0cdfc747181c087aca4190a886a35a35c4dc8b07c8d7d", + "docs/topics/external-action-requests/test-plan.md": "7a53705e10776768bc9aa8b9c2fc625cfad4a7f6f74f41e18dab7e512f1399ff", + "docs/topics/fixtures/README.md": "79079486ffeca402ccf9e67b2a9c5d848efb4d9109887cdd2bb711678a3730e3", + "docs/topics/fixtures/test-plan.md": "261248e06c2da1840039b990258dfd1bcf7db5748e38fa169f4067916c52f348", + "docs/topics/lawpack-authoring/README.md": "ff55f321cd12899d63c0968841dcfbdfffaafb4c03d457ccd51a3dffabc73881", + "docs/topics/lawpack-authoring/test-plan.md": "56693e41a6fd25c6aa92065225f610bab767ba109689425cd385b57484422112", + "docs/topics/lawpacks/README.md": "22b8560e228f4608cd77f8de057a21fb618a6b10c7e7636691d4682d06e7b409", + "docs/topics/lawpacks/test-plan.md": "574f246ce5c7c815e8f9f5fa56270ed1361df32ccc7570d3f9c3eafffcc1b321", + "docs/topics/lowerability/README.md": "0272cd674d01c80f26d77fb01d2f9a1471cca71dc496afa1d539bb419b280573", + "docs/topics/lowerability/test-plan.md": "9cfca95e5d4212e84d93a6d2875a96d9bfd8d34edbfb41f2be83791b470dc6ae", + "docs/topics/obstruction-strands/README.md": "bdbc56030383f514ce09aa1c3a38fc62ae2ba23985c26af1c0b4f2f0c21a69a9", + "docs/topics/obstruction-strands/test-plan.md": "9f6d5086d1808bdea1bf50bb7547b7f9949ecf5240a2137080f306372dbc918a", + "docs/topics/providers/README.md": "7d93a17892e4995c7e2fb5813f0d3113f03778f6bd62ea09fbe4373d52ce95ab", + "docs/topics/providers/architecture.md": "87a1f565ed08a3b83996e990ca403b3720ce850bba65d126790809b62572fb16", + "docs/topics/providers/test-plan.md": "839d25b278debf152468729c0eccec3d1b2829883781f624425814bcaeddc978", + "docs/topics/public-rust-api/README.md": "5452ae2c536ddace20e83f1f5aaa33921634efa468745d43331608b12d15acda", + "docs/topics/public-rust-api/test-plan.md": "4529a6bc909a2d98b76c415b7e03aa5f1eea0da04f65f309cac10d6403c504a4", + "docs/topics/release-process/README.md": "04276147621f5ef8daa09e3d2921d8f7b8ede4b1190bdfbe9642989c0e224383", + "docs/topics/release-process/policy.toml": "203a7da2e6b327ca5664c4abbc813cf42ef9cf608cb105344944bc3241e81cff", + "docs/topics/release-process/runbook.md": "900f89932c5664d64f27f2ad5ecf5bda4e59e216770c8bab8ddc456a0ae4cd39", + "docs/topics/release-process/test-plan.md": "d4401f8b6819c9128dd09f7761f2fff5fca52b3fe82daa3ed922bb98f0c2f44f", + "docs/topics/result-projections/README.md": "0c845ca6e2c94c3af767edce3e4734a57a90542cd22759425fe4a950d0c13316", + "docs/topics/result-projections/test-plan.md": "9c7b9003189f6be6c67232281d7559152f49bc29b144b6bf0a4f20c5f351bb0a", + "docs/topics/review-process/README.md": "ad39e621572f4a472627cce3054909de645b6d5f882d88596f58cda073f13b88", + "docs/topics/review-process/policy.toml": "4ef2212a5c0843061ac64c0e568728ccc9ed1fc5091179177865ac21a8f55be3", + "docs/topics/review-process/test-plan.md": "387fb196d75b41096efd8e01d078f8ae946e46e23504d2798263074bced0aac5", + "docs/topics/rust-standards/README.md": "458ac52d1f35c2a2dc6a7b8904538d3f7db01b5c0e6986232440b797c1a167ed", + "docs/topics/rust-standards/test-plan.md": "9ca0677387942cd93c4fd2ff2196ee58303988e04d343990d623662f1d05d2f6", + "docs/topics/semantic-validation/README.md": "d39c0a87fb27d4c628345cf7dc84936ad49b5c87d7c3b318d234c1bcc0423054", + "docs/topics/semantic-validation/test-plan.md": "5b419c5c96760709cb889aa7f00aeea54b1eb14bed6d7f1ebf8250688326de47", + "docs/topics/syntax/README.md": "60ab4d64ddecf3757155b837c048eb2906023c8b324b41c7e43258b154b3388e", + "docs/topics/syntax/test-plan.md": "11ce0ebab9bb67eb67571404812e1a2ce141d8c2a3aaf6a760f40dfc47d91f33", + "docs/topics/target-ir/README.md": "0115bca1607aad12517b0c9339d87ede338d67cafd6e5c1b7c01380c98ae807f", + "docs/topics/target-ir/test-plan.md": "1904169bb88b7738eb3414b1db71b8d6a5e09ebbc668162e58e8e1f2aea852d8", + "docs/topics/target-profiles/README.md": "b42a301c561d9ea6fd7455263762752c89393d6c48d518180969a1b5211d3978", + "docs/topics/target-profiles/test-plan.md": "523f92ed32ae20f1a319e6eb5b21d2d18dffcd23aa4dbd83288ecc59a96ec86f", + "docs/topics/tests/README.md": "756221e24179a044b9d46c98e7340c01f2608a64388fffa0666d81a868a3236d", + "docs/topics/tests/test-plan.md": "58b750304af182e5033e2a4e0decee1fd2ce08aa99626272d131f13548280993", + "docs/topics/v2-design/README.md": "bbeb46d1ca9745e0809340f42166220d0911a6728230bdf24bab2dcc06705956", + "docs/topics/v2-design/test-plan.md": "6484de0febe1c061e0da0cdfbf07c59d849f9aa1a5419e62e248e2a15ec887c7", + "editors/README.md": "6fe19fe526c03268e29e45034fa6194883211dcc492b917d666f0c8af875e0e4", + "editors/vscode/.vscodeignore": "350c3f2808c5afc7de666c9a1b52c8fcf6f17c56d473c2e9f2f350174badd40a", + "editors/vscode/README.md": "05910adb7ad6ebfe78777324b7429cc275f0c954ce39ea87d74ddc17753a06b8", + "editors/vscode/language-configuration.json": "c48833f0c475f5f47b24ea3f50224ab93e91c5cf4be948a3ed1d45e6c3ff695b", + "editors/vscode/package.json": "d78a1cbdba4fa4ba3924ff9091918885d945b0e0320287ad6853502165d2fdb5", + "editors/vscode/syntaxes/edict.tmLanguage.json": "3384038419ccd7300453255e07a4c2fd8b6bc357fb83ee9eabe7a9ea3c1a8c21", + "fixtures/README.md": "f5b662bbe9cb2e771948945ce375aa451aa64c27a24bf21ff7714c92ffd97fd8", + "fixtures/authority-facts/canonical/README.md": "cae609cf8e98447c47e8e88c72e92b8a8c3a8d7f633ceb8e2e679e9a22142d04", + "fixtures/authority-facts/canonical/example-effectful.authority-facts.cbor": "d5ef9ae4c3ed7ad9ea6d82e0ddd79b2d4f2f1b231f084a009299f2c37a738074", + "fixtures/authority-facts/canonical/example-effectful.authority-facts.json": "16971188ce3f09095b890131b5c57c82eed608fb28495dba1c89b2c96e3397d4", + "fixtures/authority-facts/canonical/example-effectful.authority-facts.sha256": "54164d1d71430a87cfda496a9b5dc0885e7a9d7b4e66630e183d099432b15f74", + "fixtures/bundle/assembly/bounded-hello.bundle-digests.txt": "bd8d2d2a03e2a6b32911c7eee4eb1bdd390efb7011b95b34974d52a400e47cbd", + "fixtures/cli/01-source-ok/expected.stdout.jsonl": "d283f2ee7e143a6b60b803a627e2dee90f339241cd63bef1229c1a8e315fd274", + "fixtures/cli/01-source-ok/request.jsonl": "49a53d641de070134b686e545f2929d067ec7af4396c3a6702216cc1e9d3782a", + "fixtures/cli/02-source-parse-rejection/exit": "4355a46b19d348dc2f57c046f8ef63d4538ebb936000f3c9ee954a27460dd865", + "fixtures/cli/02-source-parse-rejection/expected.stderr.jsonl": "1c104870ac2bac548fb272e3672227b1ac8d85eb480637b9a09c4a2d31bbc654", + "fixtures/cli/02-source-parse-rejection/request.jsonl": "086cb795184703d2fc0eb07f7f425961bf2348aaa1e4e1af9dee2ed0d1971ab3", + "fixtures/cli/03-source-semantic-rejection/exit": "4355a46b19d348dc2f57c046f8ef63d4538ebb936000f3c9ee954a27460dd865", + "fixtures/cli/03-source-semantic-rejection/expected.stderr.jsonl": "90125d225064524dc65ceb0f5b90b8713c345aa4af0152c5b476fc389eb2e449", + "fixtures/cli/03-source-semantic-rejection/request.jsonl": "6e24d2bae9ba37e25177830b2b5c6b983adad8276835dcd6c226d11518e9f7d7", + "fixtures/cli/04-cli-missing-settings/exit": "53c234e5e8472b6ac51c1ae1cab3fe06fad053beb8ebfd8977b010655bfdd3c3", + "fixtures/cli/04-cli-missing-settings/expected.stderr.jsonl": "29572d578b44c71f8b6f78b0932dc14997be05cc9881e43ff1255a36347cc6f2", + "fixtures/cli/04-cli-missing-settings/request.jsonl": "9e5abbd3690d9a7af8a9b57ef7282596aef168d453be14314a6f89d6d11a82f2", + "fixtures/cli/05-path-input-ok/expected.stdout.jsonl": "68d4ad7ce44ec648cfbb4157a47e64a96a9005f6ae7ce3c718bd27abb8a04ac9", + "fixtures/cli/05-path-input-ok/inputs/hello.edict": "459640d110280d466496c4b74ab33fb2d1b499421d0cf069a6271c80c6a8bfa9", + "fixtures/cli/05-path-input-ok/request.jsonl": "8ec7682d92d628d12ab42b7dd7f271246001ba6e8c253be8818658905e88ae07", + "fixtures/cli/06-directory-expansion-ok/expected.stdout.jsonl": "ad161bbc118eeffd176dd4a4012f4f7eff179e9099a550d72baa690897b6884b", + "fixtures/cli/06-directory-expansion-ok/inputs/a.edict": "459640d110280d466496c4b74ab33fb2d1b499421d0cf069a6271c80c6a8bfa9", + "fixtures/cli/06-directory-expansion-ok/inputs/ignore.txt": "4c434d1d1573ce9a0ee2770f8668f7ea9d3a432625abc3f9c9370f84a2a5b4c2", + "fixtures/cli/06-directory-expansion-ok/inputs/nested/b.edict": "459640d110280d466496c4b74ab33fb2d1b499421d0cf069a6271c80c6a8bfa9", + "fixtures/cli/06-directory-expansion-ok/request.jsonl": "17831d76d91e32f7f18bfaf3a9cb4c069419d96be7d50be5641c8a22101b4522", + "fixtures/cli/07-path-list-ok/expected.stdout.jsonl": "b406e74333b798f86b73a87f3f528ecd7651cabf21f642e7b49120a12d2b5c49", + "fixtures/cli/07-path-list-ok/inputs/first.edict": "459640d110280d466496c4b74ab33fb2d1b499421d0cf069a6271c80c6a8bfa9", + "fixtures/cli/07-path-list-ok/inputs/second.edict": "459640d110280d466496c4b74ab33fb2d1b499421d0cf069a6271c80c6a8bfa9", + "fixtures/cli/07-path-list-ok/request.jsonl": "99a931efb17b128401f9e7c2efcff07d58ef424939d675a5f5fb2fa01b2ffd82", + "fixtures/cli/08-glob-expansion-ok/expected.stdout.jsonl": "1becf0452a9dbecc53d7b89f06ec62903c21cbe034c2dec0c5e2413641d8ebba", + "fixtures/cli/08-glob-expansion-ok/inputs/x.edict": "459640d110280d466496c4b74ab33fb2d1b499421d0cf069a6271c80c6a8bfa9", + "fixtures/cli/08-glob-expansion-ok/inputs/y.edict": "459640d110280d466496c4b74ab33fb2d1b499421d0cf069a6271c80c6a8bfa9", + "fixtures/cli/08-glob-expansion-ok/request.jsonl": "460c88f3012149a427fa33c187fbb4c540cbb5a04ac1bb962df9d842b9e19681", + "fixtures/cli/09-shape-source-ok/expected.stdout.jsonl": "ced445625029b147a51d44dedfa4e1de45bb4d118547dd3b35f8e231aebb897d", + "fixtures/cli/09-shape-source-ok/request.jsonl": "7c61374ae76501e1ec541ae00cb9ffcf0f573e8e891494622639738ab56e669a", + "fixtures/cli/10-input-extra-field/exit": "53c234e5e8472b6ac51c1ae1cab3fe06fad053beb8ebfd8977b010655bfdd3c3", + "fixtures/cli/10-input-extra-field/expected.stderr.jsonl": "72b2e4740ce4f08c37716f7134bb4bbd6404e1a87b7767a27f73543c6b89df75", + "fixtures/cli/10-input-extra-field/request.jsonl": "1f0687ce65f17e71f7d0c85da8c9032abf9d137ca188d47a569639387d6b93d7", + "fixtures/cli/11-input-hybrid-kind/exit": "53c234e5e8472b6ac51c1ae1cab3fe06fad053beb8ebfd8977b010655bfdd3c3", + "fixtures/cli/11-input-hybrid-kind/expected.stderr.jsonl": "7228a6f4b15cc3e2c814bc9d2a5c71505445da120c6643d8cc462d374c3debb3", + "fixtures/cli/11-input-hybrid-kind/request.jsonl": "2237ebf045c7eba20756f21b64df67257cf81c0f89f9a408ed828b7cf08db3b2", + "fixtures/cli/12-input-too-large/env.json": "959ceca4ff72c2d041c96a0976e7d9359564ad7e08f0015fd5683d2b61914c2a", + "fixtures/cli/12-input-too-large/exit": "53c234e5e8472b6ac51c1ae1cab3fe06fad053beb8ebfd8977b010655bfdd3c3", + "fixtures/cli/12-input-too-large/expected.stderr.jsonl": "41a0b8447fa06b80587334650e4ab6eb7049301bf5613926bd17d1d6845e39be", + "fixtures/cli/12-input-too-large/request.jsonl": "beffabf8d4dfd383a2f1f3e6d2a36cd9e10dc9da39d348056bf73b4c6eab8d26", + "fixtures/cli/13-input-root-outside/allowed/.gitkeep": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b", + "fixtures/cli/13-input-root-outside/exit": "53c234e5e8472b6ac51c1ae1cab3fe06fad053beb8ebfd8977b010655bfdd3c3", + "fixtures/cli/13-input-root-outside/expected.stderr.jsonl": "c52a20d7c9c59096b93931060f4daa8903d76a07de450745b0380d20099357ae", + "fixtures/cli/13-input-root-outside/outside/outside.edict": "856152b284b005af913b8aa037e68e9abfeb2c068e21ca644c09646c41180e0a", + "fixtures/cli/13-input-root-outside/request.jsonl": "aa6bec1d8ca29503be3937b16d807d0dbdb419ca1699bd069758341260e4f094", + "fixtures/cli/README.md": "43699191655d06e2120651e05824fae33a49193cd8c6a9f86556d33b094c56d9", + "fixtures/core/canonical/README.md": "2be0425a72900ad00c18b03cd7dcd01c7ae2ed021d30752e8ee36b3ed238008e", + "fixtures/core/canonical/bounded-hello.core.cbor": "66c0b4e91baaa68a95d84e389539fbd4c1013aa1cf12157f3eb0f09cb4297331", + "fixtures/core/canonical/bounded-hello.core.sha256": "cb888280d435adb2c3139145c6937179e0e3f89b45b701471a279d277b0e01fc", + "fixtures/core/canonical/statement-branch.core.hex": "32c4ee079fd92bb70d278338d76a12de9e822c8023794e5319f6241e04f81580", + "fixtures/core/canonical/statement-branch.core.sha256": "e3b20f92dcf8c502f85d9906a6b7ed84da348384f5900ce8a4d7772eb89c301e", + "fixtures/core/canonical/workspace-snapshot.core.cbor": "d026d06daa6b9b6180f0273f275b350ff0a9d19d69116b35eb1b5959a943d7ef", + "fixtures/core/canonical/workspace-snapshot.core.sha256": "eeda93c7fc42a3ceb496285243016d1171b14b08827ca31bc2afc0c39e97af10", + "fixtures/core/schema/accepted/core-fn-body-minimal.fields": "7878a67508fc3c430ee1e2467139383bab65baf3b792ac2695223e95f163b774", + "fixtures/core/schema/accepted/core-intent-minimal.fields": "6b8e17aa243289cd55e0974bec0d3a8f37918804e04e85e678d5405519a88ea8", + "fixtures/core/schema/accepted/core-module-minimal.fields": "2abb412e1cd98b085f9ea2122ca616bb425b29551669376b8f6d720c874fac02", + "fixtures/core/schema/rejected/core-fn-body-effect-node-field.fields": "af63e1ac9f50f5eb2cda472163a14d2de9d3741e8af336b8f36e20a67fc047c8", + "fixtures/core/schema/rejected/core-intent-unknown-verified-mode.fields": "a9447cecad7deee7ecd3938fe8a68991072a6c4ae5fc4bb02e1d83ae3f8cc2d4", + "fixtures/core/schema/rejected/core-module-missing-intents.fields": "1a78fead2c7b8dd9674c718ba21a053c673ea9c47228a1167864335c5f2abc91", + "fixtures/core/schema/rejected/local-ref-missing-alpha-name.fields": "8ee072e0337146e0418cf56212c7de898bfc7152fe8ec1b779c10585911fc87e", + "fixtures/lang/bounds/bounded-hello.edict": "c03b747de8c642f6c64e83cca82736b70445c2919b57ac5f4cf5ee42aa63305d", + "fixtures/lang/effects/conditional-blob.edict": "7e03df8e17288d90df94ba39922847e48ee35f34ed9feac802747d599ebbffc8", + "fixtures/lang/effects/read-greeting.edict": "2fa8822ba5d99aebeffedeb85537868c8b55ebe472a7de08e7b849f57262122b", + "fixtures/lang/external-actions/workspace-snapshot.edict": "4d5098f0c836db135981348f45eef9c537752ae495911b2709e1c7775f4c876e", + "fixtures/lang/operations/explicit-basis-u64.edict": "261e30f6e76684acfc9b112d1fe2439770deb2e6dc04659492cbb29a91e7d4b4", + "fixtures/lang/tooling/highlight-smoke.edict": "9d1f0f8314b60aab75e148e2ef3cda9c083d3748018d2ceb1c575cf8628f592e", + "fixtures/lang/types/color-match.edict": "82ce21d9a500f4f10249102f363762998b9841d4b016771b04ad29cc18735987", + "fixtures/lawpack/causal-cell/README.md": "9d2f2fe3a6949a8bcd3b7d5e66e9af428fce7b1837e0ae3835645c2da602ef55", + "fixtures/lawpack/causal-cell/adapter.cbor": "9ff972460a34a566ebc2d9fd34853468ec6c7378a642f9026767f0d16a841ca3", + "fixtures/lawpack/causal-cell/adapter.sha256": "8b50d9ac114a6cb6d8ea20bec9dc7bdd9837661070db92ca5d73adbd4c0983cf", + "fixtures/lawpack/causal-cell/echo-operation-configuration.cbor": "c3101946866fcc4c353f212e649aef1a367fe6b4155859486f71a3e4b2b8d89a", + "fixtures/lawpack/causal-cell/echo-operation-configuration.sha256": "4eb0e0c5e2a600adcdd34f7f7c97d8111318876a474fe00a368e1fb78bb35cbb", + "fixtures/lawpack/causal-cell/exports.cbor": "acd2912e8746bd0389b8782793fdc8549f5b8f9070ad25592bb293bee814f3e3", + "fixtures/lawpack/causal-cell/exports.sha256": "03eab6548701dd258759440e54ad42a898b691a80b768f63f6110a056c39ca42", + "fixtures/lawpack/causal-cell/manifest.cbor": "d38f1012fc3d111e501903dd39820a61149e59bd13b09377ec37670cfeab7761", + "fixtures/lawpack/causal-cell/manifest.sha256": "817105062c5e6691880bcf0e4cc3698ee720b33f811f9671a3f85ae6d144f1f6", + "fixtures/lawpack/hello-echo/README.md": "2f83ca775b06ceff1a1df5fc6b8ca22c7cd37c8f4b1db671ac52acf80a34760c", + "fixtures/lawpack/hello-echo/adapter.cbor": "5ca8fecd2127d6ea5aff28fefdd2711ac9a92460247668bc57ea651c313d393e", + "fixtures/lawpack/hello-echo/adapter.sha256": "4de4924c943bfbf8f14427d1bf7cdf047e9a7b9f3f395067bae655785b6a4eb8", + "fixtures/lawpack/hello-echo/create-greeting.core.cbor": "bbf7e69a9146d5dbffb7f7e234830821bbc38070159ff0821c1dbf191ddebeca", + "fixtures/lawpack/hello-echo/create-greeting.core.sha256": "88cfe6dc6a54cc32a0be81f79a9ad7d8e4f51a1b1117df70b8e08007814de850", + "fixtures/lawpack/hello-echo/create-greeting.edict": "3bc0abfbaa561d4b5c08a0cc7effe8ad1a9101b5792cc4a7a5a8dcaf020acca2", + "fixtures/lawpack/hello-echo/create-greeting.result-projection.cbor": "adcd5863f896276b633d1954924849851e38a482b4fed2a600314c7e9625b35f", + "fixtures/lawpack/hello-echo/create-greeting.result-projection.sha256": "cb06288e8b212ac10e765309271a0088f2b2ab4bf952dea54f41a3e3bf5449dc", + "fixtures/lawpack/hello-echo/create-greeting.target-ir.cbor": "4ee7334328d505c54b7c61a6b1a966bd39805e273208bfe56289ea4ac60cf205", + "fixtures/lawpack/hello-echo/create-greeting.target-ir.sha256": "3f4af5f826a0d887b4c5e72b0d9808b04938223285352ad5b44fa5e90239c2bf", + "fixtures/lawpack/hello-echo/echo-operation-configuration.cbor": "fa8eb9bc27f729d33a87e70a23a0b4ac15eb5302306e2aa2664fe74415ba9d91", + "fixtures/lawpack/hello-echo/echo-operation-configuration.sha256": "18ac8912c9ee4577441518ebcceb15b06b3564590cd61586434d0b9bcae657fa", + "fixtures/lawpack/hello-echo/exports.cbor": "542cfff96f940ae83b6444b6eae1735e491b36f07b259cb2c1f6fd6642cfa1f8", + "fixtures/lawpack/hello-echo/exports.sha256": "918bece8922d623158172d78a24923abb6271f37e943b177de55ea83fc45f755", + "fixtures/lawpack/hello-echo/manifest.cbor": "1ad4ff3dbe1fa7293f542b4b82e3726a18008f53bfb137e58592d2f815cbc857", + "fixtures/lawpack/hello-echo/manifest.sha256": "69aea9344dc5dc4322ee05ba1ddbaad8906f6765c8b0f98c8d0c0ecad6d25477", + "fixtures/lawpack/workspace-patch/README.md": "a467e07814c52766583c608c683ebcb55d1f784e3b27b49da3c3f3d0cd81c331", + "fixtures/lawpack/workspace-patch/adapter.cbor": "2d9ddd3d8b00896b6bdb2f7dd3d6d06c11905b0858a1a56a2b71eb0c511cdd86", + "fixtures/lawpack/workspace-patch/adapter.sha256": "54353255601a3a3cfbb925de17bec3d0b2e16754865b9394d1470e5c43833d5b", + "fixtures/lawpack/workspace-patch/apply-validated-patch.core.cbor": "d7d11106b50d2c63606accbec221067afe86d0bb72098f9ef074d6e01e4e87ad", + "fixtures/lawpack/workspace-patch/apply-validated-patch.core.sha256": "124f6f036c6b5d7029a4cee9a9176d95c798643654c41c60e9653220abeba37d", + "fixtures/lawpack/workspace-patch/apply-validated-patch.edict": "eaaa47ab28f011938eb12dce7cda5ceb8af4bc5fa7128d72114f50652849ba1d", + "fixtures/lawpack/workspace-patch/apply-validated-patch.target-ir.cbor": "fc1d262af3da243b50a65ab4b726f049c0b3820f39d997b81eca7d7ffad2dbf5", + "fixtures/lawpack/workspace-patch/apply-validated-patch.target-ir.sha256": "5863b4b0538094c005db4294e2e73a3ef2a31f1d9277c92e5b9f35cf374a4295", + "fixtures/lawpack/workspace-patch/exports.cbor": "6c2c162d038bab0ebbf353b81f64f0f9cdfa569a953d99f9a1dc8288f2f97bbb", + "fixtures/lawpack/workspace-patch/exports.sha256": "145c439ceeed642e2497a4a1f77cadc80d7581d019ae9dc55f52653d685e62b6", + "fixtures/lawpack/workspace-patch/input-schema.cbor": "d691aae9de3a6473602c691b62eea441475efbffac9874c518c4702dee20f2c4", + "fixtures/lawpack/workspace-patch/input-schema.sha256": "8ce51f680414aee6726519ee97dde0c456ef982dc16216d9efe7ffc258d4f4e5", + "fixtures/lawpack/workspace-patch/manifest.cbor": "96900d03412a204547779707f404db2518640962856f99fc05efca5d704abd2b", + "fixtures/lawpack/workspace-patch/manifest.sha256": "d4bc64cd59615534c04b759620ff43c43a3462a7531a2ec557de814fa340ea97", + "fixtures/lawpack/workspace-patch/reconciliation-law.cbor": "776377f8d2c7c282af179aee48787913bcac053d293947143064be2fe13965a4", + "fixtures/lawpack/workspace-patch/reconciliation-law.sha256": "7620adc1e00d1d8449bac8d53671d87afa61228294196f84dc3d328419d9fd7e", + "fixtures/lawpack/workspace-patch/request-profile-configuration.cbor": "ef4bc2665b9867392c37e0378532a1410434f8fdb66e5d198b5882a74816481a", + "fixtures/lawpack/workspace-patch/request-profile-configuration.sha256": "9da854a686d5c76998a7516dc121985de895441e727b435cb7b3a237cd40d9fe", + "fixtures/lawpack/workspace-patch/settlement-schema.cbor": "d2aa24697b9fdfca6f8bdff244c99dbcb08ca128308507044057ad3836cfa017", + "fixtures/lawpack/workspace-patch/settlement-schema.sha256": "67f58bf6eb1df74f660304499ec49a97bd13d7fa1f71e6f3437157789e01ebdf", + "fixtures/lawpack/workspace-snapshot/README.md": "37ebb6d1ffa4e45197c986b823e3aaba20255123dc8111a2ffca5d4b7a85b566", + "fixtures/lawpack/workspace-snapshot/adapter.cbor": "0b06dae097530b5c6e5246a998320170a9612f55c8099711c08a388fa050c0aa", + "fixtures/lawpack/workspace-snapshot/adapter.sha256": "a00af1e62a1ade6e226ae1572cc8e2542e1e8256b8a2c377167bede46ccb99c0", + "fixtures/lawpack/workspace-snapshot/exports.cbor": "788ba1741529248ca4cd902cf56a529d79ac30d0cdd2122c8a631cd626c27059", + "fixtures/lawpack/workspace-snapshot/exports.sha256": "49c890f3a194283109b211875646e558584e27c0c0cf51ecc5d442fb667947c7", + "fixtures/lawpack/workspace-snapshot/input-schema.cbor": "bbbff7ff8ee3aff2d80a2ecdf67cc5d61b56a9dec6feb3f913369d80a35809a0", + "fixtures/lawpack/workspace-snapshot/input-schema.sha256": "b85d50e4a42a610fe1869c0ef97d17e6f6154c043d560fa35b83a8c4150c1658", + "fixtures/lawpack/workspace-snapshot/manifest.cbor": "de562334ed0ad8b868af7c7f2664a0e27adbed5633b20f8f78191d52891c8583", + "fixtures/lawpack/workspace-snapshot/manifest.sha256": "54d24bac38ebcbf1474f70b6d53ed68ed73e3fb4b3ebb85f7bf2963c3b8004fc", + "fixtures/lawpack/workspace-snapshot/observe-workspace.core.cbor": "86fa2cf6ed6edf12a92ca4bbf7d576f2a5eab32c2ff9a84a12ca25e7b843e3f6", + "fixtures/lawpack/workspace-snapshot/observe-workspace.core.sha256": "bba1e6ebcab0430e459f31ebe82004aae33a5ab32219b9f51a80416b6e6b7fbc", + "fixtures/lawpack/workspace-snapshot/observe-workspace.edict": "da2c10b6ca53a43ec0fda6a74a1a9296c533f42ee50b4ff8eaaa7d57f4b17289", + "fixtures/lawpack/workspace-snapshot/observe-workspace.target-ir.cbor": "9fc28d791ef91a2e7cecfca9244f1bf3826665d715ebaf00f73ef5f782ea82a9", + "fixtures/lawpack/workspace-snapshot/observe-workspace.target-ir.sha256": "dfbee2c71b5dfef18ddf840ab6913769cf8d85b233bdbba851feb1013a4d61b8", + "fixtures/lawpack/workspace-snapshot/reconciliation-law.cbor": "c6c3ec51e17ce74b3fd779b41f8d4a686a43df9f164b7381abda56b0f4f45d12", + "fixtures/lawpack/workspace-snapshot/reconciliation-law.sha256": "910723163a789e058922e914ba37540dc49aec320f58680218bfef0e45b90036", + "fixtures/lawpack/workspace-snapshot/request-profile-configuration.cbor": "61314a4f79e8ad572feb2a6f5479d45da11430f2ad902ed8cf1f7ff5d2211007", + "fixtures/lawpack/workspace-snapshot/request-profile-configuration.sha256": "e11e858751fb2e39205a605d7aa9a9512c8ff06b788cfbc0c5a98aa53e671bf6", + "fixtures/lawpack/workspace-snapshot/settlement-schema.cbor": "6689e3b655d25cbbbfdf7b75d52039db614d3d408677181afbbc5e7e02e0e2bd", + "fixtures/lawpack/workspace-snapshot/settlement-schema.sha256": "4775b7c7fc507035788dc3bf5fcdbe488c522114f128ca09f87ac3a28dc16e6b", + "fixtures/obstruction-strands/v0/stale-basis/README.md": "6d53a559e38c214f3850b848526fee8f1d83b38be376d284bf2ffe2d5f7ba723", + "fixtures/obstruction-strands/v0/stale-basis/source.edict": "fb36a7017af8f8f5735ea0b62f788caab1f7cd56bfb5f9f3a0509b7664b92d85", + "fixtures/provider-contracts/v1/README.md": "ce3c381dd6dab67c092b288d36558b331a7066ba2fed21d53c56d600db59502b", + "fixtures/provider-contracts/v1/edict-provider-contracts.cddl": "82273f3ea016a421c881f15b0fd451802205903ac9177bac8accbf3173f66d2c", + "fixtures/provider-contracts/v1/manifest.json": "6303668861667a30418870ef25e5f169017905ae1f9d261451ba298120afdd9d", + "fixtures/providers/README.md": "7178ed08686953bf7a3c03c4761c637808ac259b279b2fc3e0fbec9183fa60e2", + "fixtures/providers/components/guests/Cargo.lock": "85a7e30f09abcd23033599b6426b419d35c1b2ddacb69331967587b0c55745c0", + "fixtures/providers/components/guests/Cargo.toml": "3d78e0001225560207cbe97a9f6f12f71dcc8b4f1f7a06a85e7092209f4dc0d0", + "fixtures/providers/components/guests/lowerer/Cargo.toml": "62689501ef19bcfed24ca965e6dea0c301e76640907bdb5a2048847844e4691c", + "fixtures/providers/components/guests/lowerer/src/lib.rs": "76d83548c76ac6d3a1c20a24b4dbe1c8843a0facdbbf0c05015e858f05c5be7b", + "fixtures/providers/components/guests/verifier/Cargo.toml": "0fcdd68f536887afab601c04e252445f9393fc89d7b020db60da5deb5ffe3afd", + "fixtures/providers/components/guests/verifier/src/lib.rs": "426f45e8617caf5974a6e13a5cfec36e620f84f99338e3e1f5aab3407937055f", + "fixtures/providers/components/instantiation-failure-lowerer.component.wasm": "4ca29c3c16f1c0c3c3d80d5fa877cd853d41b9a84d5f30dbb11e2387f81b6e7c", + "fixtures/providers/components/instantiation-failure-lowerer.wat": "add5541aad2743d9ff16d0fed5326a9c528859b2616c34c0ab89319bd39118ba", + "fixtures/providers/components/instantiation-fuel-lowerer.component.wasm": "6511898df2801170b40323038ef642e32d57c9a9e3f0fd97b616cd2873031bdd", + "fixtures/providers/components/instantiation-fuel-lowerer.wat": "cb6ed1588c48274a6de4c36aa5f28c0315b37e89590ff1cab7f50d4e8041541d", + "fixtures/providers/components/inventory.json": "6d5d19359134e3e8cb701bd9df8c80e38dc56ac2f9ab928b88e755f80e7ea96f", + "fixtures/providers/components/lowerer.component.wasm": "0d16533735fa00f90bdb55f82495e1888802f4c857b35a5b3931429f24143885", + "fixtures/providers/components/malformed-lowerer.component.wasm": "dfcd171918373d18b9dff16778e98b7618eeb4ac85976dd7134b9e201562f41b", + "fixtures/providers/components/malformed-lowerer.wat": "b8044e5caa50bcc3a80e8b7af2eaab29d3a0d51d62725458909e1bfdf42241b6", + "fixtures/providers/components/verifier.component.wasm": "e889007a621d05820261eeb9fd69ce555f5761dbdbf82c6e9f55220ea529776d", + "fixtures/providers/echo-generated/provider-manifest.json": "96974d26f39f6cfccfe91bf499b59bdff50bc103cbaff8d1fbf7e4252c916ca5", + "fixtures/providers/echo-target-profile/README.md": "c9041ceeb1210ce520167b12fe9e8b6caff0c5fac87177aa6cf5b4c51d6b0721", + "fixtures/providers/echo-target-profile/generated/primary/target-profile.echo-dpo.cbor": "1b105d1b1f6cdf5fecdef98b7adeb238525047d43581fe9fd8c44fd213e1788e", + "fixtures/providers/wit/legacy-target-profile.wit": "9db5841289178228f2583927f02fe40a2cf71bfd0a9ea4e664ccb358506a6d57", + "fixtures/target-ir/canonical/echo-effectful.target-ir.cbor": "7a60cd64823eeb9801abcc887bb4deaa0ed4af0ca378dc84d142b3df650702bb", + "fixtures/target-ir/canonical/echo-effectful.target-ir.sha256": "522e896587f5eeeabb0b3680584a230b2521b97675c40152b43c7c7c94370483", + "fixtures/target-ir/canonical/gitwarp-append.target-ir.cbor": "49259a149d2fe02856059a7683a9a3a02fcec84ca6937b2401a08f6536391735", + "fixtures/target-ir/canonical/gitwarp-append.target-ir.sha256": "930af94de85ffe09f75afea9e112ac659062ec2c6b62af166a3ccd6e3a9daacb", + "fixtures/target-ir/canonical/workspace-snapshot.target-ir.cbor": "1c4a8bafa1fdaa681a028f5bff381904b613f951ad3a65dfaecf16a4aedfeba4", + "fixtures/target-ir/canonical/workspace-snapshot.target-ir.sha256": "218b558b825a1fa59d52e816bb74fbd3a0d359a5437a8263c8562fed381b08d6", + "fixtures/target-profile/contract-resources/README.md": "ceba47e8308c06e484aec1c30d9e4aef8ee7886d0cab13f860894e4bc62fc7dc", + "fixtures/target-profile/contract-resources/canonical-cbor.cbor": "8306e4f08c1e4e7d29ab22bcf55c324312712aac3eeeb675857ced57c3e48bdc", + "fixtures/target-profile/contract-resources/canonical-cbor.sha256": "1571de5dddfaa963952eb89b1e40e9749f5e92668645c221ff8d92c515af8e19", + "fixtures/target-profile/contract-resources/determinism.cbor": "84073f5c1734b625e16799048e28458d43e0a10befdae56a79d906f5e37ef76a", + "fixtures/target-profile/contract-resources/determinism.sha256": "bd9465934a18f73def0c38c75358440f84ec98d39d3b688ce44cdcd5c280e72e", + "fixtures/target-profile/contract-resources/diagnostics.cbor": "e465a28f1170fe478db5ff65d96a1fdbfbbcb95d327e6965021c252437991e4b", + "fixtures/target-profile/contract-resources/diagnostics.sha256": "e3cf575631bc142ae67786269211383352bb869a9690b8c5190669788bedddb7", + "fixtures/target-profile/contract-resources/fuel.cbor": "c712c2d831cc8e731bdc1dfb8ea536f4630f38f0b0e0c6448b2df57176d3d0bd", + "fixtures/target-profile/contract-resources/fuel.sha256": "afa42a66b0df107eab464a08e5c358639edb4ca9b72f77d8abf21a165d4e293e", + "fixtures/target-profile/contract-resources/wasm-component.cbor": "cd09d702db1d10be825e72effe35627bec56963cb3d78601b69478c58787e34d", + "fixtures/target-profile/contract-resources/wasm-component.sha256": "1f960c0ae125ad146775c3f40d4fe7402b7fbfc619195968d019d4213149bcb2", + "grammars/textmate/README.md": "d68a6d01eb366626b7b66e72b210e0ccfd0de961e7dcf67bf23ca11d24683791", + "grammars/textmate/edict.tmLanguage.json": "3384038419ccd7300453255e07a4c2fd8b6bc357fb83ee9eabe7a9ea3c1a8c21", + "grammars/tree-sitter-edict/README.md": "d01a9a5d0823ff83bd7eae709796d2ba9f60827258e83f4acc61a8f67cd166be", + "grammars/tree-sitter-edict/grammar.js": "648d883aeeb95276e50b83cbeb11c478ba494671a883c4156ea185cd9e1fb689", + "grammars/tree-sitter-edict/queries/highlights.scm": "c5eebabd4ecfab6d61e1a81e534be40e678313e7f62de45a012b363184051883", + "grammars/tree-sitter-edict/src/grammar.json": "ec1d17ccdab6c8c7a1b3d819f80ceb63e5fef4217b51771a19ff1b292a960172", + "grammars/tree-sitter-edict/src/node-types.json": "a79d4870fcb31450660570279de5cbb0571ec9751565eb70e663a08e78857f2c", + "grammars/tree-sitter-edict/src/parser.c": "db53b6f1984be6857920a3b669fd02ac5a61ab4c4adc297cd13d1a698200d67a", + "grammars/tree-sitter-edict/src/tree_sitter/alloc.h": "b29c1c9fb7cc82f58c84b376df1297d6e2737a1d655fd356db0859e3c29c2fea", + "grammars/tree-sitter-edict/src/tree_sitter/array.h": "31e60a1bff6f715afacce03b5b70efe42b58371b4f9595dd4af52a577ff9608c", + "grammars/tree-sitter-edict/src/tree_sitter/parser.h": "180b893c8734778fd32f372dfbc27bd6ad1cd2221f26150b31256ff6716320d2", + "grammars/tree-sitter-edict/test/corpus/current-subset.txt": "0ece2b4025504030e241bf7dc86e100d90de01ecf47be7187c69fc109402616e", + "grammars/tree-sitter-edict/tree-sitter.json": "ffd900f458d520c326b084c950c0683da5110326dfef664d2845671e9e0ba1c2", + "scripts/consumer-witnesses/README.md": "97bb29ed4ba509f5c52c6d3fc4862d0bfd2e6f1098f31441a9c6d10a0058e107", + "scripts/consumer-witnesses/jedit-state-read.Dockerfile": "33ab296609d366955e95bdfafdac88d8fd89c334a95392e0d840757372682a04", + "scripts/consumer-witnesses/jedit-state-read.Dockerfile.dockerignore": "e4281aa8c5c9399a71fc801b3f39f1d639d12ddc5e36a7bf4df684366d2a92b9", + "scripts/consumer-witnesses/jedit-state-read.py": "30933061c52eb82a511bc290c367c003129ac1853e717595ce1976fd9b6da015", + "scripts/consumer-witnesses/run-jedit-state-read.sh": "3fb7e4d9f91b8ea2506916dc70968cfc61cb481ea67a7780c44c8dc442523482", + "spec.lock.json": "0d44a0f5d8fbd77e198edd776a7d9b9bc4babae1c820b10e340c2bfda772fd0f", + "xtask/Cargo.toml": "127c5b19d72856e62c9e19766035af7122f76b12d41dbbcf2ad0c48a95291d31", + "xtask/src/contract_check.rs": "aefa5117e7bc547c85c67bef5f67756ff9f676314ea3d245be7f63e949d4f13d", + "xtask/src/goldens.rs": "33d10989d188149517bc5f1a59632da00a27f85299f4b209f99803d650d7022d", + "xtask/src/lawpack_goldens.rs": "9555cdfd2624ca4dc7ddf2143562096fce7f4ef56c617809764b231bf8b5a0f6", + "xtask/src/main.rs": "b634296a41c26dcc5f4c2d5308437a089c7e0bc4ac1c244c2641c5ae70074ecb", + "xtask/src/provider_components.rs": "db291c46e24c38e1955c9f4077b135a74d08ae5ed9aef05e4ef771c1e7aaf500", + "xtask/src/provider_contract_pack.rs": "2d9d14184b63d0253732225442483da51c70ccdb6092efd2e7705b74f4986479", + "xtask/src/provider_dependencies.rs": "aa2236f057acda35445c429d4fd3a37c0606cc477f898354a292952b744f2415", + "xtask/src/release_dates.rs": "733a1d6915e4a897308f458f080f576f023f071183b263ce4dbe2302297471cb", + "xtask/src/release_prep.rs": "a0c335406b15c86314dd0c00e3a0b8ff5e14b47d92b5f5b1dc763ceb48759520", + "xtask/src/tests.rs": "3ea68d101e9cbcce69ce5067ecd034a58a809af703d6ddece9455cfd16abc02d", + "xtask/src/util.rs": "9fd9d75981d0e38dc4cfd87090a96f3665435c5d010607508c848f759b749539" + } +} diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/compiler-source.json b/edict/replace-range-probes/range-assembly/evidence/candidate/compiler-source.json new file mode 100644 index 00000000..3ef03a8f --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/compiler-source.json @@ -0,0 +1,1802 @@ +{ + "commit": "01dc5abb9a8a74f8fd8b0e0a6d1041d0adb86d6e", + "tree": "74e571125a1da6ac5b2eac80944e343811708d51", + "files": [ + { + "path": ".cargo/config.toml", + "gitBlob": "5592118f6c54bf8b53b16848e04ece896dd56384" + }, + { + "path": ".github/workflows/auto-release-tag.yml", + "gitBlob": "87404ceb685191afd496c93494b0bc61e2a59504" + }, + { + "path": ".github/workflows/ci.yml", + "gitBlob": "c6c6a17f59b6b96db88e3d4b2775bc64b7fe01f3" + }, + { + "path": ".github/workflows/release.yml", + "gitBlob": "2c612fc786998bfa5b11e76ae1185114a7cc535f" + }, + { + "path": ".gitignore", + "gitBlob": "30d7faf0fc8b7f010f99280302d4ed269d5da9ba" + }, + { + "path": ".markdownlint.json", + "gitBlob": "f3ec2c8dc2fbacc425154a2baedec50c7474aefa" + }, + { + "path": "AGENTS.md", + "gitBlob": "0c48a5794454cf84e20640994a372316efde7bb5" + }, + { + "path": "ARCHITECTURE.md", + "gitBlob": "5b513dd25028092e7e75c8974f1d5f3cc31889ed" + }, + { + "path": "CHANGELOG.md", + "gitBlob": "cd40892f0f2ed2e5667c65e274f9a1ead1619990" + }, + { + "path": "CODE_OF_CONDUCT.md", + "gitBlob": "784cf2799bcf8d2a69db5f5781359ef7e18a05fc" + }, + { + "path": "CONTRIBUTING.md", + "gitBlob": "9676914060f734dc59eabd9075898dc8170d4d19" + }, + { + "path": "Cargo.lock", + "gitBlob": "bacb208de0583f182379af7b5e078d31b25e2ca5" + }, + { + "path": "Cargo.toml", + "gitBlob": "b2e7106eb78f79230c091492ef21b497bdc9ed19" + }, + { + "path": "EDICT.md", + "gitBlob": "35376134195082d506f0161ba7ecb97efa8b770a" + }, + { + "path": "LICENSE", + "gitBlob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "NOTICE", + "gitBlob": "c300687bdd9d931d1f257d291e1cb6ff9d7d3607" + }, + { + "path": "README.md", + "gitBlob": "0812ef9a0c4611bf655dfc67d2ecc3631af9a536" + }, + { + "path": "ROADMAP.md", + "gitBlob": "d0e0135780537afab1d1a3f53808b363b35a63f4" + }, + { + "path": "SECURITY.md", + "gitBlob": "0bcc4e7375442e1334405a2d046df316cee05cd5" + }, + { + "path": "crates/edict-cli/Cargo.toml", + "gitBlob": "e9d844553c395bd312f84e806eb5bac30c5c3a54" + }, + { + "path": "crates/edict-cli/src/application_build.rs", + "gitBlob": "9c56ae6b4dd4eef0b9fe6db40316e100b2ffa699" + }, + { + "path": "crates/edict-cli/src/lawpack_build.rs", + "gitBlob": "55e9579153f34a3d5b139141c9de6640808cd386" + }, + { + "path": "crates/edict-cli/src/lawpack_build_windows.rs", + "gitBlob": "f71d03b368ae83becc1608bbba11cd5f1afa4f07" + }, + { + "path": "crates/edict-cli/src/lib.rs", + "gitBlob": "60883af60cf4b441680952ecce7ef4fcbfeabb97" + }, + { + "path": "crates/edict-cli/src/main.rs", + "gitBlob": "0dd9776642c4090479322111e4164ee7049fb9d0" + }, + { + "path": "crates/edict-cli/tests/golden_cli.rs", + "gitBlob": "9897caad3bcc6fa8bb0f20a1d0e18032285b1fa7" + }, + { + "path": "crates/edict-cli/tests/jsonl_cli.rs", + "gitBlob": "9ed353ca27d073fc7da49d3800c81ba4c58edd5d" + }, + { + "path": "crates/edict-cli/tests/lawpack_authoring_cli.rs", + "gitBlob": "dd7d7bfebf0e051c77d894a55c0204d373b19c63" + }, + { + "path": "crates/edict-provider-host-wasmtime/Cargo.toml", + "gitBlob": "ebeeb941f09012293d9923fe0e6039b2761b328e" + }, + { + "path": "crates/edict-provider-host-wasmtime/src/conversion.rs", + "gitBlob": "62c3cd4a85eb156b8c9a405ef3ea4d8a09b80cc3" + }, + { + "path": "crates/edict-provider-host-wasmtime/src/invocation.rs", + "gitBlob": "a4d6680d289094afebc0f1063abccf706f8149db" + }, + { + "path": "crates/edict-provider-host-wasmtime/src/lib.rs", + "gitBlob": "353ea7394f265219ebdecad56a3070c9e7d2685c" + }, + { + "path": "crates/edict-provider-host-wasmtime/src/limits.rs", + "gitBlob": "9e4d12c1b606d2b180f732db17bfbc78f8e26e3a" + }, + { + "path": "crates/edict-provider-host-wasmtime/src/replay.rs", + "gitBlob": "b8fa7be7c7ee5039793dad4cd0fa6a4f14ce388e" + }, + { + "path": "crates/edict-provider-host-wasmtime/tests/invocation.rs", + "gitBlob": "7a59a3192852a80bc01221ebf3dd1c437bda9508" + }, + { + "path": "crates/edict-provider-host-wasmtime/tests/preflight.rs", + "gitBlob": "a295e7547b0294f0355a85d5b9b8d045c8fceefd" + }, + { + "path": "crates/edict-provider-schema/Cargo.toml", + "gitBlob": "0e74f58acdc054ecce192cb8341afeaddc40deb5" + }, + { + "path": "crates/edict-provider-schema/src/contract_pack.rs", + "gitBlob": "370480d9c606134dd08ee62ae29ef143941e2f54" + }, + { + "path": "crates/edict-provider-schema/src/lib.rs", + "gitBlob": "51f5bee8892c9fb2122cb20022edc4d414759ff7" + }, + { + "path": "crates/edict-provider-schema/src/recursive_dispatch.rs", + "gitBlob": "6d97565b96f941b359d16f7a1c201189968fbeff" + }, + { + "path": "crates/edict-provider-schema/src/schema_safety.rs", + "gitBlob": "a2f605f62a2bfedcb84b68e37db9ff84b1dc3b05" + }, + { + "path": "crates/edict-provider-schema/tests/authority_facts_abi.rs", + "gitBlob": "7dd4d0302805ceecffc2045cdb91e386f8e08517" + }, + { + "path": "crates/edict-provider-schema/tests/provider_contract_pack.rs", + "gitBlob": "a26be8054b39215048825dd8cae7e9bddcfe27c9" + }, + { + "path": "crates/edict-provider-schema/tests/registry.rs", + "gitBlob": "bdd13ec00e441aef9e67ba49f6592ecbc7dcb303" + }, + { + "path": "crates/edict-syntax/Cargo.toml", + "gitBlob": "f55bb23e528af78b1e97b52f9b72cbd876a44ba7" + }, + { + "path": "crates/edict-syntax/src/admission.rs", + "gitBlob": "471430dd13a617bac886fcd44afbf15263e7db3b" + }, + { + "path": "crates/edict-syntax/src/ast.rs", + "gitBlob": "2a5d208a53a82408f8a18d9a13ccb133ec6a7a2e" + }, + { + "path": "crates/edict-syntax/src/authority_facts.rs", + "gitBlob": "644de86d63983bdbfbf1279fdbf1dbdaecc151d5" + }, + { + "path": "crates/edict-syntax/src/canonical.rs", + "gitBlob": "6fb29d50ea4a55eb888a1b9600cdcb31713a6e20" + }, + { + "path": "crates/edict-syntax/src/compiler.rs", + "gitBlob": "d9661e2605f23f503a8fdf4471462cc0b9bad4c1" + }, + { + "path": "crates/edict-syntax/src/compiler/byte_concat.rs", + "gitBlob": "185d11c0ae20931cd2737774a34cac92b13d6712" + }, + { + "path": "crates/edict-syntax/src/compiler/byte_length.rs", + "gitBlob": "0d8d6291064415baee9253d9fe1e11ad87945773" + }, + { + "path": "crates/edict-syntax/src/compiler/byte_slice.rs", + "gitBlob": "84385fffdf4e38e21285e1fde252e9185a3a76fa" + }, + { + "path": "crates/edict-syntax/src/compiler/unsigned_subtraction.rs", + "gitBlob": "c2ef2deda74afb52e4346076a310df341556e1c8" + }, + { + "path": "crates/edict-syntax/src/contract_bundle.rs", + "gitBlob": "9a31645f0e30879d019787e29c21c82eebf58129" + }, + { + "path": "crates/edict-syntax/src/core_ir.rs", + "gitBlob": "4c6f350b325d13a27947687dd1f4114edf6d548d" + }, + { + "path": "crates/edict-syntax/src/highlight.rs", + "gitBlob": "28b3f7dcdfe8d4982bdcfb05759f769ccdbffc7f" + }, + { + "path": "crates/edict-syntax/src/lawpack.rs", + "gitBlob": "54f85bda48c960ad0b7bc316d332b379ab5b6ae0" + }, + { + "path": "crates/edict-syntax/src/lawpack_adapter.rs", + "gitBlob": "e425960e2437faa2f9eeb5d089ff507417d39586" + }, + { + "path": "crates/edict-syntax/src/lawpack_authoring.rs", + "gitBlob": "11ff578f458b8a4c8e4df75c0c616e37fa468d49" + }, + { + "path": "crates/edict-syntax/src/lib.rs", + "gitBlob": "7323475cc7f846e11c2d73f4c26a5e581b7e6157" + }, + { + "path": "crates/edict-syntax/src/lowerability.rs", + "gitBlob": "c6a1323fd6a79b0460b43aaf338956c3906a633e" + }, + { + "path": "crates/edict-syntax/src/parser.rs", + "gitBlob": "0b3650e3012e49023ccbb9cc9effe9b5b102f19d" + }, + { + "path": "crates/edict-syntax/src/provider.rs", + "gitBlob": "18fa661d880979c53dd335fb7e68d5445b638d4c" + }, + { + "path": "crates/edict-syntax/src/provider_invocation.rs", + "gitBlob": "2526168f0a6f2d1d9b6181b689ff43e203434122" + }, + { + "path": "crates/edict-syntax/src/provider_lowering.rs", + "gitBlob": "50a4e60b561127cb8c78e3f7c04c6bbaca068e52" + }, + { + "path": "crates/edict-syntax/src/result_projection.rs", + "gitBlob": "79ba246d4c58960fe368eaca4c7d135fe187832a" + }, + { + "path": "crates/edict-syntax/src/semantic.rs", + "gitBlob": "76bd133ef5859bf7722d1987613f7fd84836ab62" + }, + { + "path": "crates/edict-syntax/src/target_ir.rs", + "gitBlob": "9dd759a18ea3a171837baa50e88c67987c84da13" + }, + { + "path": "crates/edict-syntax/src/target_ir/byte_concat.rs", + "gitBlob": "bff3a35e1d3183813ffb1e69655934f65f2c9131" + }, + { + "path": "crates/edict-syntax/src/target_ir/byte_length.rs", + "gitBlob": "972e6ffa943bc7a7a943d76f0af42b342e3d2aac" + }, + { + "path": "crates/edict-syntax/src/target_ir/byte_slice.rs", + "gitBlob": "62a1c0b9e84a331bb17ab78090cce6d8eb8da486" + }, + { + "path": "crates/edict-syntax/src/target_ir/execution_order.rs", + "gitBlob": "e69a28805dc5e414a64afdaafee34161c217a044" + }, + { + "path": "crates/edict-syntax/src/target_ir/totality.rs", + "gitBlob": "a4fb9573d59e1a4bb9d7c250402c5b7e1da0a8c3" + }, + { + "path": "crates/edict-syntax/src/target_ir/unsigned_subtraction.rs", + "gitBlob": "b83522bfe9a2b506413b4d306f4bc49f8b053f36" + }, + { + "path": "crates/edict-syntax/src/target_profile.rs", + "gitBlob": "dd514f7380243e795f0655a78aecd06ee3fa2eda" + }, + { + "path": "crates/edict-syntax/src/target_profile_contract_resources.rs", + "gitBlob": "4efd22961c2fd7591440efd6087944ecaf21e991" + }, + { + "path": "crates/edict-syntax/src/token.rs", + "gitBlob": "2768586eea6d42d5df357c4cc62a011ee7f455de" + }, + { + "path": "crates/edict-syntax/tests/admission.rs", + "gitBlob": "57edbc320307c1d6daba85f03d8dc79558d7b849" + }, + { + "path": "crates/edict-syntax/tests/authority_facts.rs", + "gitBlob": "add9d272be6e8eb1cd6fdde2999a5fb452ecd852" + }, + { + "path": "crates/edict-syntax/tests/authority_facts_cbor.rs", + "gitBlob": "7359f047d9f731fee208efb5f69072b612d69547" + }, + { + "path": "crates/edict-syntax/tests/byte_concat.rs", + "gitBlob": "72da10e53a2e84f4a23217122b54dd9eac76338f" + }, + { + "path": "crates/edict-syntax/tests/byte_length.rs", + "gitBlob": "50945944e8c2223abcc6b1081322432bc540c017" + }, + { + "path": "crates/edict-syntax/tests/byte_slice.rs", + "gitBlob": "99aae98ac1637a95532cdd833463210bbaa5a5be" + }, + { + "path": "crates/edict-syntax/tests/canonical_encoding.rs", + "gitBlob": "e4c5d59a88f88193f522eb555359919f7034a264" + }, + { + "path": "crates/edict-syntax/tests/common/mod.rs", + "gitBlob": "89560bfacb3dab031485c2dfa30d7eb325966574" + }, + { + "path": "crates/edict-syntax/tests/compiler_spine.rs", + "gitBlob": "2237318cfc0d4209e8a629e45320e42a4b72dbef" + }, + { + "path": "crates/edict-syntax/tests/contract_bundle.rs", + "gitBlob": "e6a2948335a0efc86d8bbb2e9e2c3d634e53965a" + }, + { + "path": "crates/edict-syntax/tests/core_golden_fixtures.rs", + "gitBlob": "0e0e42d19b52dc0557902dad9e1b85f37edf53f8" + }, + { + "path": "crates/edict-syntax/tests/core_graph_depth.rs", + "gitBlob": "1d95462ad2426d29b5974e6bb56ab8c125a92837" + }, + { + "path": "crates/edict-syntax/tests/external_action_requests.rs", + "gitBlob": "20aac8c03325ea0cdab8f4f54660cb980b4667c4" + }, + { + "path": "crates/edict-syntax/tests/highlighting.rs", + "gitBlob": "17e6b9ba08c96f0efb6efd440590f0fc917316e2" + }, + { + "path": "crates/edict-syntax/tests/lawpack.rs", + "gitBlob": "a675999ed96309358c8552a9d32781b5eede20dc" + }, + { + "path": "crates/edict-syntax/tests/lawpack_authoring.rs", + "gitBlob": "3a905cbd6d7d2625bc1d7826a6f6f1e991efbab0" + }, + { + "path": "crates/edict-syntax/tests/lowerability.rs", + "gitBlob": "5cfa58f5cbc51cccc7f119caddc1c3fcbc2e4806" + }, + { + "path": "crates/edict-syntax/tests/operation_prerequisites.rs", + "gitBlob": "753659e1a6e7751c455b8518226fa0902157a745" + }, + { + "path": "crates/edict-syntax/tests/parse_control_flow.rs", + "gitBlob": "5245561866d8902c1fbd5ab21f2e34807d568e17" + }, + { + "path": "crates/edict-syntax/tests/parse_greeting.rs", + "gitBlob": "f214d0c17745b8203d562780caa8f37b71c1e62c" + }, + { + "path": "crates/edict-syntax/tests/parse_hello.rs", + "gitBlob": "bf7b1b065277188f4be8754eb11ace94298394ba" + }, + { + "path": "crates/edict-syntax/tests/parse_keywords.rs", + "gitBlob": "78d8a64d785136d42a32655afda3df240c54f884" + }, + { + "path": "crates/edict-syntax/tests/parse_loops.rs", + "gitBlob": "d9ece2fce96fd6835d080055f06955d139c7e0ce" + }, + { + "path": "crates/edict-syntax/tests/parse_negative.rs", + "gitBlob": "17fdb983b8250470368a8f19d3a7bd9680052548" + }, + { + "path": "crates/edict-syntax/tests/parse_review_regressions.rs", + "gitBlob": "560215cfe044a528e190aa1ea7670e52b9365bdf" + }, + { + "path": "crates/edict-syntax/tests/parse_variants.rs", + "gitBlob": "8849f68f5ca1e2b06d0f66496e59b20d1c0fd022" + }, + { + "path": "crates/edict-syntax/tests/provider.rs", + "gitBlob": "7e8a596109b1e1fd3f22b3a0ef82f4755f127291" + }, + { + "path": "crates/edict-syntax/tests/provider_invocation.rs", + "gitBlob": "402647dd6701be65a9e693fd3f5688f26d84988e" + }, + { + "path": "crates/edict-syntax/tests/provider_lowering.rs", + "gitBlob": "411c306f3ab641de9dc2f7aed229767eba9dbd72" + }, + { + "path": "crates/edict-syntax/tests/result_projection.rs", + "gitBlob": "a74dd2a419266cb77d846d83da27f726095660f1" + }, + { + "path": "crates/edict-syntax/tests/semantic_validation.rs", + "gitBlob": "a127988d178c00ed12a0a25f70df6b7fd5e6d931" + }, + { + "path": "crates/edict-syntax/tests/target_ir.rs", + "gitBlob": "928e1cf921dead0b559bd115bb6eef3faaddd37e" + }, + { + "path": "crates/edict-syntax/tests/target_ir/ordered.rs", + "gitBlob": "a1b05db81a97a43ec5a2dc2d9bcc9578bc286f30" + }, + { + "path": "crates/edict-syntax/tests/target_profile.rs", + "gitBlob": "42f1c907f6c60dea1e8a9b4558b56ffd0b3a59ab" + }, + { + "path": "crates/edict-syntax/tests/target_profile_contract_resources.rs", + "gitBlob": "270c180a12dc10fb7e208cc4dc1e202da82c85fb" + }, + { + "path": "crates/edict-syntax/tests/target_unsigned_subtraction.rs", + "gitBlob": "e30d91f896afda48eb3cf11617bccf1f9d160e32" + }, + { + "path": "crates/edict-syntax/tests/unsigned_subtraction.rs", + "gitBlob": "fbd24482fdad4c8ceb4df41302b33595ada337ec" + }, + { + "path": "crates/edict/Cargo.toml", + "gitBlob": "525403f4f36db4040531e4dd747ec2398f9052cd" + }, + { + "path": "crates/edict/README.md", + "gitBlob": "a1ecf50bff3443d25a23fabfa6374d3f0a28ca82" + }, + { + "path": "crates/edict/src/lib.rs", + "gitBlob": "169d820759d6333f27a45ebb712bfcc4f0115107" + }, + { + "path": "crates/edict/tests/artifact_models.rs", + "gitBlob": "b923109c7195ce2c0071dc54179f0746b95329f0" + }, + { + "path": "crates/edict/tests/public_surface.rs", + "gitBlob": "a24c4bc9d9484f540da9b280790896701922968a" + }, + { + "path": "deny.toml", + "gitBlob": "e3f0f54060cead9a0d48b96ed86948d0909c4f78" + }, + { + "path": "docs/DESIGN_runtime-neutral-edict-sha-lock-assurance.md", + "gitBlob": "ea3badf78ebd19545147a93671fdb5f9af4a61ea" + }, + { + "path": "docs/GUIDE_edict-assurance-transparency.md", + "gitBlob": "100321157ec43055c45794f1c161b1e5281ba6b4" + }, + { + "path": "docs/README.md", + "gitBlob": "e21739b842be14d91a17f2508b1a1b629754af01" + }, + { + "path": "docs/REQUIREMENTS.md", + "gitBlob": "fd69cf5b3f57af39cda8bcf7f94ff21666a34636" + }, + { + "path": "docs/RETRO_phase1-parser.md", + "gitBlob": "5cfb7b85ca2f140fc58f9186c47e4635e94a1e6f" + }, + { + "path": "docs/SPEC_continuum-admission-v1.md", + "gitBlob": "0a74a0bfc642337d5d7a85133ce50a0a22caffbd" + }, + { + "path": "docs/SPEC_continuum-contract-bundle-v1.md", + "gitBlob": "65b36bb33a34beb1f246d1f97384631c83ca631e" + }, + { + "path": "docs/SPEC_edict-language-v1.md", + "gitBlob": "e137ddc947f8ca3e057ea618c0cdf103096130b3" + }, + { + "path": "docs/SPEC_edict-lawpack-abi-v1.md", + "gitBlob": "ea1d801f07ab3677f7a411a1f58a28feda589ec3" + }, + { + "path": "docs/SPEC_edict-target-profile-abi-v1.md", + "gitBlob": "91687bfe45565a21f5f93f6ce9eed84095268691" + }, + { + "path": "docs/TECHNICAL_EXPLANATION.md", + "gitBlob": "d88561c0552c0e75d1ecc2eef6f9afd003e99674" + }, + { + "path": "docs/abi/edict-authority-facts.cddl", + "gitBlob": "e9a6d8685706ae0d8dabda401655234161e94299" + }, + { + "path": "docs/abi/edict-common.cddl", + "gitBlob": "836c11b92425beb6d42b378c0defe6f02d144dd7" + }, + { + "path": "docs/abi/edict-core.cddl", + "gitBlob": "862f02939fcc3858b4a60cb75f9bf149eae8ffda" + }, + { + "path": "docs/abi/edict-lawpack-adapter.cddl", + "gitBlob": "8e887c2e196ba7502470ddb45dc7cfd10116ad6b" + }, + { + "path": "docs/abi/edict-lawpack.cddl", + "gitBlob": "96efd51d437ec785b108b51835e9e8bf87aeab51" + }, + { + "path": "docs/abi/edict-result-projection.cddl", + "gitBlob": "98b5c2e861e7e9b66b7481502287cb041f6e77e6" + }, + { + "path": "docs/abi/edict-target-ir.cddl", + "gitBlob": "98134f277ded1920a3a36e5e3946c51153f2e84d" + }, + { + "path": "docs/abi/edict-target-profile.cddl", + "gitBlob": "746ae03001310f3a83524e5332819dad1a4eea5a" + }, + { + "path": "docs/abi/edict-target-provider.wit", + "gitBlob": "0efa5903a52d38dc61e429619d86322c6c5f1fa0" + }, + { + "path": "docs/audit/2026-06-28_code-quality.md", + "gitBlob": "143cbf4f4491a76a6649e919c6edaba73f0bcf4b" + }, + { + "path": "docs/audit/2026-06-28_documentation-quality.md", + "gitBlob": "656b4fa8dea43306af1818f8622cafd72e82a370" + }, + { + "path": "docs/audit/2026-06-28_ship-readiness.md", + "gitBlob": "b9d34a8693564d0134f550092e7645e5d5137442" + }, + { + "path": "docs/design/authority-fact-governance.md", + "gitBlob": "8531061cf718c47ec791f5712b2f357d92adc9e4" + }, + { + "path": "docs/design/canonical-target-ir-v0.11.md", + "gitBlob": "a46acb84e3523b51e2348c776cfdb63a8b98107a" + }, + { + "path": "docs/design/contract-bundle-assembly-v0.11.md", + "gitBlob": "a364f8ade5445808f87cf0c63ab3484c03ad616a" + }, + { + "path": "docs/design/crate-scope-v0.11.md", + "gitBlob": "92fe92285d02465d84bbe82e29d051fdc461f3a6" + }, + { + "path": "docs/design/obstruction-strands-v0.md", + "gitBlob": "81f70fd688c12798cd23472a4e810191e61eabe2" + }, + { + "path": "docs/design/provider-artifact-pipeline-alpha.md", + "gitBlob": "60eefa7dc160aba986bcd1188b79610ff5e9f299" + }, + { + "path": "docs/design/schema-as-sot-codegen.md", + "gitBlob": "d818e0e3f1fafd1d3aba26cb37c739f3ebe69763" + }, + { + "path": "docs/design/v2-obligation-closure.md", + "gitBlob": "816d22d843a33c6f7e143da4cb45e80679609dc8" + }, + { + "path": "docs/releases/v0.1.0-alpha.1.md", + "gitBlob": "5dd96057ba7f109cf5e5acde16e29d18627f98d3" + }, + { + "path": "docs/releases/v0.10.0-alpha.1.md", + "gitBlob": "363c4e9ed6f5ea5758198c7124681b520098e583" + }, + { + "path": "docs/releases/v0.11.0-alpha.1.md", + "gitBlob": "4612dbb5a1aaf20710bdb199b658ded7ced4ebab" + }, + { + "path": "docs/releases/v0.2.0-alpha.1.md", + "gitBlob": "7302ef93ed5ff9b562d9cec92d49d85a6b789b27" + }, + { + "path": "docs/releases/v0.3.0-alpha.1.md", + "gitBlob": "bf023ba4ca2c38f0120c461781447d58fe239ae0" + }, + { + "path": "docs/releases/v0.4.0-alpha.1.md", + "gitBlob": "769500b59800c02c536b76b0eb850d06d6cd8f58" + }, + { + "path": "docs/releases/v0.5.0-alpha.1.md", + "gitBlob": "7c7354e89846ea816992aaf55d4ad04367d61a10" + }, + { + "path": "docs/releases/v0.6.0-alpha.1.md", + "gitBlob": "3f2a0edfc4bccd9f3c60a7443ef4f8cbcbac1971" + }, + { + "path": "docs/releases/v0.7.0-alpha.1.md", + "gitBlob": "57671d5ef5a6b9f16d1674e0a35ddeb86ff126a8" + }, + { + "path": "docs/releases/v0.8.0-alpha.1.md", + "gitBlob": "12f77bda185c54fbbd136bf0dc7292716ecdfa39" + }, + { + "path": "docs/releases/v0.9.0-alpha.1.md", + "gitBlob": "fa295fcf0967415bb052f238256919b32b3fe6ba" + }, + { + "path": "docs/schemas/edict.cli-check-result.v1.schema.json", + "gitBlob": "eef8cd11f07e06d68b7051efa60ae05f2cfd8a63" + }, + { + "path": "docs/schemas/edict.cli-diagnostic.v1.schema.json", + "gitBlob": "92a2151a76893c598a4191ed6cecd8a0e671613f" + }, + { + "path": "docs/schemas/edict.cli-event.v1.schema.json", + "gitBlob": "705d82a893c2ea91caa91ad6977a9be8646b47bb" + }, + { + "path": "docs/schemas/edict.cli-info.v1.schema.json", + "gitBlob": "2d9a0777b4190b56ff569625275d352d17363afa" + }, + { + "path": "docs/schemas/edict.compiler-input.v1.schema.json", + "gitBlob": "26da3ba0fe85fab4c826ad79f13968ce09c4f29b" + }, + { + "path": "docs/schemas/edict.compiler-settings.v1.schema.json", + "gitBlob": "a3e8ba469895b84ab81724da1075c73141a8dd0c" + }, + { + "path": "docs/schemas/edict.projection-core.v1.schema.json", + "gitBlob": "8c0afe3834256abd1e18efb5f31eae1c4bdf0374" + }, + { + "path": "docs/schemas/edict.projection-diagnostics.v1.schema.json", + "gitBlob": "28cfb0a67dff7b8f879122c74433158dc0a4e5df" + }, + { + "path": "docs/schemas/edict.projection-syntax.v1.schema.json", + "gitBlob": "a85f2e14f536863f5e7b107b1a9f3f10816e6234" + }, + { + "path": "docs/schemas/edict.projection-target-ir.v1.schema.json", + "gitBlob": "8bbb6495ad8800d775d1c08506e85351038d678a" + }, + { + "path": "docs/topics/README.md", + "gitBlob": "99b06d3124c71cb62dfe6faff7604c13063162a7" + }, + { + "path": "docs/topics/admission/README.md", + "gitBlob": "755dcba96c0a428eec18d58a529f3e26d57d118c" + }, + { + "path": "docs/topics/admission/test-plan.md", + "gitBlob": "68ee0a2d2502103285985bf862de9fadf2bac5a0" + }, + { + "path": "docs/topics/assurance/README.md", + "gitBlob": "cf382008f3d3094a5380a687abbf07538e07404d" + }, + { + "path": "docs/topics/assurance/test-plan.md", + "gitBlob": "0ea6c971924db763088577a0a52bbd30bfec814c" + }, + { + "path": "docs/topics/authority-facts/README.md", + "gitBlob": "c5589d2489d6e4a5729c0df2b2655ff281d8d88d" + }, + { + "path": "docs/topics/authority-facts/test-plan.md", + "gitBlob": "e3769edf8309347b23ffa2e8f0901e06feabd654" + }, + { + "path": "docs/topics/cli/README.md", + "gitBlob": "af38946c9ccae8da343877c3861b0f52b6076e1b" + }, + { + "path": "docs/topics/cli/test-plan.md", + "gitBlob": "d72d69ef1d340ffd7057a63dd7bc07e3dfb2c166" + }, + { + "path": "docs/topics/compiler-spine/README.md", + "gitBlob": "740a1433877b7bdcf233e5f3e178ff263471c0b2" + }, + { + "path": "docs/topics/compiler-spine/test-plan.md", + "gitBlob": "ccf687876fc30b04de11db9dc86ea41afae87641" + }, + { + "path": "docs/topics/contract-bundles/README.md", + "gitBlob": "2347499e8da9dd57bb1588faf67fe386c7a70c03" + }, + { + "path": "docs/topics/contract-bundles/test-plan.md", + "gitBlob": "3ae4c7362f90fa89081ab9ff2bf1c3db1a811874" + }, + { + "path": "docs/topics/core-ir/README.md", + "gitBlob": "d747a18d1f53de2b29473ada7a06b819c77cd162" + }, + { + "path": "docs/topics/core-ir/canonical-encoding.md", + "gitBlob": "34927c69fb1de10b685294a155fc46bb4ac21628" + }, + { + "path": "docs/topics/core-ir/test-plan.md", + "gitBlob": "0f80304a4dd6b160c78674b73605bdbbb7e11066" + }, + { + "path": "docs/topics/developer-tooling/README.md", + "gitBlob": "8648d3c1bdf4f6b774bc5fec71c71aa8c59b0ce8" + }, + { + "path": "docs/topics/developer-tooling/test-plan.md", + "gitBlob": "9240f717434dfbca08a6366e6d3ebafd4ef2c908" + }, + { + "path": "docs/topics/documentation/README.md", + "gitBlob": "34fa7f4db136c274a88b680f99619d657fda15d5" + }, + { + "path": "docs/topics/documentation/test-plan.md", + "gitBlob": "47964954fbf640211bc30b0dd361c44c9955c488" + }, + { + "path": "docs/topics/external-action-requests/README.md", + "gitBlob": "45bc73e469919d3eff6e7eddbe9baa0383c7d91b" + }, + { + "path": "docs/topics/external-action-requests/test-plan.md", + "gitBlob": "38e7e53827d223c031d414f4ecd63720eb78eae0" + }, + { + "path": "docs/topics/fixtures/README.md", + "gitBlob": "c8b3b196109fb6d4e37d8ffa17635166010075fb" + }, + { + "path": "docs/topics/fixtures/test-plan.md", + "gitBlob": "624357dbc544d365835390d3d3c2f11015b7b82f" + }, + { + "path": "docs/topics/lawpack-authoring/README.md", + "gitBlob": "74bb25cc22e1f88cf4ee952b42313d919339113a" + }, + { + "path": "docs/topics/lawpack-authoring/test-plan.md", + "gitBlob": "d7ad2eacde45dbce3eeb2b1a22c6482134b841ba" + }, + { + "path": "docs/topics/lawpacks/README.md", + "gitBlob": "dedaa524dc55663a44bf8101241ab4b6d4755531" + }, + { + "path": "docs/topics/lawpacks/test-plan.md", + "gitBlob": "f8aa2c7ce40dad2665134956dc95d951d311808f" + }, + { + "path": "docs/topics/lowerability/README.md", + "gitBlob": "fb9519af3539d846dc5bf2915bf5ca86816e46f8" + }, + { + "path": "docs/topics/lowerability/test-plan.md", + "gitBlob": "e0fbff0799ba805c9531097d6b8aeea657e2b815" + }, + { + "path": "docs/topics/obstruction-strands/README.md", + "gitBlob": "a2930645065390cecff8008bfd48b7f034bfcd18" + }, + { + "path": "docs/topics/obstruction-strands/test-plan.md", + "gitBlob": "20c54ffcaa19930a5bc772a49a5f01119054be2d" + }, + { + "path": "docs/topics/providers/README.md", + "gitBlob": "8b5a07fb9c708b753861a4e156b866115f4d687b" + }, + { + "path": "docs/topics/providers/architecture.md", + "gitBlob": "664b38347ccaf37f298d6ac9f19d3423c0277f9e" + }, + { + "path": "docs/topics/providers/test-plan.md", + "gitBlob": "95c55f9e132ca6859fd9df70470973e678ed8d92" + }, + { + "path": "docs/topics/public-rust-api/README.md", + "gitBlob": "c64a1081b7f693b02bd2ea63329f2610bae9d84c" + }, + { + "path": "docs/topics/public-rust-api/test-plan.md", + "gitBlob": "4c3b9e9662afd9edb790ba2b5c57ed5e93df595c" + }, + { + "path": "docs/topics/release-process/README.md", + "gitBlob": "a474ab8b6a4a58c5c73334c9e677be7c20d1837c" + }, + { + "path": "docs/topics/release-process/policy.toml", + "gitBlob": "e40b4f4ec721ae61210ec1bb022a847bcb49fb4a" + }, + { + "path": "docs/topics/release-process/runbook.md", + "gitBlob": "0b6bd8ef44cbfe8c7cdc347273fa74b7c96c4823" + }, + { + "path": "docs/topics/release-process/test-plan.md", + "gitBlob": "61ecded1d2318d7dd74070cd1c6155f353c947e9" + }, + { + "path": "docs/topics/result-projections/README.md", + "gitBlob": "d5c2f85a7681a15dcdc3e35f992a389c50d13461" + }, + { + "path": "docs/topics/result-projections/test-plan.md", + "gitBlob": "9e69d58c88d6a9b7389334a78b994a3449721faa" + }, + { + "path": "docs/topics/review-process/README.md", + "gitBlob": "25190d37dc30110f75ba5d3a41494575ffecc1c3" + }, + { + "path": "docs/topics/review-process/policy.toml", + "gitBlob": "a826ba58aad2e509220b65aa8f96c290b600e094" + }, + { + "path": "docs/topics/review-process/test-plan.md", + "gitBlob": "f1a50aeae47913e4513a8149c1679d9a94c5ef21" + }, + { + "path": "docs/topics/rust-standards/README.md", + "gitBlob": "2fe29258705d117f4d10604a83fd832a8476e303" + }, + { + "path": "docs/topics/rust-standards/test-plan.md", + "gitBlob": "0e0d6b306cd2b58db07a7a5da6a752925fe58764" + }, + { + "path": "docs/topics/semantic-validation/README.md", + "gitBlob": "51cd9761755e7b5879069bf3774eeb487982ca97" + }, + { + "path": "docs/topics/semantic-validation/test-plan.md", + "gitBlob": "b43969d8eb0a884c1663ab761662f9622617bb3b" + }, + { + "path": "docs/topics/syntax/README.md", + "gitBlob": "b2a372bf41b1976567c61f400bf000f33abc20cc" + }, + { + "path": "docs/topics/syntax/test-plan.md", + "gitBlob": "a69efaf12dfe12661fca049b8790b37fa3fb3665" + }, + { + "path": "docs/topics/target-ir/README.md", + "gitBlob": "93b73c18871d68b5ee5290ccbf52cf7f720a88c8" + }, + { + "path": "docs/topics/target-ir/test-plan.md", + "gitBlob": "124306f0b893100e389ff55fe3ffb66d30f7332a" + }, + { + "path": "docs/topics/target-profiles/README.md", + "gitBlob": "6a88f4d732f8069855b2ed2cb9a8769a117b2f60" + }, + { + "path": "docs/topics/target-profiles/test-plan.md", + "gitBlob": "90084c3f3a1296745469cd86e9b5f2bc928825be" + }, + { + "path": "docs/topics/tests/README.md", + "gitBlob": "4ad079b6a9718e2a8446a6c67ff45735015bef84" + }, + { + "path": "docs/topics/tests/test-plan.md", + "gitBlob": "46bc0572d02a41e86f71c6d46baf5be611a462a6" + }, + { + "path": "docs/topics/v2-design/README.md", + "gitBlob": "b33a07599e43e660aa4def7f119ddd02df6a16de" + }, + { + "path": "docs/topics/v2-design/test-plan.md", + "gitBlob": "f17f96d381f81b20842393f70ff55b9597858b84" + }, + { + "path": "editors/README.md", + "gitBlob": "7a933576262bc58bac197f9264fdbf649dd5e696" + }, + { + "path": "editors/vscode/.vscodeignore", + "gitBlob": "f15b3142e4b8af11d580789a0c82acee3499f571" + }, + { + "path": "editors/vscode/README.md", + "gitBlob": "8b29840ae9ec8f618b7364022329f694d0ed9746" + }, + { + "path": "editors/vscode/language-configuration.json", + "gitBlob": "b7f583841649c9c437785edbfcb70ee24e495c79" + }, + { + "path": "editors/vscode/package.json", + "gitBlob": "cd9e391e7c9afb6f9393fcead118e0e55aadc839" + }, + { + "path": "editors/vscode/syntaxes/edict.tmLanguage.json", + "gitBlob": "5847d8edfdb32d822f0f3950f41d00c947982185" + }, + { + "path": "fixtures/README.md", + "gitBlob": "470e3e0fc3aa00654930ecdef892ee9df8a42c8d" + }, + { + "path": "fixtures/authority-facts/canonical/README.md", + "gitBlob": "28692ce70add5d4f2d4ff5318309c3353924caf9" + }, + { + "path": "fixtures/authority-facts/canonical/example-effectful.authority-facts.cbor", + "gitBlob": "fe2e59a8e2602e02c52094010a130db2637c5227" + }, + { + "path": "fixtures/authority-facts/canonical/example-effectful.authority-facts.json", + "gitBlob": "009faa5d2dc1dcf55cf284dcfd14c0b6405f3e0d" + }, + { + "path": "fixtures/authority-facts/canonical/example-effectful.authority-facts.sha256", + "gitBlob": "a3d68f0a3b3a586e85b6a84cbd884866e662951f" + }, + { + "path": "fixtures/bundle/assembly/bounded-hello.bundle-digests.txt", + "gitBlob": "da5402db7bd41dd88c6152b7799723561130c91e" + }, + { + "path": "fixtures/cli/01-source-ok/expected.stdout.jsonl", + "gitBlob": "e08ccf8fdedd3a73beef5d06c443a1bc60274ce1" + }, + { + "path": "fixtures/cli/01-source-ok/request.jsonl", + "gitBlob": "002fea597e6b93c8468d6972b73cc1344600fa87" + }, + { + "path": "fixtures/cli/02-source-parse-rejection/exit", + "gitBlob": "d00491fd7e5bb6fa28c517a0bb32b8b506539d4d" + }, + { + "path": "fixtures/cli/02-source-parse-rejection/expected.stderr.jsonl", + "gitBlob": "1077b73c9a7c02eae99f737bea7b6ff8c64d04da" + }, + { + "path": "fixtures/cli/02-source-parse-rejection/request.jsonl", + "gitBlob": "dce01f0466bd9384fc6f5cbe2845b6e0bd9a9cfd" + }, + { + "path": "fixtures/cli/03-source-semantic-rejection/exit", + "gitBlob": "d00491fd7e5bb6fa28c517a0bb32b8b506539d4d" + }, + { + "path": "fixtures/cli/03-source-semantic-rejection/expected.stderr.jsonl", + "gitBlob": "5ec447700da52d0b4ce1f75825eb9bffaed4884b" + }, + { + "path": "fixtures/cli/03-source-semantic-rejection/request.jsonl", + "gitBlob": "ddfd529e5448760387961febbd4ce013e49de435" + }, + { + "path": "fixtures/cli/04-cli-missing-settings/exit", + "gitBlob": "0cfbf08886fca9a91cb753ec8734c84fcbe52c9f" + }, + { + "path": "fixtures/cli/04-cli-missing-settings/expected.stderr.jsonl", + "gitBlob": "5060bd2fd773ba9ea3ea6db8c80b86a846bfadbd" + }, + { + "path": "fixtures/cli/04-cli-missing-settings/request.jsonl", + "gitBlob": "8eb12e58d427bd64ccfe339190e05bdccf4c8634" + }, + { + "path": "fixtures/cli/05-path-input-ok/expected.stdout.jsonl", + "gitBlob": "a05fc582efc41b6414e785167b5deeb7532088ef" + }, + { + "path": "fixtures/cli/05-path-input-ok/inputs/hello.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/05-path-input-ok/request.jsonl", + "gitBlob": "18facaab79dc198134c535df389cba79efe7dce7" + }, + { + "path": "fixtures/cli/06-directory-expansion-ok/expected.stdout.jsonl", + "gitBlob": "ef59591526e2084ddf5057249bbc96ab660cf256" + }, + { + "path": "fixtures/cli/06-directory-expansion-ok/inputs/a.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/06-directory-expansion-ok/inputs/ignore.txt", + "gitBlob": "ed34ae8da336ff94a67b6125fbd6be730c976d91" + }, + { + "path": "fixtures/cli/06-directory-expansion-ok/inputs/nested/b.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/06-directory-expansion-ok/request.jsonl", + "gitBlob": "bd9aad14fe79caccacaa6d00ffd32b5e13b3551f" + }, + { + "path": "fixtures/cli/07-path-list-ok/expected.stdout.jsonl", + "gitBlob": "643ecb3e659c10cb98255ec1aced772778e76eb0" + }, + { + "path": "fixtures/cli/07-path-list-ok/inputs/first.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/07-path-list-ok/inputs/second.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/07-path-list-ok/request.jsonl", + "gitBlob": "f11265b02c5b7559ced4d975471a78b5bef3ee27" + }, + { + "path": "fixtures/cli/08-glob-expansion-ok/expected.stdout.jsonl", + "gitBlob": "90164a7fce6c51abdadef8f0586d2c56113d9712" + }, + { + "path": "fixtures/cli/08-glob-expansion-ok/inputs/x.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/08-glob-expansion-ok/inputs/y.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/08-glob-expansion-ok/request.jsonl", + "gitBlob": "9335acf3a008ab8fb9942b3e22d73c456ed3827e" + }, + { + "path": "fixtures/cli/09-shape-source-ok/expected.stdout.jsonl", + "gitBlob": "ac6f9259502ebfe484e1c07a5f53865888dd8207" + }, + { + "path": "fixtures/cli/09-shape-source-ok/request.jsonl", + "gitBlob": "64c75d9a7b40985bacf0e59a943a16e20419c602" + }, + { + "path": "fixtures/cli/10-input-extra-field/exit", + "gitBlob": "0cfbf08886fca9a91cb753ec8734c84fcbe52c9f" + }, + { + "path": "fixtures/cli/10-input-extra-field/expected.stderr.jsonl", + "gitBlob": "2f5a8fba093b71d15a5b37504ad0352191c8299c" + }, + { + "path": "fixtures/cli/10-input-extra-field/request.jsonl", + "gitBlob": "6052212c652d41f03144a7d3d4018b1cdd18cd09" + }, + { + "path": "fixtures/cli/11-input-hybrid-kind/exit", + "gitBlob": "0cfbf08886fca9a91cb753ec8734c84fcbe52c9f" + }, + { + "path": "fixtures/cli/11-input-hybrid-kind/expected.stderr.jsonl", + "gitBlob": "7b6d2ac0c8afbf5e3991498846c2fc4847ac9453" + }, + { + "path": "fixtures/cli/11-input-hybrid-kind/request.jsonl", + "gitBlob": "b893b640aa6631c77f2a889a807afa31632ac2db" + }, + { + "path": "fixtures/cli/12-input-too-large/env.json", + "gitBlob": "ab0c7f13fc6b22d61fc73da2f1787ff3aa298ecb" + }, + { + "path": "fixtures/cli/12-input-too-large/exit", + "gitBlob": "0cfbf08886fca9a91cb753ec8734c84fcbe52c9f" + }, + { + "path": "fixtures/cli/12-input-too-large/expected.stderr.jsonl", + "gitBlob": "ebda022d79c978d4ff511579512be2c642e3e902" + }, + { + "path": "fixtures/cli/12-input-too-large/request.jsonl", + "gitBlob": "1e2fbb102503356bbcc627f49a5b58590859f170" + }, + { + "path": "fixtures/cli/13-input-root-outside/allowed/.gitkeep", + "gitBlob": "8b137891791fe96927ad78e64b0aad7bded08bdc" + }, + { + "path": "fixtures/cli/13-input-root-outside/exit", + "gitBlob": "0cfbf08886fca9a91cb753ec8734c84fcbe52c9f" + }, + { + "path": "fixtures/cli/13-input-root-outside/expected.stderr.jsonl", + "gitBlob": "9c5b8567a755c9ea2ee6e0168bf96f429185f675" + }, + { + "path": "fixtures/cli/13-input-root-outside/outside/outside.edict", + "gitBlob": "44abebc15811c38cc266007484dd74ae10a26a4d" + }, + { + "path": "fixtures/cli/13-input-root-outside/request.jsonl", + "gitBlob": "116dbbb4b1a80938bc042e41747872cb6da161cd" + }, + { + "path": "fixtures/cli/README.md", + "gitBlob": "9388df4182fedec41c353e85cf9210e88906fa3d" + }, + { + "path": "fixtures/core/canonical/README.md", + "gitBlob": "d9a0ca79557c3623c0b843d9eff4808f94fd7b18" + }, + { + "path": "fixtures/core/canonical/bounded-hello.core.cbor", + "gitBlob": "a0ec54aa1a5e20624192091526445cfd803e6f0c" + }, + { + "path": "fixtures/core/canonical/bounded-hello.core.sha256", + "gitBlob": "86ba062c26a3ad3fd733ccd8c80d7faa7ed62d94" + }, + { + "path": "fixtures/core/canonical/statement-branch.core.hex", + "gitBlob": "c22760cace0e4d146a2fdc8d7c7b50c38497622a" + }, + { + "path": "fixtures/core/canonical/statement-branch.core.sha256", + "gitBlob": "0b62657b192232390479319f0a1c8f601020a58f" + }, + { + "path": "fixtures/core/canonical/workspace-snapshot.core.cbor", + "gitBlob": "58e4f724610861f5b61537bf386a87062e8a57a7" + }, + { + "path": "fixtures/core/canonical/workspace-snapshot.core.sha256", + "gitBlob": "4bcb3e0813cd3f4a7afc7cf311d846f1dfdd0a9d" + }, + { + "path": "fixtures/core/schema/accepted/core-fn-body-minimal.fields", + "gitBlob": "bef3ca412ab0ea97465b8658499ae5e05e1ec760" + }, + { + "path": "fixtures/core/schema/accepted/core-intent-minimal.fields", + "gitBlob": "268b28ce942fed4f139aafe5c7cd50c15a0ee640" + }, + { + "path": "fixtures/core/schema/accepted/core-module-minimal.fields", + "gitBlob": "249ff76349f936c9a5ff6cb65d81de8e80d53de8" + }, + { + "path": "fixtures/core/schema/rejected/core-fn-body-effect-node-field.fields", + "gitBlob": "9af8fa3540b25ec810936bc4dc82e26f6dd0dd48" + }, + { + "path": "fixtures/core/schema/rejected/core-intent-unknown-verified-mode.fields", + "gitBlob": "667ae032ee117f32c1bcbafd21393e406621f517" + }, + { + "path": "fixtures/core/schema/rejected/core-module-missing-intents.fields", + "gitBlob": "17f37c7ac4c199de4eace7f31e6a59b9a6d3a0f6" + }, + { + "path": "fixtures/core/schema/rejected/local-ref-missing-alpha-name.fields", + "gitBlob": "456a89528ffe74d892be40c9c9be4a078ff5c18a" + }, + { + "path": "fixtures/lang/bounds/bounded-hello.edict", + "gitBlob": "e3443a1d3b1c8f0e137ac698b621dd2f3afb673b" + }, + { + "path": "fixtures/lang/effects/conditional-blob.edict", + "gitBlob": "1e4f2ca6112f26d57ee4d20058666ec7cd693b75" + }, + { + "path": "fixtures/lang/effects/read-greeting.edict", + "gitBlob": "5e3838d1547be171e0a0384a7a200f52a2b9d139" + }, + { + "path": "fixtures/lang/external-actions/workspace-snapshot.edict", + "gitBlob": "e54b0fbccad2fd680505f3ee46ca28d39d7e776e" + }, + { + "path": "fixtures/lang/operations/explicit-basis-u64.edict", + "gitBlob": "444d8ca77b9827746df81885f0620dce2d1a3b73" + }, + { + "path": "fixtures/lang/tooling/highlight-smoke.edict", + "gitBlob": "8c2d91084be22e5e1594a42159992aca95c73612" + }, + { + "path": "fixtures/lang/types/color-match.edict", + "gitBlob": "dd98d6de677904f36d7601165a0094d92928e536" + }, + { + "path": "fixtures/lawpack/causal-cell/README.md", + "gitBlob": "52e8cc1e2af8aea86c1090a1b20b5f5ab3e07c06" + }, + { + "path": "fixtures/lawpack/causal-cell/adapter.cbor", + "gitBlob": "3b0c8b1b3a8591a322b6e785d9f963899319310c" + }, + { + "path": "fixtures/lawpack/causal-cell/adapter.sha256", + "gitBlob": "f8231bc941e1fbe02279865a82e183cbeeb0988a" + }, + { + "path": "fixtures/lawpack/causal-cell/echo-operation-configuration.cbor", + "gitBlob": "24527d30d0146b567fda157561ac6a2587cae919" + }, + { + "path": "fixtures/lawpack/causal-cell/echo-operation-configuration.sha256", + "gitBlob": "d293c8a14b1955a3e171703400c4df620c7871a1" + }, + { + "path": "fixtures/lawpack/causal-cell/exports.cbor", + "gitBlob": "384f4839adfe8e5b0f1aa848bfe2aeb1c3f640b6" + }, + { + "path": "fixtures/lawpack/causal-cell/exports.sha256", + "gitBlob": "4f836f6b03497338a1f8eacc55480cbe1a3b49e9" + }, + { + "path": "fixtures/lawpack/causal-cell/manifest.cbor", + "gitBlob": "b9311a236d7898861a0b90b1f30b852b35cef623" + }, + { + "path": "fixtures/lawpack/causal-cell/manifest.sha256", + "gitBlob": "685fd6a6c72fc3100d595d009b6198a81c731a40" + }, + { + "path": "fixtures/lawpack/hello-echo/README.md", + "gitBlob": "79f6612f1f5608a8f7dc4835e5470878cd27f96e" + }, + { + "path": "fixtures/lawpack/hello-echo/adapter.cbor", + "gitBlob": "24e2f546e2b97747b53462a72faaa1d5d85d62f1" + }, + { + "path": "fixtures/lawpack/hello-echo/adapter.sha256", + "gitBlob": "91df491028061e026ecaaeb4e1598e2ac369af44" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.core.cbor", + "gitBlob": "246b6135855c415def0bd89b275f0457752ee563" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.core.sha256", + "gitBlob": "9adc71605e0a275349161809614bd17de97d129c" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.edict", + "gitBlob": "825d50565230bd71d62bfbeb59d0399a89864b4c" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.result-projection.cbor", + "gitBlob": "981cba6e1c7ab6bdae6829116749c4796167e4e6" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.result-projection.sha256", + "gitBlob": "d55e4083771e1d9791f59cf87fd5cc5f1ea3b9f4" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.target-ir.cbor", + "gitBlob": "c8a934cefec17dbab0a43d9be9cebd2533268798" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.target-ir.sha256", + "gitBlob": "20186cbe9482e8a7df7c44fabec13ffd4efbcf36" + }, + { + "path": "fixtures/lawpack/hello-echo/echo-operation-configuration.cbor", + "gitBlob": "84838ab0d8627237232fa5a9b9fa39087bcc5f8a" + }, + { + "path": "fixtures/lawpack/hello-echo/echo-operation-configuration.sha256", + "gitBlob": "0898688f14067560dd22abd04b97f020071fd3e8" + }, + { + "path": "fixtures/lawpack/hello-echo/exports.cbor", + "gitBlob": "0e1220ceed9442a7b35870eeb02fcb65454d8c5c" + }, + { + "path": "fixtures/lawpack/hello-echo/exports.sha256", + "gitBlob": "e1f3e9223de9ce935bc7f60dda3cfa7d12d54fdc" + }, + { + "path": "fixtures/lawpack/hello-echo/manifest.cbor", + "gitBlob": "d715900f03ec454a0ad96e6710f52a46120d0b9d" + }, + { + "path": "fixtures/lawpack/hello-echo/manifest.sha256", + "gitBlob": "20171199b401cecace2dd74e18f3cc1d5c7ed3de" + }, + { + "path": "fixtures/lawpack/workspace-patch/README.md", + "gitBlob": "67cd35f2e0660aa7455de1c197ad821d5438679b" + }, + { + "path": "fixtures/lawpack/workspace-patch/adapter.cbor", + "gitBlob": "2d6f09a7e2fab381b97a05cfad1e692902e878c3" + }, + { + "path": "fixtures/lawpack/workspace-patch/adapter.sha256", + "gitBlob": "d44eb9675e126716e8a5ef3c53fd39ade49d76fb" + }, + { + "path": "fixtures/lawpack/workspace-patch/apply-validated-patch.core.cbor", + "gitBlob": "6a88c127e426288a3e51d4749d5c31d5b0cb60cb" + }, + { + "path": "fixtures/lawpack/workspace-patch/apply-validated-patch.core.sha256", + "gitBlob": "0204b6f1d8b346a67800a7738ee39df49e78571f" + }, + { + "path": "fixtures/lawpack/workspace-patch/apply-validated-patch.edict", + "gitBlob": "6e11a3d022a53a8fb2c20a77e35e29840f5fe086" + }, + { + "path": "fixtures/lawpack/workspace-patch/apply-validated-patch.target-ir.cbor", + "gitBlob": "a6124a995a3cdbb5d39cd0a6e046b329048703aa" + }, + { + "path": "fixtures/lawpack/workspace-patch/apply-validated-patch.target-ir.sha256", + "gitBlob": "f7ac419ce15b32d491e09bddbe7c75f8227f51d8" + }, + { + "path": "fixtures/lawpack/workspace-patch/exports.cbor", + "gitBlob": "3a6fd19dc8059b9fe1bde74fb1da61398b0e80cc" + }, + { + "path": "fixtures/lawpack/workspace-patch/exports.sha256", + "gitBlob": "b301dd883a31fffe324e9306ec90ae2b1ec44520" + }, + { + "path": "fixtures/lawpack/workspace-patch/input-schema.cbor", + "gitBlob": "3045d9b696864fefe111c3eb641b3b68532752d2" + }, + { + "path": "fixtures/lawpack/workspace-patch/input-schema.sha256", + "gitBlob": "9f1284b4f0a2c7f6dbe1915a6113cd13a9700cb8" + }, + { + "path": "fixtures/lawpack/workspace-patch/manifest.cbor", + "gitBlob": "77e56c7525f0e64ab191f0adfeac12b540c87848" + }, + { + "path": "fixtures/lawpack/workspace-patch/manifest.sha256", + "gitBlob": "8316978e68565f29a30a6978d33d907710185857" + }, + { + "path": "fixtures/lawpack/workspace-patch/reconciliation-law.cbor", + "gitBlob": "0736b75f81913fca7ac95c56ec45f66b95aea4cf" + }, + { + "path": "fixtures/lawpack/workspace-patch/reconciliation-law.sha256", + "gitBlob": "de31fc9fda59fa3c29397e5fc48db224e8e1fee7" + }, + { + "path": "fixtures/lawpack/workspace-patch/request-profile-configuration.cbor", + "gitBlob": "5e2870b2f562bafaa73a91a3fc192f5ed39257c7" + }, + { + "path": "fixtures/lawpack/workspace-patch/request-profile-configuration.sha256", + "gitBlob": "4345ae2e39ce3f4d9cfa6b0dddf4ce56d56c035c" + }, + { + "path": "fixtures/lawpack/workspace-patch/settlement-schema.cbor", + "gitBlob": "0a93ac19c51b341602eeba524769147e962d5d60" + }, + { + "path": "fixtures/lawpack/workspace-patch/settlement-schema.sha256", + "gitBlob": "f1bb3fb0313dd6815b4184345194949ec40fe9e1" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/README.md", + "gitBlob": "996bd1d29b28769fff477084d9118d0833ca2970" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/adapter.cbor", + "gitBlob": "9be4ea568b602b56269af505deb809989a3fa8b5" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/adapter.sha256", + "gitBlob": "1e287be0a322e5444dea15fa14bcfc7cf12975c4" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/exports.cbor", + "gitBlob": "33fe04db74775c191d4b7400e1fb2b6393c5a010" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/exports.sha256", + "gitBlob": "e057cac7fc360e6599b7ddab88508aaf0f2f55f8" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/input-schema.cbor", + "gitBlob": "49c849169946e44c8b5f300279dd085bd6b63aeb" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/input-schema.sha256", + "gitBlob": "9dd7bb6e48192e90d19fc346d1705f736b1d85d7" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/manifest.cbor", + "gitBlob": "d4e58e3d4646ca967170a6882f2a617cb8d81390" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/manifest.sha256", + "gitBlob": "0edb311125a89a5816ee3fa0c9b700c9b3bcff3d" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/observe-workspace.core.cbor", + "gitBlob": "a4b249dfb197f1a6b4adc06855f16e4305a1c798" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/observe-workspace.core.sha256", + "gitBlob": "ea6b914d14907d9fd915058e579aff33c954da2c" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/observe-workspace.edict", + "gitBlob": "c2c10f1ef1009796d67061b9722c4db9bb4e031b" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/observe-workspace.target-ir.cbor", + "gitBlob": "bdab1b0c55a34360c7e9ab304af91fe2b1e4afce" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/observe-workspace.target-ir.sha256", + "gitBlob": "7342aaa96221d6c8efa75ead2af5563791ccfeff" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/reconciliation-law.cbor", + "gitBlob": "df55572b350002a3df98ccb3e72dd60c86b9aead" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/reconciliation-law.sha256", + "gitBlob": "957cd04c78c130b07d2cad2fd7e07ae69978be57" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/request-profile-configuration.cbor", + "gitBlob": "708f18918ee1703491a910df82e129e711a4cc46" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/request-profile-configuration.sha256", + "gitBlob": "d9953d9dcaa41c98387226d1980f40b24d2bc3cb" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/settlement-schema.cbor", + "gitBlob": "f01ad68531267666e6bf93bf30a37d5b311c1676" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/settlement-schema.sha256", + "gitBlob": "06fcc0ee2b976a09b3017bd93132a3c51eb1317e" + }, + { + "path": "fixtures/obstruction-strands/v0/stale-basis/README.md", + "gitBlob": "25efbfa04e2e6104c5434f329128333e895e2b0a" + }, + { + "path": "fixtures/obstruction-strands/v0/stale-basis/source.edict", + "gitBlob": "e487b46e81220c50e6f928922dada29f3a21ca6a" + }, + { + "path": "fixtures/provider-contracts/v1/README.md", + "gitBlob": "447692907f9268ce3b6b78c43b7cbbb0417aeadf" + }, + { + "path": "fixtures/provider-contracts/v1/edict-provider-contracts.cddl", + "gitBlob": "07048aeeadb5062eabb89e995713cbc0893b7d7e" + }, + { + "path": "fixtures/provider-contracts/v1/manifest.json", + "gitBlob": "d2c8de5d61049e9f4182c630bf82b138f0f96792" + }, + { + "path": "fixtures/providers/README.md", + "gitBlob": "c26ee60a4930e3e0784c76cb855e48234a5c6b58" + }, + { + "path": "fixtures/providers/components/guests/Cargo.lock", + "gitBlob": "d7858ce7bc67deabb5ff352a24c85a7caa0ef4b0" + }, + { + "path": "fixtures/providers/components/guests/Cargo.toml", + "gitBlob": "450a24aed25dc73661b0ae8adfe2630dfecc9b07" + }, + { + "path": "fixtures/providers/components/guests/lowerer/Cargo.toml", + "gitBlob": "568aa137fa215b6b973fe31e12322530b393b9dc" + }, + { + "path": "fixtures/providers/components/guests/lowerer/src/lib.rs", + "gitBlob": "b39a8a0b18fe9ed7cb90277f793056434afa1318" + }, + { + "path": "fixtures/providers/components/guests/verifier/Cargo.toml", + "gitBlob": "f814f2c8c248bbf03389f5a0936f80cd4dada5b6" + }, + { + "path": "fixtures/providers/components/guests/verifier/src/lib.rs", + "gitBlob": "3f07ffdfd808ff95b206a2c08c2d481ccaf0e165" + }, + { + "path": "fixtures/providers/components/instantiation-failure-lowerer.component.wasm", + "gitBlob": "bd2d7c0d31798d7676aedab0bd0d289fc2053bef" + }, + { + "path": "fixtures/providers/components/instantiation-failure-lowerer.wat", + "gitBlob": "f6f5a70edb80d3a7fa1dee13b34ab5b8b44274d7" + }, + { + "path": "fixtures/providers/components/instantiation-fuel-lowerer.component.wasm", + "gitBlob": "0804d26d3ddb428682ca87ecad03cf0e05ef64af" + }, + { + "path": "fixtures/providers/components/instantiation-fuel-lowerer.wat", + "gitBlob": "80e972463ef593602d27c7d7cec78d87d22ff727" + }, + { + "path": "fixtures/providers/components/inventory.json", + "gitBlob": "45cf2e8e937a17a8ee05dfa8d68e94dcc155e129" + }, + { + "path": "fixtures/providers/components/lowerer.component.wasm", + "gitBlob": "6c1cf123a44284d15b7b1e90f1905ae94e65c158" + }, + { + "path": "fixtures/providers/components/malformed-lowerer.component.wasm", + "gitBlob": "be873af81100dc76ed1f3f1f818a41da45a38e4c" + }, + { + "path": "fixtures/providers/components/malformed-lowerer.wat", + "gitBlob": "1e7bfffe0a0baf230d9fb5766083f82198f4029c" + }, + { + "path": "fixtures/providers/components/verifier.component.wasm", + "gitBlob": "671adbe7931d0a9a5e0c78d459c244d37a135a69" + }, + { + "path": "fixtures/providers/echo-generated/provider-manifest.json", + "gitBlob": "22c8560e7ddecacd5da388e52d3935d7fc1474b9" + }, + { + "path": "fixtures/providers/echo-target-profile/README.md", + "gitBlob": "350c33dcda2d66d2d50e589c58db7c6d7b14a80b" + }, + { + "path": "fixtures/providers/echo-target-profile/generated/primary/target-profile.echo-dpo.cbor", + "gitBlob": "9fa43529b1021dfd8e3a33256c832d4eee6f4a47" + }, + { + "path": "fixtures/providers/wit/legacy-target-profile.wit", + "gitBlob": "ae7d6af764012b16bf06bfa260ccba98a7f04868" + }, + { + "path": "fixtures/target-ir/canonical/echo-effectful.target-ir.cbor", + "gitBlob": "727a80eb37319dbdbea40d7d9b4e37f0d93d8d84" + }, + { + "path": "fixtures/target-ir/canonical/echo-effectful.target-ir.sha256", + "gitBlob": "6d050bb46ac8981ea8e47c7a52371027b941fd89" + }, + { + "path": "fixtures/target-ir/canonical/gitwarp-append.target-ir.cbor", + "gitBlob": "89b46b138a7b90252a4397c0e8b622bceff10a33" + }, + { + "path": "fixtures/target-ir/canonical/gitwarp-append.target-ir.sha256", + "gitBlob": "a59a4ab9d46095d5be1797ed9e60fe841f821bce" + }, + { + "path": "fixtures/target-ir/canonical/workspace-snapshot.target-ir.cbor", + "gitBlob": "1854eeb549b3719fa2b0114867dbece6db1819d4" + }, + { + "path": "fixtures/target-ir/canonical/workspace-snapshot.target-ir.sha256", + "gitBlob": "4d0e501323d415ef9e64c0a3d25bdd57dabfc998" + }, + { + "path": "fixtures/target-profile/contract-resources/README.md", + "gitBlob": "32dcab1dd9376a4eed2c73bb1b1a29255fe3ea05" + }, + { + "path": "fixtures/target-profile/contract-resources/canonical-cbor.cbor", + "gitBlob": "4a95ba3bd9dff190ca5ec9c83262bfa6254a91d3" + }, + { + "path": "fixtures/target-profile/contract-resources/canonical-cbor.sha256", + "gitBlob": "2168df5d4bf77ed2347139dd7c45fd808df8ec7e" + }, + { + "path": "fixtures/target-profile/contract-resources/determinism.cbor", + "gitBlob": "09cd11c36048939961408550763c04fad8241557" + }, + { + "path": "fixtures/target-profile/contract-resources/determinism.sha256", + "gitBlob": "5376d6bfe23bea659463a7e3c56ad1e8afd4095f" + }, + { + "path": "fixtures/target-profile/contract-resources/diagnostics.cbor", + "gitBlob": "c47fa05f463e0da745fbcdf8daf94d70e134eb8d" + }, + { + "path": "fixtures/target-profile/contract-resources/diagnostics.sha256", + "gitBlob": "69613ec4014f27b23245e23fbf7c9447566516b2" + }, + { + "path": "fixtures/target-profile/contract-resources/fuel.cbor", + "gitBlob": "b5a3484ec5b2bf7343c2fcedc67bcb2b63a37104" + }, + { + "path": "fixtures/target-profile/contract-resources/fuel.sha256", + "gitBlob": "6ec1c830358ee35bb12bd04cc1a6edf47fb20997" + }, + { + "path": "fixtures/target-profile/contract-resources/wasm-component.cbor", + "gitBlob": "6344996c283e0d1c332ea3ce597ad4593882a3c5" + }, + { + "path": "fixtures/target-profile/contract-resources/wasm-component.sha256", + "gitBlob": "24bf3e552e4216d8258d2b85c8878af46a176c52" + }, + { + "path": "grammars/textmate/README.md", + "gitBlob": "fc116a669725d4e965d658234d32d779955d5dc8" + }, + { + "path": "grammars/textmate/edict.tmLanguage.json", + "gitBlob": "5847d8edfdb32d822f0f3950f41d00c947982185" + }, + { + "path": "grammars/tree-sitter-edict/README.md", + "gitBlob": "e2992a839d6719f1461db78c4e3f33d2e5ab0c09" + }, + { + "path": "grammars/tree-sitter-edict/grammar.js", + "gitBlob": "a82f5b9d9b78525f17a59272543fdcddd7a0da40" + }, + { + "path": "grammars/tree-sitter-edict/queries/highlights.scm", + "gitBlob": "0f46530b36996d13449901aed4e376a126577cba" + }, + { + "path": "grammars/tree-sitter-edict/src/grammar.json", + "gitBlob": "55df730a06b83c9f622e3ec17845fc9897c7d8c0" + }, + { + "path": "grammars/tree-sitter-edict/src/node-types.json", + "gitBlob": "520f6c4f7b30cd6892dd60faf6d76f3fbaa6a5c7" + }, + { + "path": "grammars/tree-sitter-edict/src/parser.c", + "gitBlob": "81cc4713cb5e05f9aa8dac16da202a864faefee6" + }, + { + "path": "grammars/tree-sitter-edict/src/tree_sitter/alloc.h", + "gitBlob": "1abdd1201578605b8d05a3001f01ebc0d58826d9" + }, + { + "path": "grammars/tree-sitter-edict/src/tree_sitter/array.h", + "gitBlob": "56fc8cd470996ded64a5452be25e26dbd2aa682a" + }, + { + "path": "grammars/tree-sitter-edict/src/tree_sitter/parser.h", + "gitBlob": "858107deb9e4a1ffcd2ed5e6ffe98a5fcab3e1f6" + }, + { + "path": "grammars/tree-sitter-edict/test/corpus/current-subset.txt", + "gitBlob": "732c5eda8e1bf95eef799476296a6ee061eb58eb" + }, + { + "path": "grammars/tree-sitter-edict/tree-sitter.json", + "gitBlob": "97d3fdd498a3bef509c8615d98b9560b527c03cb" + }, + { + "path": "scripts/consumer-witnesses/README.md", + "gitBlob": "2b7d2b9d81f9598fd8df232b3a76bef106ff7ef2" + }, + { + "path": "scripts/consumer-witnesses/jedit-state-read.Dockerfile", + "gitBlob": "7462059be67686090d0097b24b9d14bfbbd4c6f7" + }, + { + "path": "scripts/consumer-witnesses/jedit-state-read.Dockerfile.dockerignore", + "gitBlob": "ee41b3ca0a68fd5eb20e1b777b4b368fd8b44e63" + }, + { + "path": "scripts/consumer-witnesses/jedit-state-read.py", + "gitBlob": "26db295d4eabfc4e57813fc9bf17314c23350777" + }, + { + "path": "scripts/consumer-witnesses/run-jedit-state-read.sh", + "gitBlob": "18cd72bbbdfb17a5ea30a7821d47035071556d10" + }, + { + "path": "spec.lock.json", + "gitBlob": "ef8b02386e0f269a99c1d2121764f70b76e67620" + }, + { + "path": "xtask/Cargo.toml", + "gitBlob": "795c70a5172363bfcd55174b1bc76c9c131d21a3" + }, + { + "path": "xtask/src/contract_check.rs", + "gitBlob": "9e80393accf79936033972fde0f2aa2cf40f1be3" + }, + { + "path": "xtask/src/goldens.rs", + "gitBlob": "713f1f8266d9f6993684ae86db105fcd7d69ee2a" + }, + { + "path": "xtask/src/lawpack_goldens.rs", + "gitBlob": "c499e8581c73313794b83c261937144b3917850a" + }, + { + "path": "xtask/src/main.rs", + "gitBlob": "6c2c06038bb5ecdde60620071b200d8191dc116c" + }, + { + "path": "xtask/src/provider_components.rs", + "gitBlob": "ee9d6a1028f9fbfad879faab4b15a94b996ef6d4" + }, + { + "path": "xtask/src/provider_contract_pack.rs", + "gitBlob": "cf60d89892b7a57cc33300f273d2522a6e8f43f9" + }, + { + "path": "xtask/src/provider_dependencies.rs", + "gitBlob": "c4b0539ed593d2a2777d294090d2a891b13ae628" + }, + { + "path": "xtask/src/release_dates.rs", + "gitBlob": "1c6d7acb872f6d820eab3a30ca580e9c5cfba2ee" + }, + { + "path": "xtask/src/release_prep.rs", + "gitBlob": "01ed64ccbb28c9d1e908b7b800ff58076e5e1a2b" + }, + { + "path": "xtask/src/tests.rs", + "gitBlob": "9a3f6543c2dbae31d53e93d56f781e5d54f74f41" + }, + { + "path": "xtask/src/util.rs", + "gitBlob": "c1bf39e93460c43ffdcfd9a76e0424750cbb9dfd" + } + ] +} diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/first-control/application/executable-operation-package.cbor b/edict/replace-range-probes/range-assembly/evidence/candidate/first-control/application/executable-operation-package.cbor new file mode 100644 index 0000000000000000000000000000000000000000..0b860cf3bf212766bce622ea5b4a92763bf10d19 GIT binary patch literal 5656 zcmdT|eQX@X6~6?if{1-i+z!u6s$tGbGx&9bD7;) z&&=BEemYhoX!=3_osZ<0AL`zeU5F&s;6|_=?1cE<8kSZ%p-^}iL zcWoy&HU6Xj+{frw~cf;K4%U` z?oi9bG3yZVtnf=FbA3WF?|@fUU}CGI$^y@VZ$IE_j!is?J?SDLuv?{g0C^5>y4s>$ z&9|ZEDvQb)*l19lIUk`ix6)xM6Z^H>$*< zb!-t?kT{fkx@?O$SjY)m)X=rp@3_7F!Qf|CU-pw8{aN4ReYitU8%);XEl%8TzEb$1U0iLp|NMOC3DOe6h z+$nTgDrRAOva|xnK1C)rxH^+PT?HLYf~a3Z{m8|56U^(>rZHtEqR~$sV5~p0L3XN; z62xZf+hu?T20e|S27;)9+I;iuV8Dq@(Z1YJDn zHVdR0xcMTdlVql^t(KW5Bu9`RVqB^Uxka75uGvyxIap5BAm0Zi_C-FoHkb3@Uq!po z*_+Re=W@gFtVmV-CAOl+t8%$qxQ^rDfN*S8nlP}RGaCv$Y=hE~#0vtq00pWZK^h^e zW0VuA>b;J9@=eSIAcqS@V9J78ntEX}C{N;nr!arvZ6>bEFt3b!R3(&1g2gzOkdIgz zgr~5;p4Q>^qj$Z$7^8%3F&ARPG{OiUc^!nqDlSk?$DlwVPUH59X9QK)R*DJ*3KvRc zGy{!=xQGg!|Bt0im^iS05NL9xd*>wP^n8#rBy?8T2#+e*4jbO3J?U>R zs&EUA(SsgEEZ0Y4lp$*{Vw~C0^FrdGK-L)am$5Phtn?ye??XQH28uI&=bVz_HPG@Z zc1e*^v0`phqzaP#ptN^thlr1@@P>yoN7T%+W_6R^dB3U97op z8WOV@k)SC+v0Vmul68({z`X;Y(v)dxG9eE@9H?T<*(!*ITcijy*Y~u0(0^Rb7vr81 zd;8Ur)H9%BmimUK2}i0?6iX%%9iGd_#ALWWlM-oH4VU>)dCf&l6aDua5FUYaYZ?H( zqv}bE5UOti00Y$kI~w4EE+wLAAZ*RJ(qusOXbmo|2z!~; zz{Fl6d?qx%$Z`nvl42nQ0yzUg#siVOQTyztAJm83V_!4g<6l5K%<~5@NM#!^6#sl6)kkqQUBB zBp$4E6%aCbt^`+nW3iBsjcy3y}RRg3A^Sowv6yM!})3^#zZSOj+z=h&QJsQaU3sQUWPR`;9t<%drFsD0ba>Zc~RZhY_0_38J|hkyLbYk^KJBZ95eVxIi>T`jMi zIl1Q5d%E9$;y1 z*NqX~Jf^0%mEGYV+`RoaFMRx5`I^r2#fj5*+%-d6t|Qx?|NK+KPp=L)E-*cbN~-z` zv0i~nk+b<`Btyd`C){X!{Q%Xcu02w#T}&p1`B?_53VqJ(na2*C$Pd3(ym4ym;D1_w zU;1$4s+)g({wtTC?O9X#=MyiV4qNRe1i`vJ4L&L7Pxnnt?A>+GQF%r8)+c|s>)cOo zJazS&-<>@2_n~)BUH1AVINYExnFB_^=K}8E-txUOcRusAWBZ0~`qQ@`b05Sf+7F%k S@n6rJ`o}|qFP!=M$bSI}cho@u literal 0 HcmV?d00001 diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/first-control/application/verification-report.cbor b/edict/replace-range-probes/range-assembly/evidence/candidate/first-control/application/verification-report.cbor new file mode 100644 index 0000000000000000000000000000000000000000..d3afb3f9339bcb0cff16a02de105a95bc6796739 GIT binary patch literal 932 zcmZ3Ho?lv$oS&PTk(ivET2PXjl3tLQoSm4Sx+p0#r9v^aA~m_RBrz!`RX4vNwJ5P9 zGe1ukszNU{IU_$UB{My>xTGnqI3v->)GR{b3&&qW=bK%cY)ZD=^K3&Rtd9I}ZP#cL ziHi?U`*+uHMn*|uQF>~LXA#JPe2@`(#RZ9Zx|v1#Wri50C9!>be|_0)+nbZ5B2U*V z=>KNgyHG>+#qq3Vum4x^d5AP^rTG3=;bIJf^(i^kkdat1Hr-2!%5JThvUb+xZ6`_KNTY*VLZ z7Nw@87NzDTLlQ3@S7I1#6?%52OQMG4LRUqDvQ-soZ+l%G`ga`XVBgB%`fJK-qk;4m E0A!tpP5=M^ literal 0 HcmV?d00001 diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/first-control/stderr.jsonl b/edict/replace-range-probes/range-assembly/evidence/candidate/first-control/stderr.jsonl new file mode 100644 index 00000000..e69de29b diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/first-control/stdout.jsonl b/edict/replace-range-probes/range-assembly/evidence/candidate/first-control/stdout.jsonl new file mode 100644 index 00000000..a668538e --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/first-control/stdout.jsonl @@ -0,0 +1 @@ +{"checked":1,"command":"build","errors":0,"exitCode":0,"schema":"edict.cli.event/v1","status":"ok","type":"status"} diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/git-locks-receipt.jsonl b/edict/replace-range-probes/range-assembly/evidence/candidate/git-locks-receipt.jsonl new file mode 100644 index 00000000..64b0a110 --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/git-locks-receipt.jsonl @@ -0,0 +1,2 @@ +{"event":"claimed","job":"80747C0A-6071-48B4-AD6C-A901D092CD12","holder":"jim-edict-authoring","note":"Jim RangeAssembly exact source candidate compiler public replay","claimed":1791162935,"expires":1791163835,"paths":["host/docker/echo-read-runtime/","host/heavy-work"],"record":"09627a715eea26c0ac88988e4b6d392ac4492232","acquisition":"1791162935-84725-3066529233"} +{"event":"released","job":"80747C0A-6071-48B4-AD6C-A901D092CD12","paths":2} diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/guard.log b/edict/replace-range-probes/range-assembly/evidence/candidate/guard.log new file mode 100644 index 00000000..f1ca3e7e --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/guard.log @@ -0,0 +1,5 @@ +{"artifactSha256": {"executable-operation-package.cbor": "1860ab8a6cb9a4bfd63a1db99d1c2bc00aa53dae52a9d1998295654379a95d85", "verification-report.cbor": "d96e5d21eecbc1e5bbf6ce76ab438d55cc8e74f6843121d4ffb0f4343e648267"}, "artifacts": ["executable-operation-package.cbor", "verification-report.cbor"], "case": "baseline", "diagnostics": [], "exitCode": 0, "sourceSha256": "51797e77062585a9f59083ee8a1da3faaf486ef7691e1b62203369a9d9356ee0", "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61"} +{"artifactSha256": {"executable-operation-package.cbor": "d950cebad1bb978e24dfa736efab302eb0f5c96135cb32f27ad8781d6ace6b51", "verification-report.cbor": "412fb923e3dbd3f070624446ae953920058e08eda5fdc94f201d9b475842c803"}, "artifacts": ["executable-operation-package.cbor", "verification-report.cbor"], "case": "first-control", "diagnostics": [], "exitCode": 0, "sourceSha256": "fa207e40f734fce99c581efbc5159a276c95e7b399d3acce854829ace05c6d2e", "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61"} +{"artifactSha256": {"executable-operation-package.cbor": "e75c18f7265ea8fd7390e2e2d4ff49047323e99a07602d80442659d636fd61f4", "verification-report.cbor": "463a47e58e00390937c565413305b4ec553928b86aae2979fbcbf631b55961d9"}, "artifacts": ["executable-operation-package.cbor", "verification-report.cbor"], "case": "second-control", "diagnostics": [], "exitCode": 0, "sourceSha256": "b7bdfce283a977bf2a04ec95d278138a9fbcaeb3e5eedefb909b6d617b1cf8c0", "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61"} +{"artifactSha256": {"executable-operation-package.cbor": "e889d4680435139fe76f45762f0529c090afcf3d73ef7d17f787d44a49bda534", "verification-report.cbor": "7eec90854e0663aa2346ec5005ff7d05eeb50fc2229b32b407dda3cfa0280077"}, "artifacts": ["executable-operation-package.cbor", "verification-report.cbor"], "case": "assembly", "diagnostics": [], "exitCode": 0, "sourceSha256": "8e8d2703759fb30cb49b73650ba8ddfd637d68b33b86145661bfca3033c968fc", "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61"} +JIM_RANGE_ASSEMBLY_CANDIDATE_OBSERVED package-and-report-produced diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/guard.result.json b/edict/replace-range-probes/range-assembly/evidence/candidate/guard.result.json new file mode 100644 index 00000000..1a395a0b --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/guard.result.json @@ -0,0 +1,10 @@ +{ + "measurements": { + "build": 7053634163, + "data": 2900191859, + "logs": 8645095, + "host_free": 718933827584, + "vm_free": 684305022976 + }, + "exit_code": 0 +} \ No newline at end of file diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/portable-git-locks-receipt.jsonl b/edict/replace-range-probes/range-assembly/evidence/candidate/portable-git-locks-receipt.jsonl new file mode 100644 index 00000000..756508a7 --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/portable-git-locks-receipt.jsonl @@ -0,0 +1,2 @@ +{"event":"claimed","job":"A26105DF-83F3-425C-9B47-9AF022715D45","holder":"jim-edict-authoring","note":"Replay portable RangeAssembly package harness and preserve exact evidence","claimed":1791163732,"expires":1791164632,"paths":["host/docker/echo-read-runtime/","host/heavy-work"],"record":"70633e7bdf3697cf733b40aec3f88e420104b419","acquisition":"1791163732-09781-0278023995"} +{"event":"released","job":"A26105DF-83F3-425C-9B47-9AF022715D45","paths":2} diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/portable-guard.log b/edict/replace-range-probes/range-assembly/evidence/candidate/portable-guard.log new file mode 100644 index 00000000..a0427953 --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/portable-guard.log @@ -0,0 +1,5 @@ +{"artifactSha256": {"executable-operation-package.cbor": "1860ab8a6cb9a4bfd63a1db99d1c2bc00aa53dae52a9d1998295654379a95d85", "verification-report.cbor": "d96e5d21eecbc1e5bbf6ce76ab438d55cc8e74f6843121d4ffb0f4343e648267"}, "artifacts": ["executable-operation-package.cbor", "verification-report.cbor"], "case": "baseline", "diagnostics": [], "exitCode": 0, "sourceSha256": "51797e77062585a9f59083ee8a1da3faaf486ef7691e1b62203369a9d9356ee0", "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61"} +{"artifactSha256": {"executable-operation-package.cbor": "d950cebad1bb978e24dfa736efab302eb0f5c96135cb32f27ad8781d6ace6b51", "verification-report.cbor": "412fb923e3dbd3f070624446ae953920058e08eda5fdc94f201d9b475842c803"}, "artifacts": ["executable-operation-package.cbor", "verification-report.cbor"], "case": "first-control", "diagnostics": [], "exitCode": 0, "sourceSha256": "fa207e40f734fce99c581efbc5159a276c95e7b399d3acce854829ace05c6d2e", "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61"} +{"artifactSha256": {"executable-operation-package.cbor": "e75c18f7265ea8fd7390e2e2d4ff49047323e99a07602d80442659d636fd61f4", "verification-report.cbor": "463a47e58e00390937c565413305b4ec553928b86aae2979fbcbf631b55961d9"}, "artifacts": ["executable-operation-package.cbor", "verification-report.cbor"], "case": "second-control", "diagnostics": [], "exitCode": 0, "sourceSha256": "b7bdfce283a977bf2a04ec95d278138a9fbcaeb3e5eedefb909b6d617b1cf8c0", "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61"} +{"artifactSha256": {"executable-operation-package.cbor": "e889d4680435139fe76f45762f0529c090afcf3d73ef7d17f787d44a49bda534", "verification-report.cbor": "7eec90854e0663aa2346ec5005ff7d05eeb50fc2229b32b407dda3cfa0280077"}, "artifacts": ["executable-operation-package.cbor", "verification-report.cbor"], "case": "assembly", "diagnostics": [], "exitCode": 0, "sourceSha256": "8e8d2703759fb30cb49b73650ba8ddfd637d68b33b86145661bfca3033c968fc", "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61"} +JIM_RANGE_ASSEMBLY_PACKAGE_BOUNDARY_CONFIRMED diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/portable-guard.result.json b/edict/replace-range-probes/range-assembly/evidence/candidate/portable-guard.result.json new file mode 100644 index 00000000..a13a0edc --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/portable-guard.result.json @@ -0,0 +1,10 @@ +{ + "measurements": { + "build": 7060787839, + "data": 2904236671, + "logs": 8950064, + "host_free": 718894419968, + "vm_free": 683224801280 + }, + "exit_code": 0 +} \ No newline at end of file diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/portable-public-build.json b/edict/replace-range-probes/range-assembly/evidence/candidate/portable-public-build.json new file mode 100644 index 00000000..f23fd1cf --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/portable-public-build.json @@ -0,0 +1,72 @@ +{ + "compiler": { + "commit": "01dc5abb9a8a74f8fd8b0e0a6d1041d0adb86d6e", + "tree": "74e571125a1da6ac5b2eac80944e343811708d51", + "fileCount": 449, + "manifestSha256": "bce253363396aad59ed3a7e51634ab1cc357c80972fc8e1ebad3a004fff3de11", + "binarySha256": "e2700698829b03f437c66425ed9878b002ef7a34ac183a39bac4eaf6a758cc6d" + }, + "providerManifestSha256": "c5b9fb2fe3a0dc4dad282621a97413225c555be0071f3502b3272952069d42dc", + "results": { + "baseline": { + "exitCode": 0, + "diagnostics": [], + "artifacts": [ + "executable-operation-package.cbor", + "verification-report.cbor" + ], + "sourceSha256": "51797e77062585a9f59083ee8a1da3faaf486ef7691e1b62203369a9d9356ee0", + "artifactSha256": { + "executable-operation-package.cbor": "1860ab8a6cb9a4bfd63a1db99d1c2bc00aa53dae52a9d1998295654379a95d85", + "verification-report.cbor": "d96e5d21eecbc1e5bbf6ce76ab438d55cc8e74f6843121d4ffb0f4343e648267" + }, + "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61", + "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "first-control": { + "exitCode": 0, + "diagnostics": [], + "artifacts": [ + "executable-operation-package.cbor", + "verification-report.cbor" + ], + "sourceSha256": "fa207e40f734fce99c581efbc5159a276c95e7b399d3acce854829ace05c6d2e", + "artifactSha256": { + "executable-operation-package.cbor": "d950cebad1bb978e24dfa736efab302eb0f5c96135cb32f27ad8781d6ace6b51", + "verification-report.cbor": "412fb923e3dbd3f070624446ae953920058e08eda5fdc94f201d9b475842c803" + }, + "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61", + "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "second-control": { + "exitCode": 0, + "diagnostics": [], + "artifacts": [ + "executable-operation-package.cbor", + "verification-report.cbor" + ], + "sourceSha256": "b7bdfce283a977bf2a04ec95d278138a9fbcaeb3e5eedefb909b6d617b1cf8c0", + "artifactSha256": { + "executable-operation-package.cbor": "e75c18f7265ea8fd7390e2e2d4ff49047323e99a07602d80442659d636fd61f4", + "verification-report.cbor": "463a47e58e00390937c565413305b4ec553928b86aae2979fbcbf631b55961d9" + }, + "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61", + "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "assembly": { + "exitCode": 0, + "diagnostics": [], + "artifacts": [ + "executable-operation-package.cbor", + "verification-report.cbor" + ], + "sourceSha256": "8e8d2703759fb30cb49b73650ba8ddfd637d68b33b86145661bfca3033c968fc", + "artifactSha256": { + "executable-operation-package.cbor": "e889d4680435139fe76f45762f0529c090afcf3d73ef7d17f787d44a49bda534", + "verification-report.cbor": "7eec90854e0663aa2346ec5005ff7d05eeb50fc2229b32b407dda3cfa0280077" + }, + "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61", + "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + } +} diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/public-build.json b/edict/replace-range-probes/range-assembly/evidence/candidate/public-build.json new file mode 100644 index 00000000..0f239271 --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/public-build.json @@ -0,0 +1,75 @@ +{ + "compiler": { + "commit": "01dc5abb9a8a74f8fd8b0e0a6d1041d0adb86d6e", + "tree": "74e571125a1da6ac5b2eac80944e343811708d51", + "fileCount": 449, + "manifestSha256": "22e4cc00473d2ccd3db80fe1f1de2ed8377f8a976df1fd05117eac649e77c529", + "binarySha256": "e2700698829b03f437c66425ed9878b002ef7a34ac183a39bac4eaf6a758cc6d" + }, + "jimSourceCommit": "e9ac7433c12d995743c109fd3cf6bcec46f9bca7", + "providerManifestSha256": "c5b9fb2fe3a0dc4dad282621a97413225c555be0071f3502b3272952069d42dc", + "boundary": "Public compiler build and provider package/report only; runtime not exercised.", + "results": { + "baseline": { + "exitCode": 0, + "diagnostics": [], + "artifacts": [ + "executable-operation-package.cbor", + "verification-report.cbor" + ], + "sourceSha256": "51797e77062585a9f59083ee8a1da3faaf486ef7691e1b62203369a9d9356ee0", + "artifactSha256": { + "executable-operation-package.cbor": "1860ab8a6cb9a4bfd63a1db99d1c2bc00aa53dae52a9d1998295654379a95d85", + "verification-report.cbor": "d96e5d21eecbc1e5bbf6ce76ab438d55cc8e74f6843121d4ffb0f4343e648267" + }, + "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61", + "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "first-control": { + "exitCode": 0, + "diagnostics": [], + "artifacts": [ + "executable-operation-package.cbor", + "verification-report.cbor" + ], + "sourceSha256": "fa207e40f734fce99c581efbc5159a276c95e7b399d3acce854829ace05c6d2e", + "artifactSha256": { + "executable-operation-package.cbor": "d950cebad1bb978e24dfa736efab302eb0f5c96135cb32f27ad8781d6ace6b51", + "verification-report.cbor": "412fb923e3dbd3f070624446ae953920058e08eda5fdc94f201d9b475842c803" + }, + "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61", + "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "second-control": { + "exitCode": 0, + "diagnostics": [], + "artifacts": [ + "executable-operation-package.cbor", + "verification-report.cbor" + ], + "sourceSha256": "b7bdfce283a977bf2a04ec95d278138a9fbcaeb3e5eedefb909b6d617b1cf8c0", + "artifactSha256": { + "executable-operation-package.cbor": "e75c18f7265ea8fd7390e2e2d4ff49047323e99a07602d80442659d636fd61f4", + "verification-report.cbor": "463a47e58e00390937c565413305b4ec553928b86aae2979fbcbf631b55961d9" + }, + "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61", + "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "assembly": { + "exitCode": 0, + "diagnostics": [], + "artifacts": [ + "executable-operation-package.cbor", + "verification-report.cbor" + ], + "sourceSha256": "8e8d2703759fb30cb49b73650ba8ddfd637d68b33b86145661bfca3033c968fc", + "artifactSha256": { + "executable-operation-package.cbor": "e889d4680435139fe76f45762f0529c090afcf3d73ef7d17f787d44a49bda534", + "verification-report.cbor": "7eec90854e0663aa2346ec5005ff7d05eeb50fc2229b32b407dda3cfa0280077" + }, + "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61", + "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + }, + "assemblyOutcome": "package-and-report-produced" +} diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/second-control/application/executable-operation-package.cbor b/edict/replace-range-probes/range-assembly/evidence/candidate/second-control/application/executable-operation-package.cbor new file mode 100644 index 0000000000000000000000000000000000000000..e42ff61b1e1ace7dd15c617a06f51dab3c856a57 GIT binary patch literal 5658 zcmdT|U2Gl26~2KYl2$5K9%yo%GzK{lQso;P>@*a|#Plc)35jGv~~lIp;gyHz#aiRjn76?zD=@LuR$+l>!M7i9HOD5N#GZ7K5ZJ9yJcK+4H(YJf zuIAcMbCpHq3~ab2u#*sfKG zMMtnjWI^IkZtt)y;$R^U*rJMV?b>pG%aPzaH(vMcKK{yg$)z`&Pn~>gP4O4QO`E>) z^4anL>pVB8x8qPWp(5`@@e@b05uCOv%$lrYk6Bpkuj?r$#S)Jr8sNHBK?3XL)L}Uo zai`F3shEW=$@^eq#DUYQ2esS!OB`78T0gR5jzvHl3B=P06rc1=3_r?#QX#`cW$40D zw^<<7z>QZqo+LGWZMDQaAvuBs5mQo?$X)92bI@+%H_u3Sua)bm)MFPugK+c;Tn#|0>ZIXZs5Rf&TOdka0AqiBwi4>1*lN<2=WM7 zZ4;bGRq!LoCtt-}0Cc!e1*R;hrKuMtgZd;Mcnb4Z-e%&u1oKMBM-@VeBv?#w2?>d% zL3j!boM|0yKYG{Cdt;ceE#^XOn1&ePBd?8cSj83U=@?Wf#A(W2_Kctk+=@}5K;=TI zOk}XJ5EoIQ{Zm=XG)^3ax?*Z>qWUw9Ww8nM38%IjB}(jFq4kJP5zA-uV0EGO$<_IP zU3kCtx0VYR4{d*J(hHe0+m(~bI z1Pi!{RUIf}SF4&iO~!ezyQ%BMh*ZTR+%eD3Q)_abxl!@)q zBI`2VnSn#y?vff@^_93GAF8E_TqHFPy=4#@RlhZ2LF4eCnwiI<9*RR~>Dz9*wI@9_ z$V@E;wvBmaa=31gxd0`!J2NtJk};KC#ZEw~k7+1epK&!5^-h)MdLyZw@n~m?Y;?4D zZteQ=mduL6FJ=stD*)nwsY0>?OGIeO5*wBr`l;qEKplF3Ioa5Rx*`C=LPFv})6{+4 z+`FYS!i%*{xzr)dS~aYx1ZWLdzYC*rEEbr&A+yqCauFBgv`e>3eWDQ50Gdp@tNIVqCDuV_yS)u@zUIgs}$cN@YamMegQ&P+ZdS2Ns zDq1R*&25TSL9*|a_Ezl>@yTW0@L1-E23gr(wmoJKsfYv-gG`o?$2f)n%N|9N+s9&E%<<#zbn5IKsCUQ2DqS1iD(!In=`I78Bjf1gNrKyUonl{j1qHlR@>BOG{z1`qZkk{ zv4aSo3C%CE974UMSO|eY&p?pzP^52E|JE8Wyg9Ry^rrh5lRoresf9+^j8xMDFqnB> zu2ACW9kZxG?*`!nkO-%iJ@d5HyP{Se<|D;nfS3Xzs%St$tX8c1N#m*{A8Dy*u(}(G z2P3L^5i}VmHG84mLml}(6t=D# zBf5J`P2W&*$G&xE=hH8J_=nOL+AsGWIQO+jFVfYwkY``$Wp-CwW8;W~xM954bt=W+kqrU%bI@cX-u?c8_AZ@&J#djy|s8NKxI Q>GNma{{HYw=kFQ+KgVp-i2wiq literal 0 HcmV?d00001 diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/second-control/application/verification-report.cbor b/edict/replace-range-probes/range-assembly/evidence/candidate/second-control/application/verification-report.cbor new file mode 100644 index 00000000..65cb7a56 --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/second-control/application/verification-report.cbor @@ -0,0 +1 @@ +¨goutcomehacceptedgpackage¢bidx!executable-operation-package.echofdigest‚fsha256X G_€õwc$e<)¦œD€?°f¿™²f)sÚ¹5å[htargetIr¢bidoecho.span-ir/v1fdigest‚fsha256X ÊÊ eU OôL¦ƒÍ퀕o%wŸRÚ8CŠÌb‘]njapiVersionx)echo.operation-package-verifier-report/v1mdiagnosticAbi¢bidtedict.diagnostics/v1fdigest‚fsha256X (ýr©‚#9‚ÊL)Û±²Ô0b9g«;m¹×þæhæ¹odiagnosticBytes@qexecutableSubject¢ebytesYR¤gpackage¢bidx!executable-operation-package.echofdigest‚fsha256X G_€õwc$e<)¦œD€?°f¿™²f)sÚ¹5å[htargetIr¢bidoecho.span-ir/v1fdigest‚fsha256X ÊÊ eU OôL¦ƒÍ퀕o%wŸRÚ8CŠÌb‘]njapiVersionxecho.executable-subject/v1xapplicationResultProjection¢bidx(jedit.text.replace_range@1.assembleRangefdigest‚fsha256X ¸{¡ò„(²0è_FPº8â2‚šÕŽŠkü¿å••ireference¢bidxecho.executable-subject/v1fdigest‚fsha256X nÕ¯äRÑUn×Û Æz™I»2ÝÚF¾€¸ª€±(¼ÃÈ¡xapplicationResultProjection¢bidx(jedit.text.replace_range@1.assembleRangefdigest‚fsha256X ¸{¡ò„(²0è_FPº8â2‚šÕŽŠkü¿å•• \ No newline at end of file diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/second-control/stderr.jsonl b/edict/replace-range-probes/range-assembly/evidence/candidate/second-control/stderr.jsonl new file mode 100644 index 00000000..e69de29b diff --git a/edict/replace-range-probes/range-assembly/evidence/candidate/second-control/stdout.jsonl b/edict/replace-range-probes/range-assembly/evidence/candidate/second-control/stdout.jsonl new file mode 100644 index 00000000..a668538e --- /dev/null +++ b/edict/replace-range-probes/range-assembly/evidence/candidate/second-control/stdout.jsonl @@ -0,0 +1 @@ +{"checked":1,"command":"build","errors":0,"exitCode":0,"schema":"edict.cli.event/v1","status":"ok","type":"status"} diff --git a/edict/replace-range-probes/range-assembly/run.py b/edict/replace-range-probes/range-assembly/run.py index adca6c7f..6d25b611 100644 --- a/edict/replace-range-probes/range-assembly/run.py +++ b/edict/replace-range-probes/range-assembly/run.py @@ -7,6 +7,7 @@ COMPILER_COMMIT = "ac836e5c42a5c47b0dab30cfb0b09848cca73215" +CANDIDATE_COMPILER_COMMIT = "01dc5abb9a8a74f8fd8b0e0a6d1041d0adb86d6e" SOURCE_EXPRESSION = b"input.firstFragment + input.secondFragment" @@ -15,6 +16,7 @@ def main(): for name in ("compiler", "compiler-source", "compiler-manifest", "application-source", "provider-package", "work-root"): parser.add_argument("--" + name, type=Path, required=True) + parser.add_argument("--boundary", choices=("source", "package"), default="source") args = parser.parse_args() if not Path("/.dockerenv").is_file(): raise RuntimeError("Run only under shared git-locks admission and the guarded Docker lease") @@ -25,7 +27,8 @@ def main(): sha256, snapshot = common["sha256"], common["snapshot"] verify = common["verify_compiler_source"] args.work_root.mkdir() - compiler = verify(args.compiler_source, args.compiler_manifest, COMPILER_COMMIT) + expected_commit = COMPILER_COMMIT if args.boundary == "source" else CANDIDATE_COMPILER_COMMIT + compiler = verify(args.compiler_source, args.compiler_manifest, expected_commit) compiler["binarySha256"] = sha256(args.compiler) before = {"application": snapshot(args.application_source), "provider": snapshot(args.provider_package)} @@ -53,12 +56,18 @@ def main(): raise RuntimeError("Witness changed an authoritative input") if compiler["binarySha256"] != sha256(args.compiler): raise RuntimeError("Compiler binary changed during witness") - verify(args.compiler_source, args.compiler_manifest, COMPILER_COMMIT) + verify(args.compiler_source, args.compiler_manifest, expected_commit) for name in ("baseline", "first-control", "second-control"): result = evidence["results"][name] if result["exitCode"] != 0 or result["diagnostics"] or not result["artifacts"]: raise RuntimeError(f"{name} positive control did not build") result = evidence["results"]["assembly"] + if args.boundary == "package": + if (result["exitCode"] != 0 or result["diagnostics"] + or result["artifacts"] != ["executable-operation-package.cbor", "verification-report.cbor"]): + raise RuntimeError("Assembly did not reach the expected package build boundary") + print("JIM_RANGE_ASSEMBLY_PACKAGE_BOUNDARY_CONFIRMED", flush=True) + return if result["exitCode"] != 2 or result["artifacts"]: raise RuntimeError("Assembly must refuse without application artifacts") refusal = result["diagnostics"] From ac2c93db37f1bbca9c5ef2cd6c811767893af492 Mon Sep 17 00:00:00 2001 From: James Ross Date: Sun, 4 Oct 2026 23:14:39 -0700 Subject: [PATCH 20/30] test(edict): retain Buffer decoder source boundary evidence Preserve the original parser/lexer refusals and failed witness, then reproduce those distinct boundaries with a controlled Rust 1.96 build. Retain raw artifacts, resource-stop qualifications, and source/compiler/provider identities. The decoder remains unexecuted; Edict #226 and Echo #752 own the function prerequisites for Jim #296. --- .../buffer-decoder/.gitattributes | 2 + .../buffer-decoder/Decimal.edict | 75 + .../buffer-decoder/README.md | 72 + .../buffer-decoder/cases.json | 34 + .../control/edict.application.json | 20 + .../control/src/ReplaceRange.edict | 18 + .../.atom-read.edict-lawpack-build.lock | 0 .../control/vendor/atom-read/adapter.cbor | Bin 0 -> 928 bytes .../control/vendor/atom-read/adapter.sha256 | 1 + .../echo-operation-configuration.cbor | Bin 0 -> 130 bytes .../echo-operation-configuration.sha256 | 1 + .../atom-read/edict.lawpack-output.json | 67 + .../control/vendor/atom-read/exports.cbor | 1 + .../control/vendor/atom-read/exports.sha256 | 1 + .../control/vendor/atom-read/manifest.cbor | 2 + .../control/vendor/atom-read/manifest.sha256 | 1 + .../vendor/atom-read/verifier-rules.cbor | 1 + .../vendor/atom-read/verifier-rules.sha256 | 1 + .../evidence/compiler-source.json | 1802 +++++++++++++++++ .../original/decimal/ReplaceRange.edict | 93 + .../evidence/original/decimal/stderr.jsonl | 2 + .../evidence/original/decimal/stdout.jsonl | 0 .../original/fn-control/ReplaceRange.edict | 20 + .../evidence/original/fn-control/stderr.jsonl | 2 + .../evidence/original/fn-control/stdout.jsonl | 0 .../evidence/original/git-locks-receipt.jsonl | 5 + .../evidence/original/guard.launch.json | 38 + .../evidence/original/guard.log | 17 + .../evidence/original/guard.result.json | 10 + .../evidence/original/public-build.json | 101 + .../original/read-control/ReplaceRange.edict | 18 + .../executable-operation-package.cbor | Bin 0 -> 10473 bytes .../application/verification-report.cbor | Bin 0 -> 930 bytes .../original/read-control/stderr.jsonl | 0 .../original/read-control/stdout.jsonl | 1 + .../buffer-decoder/evidence/original/run.py | 75 + .../evidence/provider-manifest.echo.json | 380 ++++ .../decimal/ReplaceRange.edict | 93 + .../reproduction196/decimal/stderr.jsonl | 2 + .../reproduction196/decimal/stdout.jsonl | 0 .../fn-control/ReplaceRange.edict | 20 + .../reproduction196/fn-control/stderr.jsonl | 2 + .../reproduction196/fn-control/stdout.jsonl | 0 .../reproduction196/guard.launch.json | 38 + .../evidence/reproduction196/guard.log | 20 + .../reproduction196/guard.result.json | 10 + .../reproduction196/public-build.json | 101 + .../read-control/ReplaceRange.edict | 18 + .../executable-operation-package.cbor | Bin 0 -> 10473 bytes .../application/verification-report.cbor | Bin 0 -> 930 bytes .../reproduction196/read-control/stderr.jsonl | 0 .../reproduction196/read-control/stdout.jsonl | 1 + .../resource-stop/after-cleanup-usage.json | 7 + .../evidence/resource-stop/guard.launch.json | 38 + .../evidence/resource-stop/guard.log | 4 + .../resource-stop/observer-record.json | 17 + .../partial-toolchain-cleanup.txt | 35 + .../buffer-decoder/run.py | 98 + 58 files changed, 3365 insertions(+) create mode 100644 edict/replace-range-probes/buffer-decoder/.gitattributes create mode 100644 edict/replace-range-probes/buffer-decoder/Decimal.edict create mode 100644 edict/replace-range-probes/buffer-decoder/README.md create mode 100644 edict/replace-range-probes/buffer-decoder/cases.json create mode 100644 edict/replace-range-probes/buffer-decoder/control/edict.application.json create mode 100644 edict/replace-range-probes/buffer-decoder/control/src/ReplaceRange.edict create mode 100644 edict/replace-range-probes/buffer-decoder/control/vendor/.atom-read.edict-lawpack-build.lock create mode 100644 edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/adapter.cbor create mode 100644 edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/adapter.sha256 create mode 100644 edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/echo-operation-configuration.cbor create mode 100644 edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/echo-operation-configuration.sha256 create mode 100644 edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/edict.lawpack-output.json create mode 100644 edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/exports.cbor create mode 100644 edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/exports.sha256 create mode 100644 edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/manifest.cbor create mode 100644 edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/manifest.sha256 create mode 100644 edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/verifier-rules.cbor create mode 100644 edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/verifier-rules.sha256 create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/compiler-source.json create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/decimal/ReplaceRange.edict create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/decimal/stderr.jsonl create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/decimal/stdout.jsonl create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/fn-control/ReplaceRange.edict create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/fn-control/stderr.jsonl create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/fn-control/stdout.jsonl create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/git-locks-receipt.jsonl create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/guard.launch.json create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/guard.log create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/guard.result.json create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/public-build.json create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/read-control/ReplaceRange.edict create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/read-control/application/executable-operation-package.cbor create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/read-control/application/verification-report.cbor create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/read-control/stderr.jsonl create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/read-control/stdout.jsonl create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/original/run.py create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/provider-manifest.echo.json create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/reproduction196/decimal/ReplaceRange.edict create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/reproduction196/decimal/stderr.jsonl create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/reproduction196/decimal/stdout.jsonl create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/reproduction196/fn-control/ReplaceRange.edict create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/reproduction196/fn-control/stderr.jsonl create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/reproduction196/fn-control/stdout.jsonl create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/reproduction196/guard.launch.json create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/reproduction196/guard.log create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/reproduction196/guard.result.json create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/reproduction196/public-build.json create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/reproduction196/read-control/ReplaceRange.edict create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/reproduction196/read-control/application/executable-operation-package.cbor create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/reproduction196/read-control/application/verification-report.cbor create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/reproduction196/read-control/stderr.jsonl create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/reproduction196/read-control/stdout.jsonl create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/resource-stop/after-cleanup-usage.json create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/resource-stop/guard.launch.json create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/resource-stop/guard.log create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/resource-stop/observer-record.json create mode 100644 edict/replace-range-probes/buffer-decoder/evidence/resource-stop/partial-toolchain-cleanup.txt create mode 100644 edict/replace-range-probes/buffer-decoder/run.py diff --git a/edict/replace-range-probes/buffer-decoder/.gitattributes b/edict/replace-range-probes/buffer-decoder/.gitattributes new file mode 100644 index 00000000..edea5c09 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/.gitattributes @@ -0,0 +1,2 @@ +# Preserve the original cleanup transcript, including its final blank line. +evidence/resource-stop/partial-toolchain-cleanup.txt whitespace=-blank-at-eof diff --git a/edict/replace-range-probes/buffer-decoder/Decimal.edict b/edict/replace-range-probes/buffer-decoder/Decimal.edict new file mode 100644 index 00000000..4eb03ae4 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/Decimal.edict @@ -0,0 +1,75 @@ +package jedit.text.replace_range@1; + +// Jim's JSON boundary codec. These are internal scanner values, not intent inputs. +// A later bounded scanner must obtain each token from the retained Buffer atom. +type JsonByte = Bytes; +type DecimalState = variant { Start, Zero, Digits(U64) }; +type DecimalStep = variant { More(DecimalState), End(U64), Invalid, Overflow }; +type DecimalDigit = variant { Digit(U64), NotDigit }; + +// An End result leaves the delimiter unconsumed for the enclosing JSON scanner. +// Whitespace terminates a number; canonical-byte policy belongs to that scanner. +fn isNumberDelimiter(token: JsonByte) -> Bool { + return token == b"," || token == b"]" || token == b"}" + || token == b" " || token == b"\t" || token == b"\r" || token == b"\n"; +} + +fn decimalDigit(token: JsonByte) -> DecimalDigit { + return if token == b"0" then DecimalDigit::Digit(0u64) + else if token == b"1" then DecimalDigit::Digit(1u64) + else if token == b"2" then DecimalDigit::Digit(2u64) + else if token == b"3" then DecimalDigit::Digit(3u64) + else if token == b"4" then DecimalDigit::Digit(4u64) + else if token == b"5" then DecimalDigit::Digit(5u64) + else if token == b"6" then DecimalDigit::Digit(6u64) + else if token == b"7" then DecimalDigit::Digit(7u64) + else if token == b"8" then DecimalDigit::Digit(8u64) + else if token == b"9" then DecimalDigit::Digit(9u64) + else DecimalDigit::NotDigit; +} + +fn appendScaled(scaled: U64, digit: U64, limit: U64) -> DecimalStep { + let sum = checkedAdd(scaled, digit); + return if isSome(sum) then + if unwrap(sum) <= limit then DecimalStep::More(DecimalState::Digits(unwrap(sum))) + else DecimalStep::Overflow + else DecimalStep::Overflow; +} + +fn appendDigit(value: U64, digit: U64, limit: U64) -> DecimalStep { + let decimalRadix = 10u64; + let product = checkedMul(value, decimalRadix); + return if isSome(product) then appendScaled(unwrap(product), digit, limit) + else DecimalStep::Overflow; +} + +fn startDecimal(token: JsonByte, limit: U64) -> DecimalStep { + return match decimalDigit(token) { + Digit(value) => if value > limit then DecimalStep::Overflow + else if value == 0u64 then DecimalStep::More(DecimalState::Zero) + else DecimalStep::More(DecimalState::Digits(value)), + NotDigit => DecimalStep::Invalid, + }; +} + +fn continueDecimal(value: U64, token: JsonByte, limit: U64) -> DecimalStep { + return if value == 0u64 then DecimalStep::Invalid + else if value > limit then DecimalStep::Overflow + else match decimalDigit(token) { + Digit(digit) => appendDigit(value, digit, limit), + NotDigit => if isNumberDelimiter(token) then DecimalStep::End(value) + else DecimalStep::Invalid, + }; +} + +// canonical_head_id members use limit 255; version uses 18446744073709551615. +// The enclosing scanner owns these schema limits and starts at Start. +// Empty token, sign, leading zero, fraction, exponent and non-ASCII byte refuse. +fn stepJsonUnsigned(state: DecimalState, token: JsonByte, limit: U64) -> DecimalStep { + return match state { + Start => startDecimal(token, limit), + Zero => if isNumberDelimiter(token) then DecimalStep::End(0u64) + else DecimalStep::Invalid, + Digits(value) => continueDecimal(value, token, limit), + }; +} diff --git a/edict/replace-range-probes/buffer-decoder/README.md b/edict/replace-range-probes/buffer-decoder/README.md new file mode 100644 index 00000000..8ef30107 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/README.md @@ -0,0 +1,72 @@ +# Buffer decoder: authored decimal transitions + +This is incomplete Jim-owned codec work for [#296](https://github.com/flyingrobots/jedit/issues/296), retained in draft [#302](https://github.com/flyingrobots/jedit/pull/302). The intended outcome remains decoding the actual retained Buffer atom and deriving its canonical Head and version before the ReplaceRange basis check. The frozen application and producer pins remain unchanged. + +[`Decimal.edict`](Decimal.edict) specifies an unsigned JSON-number transition for the Buffer codec: decimal digit recognition, no leading zeros, delimiters left unconsumed, checked multiplication/addition, and the schema's U8 or U64 limit. It accepts internal scanner state and a byte token. These are **not operation inputs or authoritative caller-supplied decoded fields**. The enclosing scanner must own the limit, obtain tokens from actual retained bytes, and start at `Start`. + +[`cases.json`](cases.json) contains handwritten literal expectations, including 255/256, U64 maximum, and both addition/multiplication overflow. They remain an unexecuted conformance specification. `End` stops before its delimiter; `More` at end-of-input is incomplete. Whitespace can terminate a number, but the enclosing scanner must decide its encoding policy. These transitions neither impose canonical Buffer bytes nor implement the whole JSON grammar. + +## Observed public compiler boundaries + +The [original result](evidence/original/public-build.json), assembled sources, raw JSONL streams, positive-control artifacts, compiler-source manifest, and failed wrapper evidence are preserved. The authored source is unchanged from that run, SHA-256 `9fc1b006c298866463ab83a28fcb1e54769b970970c571f11d0868d79edc6d87`. + +| Input | Actual public build result | +| --- | --- | +| Unchanged atom-read control | Exit 0; package and separate verification report, no diagnostics | +| Read control with one unused identity function declaration | Exit 2; `InvalidApplicationSource`, `ExpectedToken`, `expected type, enum, or intent declaration` at `fn`, bytes 151–153; no application artifacts | +| Read control with the authored decimal declarations | Exit 2; `InvalidApplicationSource`, `Lex`, `invalid string escape`, bytes 861–862 at the carriage-return escape; no application artifacts | + +These are distinct boundaries. The lexer processes the source before declaration parsing, so the decimal source stops at its `b"\r"` spelling; it did not reach the function-declaration diagnostic. The trivial function control independently establishes that missing parser production. Neither refusal establishes function-body typing, arithmetic, Option proofs, byte-literal support beyond the observed point, lowering, or evaluation. + +The original harness incorrectly expected `ApplicationCompilationFailed` for both negative controls. It wrote all three actual results and completed its input/source/binary integrity checks, then failed the `fn-control` assertion. The [guard log](evidence/original/guard.log), [result](evidence/original/guard.result.json), [launch contract](evidence/original/guard.launch.json), [lock receipt](evidence/original/git-locks-receipt.jsonl), and [original runner](evidence/original/run.py) retain this wrapper **exit 1**. No success marker was produced. Correcting the expectations does not turn that historical run green. + +The current runner distinguishes the observed diagnostic kinds and rejects changes to the authored source, read-control source, or provider file hashes. It also requires the exact historical compiler-source manifest and an explicitly pinned compiler binary. The corrected source reproduction described below passed. The original outputs remain evidence of the three compiler invocations inside a historically failed witness harness. + +The first corrected-run attempt stopped before compilation or any application-build invocation. Rust 1.95.0 was absent, and invoking it began an automatic toolchain download; the external resource guard stopped the attempt when accounted data exceeded the project limit. The [attempt log](evidence/resource-stop/guard.log) and [launch contract](evidence/resource-stop/guard.launch.json) are retained. The [controller observation](evidence/resource-stop/observer-record.json) records 4,325,788,505 data bytes against the 4,294,967,296-byte limit; it is explicitly observer-authored from the displayed exception, not raw controller stdout. The [cleanup transcript](evidence/resource-stop/partial-toolchain-cleanup.txt) and [subsequent usage](evidence/resource-stop/after-cleanup-usage.json) record removal of only the new partial toolchain/downloads. This resource stop is neither a compiler RED nor a corrected-harness result. + +## Corrected source reproduction + +The [corrected witness](evidence/reproduction196/public-build.json) passed with wrapper exit 0 and `JIM_BUFFER_DECIMAL_DISTINCT_SOURCE_BOUNDARIES_CONFIRMED`. Its [build/run log](evidence/reproduction196/guard.log), [launch contract](evidence/reproduction196/guard.launch.json), [guard result](evidence/reproduction196/guard.result.json), assembled sources, raw streams, and read-control artifacts are retained separately from the original failure. + +The exact same 449-file compiler source was rebuilt with the already installed Rust 1.96.0 (`ac68faa20c58cbccd01ee7208bf3b6e93a7d7f96`) in the reusable worker and stable target. The resulting CLI SHA-256 is `83c70b3fdbb42ac43f0967a0c559c0cc8b66599987774a40412bda4fbc028d36`; this explicit pin was passed to the runner. It reproduces the source boundaries with a different compiler binary, not the historical Rust 1.95.0 binary. + +All three assembled source hashes match the original run. The read-control package and report are byte-identical to the originals. The negative cases retain the same kinds and source spans, with raw stderr hashes differing because the diagnostic paths name the new work root. Source, binary, application, and provider integrity checks completed. The executed runner matches checked-in `run.py`, SHA-256 `0d6f644eeccd8acbd0841f7c5420bd0d5353a55948471d3ed13f24618d5e0868`. + +This is a successful reproduction of one public-build control and two expected source refusals. No decimal case, scanner, rope algorithm, evaluator, or broader Jim application suite ran in this replay. + +## Exact inputs and artifact identities + +The experiment used compiler commit `17397e2aad18a83ffc617d1afd628764501f49cd`, tree `bcfd3112cd8b3d4630738a88761860679b45714b`, rebuilt with Rust 1.95.0 in the existing guarded Docker worker. All 449 compiler-source files were checked against the [Git blob manifest](evidence/compiler-source.json) before and after the public builds. Its raw manifest SHA-256 is `625592ab9dd715349255bece0133378c64b3d4539fb50e437d116c2a4296f016`; the compiler binary SHA-256 is `e2700698829b03f437c66425ed9878b002ef7a34ac183a39bac4eaf6a758cc6d`. + +The separate read-capable provider is pinned by its complete file-hash map in the result. Its [manifest](evidence/provider-manifest.echo.json) has raw SHA-256 `5b38ae704a071b88aa0cc2f85020de41cb69e76d037afe3592a4d319e22587c8`. Lowerer and verifier component hashes are respectively `4b594a8165079f0a973741b9e27b468cf041f4ad53108fccae641dc35355bd2a` and `d0be4d283399aefc45d75b395b3568f9983521ca5543c9dfd23b9495758050ed`. This witness records those exact package bytes; it does not claim to reproduce their component builds or independently establish their source commit. + +The retained read-control [package](evidence/original/read-control/application/executable-operation-package.cbor) has SHA-256 `afd931700018312d6c0d1e249871313d2c21c0ece1ae41d1f17f2be7af9e5284`; its [report](evidence/original/read-control/application/verification-report.cbor) has SHA-256 `9114fdd983d456eb83f69969475f558b6e608be23520212a5db5f26bb095d04b`. These artifacts were produced only for the unchanged read control. No decoder package was emitted and no evaluator was invoked. + +## Source contract and composition obligation + +The source follows the documented direction for non-recursive, first-order pure `fn` declarations, byte literals, checked arithmetic, and guarded Option handling. The observed failures show that the executable compiler subset is narrower. The experiment uses Edict's public application build; it supplies no native decoder, invented intrinsic, or handwritten Core/Target IR. + +The public application format accepts one source module. The experiment inserts the exact helper declarations into the retained [control](control/src/ReplaceRange.edict) before its first type declaration. The unchanged operation does not call the helpers. The assembled sources are retained alongside their diagnostics. Merely accepting unused declarations would not prove executable functions or a decoder. + +[Edict #226](https://github.com/flyingrobots/edict/issues/226) owns the full source-function compiler and semantic-contract prerequisite. [Echo #752](https://github.com/flyingrobots/echo/issues/752) depends on it for generic function admission and execution in both pure and bounded-read programs. Their acceptance must exercise called bodies, evaluate arguments once, preserve lexical scope and conditional evaluation, and enforce bounded costs through compiler-produced packages and separate verification. These are outstanding obligations, not capabilities established by this declaration-only probe. Jim #296 continues to own the actual retained-byte scanner and complete rope operation. + +The next authored work must scan actual Buffer `FactBytes`: variable-length UTF-8 key and optional path, JSON escapes, exactly 32 decimal head bytes, and version. It must preserve fields needed for encoding and derive the basis from retained state. Immutable list-only statement loops currently provide no result-producing accumulator; bytes are not an iterable List, and no generic fold is implemented. A one-byte `slice` retains the source maximum and drops exact/minimum length, so the `JsonByte` input requires a justified narrowing path. Source aliases, variants, Option, and checked arithmetic also remain separate compiler/evaluator obligations. Function parsing alone cannot complete this scanner. + +Native references are [`BufferFact` and its codec](../../../native/jedit-echo-host/src/records.rs), [`plan_replace_with_reason`](../../../native/jedit-echo-host/src/rope/replace.rs), and the [frozen schema](../../../contracts/jedit/lawpacks/replace-range-v1/text-schema-v1.json). Native Buffer reads do not perform the retained Head's universal decode/re-encode/content-identity checks; preserve that distinction. NoOp must precede version/sequence overflow. Full replacement still requires pending intermediate split facts, canonical identities, write ordering, atomic settlement, all forty oracle cases, and recovery. + +## Reproduction + +Use the existing shared guarded Docker worker and stable Cargo target under workstation git-locks admission. Do not rebuild or start a worker merely to repeat this historical observation. The corrected runner reuses the portable public-build functions in `../leaf-slice/run.py`. Copy this probe, that helper, and the retained control into the accounted worker input tree. Supply the exact compiler-source and provider identities above. By default the runner requires the historical Rust 1.95.0 binary hash. If that binary is unavailable, a controlled rebuild of the same source with an already installed toolchain may supply its own explicit `--compiler-sha256` pin. Retain the build command, toolchain version, source checks, and actual binary hash; such a run reproduces the source boundary, not the historical compiler binary. A self-reported hash alone does not establish which source built a binary. Run inside the guarded lease: + +```sh +python3 "$PROBE_ROOT/run.py" \ + --compiler "$EDICT_BINARY" \ + --compiler-sha256 "$EDICT_BINARY_SHA256" \ + --compiler-source "$EDICT_SOURCE" \ + --compiler-manifest "$PROBE_ROOT/evidence/compiler-source.json" \ + --application-source "$PROBE_ROOT/control" \ + --provider-package "$PROVIDER_PACKAGE" \ + --work-root /tmp/echo-726-runtime/jim-buffer-decoder-reproduction +``` + +The work root must be absent. The runner validates input hashes, records separate case outcomes, and expects `JIM_BUFFER_DECIMAL_DISTINCT_SOURCE_BOUNDARIES_CONFIRMED` only after all assertions pass. That marker describes successful reproduction of compiler refusals, never a working decoder. The external guard must enforce the project build/data/log budgets and stop the owned process group on timeout or monitoring failure; the runner's per-process timeout is not a disk quota. Older probe Dockerfiles that bake build output into images are historical recipes. diff --git a/edict/replace-range-probes/buffer-decoder/cases.json b/edict/replace-range-probes/buffer-decoder/cases.json new file mode 100644 index 00000000..06a337a0 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/cases.json @@ -0,0 +1,34 @@ +{ + "status": "Handwritten conformance specification; not executed", + "procedure": "Start at DecimalState::Start. Feed each listed byte in order to stepJsonUnsigned with the stated schema limit. Continue only through More. Stop at the first End, Invalid or Overflow. End leaves its delimiter unconsumed. A trailing More means an incomplete number, not successful decoding.", + "cases": [ + {"name":"zero-array-member","bytesHex":"302c","limit":"255","expected":{"kind":"End","value":"0","consumedDigits":1}}, + {"name":"zero-version","bytesHex":"307d","limit":"18446744073709551615","expected":{"kind":"End","value":"0","consumedDigits":1}}, + {"name":"u8-max","bytesHex":"3235355d","limit":"255","expected":{"kind":"End","value":"255","consumedDigits":3}}, + {"name":"u8-overflow","bytesHex":"3235365d","limit":"255","expected":{"kind":"Overflow","atByte":2}}, + {"name":"u64-max","bytesHex":"31383434363734343037333730393535313631357d","limit":"18446744073709551615","expected":{"kind":"End","value":"18446744073709551615","consumedDigits":20}}, + {"name":"u64-add-overflow","bytesHex":"31383434363734343037333730393535313631367d","limit":"18446744073709551615","expected":{"kind":"Overflow","atByte":19}}, + {"name":"u64-multiply-overflow","bytesHex":"39393939393939393939393939393939393939397d","limit":"18446744073709551615","expected":{"kind":"Overflow","atByte":19}}, + {"name":"leading-zero","bytesHex":"30302c","limit":"255","expected":{"kind":"Invalid","atByte":1}}, + {"name":"zero-followed-by-digit","bytesHex":"30317d","limit":"18446744073709551615","expected":{"kind":"Invalid","atByte":1}}, + {"name":"negative","bytesHex":"2d315d","limit":"255","expected":{"kind":"Invalid","atByte":0}}, + {"name":"plus-sign","bytesHex":"2b315d","limit":"255","expected":{"kind":"Invalid","atByte":0}}, + {"name":"fraction","bytesHex":"312e305d","limit":"255","expected":{"kind":"Invalid","atByte":1}}, + {"name":"exponent","bytesHex":"3165325d","limit":"255","expected":{"kind":"Invalid","atByte":1}}, + {"name":"missing-number","bytesHex":"5d","limit":"255","expected":{"kind":"Invalid","atByte":0}}, + {"name":"raw-non-ascii","bytesHex":"ff5d","limit":"255","expected":{"kind":"Invalid","atByte":0}}, + {"name":"quote-is-not-number-delimiter","bytesHex":"3122","limit":"255","expected":{"kind":"Invalid","atByte":1}}, + {"name":"space-terminator","bytesHex":"32353520","limit":"255","expected":{"kind":"End","value":"255","consumedDigits":3}}, + {"name":"tab-terminator","bytesHex":"3109","limit":"255","expected":{"kind":"End","value":"1","consumedDigits":1}}, + {"name":"carriage-return-terminator","bytesHex":"310d","limit":"255","expected":{"kind":"End","value":"1","consumedDigits":1}}, + {"name":"line-feed-terminator","bytesHex":"310a","limit":"255","expected":{"kind":"End","value":"1","consumedDigits":1}}, + {"name":"incomplete-nonzero","bytesHex":"3130","limit":"255","expected":{"kind":"More","state":"Digits","value":"10"}}, + {"name":"incomplete-zero","bytesHex":"30","limit":"255","expected":{"kind":"More","state":"Zero"}}, + {"name":"empty-stream","bytesHex":"","limit":"255","expected":{"kind":"Unstarted"}} + ], + "singleStepCases": [ + {"name":"empty-token","state":"Start","tokenHex":"","limit":"255","expected":{"kind":"Invalid"}}, + {"name":"invalid-zero-digits-state","state":{"Digits":"0"},"tokenHex":"2c","limit":"255","expected":{"kind":"Invalid"}}, + {"name":"over-limit-state","state":{"Digits":"256"},"tokenHex":"2c","limit":"255","expected":{"kind":"Overflow"}} + ] +} diff --git a/edict/replace-range-probes/buffer-decoder/control/edict.application.json b/edict/replace-range-probes/buffer-decoder/control/edict.application.json new file mode 100644 index 00000000..9bad89fb --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/control/edict.application.json @@ -0,0 +1,20 @@ +{ + "schema": "edict.application/v1", + "coordinate": "jedit.text.replace_range@1", + "sources": [ + "src/ReplaceRange.edict" + ], + "lawpacks": [ + { + "manifest": "vendor/atom-read/manifest.cbor", + "exports": "vendor/atom-read/exports.cbor", + "adapter": "vendor/atom-read/adapter.cbor", + "targetConfiguration": "vendor/atom-read/echo-operation-configuration.cbor" + } + ], + "target": { + "profile": "echo.dpo@1", + "providerPackage": ".build/echo-provider" + }, + "outputDirectory": ".build/application" +} diff --git a/edict/replace-range-probes/buffer-decoder/control/src/ReplaceRange.edict b/edict/replace-range-probes/buffer-decoder/control/src/ReplaceRange.edict new file mode 100644 index 00000000..1031dfc9 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/control/src/ReplaceRange.edict @@ -0,0 +1,18 @@ +package jedit.text.replace_range@1; +use lawpack jedit.text@1 digest "sha256:2ea164293719d2b03231c4904eb75ddcdf55fd29cc31f4fc5a5319d9ae5e60e7" as text; +type Input = { address: text.FactAddress, expected: text.FactBytes }; +intent replaceRange(input: Input) returns text.FactBytes + profile text.replaceRange + basis input.address.nodeId + budget <= text.replaceRangeBudget +{ + let actual: text.FactBytes = text.readFact(input.address) + else { + missing(address) => text.FactMissing, + typeMismatch(address) => text.FactMalformed, + notAtom(address) => text.FactMalformed, + tooLarge(address) => text.FactMalformed, + }; + require actual == input.expected else text.BasisNotCanonical; + return actual; +} diff --git a/edict/replace-range-probes/buffer-decoder/control/vendor/.atom-read.edict-lawpack-build.lock b/edict/replace-range-probes/buffer-decoder/control/vendor/.atom-read.edict-lawpack-build.lock new file mode 100644 index 00000000..e69de29b diff --git a/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/adapter.cbor b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/adapter.cbor new file mode 100644 index 0000000000000000000000000000000000000000..5353b5838225fc99d71948932abe4570b1fc170c GIT binary patch literal 928 zcmc(dv2N5r5QfbgP?8iRqJhRnL4p=8Cn81SlmOBx9UAYB?Y*pb_I77;z6K>!)YLQw z2Q{ML0YKsvcmf(4UV*g@7)2mNMP>V+-@D&GGp|r+@cvk~PY0|{u*`!jk^QRKnxRyj zF*bZ>Cv#{u2z&sh#NE#FvZ|qZ$Y}j$axqCv{5lA11Me;wqjs7k^QeuqCIO7HmoFqq zG6Soo=)5A+T#AB&Ho=8{HQ~Y@_Yh{8!E` O!m#XnKivOe#@_%+i*7;y literal 0 HcmV?d00001 diff --git a/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/adapter.sha256 b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/adapter.sha256 new file mode 100644 index 00000000..fe16ec8c --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/adapter.sha256 @@ -0,0 +1 @@ +sha256:bcb72bfbc93276506d8a9175263ca1742d78d5125cd3fdc49e0da7f474473c85 diff --git a/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/echo-operation-configuration.cbor b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/echo-operation-configuration.cbor new file mode 100644 index 0000000000000000000000000000000000000000..4b130f9554afbcb14a3f4813839e20cf3d01331d GIT binary patch literal 130 zcmXYqF%AMT3FT6A(W@v~(2oCN?=kVn@ye!hd)uk)T@bXr%c}8Ty$3>+*1i z!WXj2Dt$v?(ybOUn8)`?Ut}!N2bCMg_QSj9{!vV$K|ZlyUkA;F6PX_rTOjmTZGvNM QG=`r3x#N4Lx^fHWz6JX*-2eap literal 0 HcmV?d00001 diff --git a/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/echo-operation-configuration.sha256 b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/echo-operation-configuration.sha256 new file mode 100644 index 00000000..8b8e8c0b --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/echo-operation-configuration.sha256 @@ -0,0 +1 @@ +sha256:56921f7058a4b68027c3e5415150b2c6ef4388b000c2ea649cd7a14d3f565f7e diff --git a/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/edict.lawpack-output.json b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/edict.lawpack-output.json new file mode 100644 index 00000000..2f0be4de --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/edict.lawpack-output.json @@ -0,0 +1,67 @@ +{ + "schema": "edict.lawpack-output/v1", + "lawpackId": "jedit.text", + "lawpackVersion": "1", + "artifacts": [ + { + "path": "manifest.cbor", + "kind": "manifest", + "coordinate": "edict.lawpack/v1", + "digest": "sha256:2ea164293719d2b03231c4904eb75ddcdf55fd29cc31f4fc5a5319d9ae5e60e7" + }, + { + "path": "manifest.sha256", + "kind": "manifestDigest", + "coordinate": "edict.lawpack/v1", + "digest": "sha256:2ea164293719d2b03231c4904eb75ddcdf55fd29cc31f4fc5a5319d9ae5e60e7" + }, + { + "path": "exports.cbor", + "kind": "exports", + "coordinate": "jedit.text.exports/v1", + "digest": "sha256:ba805443d67297ea5cbe9775049a461eafda46af27aeb4a5712d2c6289b62f21" + }, + { + "path": "exports.sha256", + "kind": "exportsDigest", + "coordinate": "jedit.text.exports/v1", + "digest": "sha256:ba805443d67297ea5cbe9775049a461eafda46af27aeb4a5712d2c6289b62f21" + }, + { + "path": "echo-operation-configuration.cbor", + "kind": "localResource", + "coordinate": "echo.operation-lowering-configuration/v1", + "digest": "sha256:56921f7058a4b68027c3e5415150b2c6ef4388b000c2ea649cd7a14d3f565f7e" + }, + { + "path": "echo-operation-configuration.sha256", + "kind": "localResourceDigest", + "coordinate": "echo.operation-lowering-configuration/v1", + "digest": "sha256:56921f7058a4b68027c3e5415150b2c6ef4388b000c2ea649cd7a14d3f565f7e" + }, + { + "path": "verifier-rules.cbor", + "kind": "localResource", + "coordinate": "jedit.text.verifier-rules/v1", + "digest": "sha256:364fb4ff98ae64fcd8d793aae3d7cb133ff8a1ce661330cea47688b13a0a823f" + }, + { + "path": "verifier-rules.sha256", + "kind": "localResourceDigest", + "coordinate": "jedit.text.verifier-rules/v1", + "digest": "sha256:364fb4ff98ae64fcd8d793aae3d7cb133ff8a1ce661330cea47688b13a0a823f" + }, + { + "path": "adapter.cbor", + "kind": "adapter", + "coordinate": "jedit.text.echo-adapter/v1", + "digest": "sha256:bcb72bfbc93276506d8a9175263ca1742d78d5125cd3fdc49e0da7f474473c85" + }, + { + "path": "adapter.sha256", + "kind": "adapterDigest", + "coordinate": "jedit.text.echo-adapter/v1", + "digest": "sha256:bcb72bfbc93276506d8a9175263ca1742d78d5125cd3fdc49e0da7f474473c85" + } + ] +} diff --git a/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/exports.cbor b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/exports.cbor new file mode 100644 index 00000000..c8a2eebc --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/exports.cbor @@ -0,0 +1 @@ +¦etypesƒ¢jcoordinatexjedit.text@1.FactAddressjdefinitionxLRecord,typeId:Bytes,warpId:Bytes>¢jcoordinatevjedit.text@1.FactBytesjdefinitionrBytes¢jcoordinatexjedit.text@1.ObstructionDetailjdefinitionx"StringgeffectsªiinputTypexjedit.text@1.FactAddressjcoordinateujedit.text@1.readFactjoutputTypevjedit.text@1.FactByteslguardSupportõncostObligationxjedit.text@1.replaceRangeBudgetneffectFailures¤gmissing¢kpayloadTypexjedit.text@1.FactAddressnauthorityClassmresourceFaultgnotAtom¢kpayloadTypexjedit.text@1.FactAddressnauthorityClassnintegrityFaulthtooLarge¢kpayloadTypexjedit.text@1.FactAddressnauthorityClassnintegrityFaultltypeMismatch¢kpayloadTypexjedit.text@1.FactAddressnauthorityClassnintegrityFaultneffectKindHintdreadnexecutionClassgruntimentypeParameters€sfootprintObligationx"jedit.text@1.replaceRangeFootprinticonstants€lobstructionsƒ£jcoordinatexjedit.text@1.BasisNotCanonicalmpayloadSchemaxjedit.text@1.ObstructionDetailnauthorityClassndomainMappable£jcoordinatexjedit.text@1.FactMissingmpayloadSchemaxjedit.text@1.ObstructionDetailnauthorityClassmresourceFault£jcoordinatexjedit.text@1.FactMalformedmpayloadSchemaxjedit.text@1.ObstructionDetailnauthorityClassnintegrityFaultmpureFunctions€qoperationProfiles¡xjedit.text@1.replaceRange¢mopticTemplate¦iopticKindsaffectReintegrationlboundaryKindfaffectmbasisTemplatexjedit.text@1.exactHeadBasismsupportPolicyxjedit.text@1.basisBoundSupportolossDispositionujedit.text@1.losslesssapertureRequirement¢crefx"jedit.text@1.replaceRangeFootprintdkindxabstractFootprintObligationoeffectPredicatex jedit.text@1.replaceRangeEffects \ No newline at end of file diff --git a/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/exports.sha256 b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/exports.sha256 new file mode 100644 index 00000000..9a176821 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/exports.sha256 @@ -0,0 +1 @@ +sha256:ba805443d67297ea5cbe9775049a461eafda46af27aeb4a5712d2c6289b62f21 diff --git a/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/manifest.cbor b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/manifest.cbor new file mode 100644 index 00000000..40a95127 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/manifest.cbor @@ -0,0 +1,2 @@ +ªbidjjedit.textgexports¢bidujedit.text.exports/v1fdigest‚fsha256X º€TCÖr—ê\¾—ušF¯ÚF¯'®´¥q-,b‰¶/!gversiona1hverifier¢eclasskdeclarativegruleset¢bidxjedit.text.verifier-rules/v1fdigest‚fsha256X 6O´ÿ˜®düØדªã×Ë?ø¡Îf0Τvˆ±: +‚?japiVersionpedict.lawpack/v1ldependencies€mcompatibility¢bidxjedit.text.compatibility/v1fdigest‚fsha256X *߃÷˜ _RcjÖL¤Qxó:ŽÆc‡OŠaHL”^0RntargetAdapters£gadapter¢bidxjedit.text.echo-adapter/v1fdigest‚fsha256X ¼·+ûÉ2vPmŠ‘u&<¡t-xÕ\ÓýÄž §ôtG<…pacceptedTargetIr¢bidoecho.span-ir/v2fdigest‚fsha256X >€]Åè1è‹ïìLÔžÀ,9…‹o9ÚŠsµ `†®9uacceptedTargetProfile¢bidjecho.dpo@1fdigest‚fsha256X .$”ìõæ¢Ù õû…@ˆ%Ó”v_­AHLAc—É ûoacceptedCoreAbimedict.core/v1xconformanceFixtureCorpus¢bidx jedit.text.ReplaceRange.oracle@1fdigest‚fsha256X ¹´p}Õàx—Ëç¯6؉(@‡æ¯]}ˆ¨ÖM» \ No newline at end of file diff --git a/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/manifest.sha256 b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/manifest.sha256 new file mode 100644 index 00000000..bc42c481 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/manifest.sha256 @@ -0,0 +1 @@ +sha256:2ea164293719d2b03231c4904eb75ddcdf55fd29cc31f4fc5a5319d9ae5e60e7 diff --git a/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/verifier-rules.cbor b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/verifier-rules.cbor new file mode 100644 index 00000000..ef8836e5 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/verifier-rules.cbor @@ -0,0 +1 @@ +¤fschemasjedit.text.schema@1lschemaDigestxGsha256:f49b0ff6c9c7010d3a72b46734d47832853f496739a083edc41dddec3431bac7oruntimeOntologyugeneric-bounded-graphworacleIsExecutableInputô \ No newline at end of file diff --git a/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/verifier-rules.sha256 b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/verifier-rules.sha256 new file mode 100644 index 00000000..f8f7a387 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/control/vendor/atom-read/verifier-rules.sha256 @@ -0,0 +1 @@ +sha256:364fb4ff98ae64fcd8d793aae3d7cb133ff8a1ce661330cea47688b13a0a823f diff --git a/edict/replace-range-probes/buffer-decoder/evidence/compiler-source.json b/edict/replace-range-probes/buffer-decoder/evidence/compiler-source.json new file mode 100644 index 00000000..e39610bf --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/compiler-source.json @@ -0,0 +1,1802 @@ +{ + "commit": "17397e2aad18a83ffc617d1afd628764501f49cd", + "tree": "bcfd3112cd8b3d4630738a88761860679b45714b", + "files": [ + { + "path": ".cargo/config.toml", + "gitBlob": "5592118f6c54bf8b53b16848e04ece896dd56384" + }, + { + "path": ".github/workflows/auto-release-tag.yml", + "gitBlob": "87404ceb685191afd496c93494b0bc61e2a59504" + }, + { + "path": ".github/workflows/ci.yml", + "gitBlob": "c6c6a17f59b6b96db88e3d4b2775bc64b7fe01f3" + }, + { + "path": ".github/workflows/release.yml", + "gitBlob": "2c612fc786998bfa5b11e76ae1185114a7cc535f" + }, + { + "path": ".gitignore", + "gitBlob": "30d7faf0fc8b7f010f99280302d4ed269d5da9ba" + }, + { + "path": ".markdownlint.json", + "gitBlob": "f3ec2c8dc2fbacc425154a2baedec50c7474aefa" + }, + { + "path": "AGENTS.md", + "gitBlob": "0c48a5794454cf84e20640994a372316efde7bb5" + }, + { + "path": "ARCHITECTURE.md", + "gitBlob": "5b513dd25028092e7e75c8974f1d5f3cc31889ed" + }, + { + "path": "CHANGELOG.md", + "gitBlob": "cd40892f0f2ed2e5667c65e274f9a1ead1619990" + }, + { + "path": "CODE_OF_CONDUCT.md", + "gitBlob": "784cf2799bcf8d2a69db5f5781359ef7e18a05fc" + }, + { + "path": "CONTRIBUTING.md", + "gitBlob": "9676914060f734dc59eabd9075898dc8170d4d19" + }, + { + "path": "Cargo.lock", + "gitBlob": "bacb208de0583f182379af7b5e078d31b25e2ca5" + }, + { + "path": "Cargo.toml", + "gitBlob": "b2e7106eb78f79230c091492ef21b497bdc9ed19" + }, + { + "path": "EDICT.md", + "gitBlob": "35376134195082d506f0161ba7ecb97efa8b770a" + }, + { + "path": "LICENSE", + "gitBlob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "NOTICE", + "gitBlob": "c300687bdd9d931d1f257d291e1cb6ff9d7d3607" + }, + { + "path": "README.md", + "gitBlob": "0812ef9a0c4611bf655dfc67d2ecc3631af9a536" + }, + { + "path": "ROADMAP.md", + "gitBlob": "d0e0135780537afab1d1a3f53808b363b35a63f4" + }, + { + "path": "SECURITY.md", + "gitBlob": "0bcc4e7375442e1334405a2d046df316cee05cd5" + }, + { + "path": "crates/edict-cli/Cargo.toml", + "gitBlob": "e9d844553c395bd312f84e806eb5bac30c5c3a54" + }, + { + "path": "crates/edict-cli/src/application_build.rs", + "gitBlob": "9c56ae6b4dd4eef0b9fe6db40316e100b2ffa699" + }, + { + "path": "crates/edict-cli/src/lawpack_build.rs", + "gitBlob": "55e9579153f34a3d5b139141c9de6640808cd386" + }, + { + "path": "crates/edict-cli/src/lawpack_build_windows.rs", + "gitBlob": "f71d03b368ae83becc1608bbba11cd5f1afa4f07" + }, + { + "path": "crates/edict-cli/src/lib.rs", + "gitBlob": "60883af60cf4b441680952ecce7ef4fcbfeabb97" + }, + { + "path": "crates/edict-cli/src/main.rs", + "gitBlob": "0dd9776642c4090479322111e4164ee7049fb9d0" + }, + { + "path": "crates/edict-cli/tests/golden_cli.rs", + "gitBlob": "9897caad3bcc6fa8bb0f20a1d0e18032285b1fa7" + }, + { + "path": "crates/edict-cli/tests/jsonl_cli.rs", + "gitBlob": "9ed353ca27d073fc7da49d3800c81ba4c58edd5d" + }, + { + "path": "crates/edict-cli/tests/lawpack_authoring_cli.rs", + "gitBlob": "0a0c53baaedd0854d0c25bc591cb38db9c2c009b" + }, + { + "path": "crates/edict-provider-host-wasmtime/Cargo.toml", + "gitBlob": "ebeeb941f09012293d9923fe0e6039b2761b328e" + }, + { + "path": "crates/edict-provider-host-wasmtime/src/conversion.rs", + "gitBlob": "62c3cd4a85eb156b8c9a405ef3ea4d8a09b80cc3" + }, + { + "path": "crates/edict-provider-host-wasmtime/src/invocation.rs", + "gitBlob": "a4d6680d289094afebc0f1063abccf706f8149db" + }, + { + "path": "crates/edict-provider-host-wasmtime/src/lib.rs", + "gitBlob": "353ea7394f265219ebdecad56a3070c9e7d2685c" + }, + { + "path": "crates/edict-provider-host-wasmtime/src/limits.rs", + "gitBlob": "9e4d12c1b606d2b180f732db17bfbc78f8e26e3a" + }, + { + "path": "crates/edict-provider-host-wasmtime/src/replay.rs", + "gitBlob": "b8fa7be7c7ee5039793dad4cd0fa6a4f14ce388e" + }, + { + "path": "crates/edict-provider-host-wasmtime/tests/invocation.rs", + "gitBlob": "7a59a3192852a80bc01221ebf3dd1c437bda9508" + }, + { + "path": "crates/edict-provider-host-wasmtime/tests/preflight.rs", + "gitBlob": "a295e7547b0294f0355a85d5b9b8d045c8fceefd" + }, + { + "path": "crates/edict-provider-schema/Cargo.toml", + "gitBlob": "0e74f58acdc054ecce192cb8341afeaddc40deb5" + }, + { + "path": "crates/edict-provider-schema/src/contract_pack.rs", + "gitBlob": "370480d9c606134dd08ee62ae29ef143941e2f54" + }, + { + "path": "crates/edict-provider-schema/src/lib.rs", + "gitBlob": "51f5bee8892c9fb2122cb20022edc4d414759ff7" + }, + { + "path": "crates/edict-provider-schema/src/recursive_dispatch.rs", + "gitBlob": "6d97565b96f941b359d16f7a1c201189968fbeff" + }, + { + "path": "crates/edict-provider-schema/src/schema_safety.rs", + "gitBlob": "a2f605f62a2bfedcb84b68e37db9ff84b1dc3b05" + }, + { + "path": "crates/edict-provider-schema/tests/authority_facts_abi.rs", + "gitBlob": "7dd4d0302805ceecffc2045cdb91e386f8e08517" + }, + { + "path": "crates/edict-provider-schema/tests/provider_contract_pack.rs", + "gitBlob": "a26be8054b39215048825dd8cae7e9bddcfe27c9" + }, + { + "path": "crates/edict-provider-schema/tests/registry.rs", + "gitBlob": "bdd13ec00e441aef9e67ba49f6592ecbc7dcb303" + }, + { + "path": "crates/edict-syntax/Cargo.toml", + "gitBlob": "f55bb23e528af78b1e97b52f9b72cbd876a44ba7" + }, + { + "path": "crates/edict-syntax/src/admission.rs", + "gitBlob": "471430dd13a617bac886fcd44afbf15263e7db3b" + }, + { + "path": "crates/edict-syntax/src/ast.rs", + "gitBlob": "2a5d208a53a82408f8a18d9a13ccb133ec6a7a2e" + }, + { + "path": "crates/edict-syntax/src/authority_facts.rs", + "gitBlob": "644de86d63983bdbfbf1279fdbf1dbdaecc151d5" + }, + { + "path": "crates/edict-syntax/src/canonical.rs", + "gitBlob": "6fb29d50ea4a55eb888a1b9600cdcb31713a6e20" + }, + { + "path": "crates/edict-syntax/src/compiler.rs", + "gitBlob": "d9661e2605f23f503a8fdf4471462cc0b9bad4c1" + }, + { + "path": "crates/edict-syntax/src/compiler/byte_concat.rs", + "gitBlob": "185d11c0ae20931cd2737774a34cac92b13d6712" + }, + { + "path": "crates/edict-syntax/src/compiler/byte_length.rs", + "gitBlob": "0d8d6291064415baee9253d9fe1e11ad87945773" + }, + { + "path": "crates/edict-syntax/src/compiler/byte_slice.rs", + "gitBlob": "84385fffdf4e38e21285e1fde252e9185a3a76fa" + }, + { + "path": "crates/edict-syntax/src/compiler/unsigned_subtraction.rs", + "gitBlob": "c2ef2deda74afb52e4346076a310df341556e1c8" + }, + { + "path": "crates/edict-syntax/src/contract_bundle.rs", + "gitBlob": "9a31645f0e30879d019787e29c21c82eebf58129" + }, + { + "path": "crates/edict-syntax/src/core_ir.rs", + "gitBlob": "4c6f350b325d13a27947687dd1f4114edf6d548d" + }, + { + "path": "crates/edict-syntax/src/highlight.rs", + "gitBlob": "28b3f7dcdfe8d4982bdcfb05759f769ccdbffc7f" + }, + { + "path": "crates/edict-syntax/src/lawpack.rs", + "gitBlob": "54f85bda48c960ad0b7bc316d332b379ab5b6ae0" + }, + { + "path": "crates/edict-syntax/src/lawpack_adapter.rs", + "gitBlob": "e425960e2437faa2f9eeb5d089ff507417d39586" + }, + { + "path": "crates/edict-syntax/src/lawpack_authoring.rs", + "gitBlob": "11ff578f458b8a4c8e4df75c0c616e37fa468d49" + }, + { + "path": "crates/edict-syntax/src/lib.rs", + "gitBlob": "7323475cc7f846e11c2d73f4c26a5e581b7e6157" + }, + { + "path": "crates/edict-syntax/src/lowerability.rs", + "gitBlob": "c6a1323fd6a79b0460b43aaf338956c3906a633e" + }, + { + "path": "crates/edict-syntax/src/parser.rs", + "gitBlob": "0b3650e3012e49023ccbb9cc9effe9b5b102f19d" + }, + { + "path": "crates/edict-syntax/src/provider.rs", + "gitBlob": "18fa661d880979c53dd335fb7e68d5445b638d4c" + }, + { + "path": "crates/edict-syntax/src/provider_invocation.rs", + "gitBlob": "2526168f0a6f2d1d9b6181b689ff43e203434122" + }, + { + "path": "crates/edict-syntax/src/provider_lowering.rs", + "gitBlob": "50a4e60b561127cb8c78e3f7c04c6bbaca068e52" + }, + { + "path": "crates/edict-syntax/src/result_projection.rs", + "gitBlob": "79ba246d4c58960fe368eaca4c7d135fe187832a" + }, + { + "path": "crates/edict-syntax/src/semantic.rs", + "gitBlob": "76bd133ef5859bf7722d1987613f7fd84836ab62" + }, + { + "path": "crates/edict-syntax/src/target_ir.rs", + "gitBlob": "9dd759a18ea3a171837baa50e88c67987c84da13" + }, + { + "path": "crates/edict-syntax/src/target_ir/byte_concat.rs", + "gitBlob": "bff3a35e1d3183813ffb1e69655934f65f2c9131" + }, + { + "path": "crates/edict-syntax/src/target_ir/byte_length.rs", + "gitBlob": "972e6ffa943bc7a7a943d76f0af42b342e3d2aac" + }, + { + "path": "crates/edict-syntax/src/target_ir/byte_slice.rs", + "gitBlob": "62a1c0b9e84a331bb17ab78090cce6d8eb8da486" + }, + { + "path": "crates/edict-syntax/src/target_ir/execution_order.rs", + "gitBlob": "e69a28805dc5e414a64afdaafee34161c217a044" + }, + { + "path": "crates/edict-syntax/src/target_ir/totality.rs", + "gitBlob": "a4fb9573d59e1a4bb9d7c250402c5b7e1da0a8c3" + }, + { + "path": "crates/edict-syntax/src/target_ir/unsigned_subtraction.rs", + "gitBlob": "b83522bfe9a2b506413b4d306f4bc49f8b053f36" + }, + { + "path": "crates/edict-syntax/src/target_profile.rs", + "gitBlob": "dd514f7380243e795f0655a78aecd06ee3fa2eda" + }, + { + "path": "crates/edict-syntax/src/target_profile_contract_resources.rs", + "gitBlob": "4efd22961c2fd7591440efd6087944ecaf21e991" + }, + { + "path": "crates/edict-syntax/src/token.rs", + "gitBlob": "2768586eea6d42d5df357c4cc62a011ee7f455de" + }, + { + "path": "crates/edict-syntax/tests/admission.rs", + "gitBlob": "57edbc320307c1d6daba85f03d8dc79558d7b849" + }, + { + "path": "crates/edict-syntax/tests/authority_facts.rs", + "gitBlob": "add9d272be6e8eb1cd6fdde2999a5fb452ecd852" + }, + { + "path": "crates/edict-syntax/tests/authority_facts_cbor.rs", + "gitBlob": "7359f047d9f731fee208efb5f69072b612d69547" + }, + { + "path": "crates/edict-syntax/tests/byte_concat.rs", + "gitBlob": "f013cade690112b266dd79b1e5405cc65c6f2d07" + }, + { + "path": "crates/edict-syntax/tests/byte_length.rs", + "gitBlob": "50945944e8c2223abcc6b1081322432bc540c017" + }, + { + "path": "crates/edict-syntax/tests/byte_slice.rs", + "gitBlob": "99aae98ac1637a95532cdd833463210bbaa5a5be" + }, + { + "path": "crates/edict-syntax/tests/canonical_encoding.rs", + "gitBlob": "e4c5d59a88f88193f522eb555359919f7034a264" + }, + { + "path": "crates/edict-syntax/tests/common/mod.rs", + "gitBlob": "89560bfacb3dab031485c2dfa30d7eb325966574" + }, + { + "path": "crates/edict-syntax/tests/compiler_spine.rs", + "gitBlob": "2237318cfc0d4209e8a629e45320e42a4b72dbef" + }, + { + "path": "crates/edict-syntax/tests/contract_bundle.rs", + "gitBlob": "e6a2948335a0efc86d8bbb2e9e2c3d634e53965a" + }, + { + "path": "crates/edict-syntax/tests/core_golden_fixtures.rs", + "gitBlob": "0e0e42d19b52dc0557902dad9e1b85f37edf53f8" + }, + { + "path": "crates/edict-syntax/tests/core_graph_depth.rs", + "gitBlob": "1d95462ad2426d29b5974e6bb56ab8c125a92837" + }, + { + "path": "crates/edict-syntax/tests/external_action_requests.rs", + "gitBlob": "20aac8c03325ea0cdab8f4f54660cb980b4667c4" + }, + { + "path": "crates/edict-syntax/tests/highlighting.rs", + "gitBlob": "17e6b9ba08c96f0efb6efd440590f0fc917316e2" + }, + { + "path": "crates/edict-syntax/tests/lawpack.rs", + "gitBlob": "a675999ed96309358c8552a9d32781b5eede20dc" + }, + { + "path": "crates/edict-syntax/tests/lawpack_authoring.rs", + "gitBlob": "de5e9102d8cfd43706074e482d407ac5f4c6fd26" + }, + { + "path": "crates/edict-syntax/tests/lowerability.rs", + "gitBlob": "5cfa58f5cbc51cccc7f119caddc1c3fcbc2e4806" + }, + { + "path": "crates/edict-syntax/tests/operation_prerequisites.rs", + "gitBlob": "753659e1a6e7751c455b8518226fa0902157a745" + }, + { + "path": "crates/edict-syntax/tests/parse_control_flow.rs", + "gitBlob": "5245561866d8902c1fbd5ab21f2e34807d568e17" + }, + { + "path": "crates/edict-syntax/tests/parse_greeting.rs", + "gitBlob": "f214d0c17745b8203d562780caa8f37b71c1e62c" + }, + { + "path": "crates/edict-syntax/tests/parse_hello.rs", + "gitBlob": "bf7b1b065277188f4be8754eb11ace94298394ba" + }, + { + "path": "crates/edict-syntax/tests/parse_keywords.rs", + "gitBlob": "78d8a64d785136d42a32655afda3df240c54f884" + }, + { + "path": "crates/edict-syntax/tests/parse_loops.rs", + "gitBlob": "d9ece2fce96fd6835d080055f06955d139c7e0ce" + }, + { + "path": "crates/edict-syntax/tests/parse_negative.rs", + "gitBlob": "17fdb983b8250470368a8f19d3a7bd9680052548" + }, + { + "path": "crates/edict-syntax/tests/parse_review_regressions.rs", + "gitBlob": "560215cfe044a528e190aa1ea7670e52b9365bdf" + }, + { + "path": "crates/edict-syntax/tests/parse_variants.rs", + "gitBlob": "8849f68f5ca1e2b06d0f66496e59b20d1c0fd022" + }, + { + "path": "crates/edict-syntax/tests/provider.rs", + "gitBlob": "7e8a596109b1e1fd3f22b3a0ef82f4755f127291" + }, + { + "path": "crates/edict-syntax/tests/provider_invocation.rs", + "gitBlob": "402647dd6701be65a9e693fd3f5688f26d84988e" + }, + { + "path": "crates/edict-syntax/tests/provider_lowering.rs", + "gitBlob": "411c306f3ab641de9dc2f7aed229767eba9dbd72" + }, + { + "path": "crates/edict-syntax/tests/result_projection.rs", + "gitBlob": "a74dd2a419266cb77d846d83da27f726095660f1" + }, + { + "path": "crates/edict-syntax/tests/semantic_validation.rs", + "gitBlob": "a127988d178c00ed12a0a25f70df6b7fd5e6d931" + }, + { + "path": "crates/edict-syntax/tests/target_ir.rs", + "gitBlob": "928e1cf921dead0b559bd115bb6eef3faaddd37e" + }, + { + "path": "crates/edict-syntax/tests/target_ir/ordered.rs", + "gitBlob": "a1b05db81a97a43ec5a2dc2d9bcc9578bc286f30" + }, + { + "path": "crates/edict-syntax/tests/target_profile.rs", + "gitBlob": "42f1c907f6c60dea1e8a9b4558b56ffd0b3a59ab" + }, + { + "path": "crates/edict-syntax/tests/target_profile_contract_resources.rs", + "gitBlob": "270c180a12dc10fb7e208cc4dc1e202da82c85fb" + }, + { + "path": "crates/edict-syntax/tests/target_unsigned_subtraction.rs", + "gitBlob": "e30d91f896afda48eb3cf11617bccf1f9d160e32" + }, + { + "path": "crates/edict-syntax/tests/unsigned_subtraction.rs", + "gitBlob": "fbd24482fdad4c8ceb4df41302b33595ada337ec" + }, + { + "path": "crates/edict/Cargo.toml", + "gitBlob": "525403f4f36db4040531e4dd747ec2398f9052cd" + }, + { + "path": "crates/edict/README.md", + "gitBlob": "a1ecf50bff3443d25a23fabfa6374d3f0a28ca82" + }, + { + "path": "crates/edict/src/lib.rs", + "gitBlob": "169d820759d6333f27a45ebb712bfcc4f0115107" + }, + { + "path": "crates/edict/tests/artifact_models.rs", + "gitBlob": "b923109c7195ce2c0071dc54179f0746b95329f0" + }, + { + "path": "crates/edict/tests/public_surface.rs", + "gitBlob": "a24c4bc9d9484f540da9b280790896701922968a" + }, + { + "path": "deny.toml", + "gitBlob": "e3f0f54060cead9a0d48b96ed86948d0909c4f78" + }, + { + "path": "docs/DESIGN_runtime-neutral-edict-sha-lock-assurance.md", + "gitBlob": "ea3badf78ebd19545147a93671fdb5f9af4a61ea" + }, + { + "path": "docs/GUIDE_edict-assurance-transparency.md", + "gitBlob": "100321157ec43055c45794f1c161b1e5281ba6b4" + }, + { + "path": "docs/README.md", + "gitBlob": "e21739b842be14d91a17f2508b1a1b629754af01" + }, + { + "path": "docs/REQUIREMENTS.md", + "gitBlob": "fd69cf5b3f57af39cda8bcf7f94ff21666a34636" + }, + { + "path": "docs/RETRO_phase1-parser.md", + "gitBlob": "5cfb7b85ca2f140fc58f9186c47e4635e94a1e6f" + }, + { + "path": "docs/SPEC_continuum-admission-v1.md", + "gitBlob": "0a74a0bfc642337d5d7a85133ce50a0a22caffbd" + }, + { + "path": "docs/SPEC_continuum-contract-bundle-v1.md", + "gitBlob": "65b36bb33a34beb1f246d1f97384631c83ca631e" + }, + { + "path": "docs/SPEC_edict-language-v1.md", + "gitBlob": "dd3f1584b000678a12232b76836172e4e66be71b" + }, + { + "path": "docs/SPEC_edict-lawpack-abi-v1.md", + "gitBlob": "ea1d801f07ab3677f7a411a1f58a28feda589ec3" + }, + { + "path": "docs/SPEC_edict-target-profile-abi-v1.md", + "gitBlob": "91687bfe45565a21f5f93f6ce9eed84095268691" + }, + { + "path": "docs/TECHNICAL_EXPLANATION.md", + "gitBlob": "d88561c0552c0e75d1ecc2eef6f9afd003e99674" + }, + { + "path": "docs/abi/edict-authority-facts.cddl", + "gitBlob": "e9a6d8685706ae0d8dabda401655234161e94299" + }, + { + "path": "docs/abi/edict-common.cddl", + "gitBlob": "836c11b92425beb6d42b378c0defe6f02d144dd7" + }, + { + "path": "docs/abi/edict-core.cddl", + "gitBlob": "862f02939fcc3858b4a60cb75f9bf149eae8ffda" + }, + { + "path": "docs/abi/edict-lawpack-adapter.cddl", + "gitBlob": "8e887c2e196ba7502470ddb45dc7cfd10116ad6b" + }, + { + "path": "docs/abi/edict-lawpack.cddl", + "gitBlob": "96efd51d437ec785b108b51835e9e8bf87aeab51" + }, + { + "path": "docs/abi/edict-result-projection.cddl", + "gitBlob": "98b5c2e861e7e9b66b7481502287cb041f6e77e6" + }, + { + "path": "docs/abi/edict-target-ir.cddl", + "gitBlob": "98134f277ded1920a3a36e5e3946c51153f2e84d" + }, + { + "path": "docs/abi/edict-target-profile.cddl", + "gitBlob": "746ae03001310f3a83524e5332819dad1a4eea5a" + }, + { + "path": "docs/abi/edict-target-provider.wit", + "gitBlob": "0efa5903a52d38dc61e429619d86322c6c5f1fa0" + }, + { + "path": "docs/audit/2026-06-28_code-quality.md", + "gitBlob": "143cbf4f4491a76a6649e919c6edaba73f0bcf4b" + }, + { + "path": "docs/audit/2026-06-28_documentation-quality.md", + "gitBlob": "656b4fa8dea43306af1818f8622cafd72e82a370" + }, + { + "path": "docs/audit/2026-06-28_ship-readiness.md", + "gitBlob": "b9d34a8693564d0134f550092e7645e5d5137442" + }, + { + "path": "docs/design/authority-fact-governance.md", + "gitBlob": "8531061cf718c47ec791f5712b2f357d92adc9e4" + }, + { + "path": "docs/design/canonical-target-ir-v0.11.md", + "gitBlob": "a46acb84e3523b51e2348c776cfdb63a8b98107a" + }, + { + "path": "docs/design/contract-bundle-assembly-v0.11.md", + "gitBlob": "a364f8ade5445808f87cf0c63ab3484c03ad616a" + }, + { + "path": "docs/design/crate-scope-v0.11.md", + "gitBlob": "92fe92285d02465d84bbe82e29d051fdc461f3a6" + }, + { + "path": "docs/design/obstruction-strands-v0.md", + "gitBlob": "81f70fd688c12798cd23472a4e810191e61eabe2" + }, + { + "path": "docs/design/provider-artifact-pipeline-alpha.md", + "gitBlob": "60eefa7dc160aba986bcd1188b79610ff5e9f299" + }, + { + "path": "docs/design/schema-as-sot-codegen.md", + "gitBlob": "d818e0e3f1fafd1d3aba26cb37c739f3ebe69763" + }, + { + "path": "docs/design/v2-obligation-closure.md", + "gitBlob": "816d22d843a33c6f7e143da4cb45e80679609dc8" + }, + { + "path": "docs/releases/v0.1.0-alpha.1.md", + "gitBlob": "5dd96057ba7f109cf5e5acde16e29d18627f98d3" + }, + { + "path": "docs/releases/v0.10.0-alpha.1.md", + "gitBlob": "363c4e9ed6f5ea5758198c7124681b520098e583" + }, + { + "path": "docs/releases/v0.11.0-alpha.1.md", + "gitBlob": "4612dbb5a1aaf20710bdb199b658ded7ced4ebab" + }, + { + "path": "docs/releases/v0.2.0-alpha.1.md", + "gitBlob": "7302ef93ed5ff9b562d9cec92d49d85a6b789b27" + }, + { + "path": "docs/releases/v0.3.0-alpha.1.md", + "gitBlob": "bf023ba4ca2c38f0120c461781447d58fe239ae0" + }, + { + "path": "docs/releases/v0.4.0-alpha.1.md", + "gitBlob": "769500b59800c02c536b76b0eb850d06d6cd8f58" + }, + { + "path": "docs/releases/v0.5.0-alpha.1.md", + "gitBlob": "7c7354e89846ea816992aaf55d4ad04367d61a10" + }, + { + "path": "docs/releases/v0.6.0-alpha.1.md", + "gitBlob": "3f2a0edfc4bccd9f3c60a7443ef4f8cbcbac1971" + }, + { + "path": "docs/releases/v0.7.0-alpha.1.md", + "gitBlob": "57671d5ef5a6b9f16d1674e0a35ddeb86ff126a8" + }, + { + "path": "docs/releases/v0.8.0-alpha.1.md", + "gitBlob": "12f77bda185c54fbbd136bf0dc7292716ecdfa39" + }, + { + "path": "docs/releases/v0.9.0-alpha.1.md", + "gitBlob": "fa295fcf0967415bb052f238256919b32b3fe6ba" + }, + { + "path": "docs/schemas/edict.cli-check-result.v1.schema.json", + "gitBlob": "eef8cd11f07e06d68b7051efa60ae05f2cfd8a63" + }, + { + "path": "docs/schemas/edict.cli-diagnostic.v1.schema.json", + "gitBlob": "92a2151a76893c598a4191ed6cecd8a0e671613f" + }, + { + "path": "docs/schemas/edict.cli-event.v1.schema.json", + "gitBlob": "705d82a893c2ea91caa91ad6977a9be8646b47bb" + }, + { + "path": "docs/schemas/edict.cli-info.v1.schema.json", + "gitBlob": "2d9a0777b4190b56ff569625275d352d17363afa" + }, + { + "path": "docs/schemas/edict.compiler-input.v1.schema.json", + "gitBlob": "26da3ba0fe85fab4c826ad79f13968ce09c4f29b" + }, + { + "path": "docs/schemas/edict.compiler-settings.v1.schema.json", + "gitBlob": "a3e8ba469895b84ab81724da1075c73141a8dd0c" + }, + { + "path": "docs/schemas/edict.projection-core.v1.schema.json", + "gitBlob": "8c0afe3834256abd1e18efb5f31eae1c4bdf0374" + }, + { + "path": "docs/schemas/edict.projection-diagnostics.v1.schema.json", + "gitBlob": "28cfb0a67dff7b8f879122c74433158dc0a4e5df" + }, + { + "path": "docs/schemas/edict.projection-syntax.v1.schema.json", + "gitBlob": "a85f2e14f536863f5e7b107b1a9f3f10816e6234" + }, + { + "path": "docs/schemas/edict.projection-target-ir.v1.schema.json", + "gitBlob": "8bbb6495ad8800d775d1c08506e85351038d678a" + }, + { + "path": "docs/topics/README.md", + "gitBlob": "99b06d3124c71cb62dfe6faff7604c13063162a7" + }, + { + "path": "docs/topics/admission/README.md", + "gitBlob": "755dcba96c0a428eec18d58a529f3e26d57d118c" + }, + { + "path": "docs/topics/admission/test-plan.md", + "gitBlob": "68ee0a2d2502103285985bf862de9fadf2bac5a0" + }, + { + "path": "docs/topics/assurance/README.md", + "gitBlob": "cf382008f3d3094a5380a687abbf07538e07404d" + }, + { + "path": "docs/topics/assurance/test-plan.md", + "gitBlob": "0ea6c971924db763088577a0a52bbd30bfec814c" + }, + { + "path": "docs/topics/authority-facts/README.md", + "gitBlob": "c5589d2489d6e4a5729c0df2b2655ff281d8d88d" + }, + { + "path": "docs/topics/authority-facts/test-plan.md", + "gitBlob": "e3769edf8309347b23ffa2e8f0901e06feabd654" + }, + { + "path": "docs/topics/cli/README.md", + "gitBlob": "af38946c9ccae8da343877c3861b0f52b6076e1b" + }, + { + "path": "docs/topics/cli/test-plan.md", + "gitBlob": "d72d69ef1d340ffd7057a63dd7bc07e3dfb2c166" + }, + { + "path": "docs/topics/compiler-spine/README.md", + "gitBlob": "d09184ef695252b85d05fc79017015f18c3869ee" + }, + { + "path": "docs/topics/compiler-spine/test-plan.md", + "gitBlob": "1b2aaa924d95408bf0ef621d7a1a92b88a00611e" + }, + { + "path": "docs/topics/contract-bundles/README.md", + "gitBlob": "2347499e8da9dd57bb1588faf67fe386c7a70c03" + }, + { + "path": "docs/topics/contract-bundles/test-plan.md", + "gitBlob": "3ae4c7362f90fa89081ab9ff2bf1c3db1a811874" + }, + { + "path": "docs/topics/core-ir/README.md", + "gitBlob": "d747a18d1f53de2b29473ada7a06b819c77cd162" + }, + { + "path": "docs/topics/core-ir/canonical-encoding.md", + "gitBlob": "34927c69fb1de10b685294a155fc46bb4ac21628" + }, + { + "path": "docs/topics/core-ir/test-plan.md", + "gitBlob": "0f80304a4dd6b160c78674b73605bdbbb7e11066" + }, + { + "path": "docs/topics/developer-tooling/README.md", + "gitBlob": "8648d3c1bdf4f6b774bc5fec71c71aa8c59b0ce8" + }, + { + "path": "docs/topics/developer-tooling/test-plan.md", + "gitBlob": "9240f717434dfbca08a6366e6d3ebafd4ef2c908" + }, + { + "path": "docs/topics/documentation/README.md", + "gitBlob": "34fa7f4db136c274a88b680f99619d657fda15d5" + }, + { + "path": "docs/topics/documentation/test-plan.md", + "gitBlob": "47964954fbf640211bc30b0dd361c44c9955c488" + }, + { + "path": "docs/topics/external-action-requests/README.md", + "gitBlob": "45bc73e469919d3eff6e7eddbe9baa0383c7d91b" + }, + { + "path": "docs/topics/external-action-requests/test-plan.md", + "gitBlob": "38e7e53827d223c031d414f4ecd63720eb78eae0" + }, + { + "path": "docs/topics/fixtures/README.md", + "gitBlob": "c8b3b196109fb6d4e37d8ffa17635166010075fb" + }, + { + "path": "docs/topics/fixtures/test-plan.md", + "gitBlob": "624357dbc544d365835390d3d3c2f11015b7b82f" + }, + { + "path": "docs/topics/lawpack-authoring/README.md", + "gitBlob": "a7f781666822977d4ca2483024e1e451605cf9f5" + }, + { + "path": "docs/topics/lawpack-authoring/test-plan.md", + "gitBlob": "1cc83e6b0865257feb89a88787b1eb3b983d1f84" + }, + { + "path": "docs/topics/lawpacks/README.md", + "gitBlob": "dedaa524dc55663a44bf8101241ab4b6d4755531" + }, + { + "path": "docs/topics/lawpacks/test-plan.md", + "gitBlob": "f8aa2c7ce40dad2665134956dc95d951d311808f" + }, + { + "path": "docs/topics/lowerability/README.md", + "gitBlob": "fb9519af3539d846dc5bf2915bf5ca86816e46f8" + }, + { + "path": "docs/topics/lowerability/test-plan.md", + "gitBlob": "e0fbff0799ba805c9531097d6b8aeea657e2b815" + }, + { + "path": "docs/topics/obstruction-strands/README.md", + "gitBlob": "a2930645065390cecff8008bfd48b7f034bfcd18" + }, + { + "path": "docs/topics/obstruction-strands/test-plan.md", + "gitBlob": "20c54ffcaa19930a5bc772a49a5f01119054be2d" + }, + { + "path": "docs/topics/providers/README.md", + "gitBlob": "8b5a07fb9c708b753861a4e156b866115f4d687b" + }, + { + "path": "docs/topics/providers/architecture.md", + "gitBlob": "664b38347ccaf37f298d6ac9f19d3423c0277f9e" + }, + { + "path": "docs/topics/providers/test-plan.md", + "gitBlob": "95c55f9e132ca6859fd9df70470973e678ed8d92" + }, + { + "path": "docs/topics/public-rust-api/README.md", + "gitBlob": "c64a1081b7f693b02bd2ea63329f2610bae9d84c" + }, + { + "path": "docs/topics/public-rust-api/test-plan.md", + "gitBlob": "4c3b9e9662afd9edb790ba2b5c57ed5e93df595c" + }, + { + "path": "docs/topics/release-process/README.md", + "gitBlob": "a474ab8b6a4a58c5c73334c9e677be7c20d1837c" + }, + { + "path": "docs/topics/release-process/policy.toml", + "gitBlob": "e40b4f4ec721ae61210ec1bb022a847bcb49fb4a" + }, + { + "path": "docs/topics/release-process/runbook.md", + "gitBlob": "0b6bd8ef44cbfe8c7cdc347273fa74b7c96c4823" + }, + { + "path": "docs/topics/release-process/test-plan.md", + "gitBlob": "61ecded1d2318d7dd74070cd1c6155f353c947e9" + }, + { + "path": "docs/topics/result-projections/README.md", + "gitBlob": "d5c2f85a7681a15dcdc3e35f992a389c50d13461" + }, + { + "path": "docs/topics/result-projections/test-plan.md", + "gitBlob": "9e69d58c88d6a9b7389334a78b994a3449721faa" + }, + { + "path": "docs/topics/review-process/README.md", + "gitBlob": "25190d37dc30110f75ba5d3a41494575ffecc1c3" + }, + { + "path": "docs/topics/review-process/policy.toml", + "gitBlob": "a826ba58aad2e509220b65aa8f96c290b600e094" + }, + { + "path": "docs/topics/review-process/test-plan.md", + "gitBlob": "f1a50aeae47913e4513a8149c1679d9a94c5ef21" + }, + { + "path": "docs/topics/rust-standards/README.md", + "gitBlob": "2fe29258705d117f4d10604a83fd832a8476e303" + }, + { + "path": "docs/topics/rust-standards/test-plan.md", + "gitBlob": "0e0d6b306cd2b58db07a7a5da6a752925fe58764" + }, + { + "path": "docs/topics/semantic-validation/README.md", + "gitBlob": "51cd9761755e7b5879069bf3774eeb487982ca97" + }, + { + "path": "docs/topics/semantic-validation/test-plan.md", + "gitBlob": "b43969d8eb0a884c1663ab761662f9622617bb3b" + }, + { + "path": "docs/topics/syntax/README.md", + "gitBlob": "b2a372bf41b1976567c61f400bf000f33abc20cc" + }, + { + "path": "docs/topics/syntax/test-plan.md", + "gitBlob": "a69efaf12dfe12661fca049b8790b37fa3fb3665" + }, + { + "path": "docs/topics/target-ir/README.md", + "gitBlob": "73d6b50a99a6231bd0d337ded95bd2a960590328" + }, + { + "path": "docs/topics/target-ir/test-plan.md", + "gitBlob": "4ec0f497fc0c9e73599d602417acfbfe74e65ff0" + }, + { + "path": "docs/topics/target-profiles/README.md", + "gitBlob": "6a88f4d732f8069855b2ed2cb9a8769a117b2f60" + }, + { + "path": "docs/topics/target-profiles/test-plan.md", + "gitBlob": "90084c3f3a1296745469cd86e9b5f2bc928825be" + }, + { + "path": "docs/topics/tests/README.md", + "gitBlob": "4ad079b6a9718e2a8446a6c67ff45735015bef84" + }, + { + "path": "docs/topics/tests/test-plan.md", + "gitBlob": "46bc0572d02a41e86f71c6d46baf5be611a462a6" + }, + { + "path": "docs/topics/v2-design/README.md", + "gitBlob": "b33a07599e43e660aa4def7f119ddd02df6a16de" + }, + { + "path": "docs/topics/v2-design/test-plan.md", + "gitBlob": "f17f96d381f81b20842393f70ff55b9597858b84" + }, + { + "path": "editors/README.md", + "gitBlob": "7a933576262bc58bac197f9264fdbf649dd5e696" + }, + { + "path": "editors/vscode/.vscodeignore", + "gitBlob": "f15b3142e4b8af11d580789a0c82acee3499f571" + }, + { + "path": "editors/vscode/README.md", + "gitBlob": "8b29840ae9ec8f618b7364022329f694d0ed9746" + }, + { + "path": "editors/vscode/language-configuration.json", + "gitBlob": "b7f583841649c9c437785edbfcb70ee24e495c79" + }, + { + "path": "editors/vscode/package.json", + "gitBlob": "cd9e391e7c9afb6f9393fcead118e0e55aadc839" + }, + { + "path": "editors/vscode/syntaxes/edict.tmLanguage.json", + "gitBlob": "5847d8edfdb32d822f0f3950f41d00c947982185" + }, + { + "path": "fixtures/README.md", + "gitBlob": "470e3e0fc3aa00654930ecdef892ee9df8a42c8d" + }, + { + "path": "fixtures/authority-facts/canonical/README.md", + "gitBlob": "28692ce70add5d4f2d4ff5318309c3353924caf9" + }, + { + "path": "fixtures/authority-facts/canonical/example-effectful.authority-facts.cbor", + "gitBlob": "fe2e59a8e2602e02c52094010a130db2637c5227" + }, + { + "path": "fixtures/authority-facts/canonical/example-effectful.authority-facts.json", + "gitBlob": "009faa5d2dc1dcf55cf284dcfd14c0b6405f3e0d" + }, + { + "path": "fixtures/authority-facts/canonical/example-effectful.authority-facts.sha256", + "gitBlob": "a3d68f0a3b3a586e85b6a84cbd884866e662951f" + }, + { + "path": "fixtures/bundle/assembly/bounded-hello.bundle-digests.txt", + "gitBlob": "da5402db7bd41dd88c6152b7799723561130c91e" + }, + { + "path": "fixtures/cli/01-source-ok/expected.stdout.jsonl", + "gitBlob": "e08ccf8fdedd3a73beef5d06c443a1bc60274ce1" + }, + { + "path": "fixtures/cli/01-source-ok/request.jsonl", + "gitBlob": "002fea597e6b93c8468d6972b73cc1344600fa87" + }, + { + "path": "fixtures/cli/02-source-parse-rejection/exit", + "gitBlob": "d00491fd7e5bb6fa28c517a0bb32b8b506539d4d" + }, + { + "path": "fixtures/cli/02-source-parse-rejection/expected.stderr.jsonl", + "gitBlob": "1077b73c9a7c02eae99f737bea7b6ff8c64d04da" + }, + { + "path": "fixtures/cli/02-source-parse-rejection/request.jsonl", + "gitBlob": "dce01f0466bd9384fc6f5cbe2845b6e0bd9a9cfd" + }, + { + "path": "fixtures/cli/03-source-semantic-rejection/exit", + "gitBlob": "d00491fd7e5bb6fa28c517a0bb32b8b506539d4d" + }, + { + "path": "fixtures/cli/03-source-semantic-rejection/expected.stderr.jsonl", + "gitBlob": "5ec447700da52d0b4ce1f75825eb9bffaed4884b" + }, + { + "path": "fixtures/cli/03-source-semantic-rejection/request.jsonl", + "gitBlob": "ddfd529e5448760387961febbd4ce013e49de435" + }, + { + "path": "fixtures/cli/04-cli-missing-settings/exit", + "gitBlob": "0cfbf08886fca9a91cb753ec8734c84fcbe52c9f" + }, + { + "path": "fixtures/cli/04-cli-missing-settings/expected.stderr.jsonl", + "gitBlob": "5060bd2fd773ba9ea3ea6db8c80b86a846bfadbd" + }, + { + "path": "fixtures/cli/04-cli-missing-settings/request.jsonl", + "gitBlob": "8eb12e58d427bd64ccfe339190e05bdccf4c8634" + }, + { + "path": "fixtures/cli/05-path-input-ok/expected.stdout.jsonl", + "gitBlob": "a05fc582efc41b6414e785167b5deeb7532088ef" + }, + { + "path": "fixtures/cli/05-path-input-ok/inputs/hello.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/05-path-input-ok/request.jsonl", + "gitBlob": "18facaab79dc198134c535df389cba79efe7dce7" + }, + { + "path": "fixtures/cli/06-directory-expansion-ok/expected.stdout.jsonl", + "gitBlob": "ef59591526e2084ddf5057249bbc96ab660cf256" + }, + { + "path": "fixtures/cli/06-directory-expansion-ok/inputs/a.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/06-directory-expansion-ok/inputs/ignore.txt", + "gitBlob": "ed34ae8da336ff94a67b6125fbd6be730c976d91" + }, + { + "path": "fixtures/cli/06-directory-expansion-ok/inputs/nested/b.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/06-directory-expansion-ok/request.jsonl", + "gitBlob": "bd9aad14fe79caccacaa6d00ffd32b5e13b3551f" + }, + { + "path": "fixtures/cli/07-path-list-ok/expected.stdout.jsonl", + "gitBlob": "643ecb3e659c10cb98255ec1aced772778e76eb0" + }, + { + "path": "fixtures/cli/07-path-list-ok/inputs/first.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/07-path-list-ok/inputs/second.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/07-path-list-ok/request.jsonl", + "gitBlob": "f11265b02c5b7559ced4d975471a78b5bef3ee27" + }, + { + "path": "fixtures/cli/08-glob-expansion-ok/expected.stdout.jsonl", + "gitBlob": "90164a7fce6c51abdadef8f0586d2c56113d9712" + }, + { + "path": "fixtures/cli/08-glob-expansion-ok/inputs/x.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/08-glob-expansion-ok/inputs/y.edict", + "gitBlob": "39c53bb184a7c10de61da0c637b607eb1d7cc454" + }, + { + "path": "fixtures/cli/08-glob-expansion-ok/request.jsonl", + "gitBlob": "9335acf3a008ab8fb9942b3e22d73c456ed3827e" + }, + { + "path": "fixtures/cli/09-shape-source-ok/expected.stdout.jsonl", + "gitBlob": "ac6f9259502ebfe484e1c07a5f53865888dd8207" + }, + { + "path": "fixtures/cli/09-shape-source-ok/request.jsonl", + "gitBlob": "64c75d9a7b40985bacf0e59a943a16e20419c602" + }, + { + "path": "fixtures/cli/10-input-extra-field/exit", + "gitBlob": "0cfbf08886fca9a91cb753ec8734c84fcbe52c9f" + }, + { + "path": "fixtures/cli/10-input-extra-field/expected.stderr.jsonl", + "gitBlob": "2f5a8fba093b71d15a5b37504ad0352191c8299c" + }, + { + "path": "fixtures/cli/10-input-extra-field/request.jsonl", + "gitBlob": "6052212c652d41f03144a7d3d4018b1cdd18cd09" + }, + { + "path": "fixtures/cli/11-input-hybrid-kind/exit", + "gitBlob": "0cfbf08886fca9a91cb753ec8734c84fcbe52c9f" + }, + { + "path": "fixtures/cli/11-input-hybrid-kind/expected.stderr.jsonl", + "gitBlob": "7b6d2ac0c8afbf5e3991498846c2fc4847ac9453" + }, + { + "path": "fixtures/cli/11-input-hybrid-kind/request.jsonl", + "gitBlob": "b893b640aa6631c77f2a889a807afa31632ac2db" + }, + { + "path": "fixtures/cli/12-input-too-large/env.json", + "gitBlob": "ab0c7f13fc6b22d61fc73da2f1787ff3aa298ecb" + }, + { + "path": "fixtures/cli/12-input-too-large/exit", + "gitBlob": "0cfbf08886fca9a91cb753ec8734c84fcbe52c9f" + }, + { + "path": "fixtures/cli/12-input-too-large/expected.stderr.jsonl", + "gitBlob": "ebda022d79c978d4ff511579512be2c642e3e902" + }, + { + "path": "fixtures/cli/12-input-too-large/request.jsonl", + "gitBlob": "1e2fbb102503356bbcc627f49a5b58590859f170" + }, + { + "path": "fixtures/cli/13-input-root-outside/allowed/.gitkeep", + "gitBlob": "8b137891791fe96927ad78e64b0aad7bded08bdc" + }, + { + "path": "fixtures/cli/13-input-root-outside/exit", + "gitBlob": "0cfbf08886fca9a91cb753ec8734c84fcbe52c9f" + }, + { + "path": "fixtures/cli/13-input-root-outside/expected.stderr.jsonl", + "gitBlob": "9c5b8567a755c9ea2ee6e0168bf96f429185f675" + }, + { + "path": "fixtures/cli/13-input-root-outside/outside/outside.edict", + "gitBlob": "44abebc15811c38cc266007484dd74ae10a26a4d" + }, + { + "path": "fixtures/cli/13-input-root-outside/request.jsonl", + "gitBlob": "116dbbb4b1a80938bc042e41747872cb6da161cd" + }, + { + "path": "fixtures/cli/README.md", + "gitBlob": "9388df4182fedec41c353e85cf9210e88906fa3d" + }, + { + "path": "fixtures/core/canonical/README.md", + "gitBlob": "d9a0ca79557c3623c0b843d9eff4808f94fd7b18" + }, + { + "path": "fixtures/core/canonical/bounded-hello.core.cbor", + "gitBlob": "a0ec54aa1a5e20624192091526445cfd803e6f0c" + }, + { + "path": "fixtures/core/canonical/bounded-hello.core.sha256", + "gitBlob": "86ba062c26a3ad3fd733ccd8c80d7faa7ed62d94" + }, + { + "path": "fixtures/core/canonical/statement-branch.core.hex", + "gitBlob": "c22760cace0e4d146a2fdc8d7c7b50c38497622a" + }, + { + "path": "fixtures/core/canonical/statement-branch.core.sha256", + "gitBlob": "0b62657b192232390479319f0a1c8f601020a58f" + }, + { + "path": "fixtures/core/canonical/workspace-snapshot.core.cbor", + "gitBlob": "58e4f724610861f5b61537bf386a87062e8a57a7" + }, + { + "path": "fixtures/core/canonical/workspace-snapshot.core.sha256", + "gitBlob": "4bcb3e0813cd3f4a7afc7cf311d846f1dfdd0a9d" + }, + { + "path": "fixtures/core/schema/accepted/core-fn-body-minimal.fields", + "gitBlob": "bef3ca412ab0ea97465b8658499ae5e05e1ec760" + }, + { + "path": "fixtures/core/schema/accepted/core-intent-minimal.fields", + "gitBlob": "268b28ce942fed4f139aafe5c7cd50c15a0ee640" + }, + { + "path": "fixtures/core/schema/accepted/core-module-minimal.fields", + "gitBlob": "249ff76349f936c9a5ff6cb65d81de8e80d53de8" + }, + { + "path": "fixtures/core/schema/rejected/core-fn-body-effect-node-field.fields", + "gitBlob": "9af8fa3540b25ec810936bc4dc82e26f6dd0dd48" + }, + { + "path": "fixtures/core/schema/rejected/core-intent-unknown-verified-mode.fields", + "gitBlob": "667ae032ee117f32c1bcbafd21393e406621f517" + }, + { + "path": "fixtures/core/schema/rejected/core-module-missing-intents.fields", + "gitBlob": "17f37c7ac4c199de4eace7f31e6a59b9a6d3a0f6" + }, + { + "path": "fixtures/core/schema/rejected/local-ref-missing-alpha-name.fields", + "gitBlob": "456a89528ffe74d892be40c9c9be4a078ff5c18a" + }, + { + "path": "fixtures/lang/bounds/bounded-hello.edict", + "gitBlob": "e3443a1d3b1c8f0e137ac698b621dd2f3afb673b" + }, + { + "path": "fixtures/lang/effects/conditional-blob.edict", + "gitBlob": "1e4f2ca6112f26d57ee4d20058666ec7cd693b75" + }, + { + "path": "fixtures/lang/effects/read-greeting.edict", + "gitBlob": "5e3838d1547be171e0a0384a7a200f52a2b9d139" + }, + { + "path": "fixtures/lang/external-actions/workspace-snapshot.edict", + "gitBlob": "e54b0fbccad2fd680505f3ee46ca28d39d7e776e" + }, + { + "path": "fixtures/lang/operations/explicit-basis-u64.edict", + "gitBlob": "444d8ca77b9827746df81885f0620dce2d1a3b73" + }, + { + "path": "fixtures/lang/tooling/highlight-smoke.edict", + "gitBlob": "8c2d91084be22e5e1594a42159992aca95c73612" + }, + { + "path": "fixtures/lang/types/color-match.edict", + "gitBlob": "dd98d6de677904f36d7601165a0094d92928e536" + }, + { + "path": "fixtures/lawpack/causal-cell/README.md", + "gitBlob": "52e8cc1e2af8aea86c1090a1b20b5f5ab3e07c06" + }, + { + "path": "fixtures/lawpack/causal-cell/adapter.cbor", + "gitBlob": "3b0c8b1b3a8591a322b6e785d9f963899319310c" + }, + { + "path": "fixtures/lawpack/causal-cell/adapter.sha256", + "gitBlob": "f8231bc941e1fbe02279865a82e183cbeeb0988a" + }, + { + "path": "fixtures/lawpack/causal-cell/echo-operation-configuration.cbor", + "gitBlob": "24527d30d0146b567fda157561ac6a2587cae919" + }, + { + "path": "fixtures/lawpack/causal-cell/echo-operation-configuration.sha256", + "gitBlob": "d293c8a14b1955a3e171703400c4df620c7871a1" + }, + { + "path": "fixtures/lawpack/causal-cell/exports.cbor", + "gitBlob": "384f4839adfe8e5b0f1aa848bfe2aeb1c3f640b6" + }, + { + "path": "fixtures/lawpack/causal-cell/exports.sha256", + "gitBlob": "4f836f6b03497338a1f8eacc55480cbe1a3b49e9" + }, + { + "path": "fixtures/lawpack/causal-cell/manifest.cbor", + "gitBlob": "b9311a236d7898861a0b90b1f30b852b35cef623" + }, + { + "path": "fixtures/lawpack/causal-cell/manifest.sha256", + "gitBlob": "685fd6a6c72fc3100d595d009b6198a81c731a40" + }, + { + "path": "fixtures/lawpack/hello-echo/README.md", + "gitBlob": "79f6612f1f5608a8f7dc4835e5470878cd27f96e" + }, + { + "path": "fixtures/lawpack/hello-echo/adapter.cbor", + "gitBlob": "24e2f546e2b97747b53462a72faaa1d5d85d62f1" + }, + { + "path": "fixtures/lawpack/hello-echo/adapter.sha256", + "gitBlob": "91df491028061e026ecaaeb4e1598e2ac369af44" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.core.cbor", + "gitBlob": "246b6135855c415def0bd89b275f0457752ee563" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.core.sha256", + "gitBlob": "9adc71605e0a275349161809614bd17de97d129c" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.edict", + "gitBlob": "825d50565230bd71d62bfbeb59d0399a89864b4c" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.result-projection.cbor", + "gitBlob": "981cba6e1c7ab6bdae6829116749c4796167e4e6" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.result-projection.sha256", + "gitBlob": "d55e4083771e1d9791f59cf87fd5cc5f1ea3b9f4" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.target-ir.cbor", + "gitBlob": "c8a934cefec17dbab0a43d9be9cebd2533268798" + }, + { + "path": "fixtures/lawpack/hello-echo/create-greeting.target-ir.sha256", + "gitBlob": "20186cbe9482e8a7df7c44fabec13ffd4efbcf36" + }, + { + "path": "fixtures/lawpack/hello-echo/echo-operation-configuration.cbor", + "gitBlob": "84838ab0d8627237232fa5a9b9fa39087bcc5f8a" + }, + { + "path": "fixtures/lawpack/hello-echo/echo-operation-configuration.sha256", + "gitBlob": "0898688f14067560dd22abd04b97f020071fd3e8" + }, + { + "path": "fixtures/lawpack/hello-echo/exports.cbor", + "gitBlob": "0e1220ceed9442a7b35870eeb02fcb65454d8c5c" + }, + { + "path": "fixtures/lawpack/hello-echo/exports.sha256", + "gitBlob": "e1f3e9223de9ce935bc7f60dda3cfa7d12d54fdc" + }, + { + "path": "fixtures/lawpack/hello-echo/manifest.cbor", + "gitBlob": "d715900f03ec454a0ad96e6710f52a46120d0b9d" + }, + { + "path": "fixtures/lawpack/hello-echo/manifest.sha256", + "gitBlob": "20171199b401cecace2dd74e18f3cc1d5c7ed3de" + }, + { + "path": "fixtures/lawpack/workspace-patch/README.md", + "gitBlob": "67cd35f2e0660aa7455de1c197ad821d5438679b" + }, + { + "path": "fixtures/lawpack/workspace-patch/adapter.cbor", + "gitBlob": "2d6f09a7e2fab381b97a05cfad1e692902e878c3" + }, + { + "path": "fixtures/lawpack/workspace-patch/adapter.sha256", + "gitBlob": "d44eb9675e126716e8a5ef3c53fd39ade49d76fb" + }, + { + "path": "fixtures/lawpack/workspace-patch/apply-validated-patch.core.cbor", + "gitBlob": "6a88c127e426288a3e51d4749d5c31d5b0cb60cb" + }, + { + "path": "fixtures/lawpack/workspace-patch/apply-validated-patch.core.sha256", + "gitBlob": "0204b6f1d8b346a67800a7738ee39df49e78571f" + }, + { + "path": "fixtures/lawpack/workspace-patch/apply-validated-patch.edict", + "gitBlob": "6e11a3d022a53a8fb2c20a77e35e29840f5fe086" + }, + { + "path": "fixtures/lawpack/workspace-patch/apply-validated-patch.target-ir.cbor", + "gitBlob": "a6124a995a3cdbb5d39cd0a6e046b329048703aa" + }, + { + "path": "fixtures/lawpack/workspace-patch/apply-validated-patch.target-ir.sha256", + "gitBlob": "f7ac419ce15b32d491e09bddbe7c75f8227f51d8" + }, + { + "path": "fixtures/lawpack/workspace-patch/exports.cbor", + "gitBlob": "3a6fd19dc8059b9fe1bde74fb1da61398b0e80cc" + }, + { + "path": "fixtures/lawpack/workspace-patch/exports.sha256", + "gitBlob": "b301dd883a31fffe324e9306ec90ae2b1ec44520" + }, + { + "path": "fixtures/lawpack/workspace-patch/input-schema.cbor", + "gitBlob": "3045d9b696864fefe111c3eb641b3b68532752d2" + }, + { + "path": "fixtures/lawpack/workspace-patch/input-schema.sha256", + "gitBlob": "9f1284b4f0a2c7f6dbe1915a6113cd13a9700cb8" + }, + { + "path": "fixtures/lawpack/workspace-patch/manifest.cbor", + "gitBlob": "77e56c7525f0e64ab191f0adfeac12b540c87848" + }, + { + "path": "fixtures/lawpack/workspace-patch/manifest.sha256", + "gitBlob": "8316978e68565f29a30a6978d33d907710185857" + }, + { + "path": "fixtures/lawpack/workspace-patch/reconciliation-law.cbor", + "gitBlob": "0736b75f81913fca7ac95c56ec45f66b95aea4cf" + }, + { + "path": "fixtures/lawpack/workspace-patch/reconciliation-law.sha256", + "gitBlob": "de31fc9fda59fa3c29397e5fc48db224e8e1fee7" + }, + { + "path": "fixtures/lawpack/workspace-patch/request-profile-configuration.cbor", + "gitBlob": "5e2870b2f562bafaa73a91a3fc192f5ed39257c7" + }, + { + "path": "fixtures/lawpack/workspace-patch/request-profile-configuration.sha256", + "gitBlob": "4345ae2e39ce3f4d9cfa6b0dddf4ce56d56c035c" + }, + { + "path": "fixtures/lawpack/workspace-patch/settlement-schema.cbor", + "gitBlob": "0a93ac19c51b341602eeba524769147e962d5d60" + }, + { + "path": "fixtures/lawpack/workspace-patch/settlement-schema.sha256", + "gitBlob": "f1bb3fb0313dd6815b4184345194949ec40fe9e1" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/README.md", + "gitBlob": "996bd1d29b28769fff477084d9118d0833ca2970" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/adapter.cbor", + "gitBlob": "9be4ea568b602b56269af505deb809989a3fa8b5" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/adapter.sha256", + "gitBlob": "1e287be0a322e5444dea15fa14bcfc7cf12975c4" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/exports.cbor", + "gitBlob": "33fe04db74775c191d4b7400e1fb2b6393c5a010" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/exports.sha256", + "gitBlob": "e057cac7fc360e6599b7ddab88508aaf0f2f55f8" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/input-schema.cbor", + "gitBlob": "49c849169946e44c8b5f300279dd085bd6b63aeb" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/input-schema.sha256", + "gitBlob": "9dd7bb6e48192e90d19fc346d1705f736b1d85d7" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/manifest.cbor", + "gitBlob": "d4e58e3d4646ca967170a6882f2a617cb8d81390" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/manifest.sha256", + "gitBlob": "0edb311125a89a5816ee3fa0c9b700c9b3bcff3d" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/observe-workspace.core.cbor", + "gitBlob": "a4b249dfb197f1a6b4adc06855f16e4305a1c798" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/observe-workspace.core.sha256", + "gitBlob": "ea6b914d14907d9fd915058e579aff33c954da2c" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/observe-workspace.edict", + "gitBlob": "c2c10f1ef1009796d67061b9722c4db9bb4e031b" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/observe-workspace.target-ir.cbor", + "gitBlob": "bdab1b0c55a34360c7e9ab304af91fe2b1e4afce" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/observe-workspace.target-ir.sha256", + "gitBlob": "7342aaa96221d6c8efa75ead2af5563791ccfeff" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/reconciliation-law.cbor", + "gitBlob": "df55572b350002a3df98ccb3e72dd60c86b9aead" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/reconciliation-law.sha256", + "gitBlob": "957cd04c78c130b07d2cad2fd7e07ae69978be57" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/request-profile-configuration.cbor", + "gitBlob": "708f18918ee1703491a910df82e129e711a4cc46" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/request-profile-configuration.sha256", + "gitBlob": "d9953d9dcaa41c98387226d1980f40b24d2bc3cb" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/settlement-schema.cbor", + "gitBlob": "f01ad68531267666e6bf93bf30a37d5b311c1676" + }, + { + "path": "fixtures/lawpack/workspace-snapshot/settlement-schema.sha256", + "gitBlob": "06fcc0ee2b976a09b3017bd93132a3c51eb1317e" + }, + { + "path": "fixtures/obstruction-strands/v0/stale-basis/README.md", + "gitBlob": "25efbfa04e2e6104c5434f329128333e895e2b0a" + }, + { + "path": "fixtures/obstruction-strands/v0/stale-basis/source.edict", + "gitBlob": "e487b46e81220c50e6f928922dada29f3a21ca6a" + }, + { + "path": "fixtures/provider-contracts/v1/README.md", + "gitBlob": "447692907f9268ce3b6b78c43b7cbbb0417aeadf" + }, + { + "path": "fixtures/provider-contracts/v1/edict-provider-contracts.cddl", + "gitBlob": "07048aeeadb5062eabb89e995713cbc0893b7d7e" + }, + { + "path": "fixtures/provider-contracts/v1/manifest.json", + "gitBlob": "d2c8de5d61049e9f4182c630bf82b138f0f96792" + }, + { + "path": "fixtures/providers/README.md", + "gitBlob": "c26ee60a4930e3e0784c76cb855e48234a5c6b58" + }, + { + "path": "fixtures/providers/components/guests/Cargo.lock", + "gitBlob": "d7858ce7bc67deabb5ff352a24c85a7caa0ef4b0" + }, + { + "path": "fixtures/providers/components/guests/Cargo.toml", + "gitBlob": "450a24aed25dc73661b0ae8adfe2630dfecc9b07" + }, + { + "path": "fixtures/providers/components/guests/lowerer/Cargo.toml", + "gitBlob": "568aa137fa215b6b973fe31e12322530b393b9dc" + }, + { + "path": "fixtures/providers/components/guests/lowerer/src/lib.rs", + "gitBlob": "b39a8a0b18fe9ed7cb90277f793056434afa1318" + }, + { + "path": "fixtures/providers/components/guests/verifier/Cargo.toml", + "gitBlob": "f814f2c8c248bbf03389f5a0936f80cd4dada5b6" + }, + { + "path": "fixtures/providers/components/guests/verifier/src/lib.rs", + "gitBlob": "3f07ffdfd808ff95b206a2c08c2d481ccaf0e165" + }, + { + "path": "fixtures/providers/components/instantiation-failure-lowerer.component.wasm", + "gitBlob": "bd2d7c0d31798d7676aedab0bd0d289fc2053bef" + }, + { + "path": "fixtures/providers/components/instantiation-failure-lowerer.wat", + "gitBlob": "f6f5a70edb80d3a7fa1dee13b34ab5b8b44274d7" + }, + { + "path": "fixtures/providers/components/instantiation-fuel-lowerer.component.wasm", + "gitBlob": "0804d26d3ddb428682ca87ecad03cf0e05ef64af" + }, + { + "path": "fixtures/providers/components/instantiation-fuel-lowerer.wat", + "gitBlob": "80e972463ef593602d27c7d7cec78d87d22ff727" + }, + { + "path": "fixtures/providers/components/inventory.json", + "gitBlob": "45cf2e8e937a17a8ee05dfa8d68e94dcc155e129" + }, + { + "path": "fixtures/providers/components/lowerer.component.wasm", + "gitBlob": "6c1cf123a44284d15b7b1e90f1905ae94e65c158" + }, + { + "path": "fixtures/providers/components/malformed-lowerer.component.wasm", + "gitBlob": "be873af81100dc76ed1f3f1f818a41da45a38e4c" + }, + { + "path": "fixtures/providers/components/malformed-lowerer.wat", + "gitBlob": "1e7bfffe0a0baf230d9fb5766083f82198f4029c" + }, + { + "path": "fixtures/providers/components/verifier.component.wasm", + "gitBlob": "671adbe7931d0a9a5e0c78d459c244d37a135a69" + }, + { + "path": "fixtures/providers/echo-generated/provider-manifest.json", + "gitBlob": "22c8560e7ddecacd5da388e52d3935d7fc1474b9" + }, + { + "path": "fixtures/providers/echo-target-profile/README.md", + "gitBlob": "350c33dcda2d66d2d50e589c58db7c6d7b14a80b" + }, + { + "path": "fixtures/providers/echo-target-profile/generated/primary/target-profile.echo-dpo.cbor", + "gitBlob": "9fa43529b1021dfd8e3a33256c832d4eee6f4a47" + }, + { + "path": "fixtures/providers/wit/legacy-target-profile.wit", + "gitBlob": "ae7d6af764012b16bf06bfa260ccba98a7f04868" + }, + { + "path": "fixtures/target-ir/canonical/echo-effectful.target-ir.cbor", + "gitBlob": "727a80eb37319dbdbea40d7d9b4e37f0d93d8d84" + }, + { + "path": "fixtures/target-ir/canonical/echo-effectful.target-ir.sha256", + "gitBlob": "6d050bb46ac8981ea8e47c7a52371027b941fd89" + }, + { + "path": "fixtures/target-ir/canonical/gitwarp-append.target-ir.cbor", + "gitBlob": "89b46b138a7b90252a4397c0e8b622bceff10a33" + }, + { + "path": "fixtures/target-ir/canonical/gitwarp-append.target-ir.sha256", + "gitBlob": "a59a4ab9d46095d5be1797ed9e60fe841f821bce" + }, + { + "path": "fixtures/target-ir/canonical/workspace-snapshot.target-ir.cbor", + "gitBlob": "1854eeb549b3719fa2b0114867dbece6db1819d4" + }, + { + "path": "fixtures/target-ir/canonical/workspace-snapshot.target-ir.sha256", + "gitBlob": "4d0e501323d415ef9e64c0a3d25bdd57dabfc998" + }, + { + "path": "fixtures/target-profile/contract-resources/README.md", + "gitBlob": "32dcab1dd9376a4eed2c73bb1b1a29255fe3ea05" + }, + { + "path": "fixtures/target-profile/contract-resources/canonical-cbor.cbor", + "gitBlob": "4a95ba3bd9dff190ca5ec9c83262bfa6254a91d3" + }, + { + "path": "fixtures/target-profile/contract-resources/canonical-cbor.sha256", + "gitBlob": "2168df5d4bf77ed2347139dd7c45fd808df8ec7e" + }, + { + "path": "fixtures/target-profile/contract-resources/determinism.cbor", + "gitBlob": "09cd11c36048939961408550763c04fad8241557" + }, + { + "path": "fixtures/target-profile/contract-resources/determinism.sha256", + "gitBlob": "5376d6bfe23bea659463a7e3c56ad1e8afd4095f" + }, + { + "path": "fixtures/target-profile/contract-resources/diagnostics.cbor", + "gitBlob": "c47fa05f463e0da745fbcdf8daf94d70e134eb8d" + }, + { + "path": "fixtures/target-profile/contract-resources/diagnostics.sha256", + "gitBlob": "69613ec4014f27b23245e23fbf7c9447566516b2" + }, + { + "path": "fixtures/target-profile/contract-resources/fuel.cbor", + "gitBlob": "b5a3484ec5b2bf7343c2fcedc67bcb2b63a37104" + }, + { + "path": "fixtures/target-profile/contract-resources/fuel.sha256", + "gitBlob": "6ec1c830358ee35bb12bd04cc1a6edf47fb20997" + }, + { + "path": "fixtures/target-profile/contract-resources/wasm-component.cbor", + "gitBlob": "6344996c283e0d1c332ea3ce597ad4593882a3c5" + }, + { + "path": "fixtures/target-profile/contract-resources/wasm-component.sha256", + "gitBlob": "24bf3e552e4216d8258d2b85c8878af46a176c52" + }, + { + "path": "grammars/textmate/README.md", + "gitBlob": "fc116a669725d4e965d658234d32d779955d5dc8" + }, + { + "path": "grammars/textmate/edict.tmLanguage.json", + "gitBlob": "5847d8edfdb32d822f0f3950f41d00c947982185" + }, + { + "path": "grammars/tree-sitter-edict/README.md", + "gitBlob": "e2992a839d6719f1461db78c4e3f33d2e5ab0c09" + }, + { + "path": "grammars/tree-sitter-edict/grammar.js", + "gitBlob": "a82f5b9d9b78525f17a59272543fdcddd7a0da40" + }, + { + "path": "grammars/tree-sitter-edict/queries/highlights.scm", + "gitBlob": "0f46530b36996d13449901aed4e376a126577cba" + }, + { + "path": "grammars/tree-sitter-edict/src/grammar.json", + "gitBlob": "55df730a06b83c9f622e3ec17845fc9897c7d8c0" + }, + { + "path": "grammars/tree-sitter-edict/src/node-types.json", + "gitBlob": "520f6c4f7b30cd6892dd60faf6d76f3fbaa6a5c7" + }, + { + "path": "grammars/tree-sitter-edict/src/parser.c", + "gitBlob": "81cc4713cb5e05f9aa8dac16da202a864faefee6" + }, + { + "path": "grammars/tree-sitter-edict/src/tree_sitter/alloc.h", + "gitBlob": "1abdd1201578605b8d05a3001f01ebc0d58826d9" + }, + { + "path": "grammars/tree-sitter-edict/src/tree_sitter/array.h", + "gitBlob": "56fc8cd470996ded64a5452be25e26dbd2aa682a" + }, + { + "path": "grammars/tree-sitter-edict/src/tree_sitter/parser.h", + "gitBlob": "858107deb9e4a1ffcd2ed5e6ffe98a5fcab3e1f6" + }, + { + "path": "grammars/tree-sitter-edict/test/corpus/current-subset.txt", + "gitBlob": "732c5eda8e1bf95eef799476296a6ee061eb58eb" + }, + { + "path": "grammars/tree-sitter-edict/tree-sitter.json", + "gitBlob": "97d3fdd498a3bef509c8615d98b9560b527c03cb" + }, + { + "path": "scripts/consumer-witnesses/README.md", + "gitBlob": "2b7d2b9d81f9598fd8df232b3a76bef106ff7ef2" + }, + { + "path": "scripts/consumer-witnesses/jedit-state-read.Dockerfile", + "gitBlob": "7462059be67686090d0097b24b9d14bfbbd4c6f7" + }, + { + "path": "scripts/consumer-witnesses/jedit-state-read.Dockerfile.dockerignore", + "gitBlob": "ee41b3ca0a68fd5eb20e1b777b4b368fd8b44e63" + }, + { + "path": "scripts/consumer-witnesses/jedit-state-read.py", + "gitBlob": "26db295d4eabfc4e57813fc9bf17314c23350777" + }, + { + "path": "scripts/consumer-witnesses/run-jedit-state-read.sh", + "gitBlob": "18cd72bbbdfb17a5ea30a7821d47035071556d10" + }, + { + "path": "spec.lock.json", + "gitBlob": "ef8b02386e0f269a99c1d2121764f70b76e67620" + }, + { + "path": "xtask/Cargo.toml", + "gitBlob": "795c70a5172363bfcd55174b1bc76c9c131d21a3" + }, + { + "path": "xtask/src/contract_check.rs", + "gitBlob": "9e80393accf79936033972fde0f2aa2cf40f1be3" + }, + { + "path": "xtask/src/goldens.rs", + "gitBlob": "713f1f8266d9f6993684ae86db105fcd7d69ee2a" + }, + { + "path": "xtask/src/lawpack_goldens.rs", + "gitBlob": "c499e8581c73313794b83c261937144b3917850a" + }, + { + "path": "xtask/src/main.rs", + "gitBlob": "6c2c06038bb5ecdde60620071b200d8191dc116c" + }, + { + "path": "xtask/src/provider_components.rs", + "gitBlob": "ee9d6a1028f9fbfad879faab4b15a94b996ef6d4" + }, + { + "path": "xtask/src/provider_contract_pack.rs", + "gitBlob": "cf60d89892b7a57cc33300f273d2522a6e8f43f9" + }, + { + "path": "xtask/src/provider_dependencies.rs", + "gitBlob": "c4b0539ed593d2a2777d294090d2a891b13ae628" + }, + { + "path": "xtask/src/release_dates.rs", + "gitBlob": "1c6d7acb872f6d820eab3a30ca580e9c5cfba2ee" + }, + { + "path": "xtask/src/release_prep.rs", + "gitBlob": "01ed64ccbb28c9d1e908b7b800ff58076e5e1a2b" + }, + { + "path": "xtask/src/tests.rs", + "gitBlob": "9a3f6543c2dbae31d53e93d56f781e5d54f74f41" + }, + { + "path": "xtask/src/util.rs", + "gitBlob": "c1bf39e93460c43ffdcfd9a76e0424750cbb9dfd" + } + ] +} diff --git a/edict/replace-range-probes/buffer-decoder/evidence/original/decimal/ReplaceRange.edict b/edict/replace-range-probes/buffer-decoder/evidence/original/decimal/ReplaceRange.edict new file mode 100644 index 00000000..3927ed0e --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/original/decimal/ReplaceRange.edict @@ -0,0 +1,93 @@ +package jedit.text.replace_range@1; +use lawpack jedit.text@1 digest "sha256:2ea164293719d2b03231c4904eb75ddcdf55fd29cc31f4fc5a5319d9ae5e60e7" as text; + +// Jim's JSON boundary codec. These are internal scanner values, not intent inputs. +// A later bounded scanner must obtain each token from the retained Buffer atom. +type JsonByte = Bytes; +type DecimalState = variant { Start, Zero, Digits(U64) }; +type DecimalStep = variant { More(DecimalState), End(U64), Invalid, Overflow }; +type DecimalDigit = variant { Digit(U64), NotDigit }; + +// An End result leaves the delimiter unconsumed for the enclosing JSON scanner. +// Whitespace terminates a number; canonical-byte policy belongs to that scanner. +fn isNumberDelimiter(token: JsonByte) -> Bool { + return token == b"," || token == b"]" || token == b"}" + || token == b" " || token == b"\t" || token == b"\r" || token == b"\n"; +} + +fn decimalDigit(token: JsonByte) -> DecimalDigit { + return if token == b"0" then DecimalDigit::Digit(0u64) + else if token == b"1" then DecimalDigit::Digit(1u64) + else if token == b"2" then DecimalDigit::Digit(2u64) + else if token == b"3" then DecimalDigit::Digit(3u64) + else if token == b"4" then DecimalDigit::Digit(4u64) + else if token == b"5" then DecimalDigit::Digit(5u64) + else if token == b"6" then DecimalDigit::Digit(6u64) + else if token == b"7" then DecimalDigit::Digit(7u64) + else if token == b"8" then DecimalDigit::Digit(8u64) + else if token == b"9" then DecimalDigit::Digit(9u64) + else DecimalDigit::NotDigit; +} + +fn appendScaled(scaled: U64, digit: U64, limit: U64) -> DecimalStep { + let sum = checkedAdd(scaled, digit); + return if isSome(sum) then + if unwrap(sum) <= limit then DecimalStep::More(DecimalState::Digits(unwrap(sum))) + else DecimalStep::Overflow + else DecimalStep::Overflow; +} + +fn appendDigit(value: U64, digit: U64, limit: U64) -> DecimalStep { + let decimalRadix = 10u64; + let product = checkedMul(value, decimalRadix); + return if isSome(product) then appendScaled(unwrap(product), digit, limit) + else DecimalStep::Overflow; +} + +fn startDecimal(token: JsonByte, limit: U64) -> DecimalStep { + return match decimalDigit(token) { + Digit(value) => if value > limit then DecimalStep::Overflow + else if value == 0u64 then DecimalStep::More(DecimalState::Zero) + else DecimalStep::More(DecimalState::Digits(value)), + NotDigit => DecimalStep::Invalid, + }; +} + +fn continueDecimal(value: U64, token: JsonByte, limit: U64) -> DecimalStep { + return if value == 0u64 then DecimalStep::Invalid + else if value > limit then DecimalStep::Overflow + else match decimalDigit(token) { + Digit(digit) => appendDigit(value, digit, limit), + NotDigit => if isNumberDelimiter(token) then DecimalStep::End(value) + else DecimalStep::Invalid, + }; +} + +// canonical_head_id members use limit 255; version uses 18446744073709551615. +// The enclosing scanner owns these schema limits and starts at Start. +// Empty token, sign, leading zero, fraction, exponent and non-ASCII byte refuse. +fn stepJsonUnsigned(state: DecimalState, token: JsonByte, limit: U64) -> DecimalStep { + return match state { + Start => startDecimal(token, limit), + Zero => if isNumberDelimiter(token) then DecimalStep::End(0u64) + else DecimalStep::Invalid, + Digits(value) => continueDecimal(value, token, limit), + }; +} + +type Input = { address: text.FactAddress, expected: text.FactBytes }; +intent replaceRange(input: Input) returns text.FactBytes + profile text.replaceRange + basis input.address.nodeId + budget <= text.replaceRangeBudget +{ + let actual: text.FactBytes = text.readFact(input.address) + else { + missing(address) => text.FactMissing, + typeMismatch(address) => text.FactMalformed, + notAtom(address) => text.FactMalformed, + tooLarge(address) => text.FactMalformed, + }; + require actual == input.expected else text.BasisNotCanonical; + return actual; +} diff --git a/edict/replace-range-probes/buffer-decoder/evidence/original/decimal/stderr.jsonl b/edict/replace-range-probes/buffer-decoder/evidence/original/decimal/stderr.jsonl new file mode 100644 index 00000000..a4cb8dfc --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/original/decimal/stderr.jsonl @@ -0,0 +1,2 @@ +{"command":"build","input":{"kind":"stdin"},"kind":"InvalidApplicationSource","message":"Edict source `/tmp/echo-726-runtime/jim-buffer-decoder-results/decimal/src/ReplaceRange.edict` did not parse: ParseError { kind: Lex, message: \"invalid string escape\", span: Span { start: 861, end: 862 } }","schema":"edict.cli.diagnostic/v1","severity":"error","stage":"cli","type":"diagnostic"} +{"checked":0,"command":"build","errors":1,"exitCode":2,"schema":"edict.cli.event/v1","status":"error","type":"status"} diff --git a/edict/replace-range-probes/buffer-decoder/evidence/original/decimal/stdout.jsonl b/edict/replace-range-probes/buffer-decoder/evidence/original/decimal/stdout.jsonl new file mode 100644 index 00000000..e69de29b diff --git a/edict/replace-range-probes/buffer-decoder/evidence/original/fn-control/ReplaceRange.edict b/edict/replace-range-probes/buffer-decoder/evidence/original/fn-control/ReplaceRange.edict new file mode 100644 index 00000000..fe87ae1b --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/original/fn-control/ReplaceRange.edict @@ -0,0 +1,20 @@ +package jedit.text.replace_range@1; +use lawpack jedit.text@1 digest "sha256:2ea164293719d2b03231c4904eb75ddcdf55fd29cc31f4fc5a5319d9ae5e60e7" as text; +fn retainFact(value: text.FactBytes) -> text.FactBytes { return value; } + +type Input = { address: text.FactAddress, expected: text.FactBytes }; +intent replaceRange(input: Input) returns text.FactBytes + profile text.replaceRange + basis input.address.nodeId + budget <= text.replaceRangeBudget +{ + let actual: text.FactBytes = text.readFact(input.address) + else { + missing(address) => text.FactMissing, + typeMismatch(address) => text.FactMalformed, + notAtom(address) => text.FactMalformed, + tooLarge(address) => text.FactMalformed, + }; + require actual == input.expected else text.BasisNotCanonical; + return actual; +} diff --git a/edict/replace-range-probes/buffer-decoder/evidence/original/fn-control/stderr.jsonl b/edict/replace-range-probes/buffer-decoder/evidence/original/fn-control/stderr.jsonl new file mode 100644 index 00000000..3ab04b49 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/original/fn-control/stderr.jsonl @@ -0,0 +1,2 @@ +{"command":"build","input":{"kind":"stdin"},"kind":"InvalidApplicationSource","message":"Edict source `/tmp/echo-726-runtime/jim-buffer-decoder-results/fn-control/src/ReplaceRange.edict` did not parse: ParseError { kind: ExpectedToken, message: \"expected `type`, `enum`, or `intent` declaration, found Ident(\\\"fn\\\")\", span: Span { start: 151, end: 153 } }","schema":"edict.cli.diagnostic/v1","severity":"error","stage":"cli","type":"diagnostic"} +{"checked":0,"command":"build","errors":1,"exitCode":2,"schema":"edict.cli.event/v1","status":"error","type":"status"} diff --git a/edict/replace-range-probes/buffer-decoder/evidence/original/fn-control/stdout.jsonl b/edict/replace-range-probes/buffer-decoder/evidence/original/fn-control/stdout.jsonl new file mode 100644 index 00000000..e69de29b diff --git a/edict/replace-range-probes/buffer-decoder/evidence/original/git-locks-receipt.jsonl b/edict/replace-range-probes/buffer-decoder/evidence/original/git-locks-receipt.jsonl new file mode 100644 index 00000000..0e22e065 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/original/git-locks-receipt.jsonl @@ -0,0 +1,5 @@ +{"event":"claimed","job":"B7E81F92-3E24-4EE9-936A-8A34AC6B0DFA","holder":"jim-edict-authoring","note":"Guarded exact17397 compiler build and actual Buffer decimal fn refusal with accepted atom-read control","claimed":1791167534,"expires":1791168434,"paths":["host/docker/echo-read-runtime/","host/heavy-work"],"record":"df6150b65a0fff4e49c96bcf7ca1679687da1ca7","acquisition":"1791167534-76497-3105025734"} +PRE {"build": 6792403497, "data": 2956552745, "logs": 9643305, "host_free": 715318206464, "vm_free": 679804174336} CONTRACT /private/tmp/echo-739-resume/jim-buffer-public.launch.json +POST {"build": 6451069687, "data": 2959639287, "logs": 9646863, "host_free": 715316690944, "vm_free": 679804174336} EXIT 1 +GUARD_EXIT 1 +{"event":"released","job":"B7E81F92-3E24-4EE9-936A-8A34AC6B0DFA","paths":2} diff --git a/edict/replace-range-probes/buffer-decoder/evidence/original/guard.launch.json b/edict/replace-range-probes/buffer-decoder/evidence/original/guard.launch.json new file mode 100644 index 00000000..f3648fa5 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/original/guard.launch.json @@ -0,0 +1,38 @@ +{ + "worker": "echo-read-runtime", + "image": "echo-read-runtime:red", + "lock": "/tmp/echo-validation-host.lock", + "inner_lock": "/tmp/echo-validation.lock", + "source": "/echo-audit", + "outputs": [ + "/lease-target", + "/usr/local/cargo", + "/tmp/echo-726-runtime", + "all container writable-layer paths", + "/dev/shm", + "/private/tmp/echo-739-resume/jim-buffer-public.log" + ], + "measurements": { + "build": 6792403497, + "data": 2956552745, + "logs": 9643305, + "host_free": 715318206464, + "vm_free": 679804174336 + }, + "build_limit": 21474836480, + "data_limit": 4294967296, + "log_limit": 134217728, + "cpus": 4.0, + "memory": 6442450944, + "logging": { + "Type": "json-file", + "Config": { + "max-file": "5", + "max-size": "20m" + } + }, + "timeout_seconds": 600, + "guard": "2-second fail-closed monitor; freeze owned process group across the entire size measurement, including cache du; pause container for snapshotter; accept an absent process group only after confirmed owned docker-exec completion; of aggregate writable layers, shared memory, host scratch and logs; no host binds or volumes", + "termination": "docker stop/kill owned worker and host docker-exec process group on monitoring failure or limit/timeout", + "command": "test ! -e /tmp/echo-726-runtime/jim-buffer-decoder-input\nmkdir /tmp/echo-726-runtime/jim-buffer-decoder-input\ntar -xf /tmp/echo-726-runtime/jim-buffer-decoder-input.tar -C /tmp/echo-726-runtime/jim-buffer-decoder-input\npython3 - <<'INNER'\nfrom pathlib import Path\nimport runpy,subprocess\nroot=Path('/tmp/echo-726-runtime/jim-buffer-decoder-input')\ncommon=runpy.run_path(str(root/'edict/replace-range-probes/leaf-slice/run.py'))\nprint(common['verify_compiler_source'](Path('/edict-207'),root/'compiler-source.json','17397e2aad18a83ffc617d1afd628764501f49cd'),flush=True)\nassert subprocess.check_output(['git','-C','/edict-207','rev-parse','HEAD'],text=True).strip()=='17397e2aad18a83ffc617d1afd628764501f49cd'\nassert not subprocess.check_output(['git','-C','/edict-207','status','--porcelain'],text=True).strip()\nINNER\ncd /edict-207\nexport CARGO_TARGET_DIR=/lease-target CARGO_INCREMENTAL=0 CARGO_BUILD_JOBS=4 CARGO_PROFILE_DEV_DEBUG=0 CARGO_PROFILE_TEST_DEBUG=0\ncargo +1.95.0 clean -p edict-cli -p edict-syntax\ncargo +1.95.0 build --locked -p edict-cli\nsha256sum /lease-target/debug/edict\npython3 /tmp/echo-726-runtime/jim-buffer-decoder-input/edict/replace-range-probes/buffer-decoder/run.py --compiler /lease-target/debug/edict --compiler-source /edict-207 --compiler-manifest /tmp/echo-726-runtime/jim-buffer-decoder-input/compiler-source.json --application-source /read-evidence/single --provider-package /read-provider --work-root /tmp/echo-726-runtime/jim-buffer-decoder-results\n" +} \ No newline at end of file diff --git a/edict/replace-range-probes/buffer-decoder/evidence/original/guard.log b/edict/replace-range-probes/buffer-decoder/evidence/original/guard.log new file mode 100644 index 00000000..2a0ac02c --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/original/guard.log @@ -0,0 +1,17 @@ +{'commit': '17397e2aad18a83ffc617d1afd628764501f49cd', 'tree': 'bcfd3112cd8b3d4630738a88761860679b45714b', 'fileCount': 449, 'manifestSha256': '625592ab9dd715349255bece0133378c64b3d4539fb50e437d116c2a4296f016'} + Removed 575 files, 474.9MiB total + Compiling edict-syntax v0.11.0-alpha.1 (/edict-207/crates/edict-syntax) + Compiling edict-provider-schema v0.11.0-alpha.1 (/edict-207/crates/edict-provider-schema) + Compiling edict-provider-host-wasmtime v0.11.0-alpha.1 (/edict-207/crates/edict-provider-host-wasmtime) + Compiling edict-cli v0.11.0-alpha.1 (/edict-207/crates/edict-cli) + Finished `dev` profile [unoptimized] target(s) in 6.08s +e2700698829b03f437c66425ed9878b002ef7a34ac183a39bac4eaf6a758cc6d /lease-target/debug/edict +{"artifactSha256": {"executable-operation-package.cbor": "afd931700018312d6c0d1e249871313d2c21c0ece1ae41d1f17f2be7af9e5284", "verification-report.cbor": "9114fdd983d456eb83f69969475f558b6e608be23520212a5db5f26bb095d04b"}, "artifacts": ["executable-operation-package.cbor", "verification-report.cbor"], "case": "read-control", "diagnostics": [], "exitCode": 0, "sourceSha256": "4ec3cbf32fd5d98987cbeeaff95d7c9c5ab734dac555e443aac52e8ab02bfbc5", "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61"} +{"artifactSha256": {}, "artifacts": [], "case": "fn-control", "diagnostics": [{"command": "build", "input": {"kind": "stdin"}, "kind": "InvalidApplicationSource", "message": "Edict source `/tmp/echo-726-runtime/jim-buffer-decoder-results/fn-control/src/ReplaceRange.edict` did not parse: ParseError { kind: ExpectedToken, message: \"expected `type`, `enum`, or `intent` declaration, found Ident(\\\"fn\\\")\", span: Span { start: 151, end: 153 } }", "schema": "edict.cli.diagnostic/v1", "severity": "error", "stage": "cli", "type": "diagnostic"}], "exitCode": 2, "sourceSha256": "97475b0e6aaf24d3268736efa3312df377b9153b89c8e59f0e2ceb25ce691218", "stderrSha256": "001929f74b4648fdd8c7946bdb80b1ccea0fae03e5f208012bb454d0ab94a831", "stdoutSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"} +{"artifactSha256": {}, "artifacts": [], "case": "decimal", "diagnostics": [{"command": "build", "input": {"kind": "stdin"}, "kind": "InvalidApplicationSource", "message": "Edict source `/tmp/echo-726-runtime/jim-buffer-decoder-results/decimal/src/ReplaceRange.edict` did not parse: ParseError { kind: Lex, message: \"invalid string escape\", span: Span { start: 861, end: 862 } }", "schema": "edict.cli.diagnostic/v1", "severity": "error", "stage": "cli", "type": "diagnostic"}], "exitCode": 2, "sourceSha256": "860712eaae8fad67499967e2475d9a2bef9d072762b3eab1004a3ddf4dba2b94", "stderrSha256": "04838a07257a87554d0c8d0f397c0a661adf68719f0e7f604c642217190bae8b", "stdoutSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"} +Traceback (most recent call last): + File "/tmp/echo-726-runtime/jim-buffer-decoder-input/edict/replace-range-probes/buffer-decoder/run.py", line 75, in + main() + File "/tmp/echo-726-runtime/jim-buffer-decoder-input/edict/replace-range-probes/buffer-decoder/run.py", line 70, in main + raise RuntimeError(f"{name} did not reach the source function parser boundary") +RuntimeError: fn-control did not reach the source function parser boundary diff --git a/edict/replace-range-probes/buffer-decoder/evidence/original/guard.result.json b/edict/replace-range-probes/buffer-decoder/evidence/original/guard.result.json new file mode 100644 index 00000000..9c7c9295 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/original/guard.result.json @@ -0,0 +1,10 @@ +{ + "measurements": { + "build": 6451069687, + "data": 2959639287, + "logs": 9646863, + "host_free": 715316690944, + "vm_free": 679804174336 + }, + "exit_code": 1 +} \ No newline at end of file diff --git a/edict/replace-range-probes/buffer-decoder/evidence/original/public-build.json b/edict/replace-range-probes/buffer-decoder/evidence/original/public-build.json new file mode 100644 index 00000000..63bd674f --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/original/public-build.json @@ -0,0 +1,101 @@ +{ + "compiler": { + "commit": "17397e2aad18a83ffc617d1afd628764501f49cd", + "tree": "bcfd3112cd8b3d4630738a88761860679b45714b", + "fileCount": 449, + "manifestSha256": "625592ab9dd715349255bece0133378c64b3d4539fb50e437d116c2a4296f016", + "binarySha256": "e2700698829b03f437c66425ed9878b002ef7a34ac183a39bac4eaf6a758cc6d" + }, + "providerManifestSha256": "5b38ae704a071b88aa0cc2f85020de41cb69e76d037afe3592a4d319e22587c8", + "providerFiles": { + "components/lowerer.echo-dpo.component.wasm": "4b594a8165079f0a973741b9e27b468cf041f4ad53108fccae641dc35355bd2a", + "components/verifier.echo-dpo.component.wasm": "d0be4d283399aefc45d75b395b3568f9983521ca5543c9dfd23b9495758050ed", + "generated/evidence/provenance.provider-generation.json": "11a8ef81063f769ccfe431047be3473523fadd49582d6c935b7f7f8d7ccd81d5", + "generated/evidence/review.provider-generation.json": "24836f4170809f343a64dcce095a66765cdb922d652458a658d2f896d7547b78", + "generated/primary/authority-facts.echo-dpo.cbor": "e2a6a539a7156296c18ff1bc02f80dcabf62b42bb4314d0737527869e43986d6", + "generated/primary/authority-facts.echo-lawpack.cbor": "ce1af559551f8b8242c4b290b620c5a28323b9e43f8bc6bb161a191001b6f4b9", + "generated/primary/generated-artifact-profile.echo-dpo-registration.cbor": "4ef3aaad0d2131ba7129a3e2ae178d10c44f7e9b062af2c1fe211de781462f34", + "generated/primary/lawpack.echo-dpo.cbor": "8c570362671a0b1cd1a992d8210e4a90ffd153ad06dcdf1e0cb36033cc971e2c", + "generated/primary/schema.echo-provider-artifacts.cddl": "e8b2f078445f1e970bf8e92a33c69bded54a025469791dc3f4a7a418892a3252", + "generated/primary/target-profile.echo-dpo.cbor": "1b105d1b1f6cdf5fecdef98b7adeb238525047d43581fe9fd8c44fd213e1788e", + "generated/resources/resource.conformance-corpus.cbor": "f1f29d990f83c5af33952a69b16e9c9bbb7c2feb1d3989860b74c9e6c2c19b08", + "generated/resources/resource.lawpack-compatibility.cbor": "642945761cb7d60e133008620dc2a6b48fd0f77901b985e02b1d3398fb1411af", + "generated/resources/resource.lawpack-exports.cbor": "e80f3597830f30079bae7428cc6fe1ca27e9f2626614284338c5f5c7bfd9f8b8", + "generated/resources/resource.lawpack-target-adapter.cbor": "d0cf6a5310c7aa3d5bf291e40221a50a9be676d0e7f9947b71de0c52f03f9a41", + "generated/resources/resource.lawpack-verifier.cbor": "a0ca53486f2e1181027cab255792150735a68fc01a93669ab90b58e7c32bd36e", + "generated/resources/resource.target-bundle-profile.cbor": "95cc3aab106f0d6d77ec76e88591ee24acac58f4345c031b77cfd1ecf2aa0db8", + "generated/resources/resource.target-cost-algebra.cbor": "29cc941cc96ffdb420a24a377146f0e9d5409a89f84cdbb2ad597e78dfde3503", + "generated/resources/resource.target-footprint-algebra.cbor": "c08b853b22fa1920cb8971b60a6622e4d8f400c68b8027a9c4f246c5cb4a222c", + "generated/resources/resource.target-intrinsics.cbor": "d4080b044ad95d88763f605d25d678dad0d44bbfdc32c212334a962eaf456588", + "generated/resources/resource.target-ir.cbor": "f0ead7a5dcb41532d5df9067a9735d7078456b59cc267b3a9f6bb6437431000c", + "generated/resources/resource.target-lowerer-contract.cbor": "c4d788a8ae876cfe8c9e9875144014d551d38ff13b4d90bb9dfc46bc562bf280", + "generated/resources/resource.target-obstruction-taxonomy.cbor": "5eb85dc3fbb53890f4f5accf6a7a3c03889bd25bf00e7c2a23c43e497652328e", + "generated/resources/resource.target-operation-profiles.cbor": "3d560e8df1bfb38e8ba9b70b0a4bc843c848a7900e3af76d8f798db51b6b1077", + "generated/resources/resource.target-verifier-contract.cbor": "9cef12fac8190156e152e7c8ab5adeed077bf2bdadf3add2225ce90ab4be8710", + "provider-manifest.echo.json": "5b38ae704a071b88aa0cc2f85020de41cb69e76d037afe3592a4d319e22587c8" + }, + "authoredSourceSha256": "9fc1b006c298866463ab83a28fcb1e54769b970970c571f11d0868d79edc6d87", + "literalCasesStatus": "not executed", + "compositionStatus": "helpers are not connected to a retained-byte scanner", + "results": { + "read-control": { + "exitCode": 0, + "diagnostics": [], + "artifacts": [ + "executable-operation-package.cbor", + "verification-report.cbor" + ], + "sourceSha256": "4ec3cbf32fd5d98987cbeeaff95d7c9c5ab734dac555e443aac52e8ab02bfbc5", + "artifactSha256": { + "executable-operation-package.cbor": "afd931700018312d6c0d1e249871313d2c21c0ece1ae41d1f17f2be7af9e5284", + "verification-report.cbor": "9114fdd983d456eb83f69969475f558b6e608be23520212a5db5f26bb095d04b" + }, + "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61", + "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "fn-control": { + "exitCode": 2, + "diagnostics": [ + { + "command": "build", + "input": { + "kind": "stdin" + }, + "kind": "InvalidApplicationSource", + "message": "Edict source `/tmp/echo-726-runtime/jim-buffer-decoder-results/fn-control/src/ReplaceRange.edict` did not parse: ParseError { kind: ExpectedToken, message: \"expected `type`, `enum`, or `intent` declaration, found Ident(\\\"fn\\\")\", span: Span { start: 151, end: 153 } }", + "schema": "edict.cli.diagnostic/v1", + "severity": "error", + "stage": "cli", + "type": "diagnostic" + } + ], + "artifacts": [], + "sourceSha256": "97475b0e6aaf24d3268736efa3312df377b9153b89c8e59f0e2ceb25ce691218", + "artifactSha256": {}, + "stdoutSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderrSha256": "001929f74b4648fdd8c7946bdb80b1ccea0fae03e5f208012bb454d0ab94a831" + }, + "decimal": { + "exitCode": 2, + "diagnostics": [ + { + "command": "build", + "input": { + "kind": "stdin" + }, + "kind": "InvalidApplicationSource", + "message": "Edict source `/tmp/echo-726-runtime/jim-buffer-decoder-results/decimal/src/ReplaceRange.edict` did not parse: ParseError { kind: Lex, message: \"invalid string escape\", span: Span { start: 861, end: 862 } }", + "schema": "edict.cli.diagnostic/v1", + "severity": "error", + "stage": "cli", + "type": "diagnostic" + } + ], + "artifacts": [], + "sourceSha256": "860712eaae8fad67499967e2475d9a2bef9d072762b3eab1004a3ddf4dba2b94", + "artifactSha256": {}, + "stdoutSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderrSha256": "04838a07257a87554d0c8d0f397c0a661adf68719f0e7f604c642217190bae8b" + } + } +} diff --git a/edict/replace-range-probes/buffer-decoder/evidence/original/read-control/ReplaceRange.edict b/edict/replace-range-probes/buffer-decoder/evidence/original/read-control/ReplaceRange.edict new file mode 100644 index 00000000..1031dfc9 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/original/read-control/ReplaceRange.edict @@ -0,0 +1,18 @@ +package jedit.text.replace_range@1; +use lawpack jedit.text@1 digest "sha256:2ea164293719d2b03231c4904eb75ddcdf55fd29cc31f4fc5a5319d9ae5e60e7" as text; +type Input = { address: text.FactAddress, expected: text.FactBytes }; +intent replaceRange(input: Input) returns text.FactBytes + profile text.replaceRange + basis input.address.nodeId + budget <= text.replaceRangeBudget +{ + let actual: text.FactBytes = text.readFact(input.address) + else { + missing(address) => text.FactMissing, + typeMismatch(address) => text.FactMalformed, + notAtom(address) => text.FactMalformed, + tooLarge(address) => text.FactMalformed, + }; + require actual == input.expected else text.BasisNotCanonical; + return actual; +} diff --git a/edict/replace-range-probes/buffer-decoder/evidence/original/read-control/application/executable-operation-package.cbor b/edict/replace-range-probes/buffer-decoder/evidence/original/read-control/application/executable-operation-package.cbor new file mode 100644 index 0000000000000000000000000000000000000000..a14f9ea230400956ca8558be0f9bd4b23aff4ed4 GIT binary patch literal 10473 zcmeHNeQ*`k6;H)FZN_#O=-4EnE)<1W-Xkv|U_t_fU?eq|7^nqBp7-tE-M3-C*t?r- zhC!2n3ffvfaBw;u$Gik&=mA9I^~a$?B09sx%ZrV&hPxr?v{y|#5(dyv6wWYriE?fsHPFIkhl&hcur?bv20VZ zk-qwpmA{hKsfOfD6HVPxHEc)VmE?+8iX=?ekl=qCBMIins^MV6(QIsKNW|^PP;ju) zrEH~K5p*gQNY?@px@g)sj%-Jjk?5@c_KQ2Q(`{igfSV1=by7?fxgEnWNtRWtNhGBp zNwP5^UP%X*R43|S&siLcHi3W!{w9e%3yThxI&(%W>2@#~;c-fYBPuJJSX9K8#cb@z ztK?H|KsHPXH%lg)TZcVRs=lgnp-gv`=W!RZt=z|os#~V*klvJNV>y*jB`v%WSyB~D zoIaT(QDybKRYJ61DxY8a>b}a@!Mm=0?1p!a{rKzhmt&uPb=`{6xAv^P@k6#9MMGWG z-U_!G>Cdv;LsG(&x(6^-pY-kE=Z`ZB>|qP8Vc1w zVe@?*MzCmRVPyszUSXIC;@GZ8-G4c<1{GZ;1SF<#C(>LzD1m;YhiN5&dYVjsU~Dlp zs0z#Z_$1wV105?Y=M)(XF{pUu_;xlQ4@eUbmWN1Goe`3*c7W8VD6*Xc)hFI7#yt$shVqJ z9x##)wsqA2qk&fw(?}^6>efsoJ=nn?Tm}Br$*j8s5tUqRI*rIM4HZ05wQLA^B69Fx z!n6|g^?W57W)Zy6uFHMf1u{t?;FLAZ;bT`N^D&cA7Y$qG;^`R`}r*WS83MV+(bREc%BV-|qCD2CG zfXss+`;s1q!k#N=#$h;Yi7P4C8At;BSm9ucFbrbAU#(0m!xCjhJw-+9;aP)5F9?7e z{`eb3MMYkTA8Vx60NSSkmj{@qVk61E|n1b2M=5Tqc1 zsG<|4n$Z`c36KlI6a=EOk@I_I+LkJre6mw)Hgz@k!X8T$$yBuCQu5IvDnOruvSP*>U@CCyH;2pad0uvPVHH&hX zNnbMG5$fu5r*gL{-T<9o}T%_gbou0@c7FRe}ryS-A0@lDHR1E#+1EyKNCgno? z!pt%G=xDY-Hk_eHm=J)MV2Y1^MmajbC8HV+781Y$EGzq`A=KCV2OHRxZ#IAW<@2cp z{pkyeHx@(f!*F$`ikUEZH-N#8%&k#CIK}f6$-9}yQU5V5rG`WLCwf*k9<{fBwC1Vp z?zz8cx@hm)O?zkV8QQTvGCQ&L(K*wUPJU}qED67<5W4IX7Bxi3I*I;I3%pLO*sg{N zcId+1)X>VooCq6`Pl0)@L;t#ekMz}>Z``~4{Wo5kyy%Pm!}8>c!-Jh$9;q$vTNH{M z7LOeMIe;)t!WITlY=|@vK#d3R#8Fvf=w_-+38|9xHlHS!9ozKz{X)E5>^Ryoc#Zdu z+B>Hn5^rn09Zg==vTbceyWvn|3bh{slx~yW0VpBZuWYGs@S-(o#DAG@r2~)s@Wcz1 zoo)KzLWb7kEv5WGZM3P>y2ip@4%!DN*#v5*l_?Kz#5 zIi{Sn@aCQyo+RdgZ_dB*);%?Dwp2fIQ_&qvv}Bo! za~&i)W80*%k3ah$^_KA2iCY$Lx#YENo$-eombEm9+g}h)oNESBX<%+hsJ+?o-7A5_ zK+6VXh`34hz^O5ev|Q$-SsAZARNhBT8;Keeb~(Fze8}2(uAZ8<-h%|&8-wy?aW2_*2_Ct=Iw%1g8{z=$J*fY0kUN3kT8dzaQ+H* z7yfSq5QOIQ-iN@LBplVF^m(-6f2y=LLse{pt&>5Axi5lRHsU7@xO4>ywX;}gyBYNY z_*7WGvs!k0Wf>J|Dy7HBs@*fB=U8h2Psr$*0D_GZg%RwD7z1B;hO`}P31sp})NDAm zY7kZQSy2{d8Lo;jm!+H&3Awai#FNd1cbnJo^Sj&0Og!!-7BGGc{OG{iLY{=6)R`5O z{MXTn|8o|j;wsaeg@HXRx|CCFrJ1ZRU#uVDsB?=$E6vZ3vWOe!YEtL-W4v$(fyM)r zpkkwD5=w$4eVhpFHaOtv5!)TS#-tD@2kiNt9Wc>3fMwt6&9D6Bxrv_(6T9DEb>a8U zyE3+>_sc2wJ-z2AT{BbqA5J(K*^Q&Dh0~P)$DbLXGvUDQpP1C>fgRB2EW;kXMC3ua*UD_9SK^oHslwntuVTKo)J6Pl_p zDx~095bmA8rpT(|@;(-`{VbM)(p!mWW)~Djh7zGbH$4<`QI02Ed(Xwzs=-HlWw=_&cCsUO4=ikxJjxJkua3d|npiPA& zLo|tV3L7+K&K5&=0%C(g(k+U-StaNe6g%L7AxYl! z6%;BdbyOBK9A}F`Kce17T@lxjFJB0qU)n1qy}MOLRIP-ajodm7on!u6)WHc=DrJP7 zYKn_&X@zT1X63U}y<`SgH^6l1JC<7KH)Bq&zkysQX~I44X7^kNE}W5_O$aFQ;7X27 zmO)8Gg^Fgv(l>Zqq-9<5agpdBB<)!(1I>BFOQRunIzU1}{-=Qxtl0+4l#VG+(?iA> z9aISD5Fsd!u7&V9*)$Mxt6}b)(@6tHiZ$I<@DC#jT!vxxHaIUqBQ#2AIBVV9u;6o| zr?q0Xhh;4oBDnmoAeIN5>S--G%n@}9z+01Ru+BN@IW^3X(oG8>;7SZB6gmn!RrV)! z8iH8dXa^>Qx;;y+8vD)!+1+%2%m?U<+zAADAp#LL%|5eO2Dz4*StmRww3(VJb`Ns| zCT0o!j>QihCcsj%R3(;4Sjf(fNAx8ysDvPBtWb`uJySukPOCSHbjCO?ZwjIz7D)JX zn#+I!lZT_Wpt~F9--aQ=D|nps%6R`R4vhn#32CxPXRK9!-4T3-Q^qkLA4|Wx@y7xT z>VQNC&uQz2H>_nI!zAEplRf?)yk%{PL1U-8opt?WN?$eSrL+o1?tG0clE!TztUWW6 zp#o4Gp!wi$_RW!ZA;*OAEToq?j=n+KS!<{De97W4A|5qlTn8sdzgVIUIf@UXG=Djk zfmt(8^ZQ=$b)%DDa9kW0F|^a*dlwZX#u=B$#98!Do+9IvaDk2?bO(VO^5XEh3U3ek zFKB0TuiDu&Wcj?9#3fsc;t08nK*iCM*7h!D;QmAk)r z=NF{3zE7;|pEh*(_ysRtH}$8-&)GCsw7*z?Ejh(y{v79?8qdsgj{R)jlY?I#`uYB@ znwa!)DKXeCg1yuP?2AcITEw=EK(~-z{G| zboadzpIQ6JuHWr{@21PVDe0t6ZzGF$p~Vk)wM84Yu9?s_^_9|D$DWA%@xa8stvCJt zUFW02`&u?kYV)SjG+;wqf}eSo-~WSyPV3PQVcLD_Bin~ADX$~@8@7Fty6dWj&CfjB H*XI2jywEx^ literal 0 HcmV?d00001 diff --git a/edict/replace-range-probes/buffer-decoder/evidence/original/read-control/application/verification-report.cbor b/edict/replace-range-probes/buffer-decoder/evidence/original/read-control/application/verification-report.cbor new file mode 100644 index 0000000000000000000000000000000000000000..fb4ef5d0720173562ea406229704667c8b56dcae GIT binary patch literal 930 zcmZ3Ho?lv$oS&PTk(ivET2PXjl3tLQoSm4Sx+p0#r9v^aA~m_RBrz!`RX4vNwJ5P9 zGe1ukszNU{IU_$UB{My>xTGnqI3v->)GR__(K^%1vz~jY-I|!{;^wNkC#UMOR@t^^ zpF`eP9%ZxI$eB@+Sd^Yx;#mZ;ARlCeUU5NUo^EE5ewh)5X=#XGmuy7G#E{78L`XRiOzs48xhaWvNA(X_=`-x<#o4`9&rA zWrn#anThFn`Nbuf$&N{xAcp`wo|#;thY&9YD#LJ%#^0iqP0FH{O{X|~G;eR*bj2Xa zGJUmm?#}D~o@G1}*_n^f?^IcmTI^7W2*2Rcq^#8Bl0~UWAel(Uz$HUBq@}RG_BF3~GVttin0#z; text.FactBytes { return value; }\n\n" + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + for name in ("compiler", "compiler-source", "compiler-manifest", "application-source", + "provider-package", "work-root"): + parser.add_argument("--" + name, type=Path, required=True) + args = parser.parse_args() + if not Path("/.dockerenv").is_file(): + raise RuntimeError("Run under shared git-locks admission and the guarded Docker lease") + if not args.work_root.resolve().is_relative_to(Path("/tmp/echo-726-runtime")): + raise RuntimeError("Work must stay inside the declared runtime-data accounting root") + common = runpy.run_path(str(Path(__file__).parent.parent / "leaf-slice/run.py")) + sha256, snapshot, verify = common["sha256"], common["snapshot"], common["verify_compiler_source"] + compiler = verify(args.compiler_source, args.compiler_manifest, COMPILER_COMMIT) + compiler["binarySha256"] = sha256(args.compiler) + before = {"application": snapshot(args.application_source), "provider": snapshot(args.provider_package)} + original = (args.application_source / "src/ReplaceRange.edict").read_bytes() + authored = (Path(__file__).parent / "Decimal.edict").read_bytes() + package, declarations = authored.split(b"\n", 1) + if not original.startswith(package + b"\n") or b"type Input" not in original: + raise RuntimeError("Expected the unchanged generic read control's source layout") + sources = { + "read-control": original, + "fn-control": original.replace(b"type Input", TRIVIAL_FUNCTION + b"type Input", 1), + "decimal": original.replace(b"type Input", declarations + b"\ntype Input", 1), + } + args.work_root.mkdir() + evidence = {"compiler": compiler, + "providerManifestSha256": sha256(args.provider_package / "provider-manifest.echo.json"), + "providerFiles": before["provider"], + "authoredSourceSha256": sha256(Path(__file__).parent / "Decimal.edict"), + "literalCasesStatus": "not executed", + "compositionStatus": "helpers are not connected to a retained-byte scanner", + "results": {}} + for name, source in sources.items(): + root = args.work_root / name + common["prepare"](root, args.application_source, args.provider_package, source) + evidence["results"][name] = common["build"](root, args.compiler) + (args.work_root / "evidence.json").write_text(json.dumps(evidence, indent=2) + "\n") + for name, result in evidence["results"].items(): + print(json.dumps({"case": name, **result}, sort_keys=True), flush=True) + if before != {"application": snapshot(args.application_source), "provider": snapshot(args.provider_package)}: + raise RuntimeError("Public witness changed an authoritative input") + if compiler["binarySha256"] != sha256(args.compiler): + raise RuntimeError("Compiler binary changed during witness") + verify(args.compiler_source, args.compiler_manifest, COMPILER_COMMIT) + positive = evidence["results"]["read-control"] + if (positive["exitCode"] != 0 or positive["diagnostics"] or positive["artifacts"] != + ["executable-operation-package.cbor", "verification-report.cbor"]): + raise RuntimeError("Generic read control did not reach package/report success") + for name in ("fn-control", "decimal"): + negative = evidence["results"][name] + if negative["exitCode"] != 2 or negative["artifacts"] or len(negative["diagnostics"]) != 1: + raise RuntimeError(f"{name} did not refuse without application artifacts") + diagnostic = negative["diagnostics"][0] + if (diagnostic.get("kind") != "ApplicationCompilationFailed" + or "expected `type`, `enum`, or `intent` declaration" not in diagnostic.get("message", "") + or 'fn' not in diagnostic.get("message", "")): + raise RuntimeError(f"{name} did not reach the source function parser boundary") + print("JIM_BUFFER_DECIMAL_SOURCE_FUNCTION_BOUNDARY_CONFIRMED", flush=True) + + +if __name__ == "__main__": + main() diff --git a/edict/replace-range-probes/buffer-decoder/evidence/provider-manifest.echo.json b/edict/replace-range-probes/buffer-decoder/evidence/provider-manifest.echo.json new file mode 100644 index 00000000..0ce89ee2 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/provider-manifest.echo.json @@ -0,0 +1,380 @@ +{ + "apiVersion": "edict.provider-manifest/v1", + "providerAbi": "edict:target-provider@1.0.0", + "provider": { + "coordinate": "echo.edict-provider@1", + "digest": "sha256:d5971bc387d873814a60ac46e1fc500c089f0e60c6ac8a232ebb43de139d39e6" + }, + "artifacts": [ + { + "role": "authority-facts.echo-dpo", + "artifactKind": "authorityFacts", + "resource": { + "coordinate": "echo.dpo-authority-facts@1", + "digest": "sha256:0347dd3ef916b20314c9d33fbd028432dfb53043fcb333390d8825dce72d7388" + }, + "source": { + "kind": "generated", + "semanticSource": { + "coordinate": "echo.semantic-schema@1", + "digest": "sha256:322d9eb5eb8273108eaa602f2eb58ba591efcf829fecb10bb705717efae18852" + }, + "generator": { + "coordinate": "echo-wesley-gen.provider-artifact-generator@1", + "digest": "sha256:c083c08da330b9d37c7c17b12ce24c5724b5a59d61fc75c8192a53e204e0add5" + } + } + }, + { + "role": "authority-facts.echo-lawpack", + "artifactKind": "authorityFacts", + "resource": { + "coordinate": "echo.dpo-lawpack-authority-facts@1", + "digest": "sha256:0e74b34fa901809f3cfe2aacd52f4dea708aa6d8481761193d7e1cd1afeca879" + }, + "source": { + "kind": "generated", + "semanticSource": { + "coordinate": "echo.semantic-schema@1", + "digest": "sha256:322d9eb5eb8273108eaa602f2eb58ba591efcf829fecb10bb705717efae18852" + }, + "generator": { + "coordinate": "echo-wesley-gen.provider-artifact-generator@1", + "digest": "sha256:c083c08da330b9d37c7c17b12ce24c5724b5a59d61fc75c8192a53e204e0add5" + } + } + }, + { + "role": "generated-artifact-profile.echo-dpo-registration", + "artifactKind": "generatedArtifactProfile", + "resource": { + "coordinate": "echo.dpo.registration/v1", + "digest": "sha256:ff88be93c26cc533948d8a93601954dc391912d593ca1e96115c846cbf2c5b5d" + }, + "source": { + "kind": "generated", + "semanticSource": { + "coordinate": "echo.semantic-schema@1", + "digest": "sha256:322d9eb5eb8273108eaa602f2eb58ba591efcf829fecb10bb705717efae18852" + }, + "generator": { + "coordinate": "echo-wesley-gen.provider-artifact-generator@1", + "digest": "sha256:c083c08da330b9d37c7c17b12ce24c5724b5a59d61fc75c8192a53e204e0add5" + } + } + }, + { + "role": "lawpack.echo-dpo", + "artifactKind": "lawpack", + "resource": { + "coordinate": "echo.dpo-lawpack@1", + "digest": "sha256:8abe773a94945fe1f46573bf4dc166a10ef723f5f5479e27ad03f7c891b77330" + }, + "source": { + "kind": "generated", + "semanticSource": { + "coordinate": "echo.semantic-schema@1", + "digest": "sha256:322d9eb5eb8273108eaa602f2eb58ba591efcf829fecb10bb705717efae18852" + }, + "generator": { + "coordinate": "echo-wesley-gen.provider-artifact-generator@1", + "digest": "sha256:c083c08da330b9d37c7c17b12ce24c5724b5a59d61fc75c8192a53e204e0add5" + } + } + }, + { + "role": "lowerer.echo-dpo", + "artifactKind": "lowerer", + "resource": { + "coordinate": "echo.dpo.lowerer/component@1", + "digest": "sha256:4b594a8165079f0a973741b9e27b468cf041f4ad53108fccae641dc35355bd2a" + }, + "source": { + "kind": "component", + "component": { + "coordinate": "echo.dpo.lowerer/component@1", + "digest": "sha256:4b594a8165079f0a973741b9e27b468cf041f4ad53108fccae641dc35355bd2a" + } + } + }, + { + "role": "provenance.provider-generation", + "artifactKind": "generationProvenance", + "resource": { + "coordinate": "echo.edict-provider-generation-provenance@1", + "digest": "sha256:11a8ef81063f769ccfe431047be3473523fadd49582d6c935b7f7f8d7ccd81d5" + }, + "source": { + "kind": "generated", + "semanticSource": { + "coordinate": "echo.semantic-schema@1", + "digest": "sha256:322d9eb5eb8273108eaa602f2eb58ba591efcf829fecb10bb705717efae18852" + }, + "generator": { + "coordinate": "echo-wesley-gen.provider-artifact-generator@1", + "digest": "sha256:c083c08da330b9d37c7c17b12ce24c5724b5a59d61fc75c8192a53e204e0add5" + } + } + }, + { + "role": "review.provider-generation", + "artifactKind": "reviewArtifact", + "resource": { + "coordinate": "echo.edict-provider-generation-review@1", + "digest": "sha256:24836f4170809f343a64dcce095a66765cdb922d652458a658d2f896d7547b78" + }, + "source": { + "kind": "generated", + "semanticSource": { + "coordinate": "echo.semantic-schema@1", + "digest": "sha256:322d9eb5eb8273108eaa602f2eb58ba591efcf829fecb10bb705717efae18852" + }, + "generator": { + "coordinate": "echo-wesley-gen.provider-artifact-generator@1", + "digest": "sha256:c083c08da330b9d37c7c17b12ce24c5724b5a59d61fc75c8192a53e204e0add5" + } + } + }, + { + "role": "schema.echo-provider-artifacts", + "artifactKind": "artifactSchema", + "resource": { + "coordinate": "echo.provider-artifacts.cddl@1", + "digest": "sha256:e8b2f078445f1e970bf8e92a33c69bded54a025469791dc3f4a7a418892a3252" + }, + "source": { + "kind": "generated", + "semanticSource": { + "coordinate": "echo.semantic-schema@1", + "digest": "sha256:322d9eb5eb8273108eaa602f2eb58ba591efcf829fecb10bb705717efae18852" + }, + "generator": { + "coordinate": "echo-wesley-gen.provider-artifact-generator@1", + "digest": "sha256:c083c08da330b9d37c7c17b12ce24c5724b5a59d61fc75c8192a53e204e0add5" + } + } + }, + { + "role": "target-profile.echo-dpo", + "artifactKind": "targetProfile", + "resource": { + "coordinate": "echo.dpo@1", + "digest": "sha256:2e2494121aecf5e6a2d920f5fb85408825d394765fad41484c416397c920fb04" + }, + "source": { + "kind": "generated", + "semanticSource": { + "coordinate": "echo.semantic-schema@1", + "digest": "sha256:322d9eb5eb8273108eaa602f2eb58ba591efcf829fecb10bb705717efae18852" + }, + "generator": { + "coordinate": "echo-wesley-gen.provider-artifact-generator@1", + "digest": "sha256:c083c08da330b9d37c7c17b12ce24c5724b5a59d61fc75c8192a53e204e0add5" + } + } + }, + { + "role": "verifier.echo-dpo", + "artifactKind": "verifier", + "resource": { + "coordinate": "echo.dpo.verifier/component@1", + "digest": "sha256:d0be4d283399aefc45d75b395b3568f9983521ca5543c9dfd23b9495758050ed" + }, + "source": { + "kind": "component", + "component": { + "coordinate": "echo.dpo.verifier/component@1", + "digest": "sha256:d0be4d283399aefc45d75b395b3568f9983521ca5543c9dfd23b9495758050ed" + } + } + } + ], + "schemaBindings": [ + { + "domain": "echo.dpo-lawpack.adapter.echo-dpo@1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "echo-provider-lawpack-target-adapter" + }, + { + "domain": "echo.dpo-lawpack.compatibility@1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "echo-provider-lawpack-compatibility" + }, + { + "domain": "echo.dpo-lawpack.exports@1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "lawpack-exports" + }, + { + "domain": "echo.dpo-lawpack.verifier@1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "echo-provider-lawpack-verifier" + }, + { + "domain": "echo.dpo.bundle/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "echo-dpo-bundle" + }, + { + "domain": "echo.dpo.cost/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "echo-dpo-cost" + }, + { + "domain": "echo.dpo.fixtures/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "echo-provider-conformance-corpus" + }, + { + "domain": "echo.dpo.footprint/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "echo-dpo-footprint" + }, + { + "domain": "echo.dpo.intrinsics/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "intrinsics-document" + }, + { + "domain": "echo.dpo.lowerer/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "echo-dpo-lowerer" + }, + { + "domain": "echo.dpo.obstructions/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "echo-dpo-obstructions" + }, + { + "domain": "echo.dpo.operation-profiles/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "operation-profiles-document" + }, + { + "domain": "echo.dpo.verifier/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "echo-dpo-verifier" + }, + { + "domain": "echo.generated-artifact-profile/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "generated-artifact-profile" + }, + { + "domain": "echo.generated-artifact/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "generated-artifact" + }, + { + "domain": "echo.operation-lowering-configuration/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "echo-operation-lowering-configuration" + }, + { + "domain": "echo.operation-package-verifier-report/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "echo-operation-package-verifier-report" + }, + { + "domain": "echo.operation-package/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "echo-operation-package" + }, + { + "domain": "echo.review-payload/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "review-payload" + }, + { + "domain": "echo.span-ir/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "echo-span-ir" + }, + { + "domain": "echo.verifier-report/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "verifier-report" + }, + { + "domain": "edict.authority-facts/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "authority-facts" + }, + { + "domain": "edict.core.module/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "core-module" + }, + { + "domain": "edict.lawpack-adapter/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "lawpack-adapter" + }, + { + "domain": "edict.lawpack-exports/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "lawpack-exports" + }, + { + "domain": "edict.lawpack/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "lawpack-manifest" + }, + { + "domain": "edict.lowering-requirements/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "lowering-requirements" + }, + { + "domain": "edict.result-projection.artifact/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "result-projection" + }, + { + "domain": "edict.source/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "edict-source-bytes" + }, + { + "domain": "edict.target-ir.artifact/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "target-ir-artifact" + }, + { + "domain": "edict.target-profile/v1", + "schemaRole": "schema.echo-provider-artifacts", + "format": "selfContainedCddlV1", + "rootRule": "target-profile-manifest" + } + ] +} diff --git a/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/decimal/ReplaceRange.edict b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/decimal/ReplaceRange.edict new file mode 100644 index 00000000..3927ed0e --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/decimal/ReplaceRange.edict @@ -0,0 +1,93 @@ +package jedit.text.replace_range@1; +use lawpack jedit.text@1 digest "sha256:2ea164293719d2b03231c4904eb75ddcdf55fd29cc31f4fc5a5319d9ae5e60e7" as text; + +// Jim's JSON boundary codec. These are internal scanner values, not intent inputs. +// A later bounded scanner must obtain each token from the retained Buffer atom. +type JsonByte = Bytes; +type DecimalState = variant { Start, Zero, Digits(U64) }; +type DecimalStep = variant { More(DecimalState), End(U64), Invalid, Overflow }; +type DecimalDigit = variant { Digit(U64), NotDigit }; + +// An End result leaves the delimiter unconsumed for the enclosing JSON scanner. +// Whitespace terminates a number; canonical-byte policy belongs to that scanner. +fn isNumberDelimiter(token: JsonByte) -> Bool { + return token == b"," || token == b"]" || token == b"}" + || token == b" " || token == b"\t" || token == b"\r" || token == b"\n"; +} + +fn decimalDigit(token: JsonByte) -> DecimalDigit { + return if token == b"0" then DecimalDigit::Digit(0u64) + else if token == b"1" then DecimalDigit::Digit(1u64) + else if token == b"2" then DecimalDigit::Digit(2u64) + else if token == b"3" then DecimalDigit::Digit(3u64) + else if token == b"4" then DecimalDigit::Digit(4u64) + else if token == b"5" then DecimalDigit::Digit(5u64) + else if token == b"6" then DecimalDigit::Digit(6u64) + else if token == b"7" then DecimalDigit::Digit(7u64) + else if token == b"8" then DecimalDigit::Digit(8u64) + else if token == b"9" then DecimalDigit::Digit(9u64) + else DecimalDigit::NotDigit; +} + +fn appendScaled(scaled: U64, digit: U64, limit: U64) -> DecimalStep { + let sum = checkedAdd(scaled, digit); + return if isSome(sum) then + if unwrap(sum) <= limit then DecimalStep::More(DecimalState::Digits(unwrap(sum))) + else DecimalStep::Overflow + else DecimalStep::Overflow; +} + +fn appendDigit(value: U64, digit: U64, limit: U64) -> DecimalStep { + let decimalRadix = 10u64; + let product = checkedMul(value, decimalRadix); + return if isSome(product) then appendScaled(unwrap(product), digit, limit) + else DecimalStep::Overflow; +} + +fn startDecimal(token: JsonByte, limit: U64) -> DecimalStep { + return match decimalDigit(token) { + Digit(value) => if value > limit then DecimalStep::Overflow + else if value == 0u64 then DecimalStep::More(DecimalState::Zero) + else DecimalStep::More(DecimalState::Digits(value)), + NotDigit => DecimalStep::Invalid, + }; +} + +fn continueDecimal(value: U64, token: JsonByte, limit: U64) -> DecimalStep { + return if value == 0u64 then DecimalStep::Invalid + else if value > limit then DecimalStep::Overflow + else match decimalDigit(token) { + Digit(digit) => appendDigit(value, digit, limit), + NotDigit => if isNumberDelimiter(token) then DecimalStep::End(value) + else DecimalStep::Invalid, + }; +} + +// canonical_head_id members use limit 255; version uses 18446744073709551615. +// The enclosing scanner owns these schema limits and starts at Start. +// Empty token, sign, leading zero, fraction, exponent and non-ASCII byte refuse. +fn stepJsonUnsigned(state: DecimalState, token: JsonByte, limit: U64) -> DecimalStep { + return match state { + Start => startDecimal(token, limit), + Zero => if isNumberDelimiter(token) then DecimalStep::End(0u64) + else DecimalStep::Invalid, + Digits(value) => continueDecimal(value, token, limit), + }; +} + +type Input = { address: text.FactAddress, expected: text.FactBytes }; +intent replaceRange(input: Input) returns text.FactBytes + profile text.replaceRange + basis input.address.nodeId + budget <= text.replaceRangeBudget +{ + let actual: text.FactBytes = text.readFact(input.address) + else { + missing(address) => text.FactMissing, + typeMismatch(address) => text.FactMalformed, + notAtom(address) => text.FactMalformed, + tooLarge(address) => text.FactMalformed, + }; + require actual == input.expected else text.BasisNotCanonical; + return actual; +} diff --git a/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/decimal/stderr.jsonl b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/decimal/stderr.jsonl new file mode 100644 index 00000000..015af157 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/decimal/stderr.jsonl @@ -0,0 +1,2 @@ +{"command":"build","input":{"kind":"stdin"},"kind":"InvalidApplicationSource","message":"Edict source `/tmp/echo-726-runtime/jim-buffer-decoder-reproduction196/decimal/src/ReplaceRange.edict` did not parse: ParseError { kind: Lex, message: \"invalid string escape\", span: Span { start: 861, end: 862 } }","schema":"edict.cli.diagnostic/v1","severity":"error","stage":"cli","type":"diagnostic"} +{"checked":0,"command":"build","errors":1,"exitCode":2,"schema":"edict.cli.event/v1","status":"error","type":"status"} diff --git a/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/decimal/stdout.jsonl b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/decimal/stdout.jsonl new file mode 100644 index 00000000..e69de29b diff --git a/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/fn-control/ReplaceRange.edict b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/fn-control/ReplaceRange.edict new file mode 100644 index 00000000..fe87ae1b --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/fn-control/ReplaceRange.edict @@ -0,0 +1,20 @@ +package jedit.text.replace_range@1; +use lawpack jedit.text@1 digest "sha256:2ea164293719d2b03231c4904eb75ddcdf55fd29cc31f4fc5a5319d9ae5e60e7" as text; +fn retainFact(value: text.FactBytes) -> text.FactBytes { return value; } + +type Input = { address: text.FactAddress, expected: text.FactBytes }; +intent replaceRange(input: Input) returns text.FactBytes + profile text.replaceRange + basis input.address.nodeId + budget <= text.replaceRangeBudget +{ + let actual: text.FactBytes = text.readFact(input.address) + else { + missing(address) => text.FactMissing, + typeMismatch(address) => text.FactMalformed, + notAtom(address) => text.FactMalformed, + tooLarge(address) => text.FactMalformed, + }; + require actual == input.expected else text.BasisNotCanonical; + return actual; +} diff --git a/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/fn-control/stderr.jsonl b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/fn-control/stderr.jsonl new file mode 100644 index 00000000..eb0d4ec3 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/fn-control/stderr.jsonl @@ -0,0 +1,2 @@ +{"command":"build","input":{"kind":"stdin"},"kind":"InvalidApplicationSource","message":"Edict source `/tmp/echo-726-runtime/jim-buffer-decoder-reproduction196/fn-control/src/ReplaceRange.edict` did not parse: ParseError { kind: ExpectedToken, message: \"expected `type`, `enum`, or `intent` declaration, found Ident(\\\"fn\\\")\", span: Span { start: 151, end: 153 } }","schema":"edict.cli.diagnostic/v1","severity":"error","stage":"cli","type":"diagnostic"} +{"checked":0,"command":"build","errors":1,"exitCode":2,"schema":"edict.cli.event/v1","status":"error","type":"status"} diff --git a/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/fn-control/stdout.jsonl b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/fn-control/stdout.jsonl new file mode 100644 index 00000000..e69de29b diff --git a/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/guard.launch.json b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/guard.launch.json new file mode 100644 index 00000000..e07fa2b7 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/guard.launch.json @@ -0,0 +1,38 @@ +{ + "worker": "echo-read-runtime", + "image": "echo-read-runtime:red", + "lock": "/tmp/echo-validation-host.lock", + "inner_lock": "/tmp/echo-validation.lock", + "source": "/echo-audit", + "outputs": [ + "/lease-target", + "/usr/local/cargo", + "/tmp/echo-726-runtime", + "all container writable-layer paths", + "/dev/shm", + "/private/tmp/echo-739-resume/jim-buffer-reproduction196.log" + ], + "measurements": { + "build": 14641243958, + "data": 4101269302, + "logs": 11301697, + "host_free": 709769887744, + "vm_free": 674522402816 + }, + "build_limit": 21474836480, + "data_limit": 4294967296, + "log_limit": 134217728, + "cpus": 4.0, + "memory": 6442450944, + "logging": { + "Type": "json-file", + "Config": { + "max-file": "5", + "max-size": "20m" + } + }, + "timeout_seconds": 600, + "guard": "2-second fail-closed monitor; freeze owned process group across the entire size measurement, including cache du; pause container for snapshotter; accept an absent process group only after confirmed owned docker-exec completion; of aggregate writable layers, shared memory, host scratch and logs; no host binds or volumes", + "termination": "docker stop/kill owned worker and host docker-exec process group on monitoring failure or limit/timeout", + "command": "test ! -e /tmp/echo-726-runtime/buffer-reproduction196-input\nmkdir /tmp/echo-726-runtime/buffer-reproduction196-input\ntar -xf /tmp/echo-726-runtime/buffer-reproduction196-input.tar -C /tmp/echo-726-runtime/buffer-reproduction196-input\ncd /edict-207\nexport CARGO_TARGET_DIR=/lease-target CARGO_INCREMENTAL=0 CARGO_BUILD_JOBS=4 CARGO_PROFILE_DEV_DEBUG=0 CARGO_PROFILE_TEST_DEBUG=0\npython3 - <<'INNER'\nfrom pathlib import Path\nimport runpy,hashlib,subprocess\nr=Path('/tmp/echo-726-runtime/buffer-reproduction196-input/edict/replace-range-probes')\ncommon=runpy.run_path(str(r/'leaf-slice/run.py'))\nprint(common['verify_compiler_source'](Path('/edict-207'),r/'buffer-decoder/evidence/compiler-source.json','17397e2aad18a83ffc617d1afd628764501f49cd'),flush=True)\nassert not subprocess.check_output(['git','-C','/edict-207','status','--porcelain'],text=True).strip()\nbinary=Path('/lease-target/debug/edict')\nexpected='e2700698829b03f437c66425ed9878b002ef7a34ac183a39bac4eaf6a758cc6d'\nif True:\n assert '1.96.0-aarch64-unknown-linux-gnu' in subprocess.check_output(['rustup','toolchain','list'],text=True)\n print(subprocess.check_output(['rustc','+1.96.0','--version','--verbose'],text=True),flush=True)\n subprocess.run(['cargo','+1.96.0','clean','-p','edict-cli','-p','edict-syntax'],check=True)\n subprocess.run(['cargo','+1.96.0','build','--locked','-p','edict-cli'],check=True)\nprint('ACTUAL_COMPILER_BINARY',hashlib.sha256(binary.read_bytes()).hexdigest(),flush=True)\nsubprocess.run(['python3',str(r/'buffer-decoder/run.py'),'--compiler',str(binary),'--compiler-sha256',hashlib.sha256(binary.read_bytes()).hexdigest(),'--compiler-source','/edict-207','--compiler-manifest',str(r/'buffer-decoder/evidence/compiler-source.json'),'--application-source',str(r/'buffer-decoder/control'),'--provider-package','/read-provider','--work-root','/tmp/echo-726-runtime/jim-buffer-decoder-reproduction196'],check=True)\nINNER\n" +} \ No newline at end of file diff --git a/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/guard.log b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/guard.log new file mode 100644 index 00000000..a2e605f3 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/guard.log @@ -0,0 +1,20 @@ +{'commit': '17397e2aad18a83ffc617d1afd628764501f49cd', 'tree': 'bcfd3112cd8b3d4630738a88761860679b45714b', 'fileCount': 449, 'manifestSha256': '625592ab9dd715349255bece0133378c64b3d4539fb50e437d116c2a4296f016'} +rustc 1.96.0 (ac68faa20 2026-05-25) +binary: rustc +commit-hash: ac68faa20c58cbccd01ee7208bf3b6e93a7d7f96 +commit-date: 2026-05-25 +host: aarch64-unknown-linux-gnu +release: 1.96.0 +LLVM version: 22.1.2 + + Removed 140 files, 343.4MiB total + Compiling edict-syntax v0.11.0-alpha.1 (/edict-207/crates/edict-syntax) + Compiling edict-provider-schema v0.11.0-alpha.1 (/edict-207/crates/edict-provider-schema) + Compiling edict-provider-host-wasmtime v0.11.0-alpha.1 (/edict-207/crates/edict-provider-host-wasmtime) + Compiling edict-cli v0.11.0-alpha.1 (/edict-207/crates/edict-cli) + Finished `dev` profile [unoptimized] target(s) in 7.44s +ACTUAL_COMPILER_BINARY 83c70b3fdbb42ac43f0967a0c559c0cc8b66599987774a40412bda4fbc028d36 +{"artifactSha256": {"executable-operation-package.cbor": "afd931700018312d6c0d1e249871313d2c21c0ece1ae41d1f17f2be7af9e5284", "verification-report.cbor": "9114fdd983d456eb83f69969475f558b6e608be23520212a5db5f26bb095d04b"}, "artifacts": ["executable-operation-package.cbor", "verification-report.cbor"], "case": "read-control", "diagnostics": [], "exitCode": 0, "sourceSha256": "4ec3cbf32fd5d98987cbeeaff95d7c9c5ab734dac555e443aac52e8ab02bfbc5", "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61"} +{"artifactSha256": {}, "artifacts": [], "case": "fn-control", "diagnostics": [{"command": "build", "input": {"kind": "stdin"}, "kind": "InvalidApplicationSource", "message": "Edict source `/tmp/echo-726-runtime/jim-buffer-decoder-reproduction196/fn-control/src/ReplaceRange.edict` did not parse: ParseError { kind: ExpectedToken, message: \"expected `type`, `enum`, or `intent` declaration, found Ident(\\\"fn\\\")\", span: Span { start: 151, end: 153 } }", "schema": "edict.cli.diagnostic/v1", "severity": "error", "stage": "cli", "type": "diagnostic"}], "exitCode": 2, "sourceSha256": "97475b0e6aaf24d3268736efa3312df377b9153b89c8e59f0e2ceb25ce691218", "stderrSha256": "8ce5808f7da7f7457b8cdca7ad00e080f3358a4a35d502d6ac9aee5c83255090", "stdoutSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"} +{"artifactSha256": {}, "artifacts": [], "case": "decimal", "diagnostics": [{"command": "build", "input": {"kind": "stdin"}, "kind": "InvalidApplicationSource", "message": "Edict source `/tmp/echo-726-runtime/jim-buffer-decoder-reproduction196/decimal/src/ReplaceRange.edict` did not parse: ParseError { kind: Lex, message: \"invalid string escape\", span: Span { start: 861, end: 862 } }", "schema": "edict.cli.diagnostic/v1", "severity": "error", "stage": "cli", "type": "diagnostic"}], "exitCode": 2, "sourceSha256": "860712eaae8fad67499967e2475d9a2bef9d072762b3eab1004a3ddf4dba2b94", "stderrSha256": "2c45c51317aa6dffbcd96684a6b288ac9a429c2a19f3672e09c8b85b6ed1adb8", "stdoutSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"} +JIM_BUFFER_DECIMAL_DISTINCT_SOURCE_BOUNDARIES_CONFIRMED diff --git a/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/guard.result.json b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/guard.result.json new file mode 100644 index 00000000..0c9df3b9 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/guard.result.json @@ -0,0 +1,10 @@ +{ + "measurements": { + "build": 14448304197, + "data": 4104511557, + "logs": 11304883, + "host_free": 709664010240, + "vm_free": 674522402816 + }, + "exit_code": 0 +} \ No newline at end of file diff --git a/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/public-build.json b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/public-build.json new file mode 100644 index 00000000..47382e4c --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/public-build.json @@ -0,0 +1,101 @@ +{ + "compiler": { + "commit": "17397e2aad18a83ffc617d1afd628764501f49cd", + "tree": "bcfd3112cd8b3d4630738a88761860679b45714b", + "fileCount": 449, + "manifestSha256": "625592ab9dd715349255bece0133378c64b3d4539fb50e437d116c2a4296f016", + "binarySha256": "83c70b3fdbb42ac43f0967a0c559c0cc8b66599987774a40412bda4fbc028d36" + }, + "providerManifestSha256": "5b38ae704a071b88aa0cc2f85020de41cb69e76d037afe3592a4d319e22587c8", + "providerFiles": { + "components/lowerer.echo-dpo.component.wasm": "4b594a8165079f0a973741b9e27b468cf041f4ad53108fccae641dc35355bd2a", + "components/verifier.echo-dpo.component.wasm": "d0be4d283399aefc45d75b395b3568f9983521ca5543c9dfd23b9495758050ed", + "generated/evidence/provenance.provider-generation.json": "11a8ef81063f769ccfe431047be3473523fadd49582d6c935b7f7f8d7ccd81d5", + "generated/evidence/review.provider-generation.json": "24836f4170809f343a64dcce095a66765cdb922d652458a658d2f896d7547b78", + "generated/primary/authority-facts.echo-dpo.cbor": "e2a6a539a7156296c18ff1bc02f80dcabf62b42bb4314d0737527869e43986d6", + "generated/primary/authority-facts.echo-lawpack.cbor": "ce1af559551f8b8242c4b290b620c5a28323b9e43f8bc6bb161a191001b6f4b9", + "generated/primary/generated-artifact-profile.echo-dpo-registration.cbor": "4ef3aaad0d2131ba7129a3e2ae178d10c44f7e9b062af2c1fe211de781462f34", + "generated/primary/lawpack.echo-dpo.cbor": "8c570362671a0b1cd1a992d8210e4a90ffd153ad06dcdf1e0cb36033cc971e2c", + "generated/primary/schema.echo-provider-artifacts.cddl": "e8b2f078445f1e970bf8e92a33c69bded54a025469791dc3f4a7a418892a3252", + "generated/primary/target-profile.echo-dpo.cbor": "1b105d1b1f6cdf5fecdef98b7adeb238525047d43581fe9fd8c44fd213e1788e", + "generated/resources/resource.conformance-corpus.cbor": "f1f29d990f83c5af33952a69b16e9c9bbb7c2feb1d3989860b74c9e6c2c19b08", + "generated/resources/resource.lawpack-compatibility.cbor": "642945761cb7d60e133008620dc2a6b48fd0f77901b985e02b1d3398fb1411af", + "generated/resources/resource.lawpack-exports.cbor": "e80f3597830f30079bae7428cc6fe1ca27e9f2626614284338c5f5c7bfd9f8b8", + "generated/resources/resource.lawpack-target-adapter.cbor": "d0cf6a5310c7aa3d5bf291e40221a50a9be676d0e7f9947b71de0c52f03f9a41", + "generated/resources/resource.lawpack-verifier.cbor": "a0ca53486f2e1181027cab255792150735a68fc01a93669ab90b58e7c32bd36e", + "generated/resources/resource.target-bundle-profile.cbor": "95cc3aab106f0d6d77ec76e88591ee24acac58f4345c031b77cfd1ecf2aa0db8", + "generated/resources/resource.target-cost-algebra.cbor": "29cc941cc96ffdb420a24a377146f0e9d5409a89f84cdbb2ad597e78dfde3503", + "generated/resources/resource.target-footprint-algebra.cbor": "c08b853b22fa1920cb8971b60a6622e4d8f400c68b8027a9c4f246c5cb4a222c", + "generated/resources/resource.target-intrinsics.cbor": "d4080b044ad95d88763f605d25d678dad0d44bbfdc32c212334a962eaf456588", + "generated/resources/resource.target-ir.cbor": "f0ead7a5dcb41532d5df9067a9735d7078456b59cc267b3a9f6bb6437431000c", + "generated/resources/resource.target-lowerer-contract.cbor": "c4d788a8ae876cfe8c9e9875144014d551d38ff13b4d90bb9dfc46bc562bf280", + "generated/resources/resource.target-obstruction-taxonomy.cbor": "5eb85dc3fbb53890f4f5accf6a7a3c03889bd25bf00e7c2a23c43e497652328e", + "generated/resources/resource.target-operation-profiles.cbor": "3d560e8df1bfb38e8ba9b70b0a4bc843c848a7900e3af76d8f798db51b6b1077", + "generated/resources/resource.target-verifier-contract.cbor": "9cef12fac8190156e152e7c8ab5adeed077bf2bdadf3add2225ce90ab4be8710", + "provider-manifest.echo.json": "5b38ae704a071b88aa0cc2f85020de41cb69e76d037afe3592a4d319e22587c8" + }, + "authoredSourceSha256": "9fc1b006c298866463ab83a28fcb1e54769b970970c571f11d0868d79edc6d87", + "literalCasesStatus": "not executed", + "compositionStatus": "helpers are not connected to a retained-byte scanner", + "results": { + "read-control": { + "exitCode": 0, + "diagnostics": [], + "artifacts": [ + "executable-operation-package.cbor", + "verification-report.cbor" + ], + "sourceSha256": "4ec3cbf32fd5d98987cbeeaff95d7c9c5ab734dac555e443aac52e8ab02bfbc5", + "artifactSha256": { + "executable-operation-package.cbor": "afd931700018312d6c0d1e249871313d2c21c0ece1ae41d1f17f2be7af9e5284", + "verification-report.cbor": "9114fdd983d456eb83f69969475f558b6e608be23520212a5db5f26bb095d04b" + }, + "stdoutSha256": "ee9dd333c256f57a14f42869b19857a2e42c71b0483fcec23a7fc385802edd61", + "stderrSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "fn-control": { + "exitCode": 2, + "diagnostics": [ + { + "command": "build", + "input": { + "kind": "stdin" + }, + "kind": "InvalidApplicationSource", + "message": "Edict source `/tmp/echo-726-runtime/jim-buffer-decoder-reproduction196/fn-control/src/ReplaceRange.edict` did not parse: ParseError { kind: ExpectedToken, message: \"expected `type`, `enum`, or `intent` declaration, found Ident(\\\"fn\\\")\", span: Span { start: 151, end: 153 } }", + "schema": "edict.cli.diagnostic/v1", + "severity": "error", + "stage": "cli", + "type": "diagnostic" + } + ], + "artifacts": [], + "sourceSha256": "97475b0e6aaf24d3268736efa3312df377b9153b89c8e59f0e2ceb25ce691218", + "artifactSha256": {}, + "stdoutSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderrSha256": "8ce5808f7da7f7457b8cdca7ad00e080f3358a4a35d502d6ac9aee5c83255090" + }, + "decimal": { + "exitCode": 2, + "diagnostics": [ + { + "command": "build", + "input": { + "kind": "stdin" + }, + "kind": "InvalidApplicationSource", + "message": "Edict source `/tmp/echo-726-runtime/jim-buffer-decoder-reproduction196/decimal/src/ReplaceRange.edict` did not parse: ParseError { kind: Lex, message: \"invalid string escape\", span: Span { start: 861, end: 862 } }", + "schema": "edict.cli.diagnostic/v1", + "severity": "error", + "stage": "cli", + "type": "diagnostic" + } + ], + "artifacts": [], + "sourceSha256": "860712eaae8fad67499967e2475d9a2bef9d072762b3eab1004a3ddf4dba2b94", + "artifactSha256": {}, + "stdoutSha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderrSha256": "2c45c51317aa6dffbcd96684a6b288ac9a429c2a19f3672e09c8b85b6ed1adb8" + } + } +} diff --git a/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/read-control/ReplaceRange.edict b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/read-control/ReplaceRange.edict new file mode 100644 index 00000000..1031dfc9 --- /dev/null +++ b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/read-control/ReplaceRange.edict @@ -0,0 +1,18 @@ +package jedit.text.replace_range@1; +use lawpack jedit.text@1 digest "sha256:2ea164293719d2b03231c4904eb75ddcdf55fd29cc31f4fc5a5319d9ae5e60e7" as text; +type Input = { address: text.FactAddress, expected: text.FactBytes }; +intent replaceRange(input: Input) returns text.FactBytes + profile text.replaceRange + basis input.address.nodeId + budget <= text.replaceRangeBudget +{ + let actual: text.FactBytes = text.readFact(input.address) + else { + missing(address) => text.FactMissing, + typeMismatch(address) => text.FactMalformed, + notAtom(address) => text.FactMalformed, + tooLarge(address) => text.FactMalformed, + }; + require actual == input.expected else text.BasisNotCanonical; + return actual; +} diff --git a/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/read-control/application/executable-operation-package.cbor b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/read-control/application/executable-operation-package.cbor new file mode 100644 index 0000000000000000000000000000000000000000..a14f9ea230400956ca8558be0f9bd4b23aff4ed4 GIT binary patch literal 10473 zcmeHNeQ*`k6;H)FZN_#O=-4EnE)<1W-Xkv|U_t_fU?eq|7^nqBp7-tE-M3-C*t?r- zhC!2n3ffvfaBw;u$Gik&=mA9I^~a$?B09sx%ZrV&hPxr?v{y|#5(dyv6wWYriE?fsHPFIkhl&hcur?bv20VZ zk-qwpmA{hKsfOfD6HVPxHEc)VmE?+8iX=?ekl=qCBMIins^MV6(QIsKNW|^PP;ju) zrEH~K5p*gQNY?@px@g)sj%-Jjk?5@c_KQ2Q(`{igfSV1=by7?fxgEnWNtRWtNhGBp zNwP5^UP%X*R43|S&siLcHi3W!{w9e%3yThxI&(%W>2@#~;c-fYBPuJJSX9K8#cb@z ztK?H|KsHPXH%lg)TZcVRs=lgnp-gv`=W!RZt=z|os#~V*klvJNV>y*jB`v%WSyB~D zoIaT(QDybKRYJ61DxY8a>b}a@!Mm=0?1p!a{rKzhmt&uPb=`{6xAv^P@k6#9MMGWG z-U_!G>Cdv;LsG(&x(6^-pY-kE=Z`ZB>|qP8Vc1w zVe@?*MzCmRVPyszUSXIC;@GZ8-G4c<1{GZ;1SF<#C(>LzD1m;YhiN5&dYVjsU~Dlp zs0z#Z_$1wV105?Y=M)(XF{pUu_;xlQ4@eUbmWN1Goe`3*c7W8VD6*Xc)hFI7#yt$shVqJ z9x##)wsqA2qk&fw(?}^6>efsoJ=nn?Tm}Br$*j8s5tUqRI*rIM4HZ05wQLA^B69Fx z!n6|g^?W57W)Zy6uFHMf1u{t?;FLAZ;bT`N^D&cA7Y$qG;^`R`}r*WS83MV+(bREc%BV-|qCD2CG zfXss+`;s1q!k#N=#$h;Yi7P4C8At;BSm9ucFbrbAU#(0m!xCjhJw-+9;aP)5F9?7e z{`eb3MMYkTA8Vx60NSSkmj{@qVk61E|n1b2M=5Tqc1 zsG<|4n$Z`c36KlI6a=EOk@I_I+LkJre6mw)Hgz@k!X8T$$yBuCQu5IvDnOruvSP*>U@CCyH;2pad0uvPVHH&hX zNnbMG5$fu5r*gL{-T<9o}T%_gbou0@c7FRe}ryS-A0@lDHR1E#+1EyKNCgno? z!pt%G=xDY-Hk_eHm=J)MV2Y1^MmajbC8HV+781Y$EGzq`A=KCV2OHRxZ#IAW<@2cp z{pkyeHx@(f!*F$`ikUEZH-N#8%&k#CIK}f6$-9}yQU5V5rG`WLCwf*k9<{fBwC1Vp z?zz8cx@hm)O?zkV8QQTvGCQ&L(K*wUPJU}qED67<5W4IX7Bxi3I*I;I3%pLO*sg{N zcId+1)X>VooCq6`Pl0)@L;t#ekMz}>Z``~4{Wo5kyy%Pm!}8>c!-Jh$9;q$vTNH{M z7LOeMIe;)t!WITlY=|@vK#d3R#8Fvf=w_-+38|9xHlHS!9ozKz{X)E5>^Ryoc#Zdu z+B>Hn5^rn09Zg==vTbceyWvn|3bh{slx~yW0VpBZuWYGs@S-(o#DAG@r2~)s@Wcz1 zoo)KzLWb7kEv5WGZM3P>y2ip@4%!DN*#v5*l_?Kz#5 zIi{Sn@aCQyo+RdgZ_dB*);%?Dwp2fIQ_&qvv}Bo! za~&i)W80*%k3ah$^_KA2iCY$Lx#YENo$-eombEm9+g}h)oNESBX<%+hsJ+?o-7A5_ zK+6VXh`34hz^O5ev|Q$-SsAZARNhBT8;Keeb~(Fze8}2(uAZ8<-h%|&8-wy?aW2_*2_Ct=Iw%1g8{z=$J*fY0kUN3kT8dzaQ+H* z7yfSq5QOIQ-iN@LBplVF^m(-6f2y=LLse{pt&>5Axi5lRHsU7@xO4>ywX;}gyBYNY z_*7WGvs!k0Wf>J|Dy7HBs@*fB=U8h2Psr$*0D_GZg%RwD7z1B;hO`}P31sp})NDAm zY7kZQSy2{d8Lo;jm!+H&3Awai#FNd1cbnJo^Sj&0Og!!-7BGGc{OG{iLY{=6)R`5O z{MXTn|8o|j;wsaeg@HXRx|CCFrJ1ZRU#uVDsB?=$E6vZ3vWOe!YEtL-W4v$(fyM)r zpkkwD5=w$4eVhpFHaOtv5!)TS#-tD@2kiNt9Wc>3fMwt6&9D6Bxrv_(6T9DEb>a8U zyE3+>_sc2wJ-z2AT{BbqA5J(K*^Q&Dh0~P)$DbLXGvUDQpP1C>fgRB2EW;kXMC3ua*UD_9SK^oHslwntuVTKo)J6Pl_p zDx~095bmA8rpT(|@;(-`{VbM)(p!mWW)~Djh7zGbH$4<`QI02Ed(Xwzs=-HlWw=_&cCsUO4=ikxJjxJkua3d|npiPA& zLo|tV3L7+K&K5&=0%C(g(k+U-StaNe6g%L7AxYl! z6%;BdbyOBK9A}F`Kce17T@lxjFJB0qU)n1qy}MOLRIP-ajodm7on!u6)WHc=DrJP7 zYKn_&X@zT1X63U}y<`SgH^6l1JC<7KH)Bq&zkysQX~I44X7^kNE}W5_O$aFQ;7X27 zmO)8Gg^Fgv(l>Zqq-9<5agpdBB<)!(1I>BFOQRunIzU1}{-=Qxtl0+4l#VG+(?iA> z9aISD5Fsd!u7&V9*)$Mxt6}b)(@6tHiZ$I<@DC#jT!vxxHaIUqBQ#2AIBVV9u;6o| zr?q0Xhh;4oBDnmoAeIN5>S--G%n@}9z+01Ru+BN@IW^3X(oG8>;7SZB6gmn!RrV)! z8iH8dXa^>Qx;;y+8vD)!+1+%2%m?U<+zAADAp#LL%|5eO2Dz4*StmRww3(VJb`Ns| zCT0o!j>QihCcsj%R3(;4Sjf(fNAx8ysDvPBtWb`uJySukPOCSHbjCO?ZwjIz7D)JX zn#+I!lZT_Wpt~F9--aQ=D|nps%6R`R4vhn#32CxPXRK9!-4T3-Q^qkLA4|Wx@y7xT z>VQNC&uQz2H>_nI!zAEplRf?)yk%{PL1U-8opt?WN?$eSrL+o1?tG0clE!TztUWW6 zp#o4Gp!wi$_RW!ZA;*OAEToq?j=n+KS!<{De97W4A|5qlTn8sdzgVIUIf@UXG=Djk zfmt(8^ZQ=$b)%DDa9kW0F|^a*dlwZX#u=B$#98!Do+9IvaDk2?bO(VO^5XEh3U3ek zFKB0TuiDu&Wcj?9#3fsc;t08nK*iCM*7h!D;QmAk)r z=NF{3zE7;|pEh*(_ysRtH}$8-&)GCsw7*z?Ejh(y{v79?8qdsgj{R)jlY?I#`uYB@ znwa!)DKXeCg1yuP?2AcITEw=EK(~-z{G| zboadzpIQ6JuHWr{@21PVDe0t6ZzGF$p~Vk)wM84Yu9?s_^_9|D$DWA%@xa8stvCJt zUFW02`&u?kYV)SjG+;wqf}eSo-~WSyPV3PQVcLD_Bin~ADX$~@8@7Fty6dWj&CfjB H*XI2jywEx^ literal 0 HcmV?d00001 diff --git a/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/read-control/application/verification-report.cbor b/edict/replace-range-probes/buffer-decoder/evidence/reproduction196/read-control/application/verification-report.cbor new file mode 100644 index 0000000000000000000000000000000000000000..fb4ef5d0720173562ea406229704667c8b56dcae GIT binary patch literal 930 zcmZ3Ho?lv$oS&PTk(ivET2PXjl3tLQoSm4Sx+p0#r9v^aA~m_RBrz!`RX4vNwJ5P9 zGe1ukszNU{IU_$UB{My>xTGnqI3v->)GR__(K^%1vz~jY-I|!{;^wNkC#UMOR@t^^ zpF`eP9%ZxI$eB@+Sd^Yx;#mZ;ARlCeUU5NUo^EE5ewh)5X=#XGmuy7G#E{78L`XRiOzs48xhaWvNA(X_=`-x<#o4`9&rA zWrn#anThFn`Nbuf$&N{xAcp`wo|#;thY&9YD#LJ%#^0iqP0FH{O{X|~G;eR*bj2Xa zGJUmm?#}D~o@G1}*_n^f?^IcmTI^7W2*2Rcq^#8Bl0~UWAel(Uz$HUBq@}RG_BF3~GVttin0#z; text.FactBytes { return value; }\n\n" + + +def compiler_digest(value): + if len(value) != 64 or any(char not in "0123456789abcdef" for char in value): + raise argparse.ArgumentTypeError("compiler SHA-256 must be 64 lowercase hexadecimal digits") + return value + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + for name in ("compiler", "compiler-source", "compiler-manifest", "application-source", + "provider-package", "work-root"): + parser.add_argument("--" + name, type=Path, required=True) + parser.add_argument("--compiler-sha256", type=compiler_digest, + default=HISTORICAL_COMPILER_SHA256, + help="explicit binary pin from the controlled compiler build; defaults to the historical binary") + args = parser.parse_args() + if not Path("/.dockerenv").is_file(): + raise RuntimeError("Run under shared git-locks admission and the guarded Docker lease") + if not args.work_root.resolve().is_relative_to(Path("/tmp/echo-726-runtime")): + raise RuntimeError("Work must stay inside the declared runtime-data accounting root") + common = runpy.run_path(str(Path(__file__).parent.parent / "leaf-slice/run.py")) + sha256, snapshot, verify = common["sha256"], common["snapshot"], common["verify_compiler_source"] + compiler = verify(args.compiler_source, args.compiler_manifest, COMPILER_COMMIT) + compiler["binarySha256"] = sha256(args.compiler) + before = {"application": snapshot(args.application_source), "provider": snapshot(args.provider_package)} + original = (args.application_source / "src/ReplaceRange.edict").read_bytes() + authored = (Path(__file__).parent / "Decimal.edict").read_bytes() + package, declarations = authored.split(b"\n", 1) + if not original.startswith(package + b"\n") or b"type Input" not in original: + raise RuntimeError("Expected the unchanged generic read control's source layout") + expected = json.loads((Path(__file__).parent / "evidence/original/public-build.json").read_text()) + expected_compiler = dict(expected["compiler"], binarySha256=args.compiler_sha256) + if compiler != expected_compiler: + raise RuntimeError("Compiler source or explicitly pinned binary identity differs") + if before["provider"] != expected["providerFiles"]: + raise RuntimeError("Provider bytes differ from the retained public witness") + if sha256(Path(__file__).parent / "Decimal.edict") != expected["authoredSourceSha256"]: + raise RuntimeError("Authored source differs from the retained public witness") + if sha256(args.application_source / "src/ReplaceRange.edict") != expected["results"]["read-control"]["sourceSha256"]: + raise RuntimeError("Read control differs from the retained public witness") + sources = { + "read-control": original, + "fn-control": original.replace(b"type Input", TRIVIAL_FUNCTION + b"type Input", 1), + "decimal": original.replace(b"type Input", declarations + b"\ntype Input", 1), + } + args.work_root.mkdir() + evidence = {"compiler": compiler, + "providerManifestSha256": sha256(args.provider_package / "provider-manifest.echo.json"), + "providerFiles": before["provider"], + "authoredSourceSha256": sha256(Path(__file__).parent / "Decimal.edict"), + "literalCasesStatus": "not executed", + "compositionStatus": "helpers are not connected to a retained-byte scanner", + "results": {}} + for name, source in sources.items(): + root = args.work_root / name + common["prepare"](root, args.application_source, args.provider_package, source) + evidence["results"][name] = common["build"](root, args.compiler) + (args.work_root / "evidence.json").write_text(json.dumps(evidence, indent=2) + "\n") + for name, result in evidence["results"].items(): + print(json.dumps({"case": name, **result}, sort_keys=True), flush=True) + if before != {"application": snapshot(args.application_source), "provider": snapshot(args.provider_package)}: + raise RuntimeError("Public witness changed an authoritative input") + if compiler["binarySha256"] != sha256(args.compiler): + raise RuntimeError("Compiler binary changed during witness") + verify(args.compiler_source, args.compiler_manifest, COMPILER_COMMIT) + positive = evidence["results"]["read-control"] + if (positive["exitCode"] != 0 or positive["diagnostics"] or positive["artifacts"] != + ["executable-operation-package.cbor", "verification-report.cbor"]): + raise RuntimeError("Generic read control did not reach package/report success") + expected_messages = { + "fn-control": ("kind: ExpectedToken", "expected `type`, `enum`, or `intent` declaration", "fn"), + "decimal": ("kind: Lex", "invalid string escape"), + } + for name, markers in expected_messages.items(): + negative = evidence["results"][name] + if negative["exitCode"] != 2 or negative["artifacts"] or len(negative["diagnostics"]) != 1: + raise RuntimeError(f"{name} did not refuse without application artifacts") + diagnostic = negative["diagnostics"][0] + if (diagnostic.get("kind") != "InvalidApplicationSource" + or any(marker not in diagnostic.get("message", "") for marker in markers)): + raise RuntimeError(f"{name} did not reach its retained source boundary") + print("JIM_BUFFER_DECIMAL_DISTINCT_SOURCE_BOUNDARIES_CONFIRMED", flush=True) + + +if __name__ == "__main__": + main() From a7bcff6b7c72fd6c6bc09c9361b4f70868328a8e Mon Sep 17 00:00:00 2001 From: James Ross Date: Thu, 15 Oct 2026 19:23:38 -0700 Subject: [PATCH 21/30] build(edict): repin ReplaceRange application to Edict and Echo main Move the toolchain lock from the Edict 3f81f759 and Echo #724/#726 candidate pins to Edict main e60411fc and Echo main 9b3b9396, and the Rust toolchain to 1.96.0 as Edict main requires. Regenerate the build lock through the harness's --write-locks path. The executable-subject lock is byte-identical, so the verified package did not change. The full proof harness passes 12/12 under Node 22.23.1 and npm 10.9.8 in a container, against isolated clones of both pinned commits. Refs #296, #302 --- CHANGELOG.md | 6 +++++ edict/replace-range/README.md | 24 ++++++++++++------- edict/replace-range/edict.build-lock.json | 20 ++++++++-------- edict/replace-range/edict.toolchain-lock.json | 22 ++++++++--------- edict/replace-range/tests/runtime/Cargo.lock | 19 ++++++++++----- edict/replace-range/tests/runtime/Cargo.toml | 4 ++-- 6 files changed, 57 insertions(+), 38 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e62fb8dc..a2628732 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,12 @@ ## Unreleased +- Repinned the ReplaceRange Edict application to Edict main `e60411fc` and + Echo main `9b3b9396` (provider and pure evaluator), with Rust 1.96.0 as Edict + now requires. The verified executable subject is byte-identical to the + earlier candidate pins; only the build closure changed. The leaf-slice and + range-assembly probe sources now build against Edict main; the Buffer decoder + still refuses at lexing. - Fixed the Edict package-chain harness to use Cargo's reported executable path when CI redirects build output with `CARGO_TARGET_DIR`. The regression compiles and executes the real pinned package without a default-path compiler binary; diff --git a/edict/replace-range/README.md b/edict/replace-range/README.md index 1132d682..9129306a 100644 --- a/edict/replace-range/README.md +++ b/edict/replace-range/README.md @@ -25,24 +25,30 @@ not claim to traverse or rewrite a rope yet. With the merged Edict #201, the public application build lowers those Core `let` nodes into generic, source-ordered Target IR and independently verifies the compiler-owned -result projection. The pinned Echo #724 candidate emits a distinct +result projection. The pinned Echo provider emits a distinct `compiler-produced-bounded-pure/v1` executable package containing the exact Core, lawpack exports, Target IR, and result projection. Echo's structurally separate verifier independently reconstructs that package relation and emits an accepted report bound to retained canonical `echo.executable-subject/v1` bytes. -The compiler pin is Edict main `3f81f759e921a69b04fe8cf8e62e62f8f3dc7b7e`. +The compiler pin is Edict main `e60411fc6eb93c55468cc8c728f7fa9166207a6d`, +which includes merged source functions (#228), proven unsigned subtraction +(#211, #214), and bounded byte length, slice, and concatenation (#217, #221, +#223). Core retains the imported nominal definitions and their shared exact-length `NodeId` representation; record fields refer to those named definitions. The nominal identity test follows that reference chain, and repeated public builds must reproduce identical Core, Target, package, and verifier-report bytes. -The Echo provider remains pinned to the open #724 candidate -`49e9efb68001dfd78563d18bac9359a87671e431`; this evidence does not claim that -provider or this Jedit application has landed on its repository's main branch. +The Echo provider is pinned to Echo main +`9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a`; this evidence does not claim that +this Jedit application has landed on Jedit's main branch. Repinning from the +earlier #724 provider and #726 evaluator candidates left the executable-subject +lock byte-identical; only the build closure changed. The application gate passes that accepted package unchanged to Echo's generic -pure evaluator at `8c725d699241a7e3adee482029031ff6bade25fa`, the open #726 -candidate. A separate test-only Rust host consumes the fresh public-build +pure evaluator at Echo main `9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a`, which +includes the merged pure and bounded-read source-function evaluator (#753). +A separate test-only Rust host consumes the fresh public-build output, not the fixture retained in Echo. It checks both conditional branches, the imported helper result, exact projected bytes, deterministic repetition, the reversed-range constraint, malformed identity bytes, and package-pin @@ -107,8 +113,8 @@ and Echo file; any content, identity, or timestamp mutation fails the run. Only disposable Cargo cache; otherwise runtime build output stays under `.build/`. The runtime witness runs with `--locked` and must emit its completion marker after all assertions pass, so a zero-test Cargo invocation cannot satisfy the -gate. The provider stays pinned to #724; the runtime is independently pinned -to #726. Neither is described as a released or installed product dependency. +gate. The provider and the runtime are both pinned to the same Echo main +commit. Neither is described as a released or installed product dependency. Distinct nominal `BufferId` and `HeadId` contracts retain the same exact 32-byte representation, while a negative compiler witness proves that neither can cross the imported lawpack boundary as diff --git a/edict/replace-range/edict.build-lock.json b/edict/replace-range/edict.build-lock.json index d2d43e57..23cdad44 100644 --- a/edict/replace-range/edict.build-lock.json +++ b/edict/replace-range/edict.build-lock.json @@ -2,10 +2,10 @@ "schema": "jedit.edict-build-lock/v1", "applicationCoordinate": "jedit.text.replace_range@1", "operationCoordinate": "jedit.text.replace_range@1.replaceRange", - "toolchainLockSha256": "5323f86f94f6b1ac5b1bb25c7104f703cc633ff3cc57df5caaa637a7a8455e75", + "toolchainLockSha256": "93237fa565b0b6fc76bf73af21011c1fb96fafad00f853a648090d37608f03df", "sourceClosure": { "schema": "jedit.edict-source-closure/v1", - "digest": "sha256:aa0e80326f1931a0abce94173fc5791c8e28f5021f732ed286117752d8387a8d", + "digest": "sha256:99a6b580413d31a35c92753cc32466a66bf1939e241b8c957bf7b04927cf2b89", "files": [ { "path": "application/edict.application.json", @@ -17,7 +17,7 @@ }, { "path": "application/edict.toolchain-lock.json", - "sha256": "5323f86f94f6b1ac5b1bb25c7104f703cc633ff3cc57df5caaa637a7a8455e75" + "sha256": "93237fa565b0b6fc76bf73af21011c1fb96fafad00f853a648090d37608f03df" }, { "path": "application/src/ReplaceRange.edict", @@ -41,11 +41,11 @@ }, { "path": "application/tests/runtime/Cargo.toml", - "sha256": "8cdf2a89e74d70388e872bbf30484053a639423c9b3c3934e99d67c3254fe53b" + "sha256": "697408353a165e21ca51e887af492af30f6a2359911d0a0296fa981335f0d3c6" }, { "path": "application/tests/runtime/Cargo.lock", - "sha256": "22699d9bfad35c2ecc1bcab2a6bf6b5eeb97cb596e0169ebd37cb18ab2f01b7c" + "sha256": "1831cd4a0a2fcabb8559734a778be6db2d074a5fc7c43dcab20610ff23b7e65a" }, { "path": "application/tests/runtime/compiled_boundary.rs", @@ -81,11 +81,11 @@ }, { "path": "project/package.json", - "sha256": "735a70d8e48f118695529446780d547f8f200dcb0fa453099aa2241d820d9eb5" + "sha256": "87cdea23b9312e769f0eed0e2235bc9172b15007dd5de601b4db7c9f73ad6e76" }, { "path": "project/package-lock.json", - "sha256": "d39f4b39e262e55355315e0a38ad2d10953ae5f6cd48b9fe3a530a128afd01d2" + "sha256": "4e8b2b702328a0f18453b8681a5c1290d05ee445af5c78c4526516d0e396c4e8" } ] }, @@ -95,7 +95,7 @@ }, "provider": { "coordinate": "echo.edict-provider@1", - "digest": "sha256:b065242a81179df02cd450763c8266e866bbca959308f5198b791a919050e0c2" + "digest": "sha256:5650d1d272c78d11a3eee1191c21d7f5cc136c71b163f2398fed42cd6d082c9f" }, "artifacts": { "core": { @@ -128,8 +128,8 @@ "verificationReport": { "coordinate": "jedit.edict-verification-evidence/v1", "domain": "jedit.edict-verification-evidence/v1", - "digest": "sha256:ee2a9c8332640579d184c5bc16118e152490be8213dc0f23c955bab84fd08a18", - "rawSha256": "ab68a3e18ba9c83fb9988e5f7b9fc4e7a5b96a257218717ef4d66f7e2b8ba0e2" + "digest": "sha256:4e76cca44d48e258ea8ca271f859e8ffe986dd4a6ee33b6e069c51bf6e247a9b", + "rawSha256": "c3e641fb7cdcddd5e70ef362333a06ec42cefbdd23b43e3c7754d2111e37d824" }, "executableSubject": { "coordinate": "echo.executable-subject/v1", diff --git a/edict/replace-range/edict.toolchain-lock.json b/edict/replace-range/edict.toolchain-lock.json index a3caa289..a9ef7916 100644 --- a/edict/replace-range/edict.toolchain-lock.json +++ b/edict/replace-range/edict.toolchain-lock.json @@ -1,9 +1,9 @@ { "schema": "jedit.edict-toolchain-lock/v1", "rust": { - "toolchain": "1.94.0", - "rustcVersion": "rustc 1.94.0 (4a4ef493e 2026-03-02)", - "cargoVersion": "cargo 1.94.0 (85eff7c80 2026-01-15)" + "toolchain": "1.96.0", + "rustcVersion": "rustc 1.96.0 (ac68faa20 2026-05-25)", + "cargoVersion": "cargo 1.96.0 (30a34c682 2026-05-25)" }, "validation": { "nodeVersion": "22.23.1", @@ -16,11 +16,11 @@ "files": [ { "path": "package.json", - "sha256": "735a70d8e48f118695529446780d547f8f200dcb0fa453099aa2241d820d9eb5" + "sha256": "87cdea23b9312e769f0eed0e2235bc9172b15007dd5de601b4db7c9f73ad6e76" }, { "path": "package-lock.json", - "sha256": "d39f4b39e262e55355315e0a38ad2d10953ae5f6cd48b9fe3a530a128afd01d2" + "sha256": "4e8b2b702328a0f18453b8681a5c1290d05ee445af5c78c4526516d0e396c4e8" }, { "path": ".github/workflows/ci.yml", @@ -29,26 +29,26 @@ ] }, "edict": { - "commit": "3f81f759e921a69b04fe8cf8e62e62f8f3dc7b7e", + "commit": "e60411fc6eb93c55468cc8c728f7fa9166207a6d", "cliVersion": "0.11.0-alpha.1" }, "echo": { - "commit": "49e9efb68001dfd78563d18bac9359a87671e431", + "commit": "9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a", "provider": { "coordinate": "echo.edict-provider@1", - "digest": "sha256:b065242a81179df02cd450763c8266e866bbca959308f5198b791a919050e0c2", - "manifestSha256": "c5b9fb2fe3a0dc4dad282621a97413225c555be0071f3502b3272952069d42dc", + "digest": "sha256:5650d1d272c78d11a3eee1191c21d7f5cc136c71b163f2398fed42cd6d082c9f", + "manifestSha256": "196ba049ec8ae1c421547c937957983a42c538327d2b980075a8b313dcc76044", "targetProfile": { "coordinate": "echo.dpo@1", "digest": "sha256:2e2494121aecf5e6a2d920f5fb85408825d394765fad41484c416397c920fb04" }, "lowerer": { "coordinate": "echo.dpo.lowerer/component@1", - "sha256": "e842063bd8d8ec12fff5b392a9d6bc646e2e3025c7a0c93726f53eed3cb5a0bf" + "sha256": "ec0debac21c4398b73598c5b5a15a08079ee1f03b8d9d77860d929dd801751b8" }, "verifier": { "coordinate": "echo.dpo.verifier/component@1", - "sha256": "174cf8758815bf2b9f2ef575517aa6d144ed3f2d1995fc65d25a211b9dea82d9", + "sha256": "c262841549c088dbf8892c16e15515a17a2575dcc3e011b1b414b6fe63105790", "contract": { "coordinate": "echo.dpo.verifier/v1", "digest": "sha256:ca96b190728de3d668072ec1bd37d24e5197e7bd9bd54f70966d8c566b9b67f2" diff --git a/edict/replace-range/tests/runtime/Cargo.lock b/edict/replace-range/tests/runtime/Cargo.lock index 3701589c..678e9613 100644 --- a/edict/replace-range/tests/runtime/Cargo.lock +++ b/edict/replace-range/tests/runtime/Cargo.lock @@ -48,6 +48,12 @@ dependencies = [ "generic-array", ] +[[package]] +name = "bunny-num" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2d5c3288a3b7dcf4517c717a864c648777af349a15c86e25db48f86ec099f864" + [[package]] name = "bytemuck" version = "1.25.2" @@ -212,7 +218,7 @@ dependencies = [ [[package]] name = "echo-edict-canonical" version = "0.1.0" -source = "git+https://github.com/flyingrobots/echo?rev=8c725d699241a7e3adee482029031ff6bade25fa#8c725d699241a7e3adee482029031ff6bade25fa" +source = "git+https://github.com/flyingrobots/echo?rev=9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a#9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a" dependencies = [ "hex", "sha2", @@ -221,17 +227,17 @@ dependencies = [ [[package]] name = "echo-registry-api" version = "0.1.0" -source = "git+https://github.com/flyingrobots/echo?rev=8c725d699241a7e3adee482029031ff6bade25fa#8c725d699241a7e3adee482029031ff6bade25fa" +source = "git+https://github.com/flyingrobots/echo?rev=9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a#9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a" [[package]] name = "echo-runtime-schema" version = "0.1.0" -source = "git+https://github.com/flyingrobots/echo?rev=8c725d699241a7e3adee482029031ff6bade25fa#8c725d699241a7e3adee482029031ff6bade25fa" +source = "git+https://github.com/flyingrobots/echo?rev=9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a#9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a" [[package]] name = "echo-wasm-abi" version = "0.1.0" -source = "git+https://github.com/flyingrobots/echo?rev=8c725d699241a7e3adee482029031ff6bade25fa#8c725d699241a7e3adee482029031ff6bade25fa" +source = "git+https://github.com/flyingrobots/echo?rev=9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a#9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a" dependencies = [ "blake3", "ciborium", @@ -567,7 +573,7 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" [[package]] name = "warp-core" version = "0.1.1" -source = "git+https://github.com/flyingrobots/echo?rev=8c725d699241a7e3adee482029031ff6bade25fa#8c725d699241a7e3adee482029031ff6bade25fa" +source = "git+https://github.com/flyingrobots/echo?rev=9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a#9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a" dependencies = [ "blake3", "bytemuck", @@ -588,8 +594,9 @@ dependencies = [ [[package]] name = "warp-math" version = "0.1.0" -source = "git+https://github.com/flyingrobots/echo?rev=8c725d699241a7e3adee482029031ff6bade25fa#8c725d699241a7e3adee482029031ff6bade25fa" +source = "git+https://github.com/flyingrobots/echo?rev=9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a#9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a" dependencies = [ + "bunny-num", "libm", ] diff --git a/edict/replace-range/tests/runtime/Cargo.toml b/edict/replace-range/tests/runtime/Cargo.toml index e8d8fd5d..a8fc5372 100644 --- a/edict/replace-range/tests/runtime/Cargo.toml +++ b/edict/replace-range/tests/runtime/Cargo.toml @@ -8,8 +8,8 @@ publish = false [workspace] [dev-dependencies] -echo-edict-canonical = { git = "https://github.com/flyingrobots/echo", rev = "8c725d699241a7e3adee482029031ff6bade25fa" } -warp-core = { git = "https://github.com/flyingrobots/echo", rev = "8c725d699241a7e3adee482029031ff6bade25fa", features = ["trusted_runtime"] } +echo-edict-canonical = { git = "https://github.com/flyingrobots/echo", rev = "9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a" } +warp-core = { git = "https://github.com/flyingrobots/echo", rev = "9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a", features = ["trusted_runtime"] } [[test]] name = "compiled_boundary" From 783db5311bd0d40115f2f3b238aa7e62e4633dc8 Mon Sep 17 00:00:00 2001 From: James Ross Date: Thu, 15 Oct 2026 19:37:58 -0700 Subject: [PATCH 22/30] docs(edict): draft Edict-authored rope representation and source Add DL-0159, a draft representation for the rope that Jim's Edict source reads and writes: every structural relation is a typed Echo edge, facts use canonical CBOR, immutable nodes are content-addressed over their facts and children, each head links to its basis so every version stays inside Echo's state root, and an import head is anchored to its file coordinate and host digest. Add complete drafts of ReplaceRange in Edict source against that representation: a deliberately inefficient flat-text semantic reference and the persistent AVL rope (pure split, join, balance, build, and collect, plus the effectful intent). They do not compile on Edict main; the README classifies every blocker as language, primitive, runtime, resource, or defect, separates confirmed refusals from code reading, and states the evidence plan. Nothing here enters the application gate. Refs #296, #302, #350 --- CHANGELOG.md | 8 + docs/design/0159-edict-rope-representation.md | 281 ++++++++++++++++++ edict/replace-range/draft/README.md | 133 +++++++++ edict/replace-range/draft/Reference.edict | 93 ++++++ edict/replace-range/draft/ReplaceRange.edict | 165 ++++++++++ edict/replace-range/draft/Rope.edict | 278 +++++++++++++++++ edict/replace-range/draft/Text.edict | 71 +++++ 7 files changed, 1029 insertions(+) create mode 100644 docs/design/0159-edict-rope-representation.md create mode 100644 edict/replace-range/draft/README.md create mode 100644 edict/replace-range/draft/Reference.edict create mode 100644 edict/replace-range/draft/ReplaceRange.edict create mode 100644 edict/replace-range/draft/Rope.edict create mode 100644 edict/replace-range/draft/Text.edict diff --git a/CHANGELOG.md b/CHANGELOG.md index a2628732..662b6432 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,14 @@ ## Unreleased +- Added DL-0159, a draft representation for the Edict-authored rope: schema 2 + with typed Echo edges for every structural relation, canonical CBOR facts, + content-addressed immutable nodes, a basis chain that keeps every version + inside Echo's state root, and an import anchor tying a head to its file. +- Added complete, not-yet-compiling drafts of `ReplaceRange` in Edict source + under `edict/replace-range/draft/`: a flat-text semantic reference and the + persistent AVL rope. Their README classifies every blocker by owner and + states the evidence plan. They are not part of the application gate. - Repinned the ReplaceRange Edict application to Edict main `e60411fc` and Echo main `9b3b9396` (provider and pure evaluator), with Rust 1.96.0 as Edict now requires. The verified executable subject is byte-identical to the diff --git a/docs/design/0159-edict-rope-representation.md b/docs/design/0159-edict-rope-representation.md new file mode 100644 index 00000000..b5bbe67f --- /dev/null +++ b/docs/design/0159-edict-rope-representation.md @@ -0,0 +1,281 @@ +--- +title: "DL-0159 - Edict-Authored Rope Representation" +legend: "DL" +lane: "design" +issue: "https://github.com/flyingrobots/jedit/issues/296" +status: "draft" +owners: + - "@flyingrobots" +created: "2026-10-15" +updated: "2026-10-15" +--- + +# DL-0159 - Edict-Authored Rope Representation + +## Linked Issue + +- [#296 Author and prove Jim's first Edict operation: `ReplaceRange`](https://github.com/flyingrobots/jedit/issues/296) +- [#302 Author ReplaceRange as Jedit-owned Edict source](https://github.com/flyingrobots/jedit/pull/302) +- [#350 Reopening a file silently reuses a stale rope](https://github.com/flyingrobots/jedit/issues/350) +- Echo decision: [Application operation semantics authored in Edict source](https://github.com/flyingrobots/echo/blob/docs/edict-authored-operation-effects/docs/topics/GeneratedRules.md#application-operation-semantics-authored-in-edict-source) + (proposed for review) +- Echo design: [Authored Operation Effects](https://github.com/flyingrobots/echo/blob/docs/edict-authored-operation-effects/docs/architecture/authored-operation-effects.md) + (proposed for review) + +## Decision Summary + +The rope that Jim's Edict source reads and writes uses a new text schema, +`jedit.text.schema@2`. Every structural relation is an Echo edge; atoms carry +only scalar facts. Atom payloads use Echo's canonical CBOR v1. Immutable nodes +are content-addressed over their facts and their ordered children, so unchanged +subtrees keep their identity across edits. Each head links to its basis head, so +every retained version stays reachable from the worldline root and therefore +inside the state root. An imported head is anchored to the file coordinate and +the host digest of the bytes it was built from. + +This replaces nothing in production yet. `jedit.text.schema@1` (DL-0158), the +native planner, and its oracle remain the current truth. Schema 2 is the +representation the authored source in `edict/replace-range/draft/` targets. + +## Sponsored Human + +A developer editing in Jim wants every edit to be explainable and recoverable +from Echo's own history, without trusting a native planner whose structure Echo +cannot see. + +## Sponsored Agent + +An agent needs every rope version, and the file bytes each version came from, +to be reachable through typed graph structure, so it can explain or replay an +edit without decoding application JSON. + +## Hill + +A reviewer can check, from this document and the draft source alone, which +node, edge, and atom an Edict-authored `ReplaceRange` reads and writes, and why +old versions remain visible to the state root. + +## Current Truth + +Schema 1 (DL-0158, `native/jedit-echo-host/src/records.rs`): + +- Seven fact types (Buffer, Blob, Leaf, Branch, Head, Rewrite, Diff), each a + node whose alpha atom is compact field-ordered UTF-8 JSON. +- Child links are node ids inside that JSON. The graph has no edges. +- Leaves reference a byte range inside a separate Blob. +- Per-node metrics include UTF-16 length, which only the native rope reads. +- `BufferFact` is the only mutable node; it names the canonical head by id. + +Echo facts that constrain the choice (Echo main `9b3b9396`): + +- The state root walks outgoing edges from the worldline root. Nodes reachable + only through ids inside atom bytes are excluded from it + (`crates/warp-core/src/snapshot.rs`, `worldline_state.rs`). +- Echo's attachment law forbids hiding structural dependencies in payload bytes + (`crates/warp-core/src/attachment.rs`; `docs/invariants/warp-two-plane-law.md`). +- Edge ids are caller-chosen 32 bytes; a node may have many incoming edges. +- Nothing is garbage-collected; reachability decides only what the state root + commits. + +So schema 1 rope versions persist in the store but are invisible to the state +root, and Edict would have to parse JSON to follow a child. + +## Problem + +Jim's rope must be authored in Edict and realized by generic Echo machinery. +That needs a representation whose structure Echo can see, hash, and retain; +whose bytes have one canonical spelling; and whose identity is honestly related +to the file it came from. + +## Scope + +- Fact types, codec, identity law, edge types, and metrics for schema 2. +- The head-to-file anchor. +- Which generic Echo and Edict capabilities this representation requires. + +## Non-Goals + +- Migrating schema 1 buffers. A witnessed migration operation is follow-on work. +- Save/export. The export crossing is designed separately; #350 covers reopen. +- Checkpoints, rewrites, diffs, and anchors beyond the import anchor. +- Any change to Echo or Edict. This document names their gaps only. + +## Data / State Model + +Facts (alpha atoms, canonical CBOR v1 via `echo-edict-canonical`): + +| Node | Atom fields | Mutable | +| --- | --- | --- | +| `Buffer` | `bufferKey`, `version: U64` | yes: `version` and its `canonicalHead` edge | +| `Head` | `byteLength: U64`, `lineCount: U64`, `sequence: U64` | no | +| `Branch` | `byteLength: U64`, `lineBreaks: U64`, `height: U8` | no | +| `Leaf` | `bytes: Bytes`, `lineBreaks: U64` | no | +| `Import` | `fileCoordinate`, `hostDigest: Bytes` | no | + +Edges (no payload; one edge per source node and type): + +| Edge type | From → to | Meaning | +| --- | --- | --- | +| `jedit.text.canonicalHead` | Buffer → Head | current head; retargeted by each edit | +| `jedit.text.root` | Head → Branch or Leaf | the head's tree; absent for empty text | +| `jedit.text.basis` | Head → Head | the head this one was derived from | +| `jedit.text.anchor` | Head → Import | the imported bytes a head descends from | +| `jedit.text.left`, `jedit.text.right` | Branch → Branch or Leaf | ordered children | + +Identity law: + +- Immutable node id: `H("jedit.text.node.v2", typeId, atomBytes, childIds...)` + with children in edge-type order. Equal subtrees have equal ids. +- Edge id: `H("jedit.text.edge.v2", fromNodeId, edgeTypeId)`. This makes + "one edge per source and type" hold by construction, and retargeting the + canonical head an edge replacement rather than a new edge. +- Buffer id: `H("jedit.text.buffer.v2", bufferKey)`, as in schema 1. +- `H` is the domain-separated hash Echo exposes to Edict; which hash that is + remains an open question below. + +Rope law (unchanged from schema 1 except where noted): + +- Leaves hold at most 4096 bytes and end on a UTF-8 boundary. +- Branches are binary and AVL-balanced by `height`. +- Edits path-copy: only nodes on the affected paths and the new head are new. + Nothing is deleted. +- Leaves hold their bytes inline. Schema 1's Blob indirection is dropped; + content addressing already deduplicates equal leaves. +- UTF-16 length is dropped from stored metrics. No consumer outside the native + rope reads it; a reading may derive it. + +History reachability: worldline root → Buffer → `canonicalHead` → Head → +`basis` → older Head → … Every retained version is reachable, so the state root +commits all of them. + +Head-to-file identity (anchored refinement): + +- Importing a file creates an `Import` node for its coordinate and the host + digest of the imported bytes, and anchors the import head to it. +- Every later head reaches its `Import` through the `basis` chain. +- Reopening compares the current host digest with the anchored digest. A + mismatch is a typed obstruction or an explicit, witnessed external-edit + transition, never silent reuse (#350). +- Export to the file is a separate witnessed crossing, designed later. + +## Runtime / API Contract + +The authored `ReplaceRange` operation, in schema 2 terms: + +1. Read Buffer and its `canonicalHead`; require it equals the invocation basis. +2. Read the bounded closure of nodes the edit touches: both boundary paths and + the spines a join may descend. +3. Compute, purely, the new nodes and edges. +4. `ensure` each new immutable node and edge; replace the `canonicalHead` edge + and bump `Buffer.version`. All or nothing. + +Generic capabilities this needs, none of which exists today: + +| Need | Owner | Status on main | +| --- | --- | --- | +| Read outgoing edges by type (`edict_read`) | Echo | absent; reads alpha atoms only | +| Bounded closure read guided by a pure selector | Echo + Edict | absent | +| `ensure` (create, or require equal existing) | Echo + Edict | absent; create obstructs on existing | +| Multi-node, multi-edge atomic effects from evaluation | Echo | absent; see Echo bridge design | +| Edge create and replace effects | Echo + Edict | absent | +| Domain-separated hash in Edict source | Edict + Echo | absent | + +## Lower Modes + +Not applicable: this is a storage representation, not a user surface. + +## Accessibility Posture + +Not applicable. + +## Localization / Directionality Posture + +Text is stored as UTF-8 bytes without normalization. Line breaks count `\n` +only, as in schema 1. + +## Agent Inspectability / Explainability Posture + +Every relation an agent needs is a typed edge, so an agent can traverse rope +history without decoding application payloads. + +## Linked Invariants + +- Echo two-plane law: structure in the skeleton, not in payload bytes. +- History Over State ch. 21 and 42: a rope head is the workspace coordinate, + an anchored refinement of it, or the source of a witnessed crossing. +- DL-0158: codec or edge migration is a separately admitted operation. + +## Design Alternatives Considered + +- **Child ids inside atoms (schema 1 shape).** Rejected: children fall outside + the state root, and the shape breaks Echo's two-plane law. +- **Edges plus duplicated child ids in atoms.** It would let today's + `edict_read` follow children without an edge read. Rejected: two sources of + truth for one relation, with nothing enforcing agreement. +- **Keep JSON atoms.** Rejected: forces Edict source to parse JSON + byte-by-byte (the #302 Buffer-decoder probe) and admits several spellings. +- **Keep Blob slices.** Rejected for schema 2: adds an indirection and a slice + read per leaf; content-addressed leaves already deduplicate. +- **Keep UTF-16 length.** Deferred: adds a Unicode-counting primitive to the + critical path for a metric nothing outside the native rope reads. + +## Decision + +Adopt schema 2 as above for the Edict-authored rope, on review of this document +and the Echo evaluation-to-effect design. + +## Implementation Slices + +1. Publish `jedit.text.schema@2` (machine-readable, like schema 1). +2. Write a simple, deliberately inefficient Edict reference `ReplaceRange` + (semantic target), then the persistent rope (persistence target). +3. Build a schema 2 oracle by differential comparison: the reference and the + persistent rope must agree on logical text and outcomes, not physical roots. +4. Witnessed schema 1 → 2 migration. + +## Tests To Write First + +- Canonical codec vectors for every fact type, including rejection of + non-canonical encodings. +- Identity: equal subtrees produce equal ids; any atom or child change changes + the id. +- Reachability: after N edits, all N+1 heads are reachable and inside the state + root. +- Anchor: reopen with a changed host digest obstructs (#350). + +## Acceptance Criteria + +- Schema 2 declaration published with codec vectors. +- The draft authored source reads and writes only schema 2 propositions. +- Every needed generic capability has an owner issue. + +## Validation Plan + +Codec and identity vectors in this repository; reachability and atomicity +through the Echo bridge once it exists. + +## Playback / Witness + +None yet. This is a representation decision. + +## Risks + +- **State-root cost.** Echo recomputes the root by walking the whole reachable + graph on every commit. Keeping all history reachable makes that walk grow + with history. This is a generic Echo cost (an incremental or Merkle root + would fix it), not a reason to hide history. Recorded; deferred. +- **Patch size.** About `(depth + 1) × (node + atom + up to 2 edges)` operations + per edit, against Echo's 128 operations per tick. Depth stays near + `1.44 × log2(leaves)`; to be measured. +- **Hash choice.** The id hash must be one Edict and Echo both expose. + +## Follow-On Debt + +- Open: which hash Edict source exposes for identities. +- Open: whether Head should carry a content digest of its full text, so a + reopen check need not materialize the rope. +- Open: Rewrite and Diff facts in schema 2. + +## Retrospective + +Not yet. diff --git a/edict/replace-range/draft/README.md b/edict/replace-range/draft/README.md new file mode 100644 index 00000000..0a185afe --- /dev/null +++ b/edict/replace-range/draft/README.md @@ -0,0 +1,133 @@ +# ReplaceRange in Edict source: complete drafts + +These files are the whole `ReplaceRange` program written the way it should +read, against the schema 2 representation in +[DL-0159](../../../docs/design/0159-edict-rope-representation.md). They are not +part of the application gate and they do not compile yet. Their job is to let +the program drive the language and runtime work instead of isolated probes. + +| File | Target | Content | +| --- | --- | --- | +| `Text.edict` | shared | schema 2 facts, edge types, identity law, text metrics | +| `Reference.edict` | 1: semantic correctness | flat-text `ReplaceRange`; deliberately inefficient | +| `Rope.edict` | 2: persistent rope | pure AVL split, join, balance, build, collect | +| `ReplaceRange.edict` | 2: persistent rope | closure read, pure replace, `ensure` effects, head retarget | + +The two targets are separate on purpose. Target 1 needs almost no new language +and isolates the Echo effect bridge. Target 2 adds the language features a +persistent structure needs. Target 1 then serves as a differential oracle for +target 2: they must agree on logical text and outcomes, not physical roots. +Target 1 does not complete the rope. + +## Compiler result + +Built against Edict main `e60411fc` with this application's lawpack closure: + +| File | First refusal | +| --- | --- | +| `Text.edict` | parse: bytes literal `b"\n"` (bytes literals are not lexed; see below) | +| `Reference.edict` | parse: `use module` is not an import kind | +| `Rope.edict` | parse: `use module` is not an import kind | +| `ReplaceRange.edict` | parse: `use module` is not an import kind | + +The parser stops at the first error, so the classification below is per +construct. **Confirmed** means a build against Edict main was run for that +construct. **Read** means it was established by reading compiler or runtime +source on main, not by running it. + +## Blockers by class + +### Language expressiveness (Edict source) + +| Construct | Used by | Status on main | +| --- | --- | --- | +| Integer `+` on `U64` | both | refused, **confirmed** (`TypeMismatch`) | +| Variant types and `match` | target 2 | refused, **confirmed** (`only record type declarations`) | +| Recursive types with a depth bound | target 2 | refused, **confirmed** (`UnresolvedType`) | +| Recursive functions with a termination measure | target 2 | refused, **confirmed** (`ReferenceCycle`) | +| Expression `if … else if …` | both | accepted, **confirmed** | +| Bytes slice and concatenation | both | accepted, **confirmed** (leaf-slice, range-assembly probes) | +| Source-module import (`use module`) | both | refused, **confirmed** | +| Bytes literals `b"…"` | both | refused anywhere, **confirmed**: lexed as identifier `b` then a string; [edict#249](https://github.com/flyingrobots/edict/issues/249) | +| `\r` and explicit byte escapes | decoder only | refused, **confirmed**; [edict#249](https://github.com/flyingrobots/edict/issues/249) | +| `Option`, `some`/`none`/`isSome`/`unwrap` | target 2 | refused, read | +| `List` construction, `++`, `len(list)` | target 2 | refused, read | +| `enum` declarations | target 2 | refused, read | +| Record spread `{ ...x, f: v }` | both | refused, read | +| Function preconditions and flow-sensitive proofs for `-` and `slice` | both | refused inside functions, read | +| Typed failure in pure functions (`fails`, `expect`) | target 2 | not in the spec; proposed | +| `U64` division, `min`/`max` | target 2 | refused, read | +| Source `hash` with a domain label | both | in the spec; not implemented, read | + +### Generic data-structure primitives + +| Primitive | Used by | Why | +| --- | --- | --- | +| `core.bytes.at(bytes, i) -> U8` | both | UTF-8 boundary check | +| `core.bytes.count(bytes, byte) -> U64` | both | line-break metric | +| `core.bytes.isUtf8(bytes) -> Bool` | both | replacement validity | +| `core.cbor.encode(value)` | both | identity input in the canonical codec | + +None of these knows about text editing. They are byte and codec utilities. + +### Runtime realization (Echo) + +All are covered by the proposed Echo design +[Authored Operation Effects](https://github.com/flyingrobots/echo/blob/docs/edict-authored-operation-effects/docs/architecture/authored-operation-effects.md): + +| Need | Used by | Status on main | +| --- | --- | --- | +| Evaluated operation → proposed effects → atomic commit | both | absent (read) | +| `ensure` node: create, or require identical | both | absent; create obstructs on existing (read) | +| Edge read by type, edge `ensure`, edge compare-and-retarget | both | absent (read) | +| Atom compare-and-replace from evaluation | both | only with caller-supplied bytes (read) | +| Guided closure read with a pure Edict selector | target 2 | absent (read) | +| `for` with effects lowered to Target IR | target 2 | Target refuses `For` (read) | + +### Performance and resources + +- Closure size: two boundary paths plus their inner spines, `O(h²)` nodes, + with `h ≤ 1.44 log2(leaves)`. Bounded by `text.maxClosureNodes`. +- Patch size: about `(h + 1)` new branches, up to 2 new leaves plus + `replacement / 4096` leaves, two edges per branch, one head, three head + edges. Echo caps a Tick at 128 operations, which a 1 MiB replacement exceeds; + the cap or the replacement bound must move, and that is a measured decision. +- Echo's state root walks all reachable history on every commit (DL-0159 risk). +- Echo charges a full copy for every local read; `Tree` values are large. + +### Ordinary defects + +- [jedit#350](https://github.com/flyingrobots/jedit/issues/350): reopen reuses + a stale rope. Prerequisite for durable file integration. +- [edict#249](https://github.com/flyingrobots/edict/issues/249): lexer escapes. + +## Evidence plan + +The 40-case oracle (6 committing, 34 obstructed) is a baseline generated from +the native planner. The rope is not complete until these also hold: + +| Property | Evidence | +| --- | --- | +| Edit correctness | Generated edit sequences give the same logical text through target 1 and target 2, and through the native planner where its schema 1 cases apply. | +| Persistence | After N edits, every earlier head is still readable and unchanged. | +| Structural sharing | Nodes outside the boundary closure keep their ids across an edit. | +| Canonicalization | Logically equal facts encode to identical bytes; non-canonical encodings are refused. | +| Replay | The same admitted history reproduces identical roots and receipts on a fresh host. | +| Atomicity | A failure injected at any effect of a multi-node edit leaves no partial effect. | +| Conflict | A stale basis, or an `ensure` that meets different existing content, obstructs safely. | +| Unicode | UTF-8 boundaries, multi-byte scalars, combining marks, and surrogate-pair characters (four-byte UTF-8) at every split position. | +| Resource bounds | Exhausting steps, bytes, closure nodes, or the Tick operation cap gives a typed result with no commit. | +| Reopen and save | An external file change can never silently reuse stale rope state (#350). | +| Commutation | Two edits against one fixed basis: state exactly when their order can commute, and test that condition rather than assume it. | +| Closure sufficiency | Over generated trees and ranges, `replace` never fails with `ClosureTooSmall` under the selector. | + +## Open design points in the drafts + +- The closure selector's expansion rule (boundary paths, inner spines, and the + no-op range) is argued, not proven. A `ClosureTooSmall` failure maps to + `MalformedRope`; it should instead be impossible, and a property test must + show it. +- Duplicate fresh leaves with equal content produce the same id twice; the + effect bridge must make a repeated `ensure` in one proposal canonical. +- `Reference.edict`'s single text node is bounded at 1 MiB; target 1 says + nothing about larger buffers. diff --git a/edict/replace-range/draft/Reference.edict b/edict/replace-range/draft/Reference.edict new file mode 100644 index 00000000..82009749 --- /dev/null +++ b/edict/replace-range/draft/Reference.edict @@ -0,0 +1,93 @@ +// Draft: semantic reference ReplaceRange (acceptance target 1). +// +// Deliberately inefficient. A head owns one flat Text node holding the whole +// buffer, so every edit rewrites the whole text. It exists to prove the +// language and the Echo effect bridge on a small surface, and to serve as a +// differential oracle for the persistent rope in Rope.edict and +// ReplaceRange.edict. The two agree on logical text and outcomes, not on +// physical roots. It does not complete the rope. +package jedit.text.reference@1; + +use lawpack jedit.text@2 as text; +use target echo.dpo@1 as echo; +use module jedit.text.v2@1 as v2; // PROPOSED: source-module import + +type TextFact = { + bytes: Bytes, + lineBreaks: U64, +}; + +type Input = { + bufferId: text.BufferId, + basisHeadId: text.HeadId, + startByte: U64, + endByte: U64, + replacement: Bytes, +}; + +type Result = { + headId: text.HeadId, + byteLength: U64, + lineCount: U64, + sequence: U64, +}; + +intent replaceRange(input: Input) returns Result + profile text.replaceRange + basis input.basisHeadId + footprint <= text.referenceReplaceRangeFootprint + budget <= text.referenceReplaceRangeBudget + where input.startByte <= input.endByte +{ + let bufferRef = echo.ref(input.bufferId); + let buffer = bufferRef.read() else text.FactMissing; + let canonical = echo.edge(bufferRef) + .target() else text.FactMissing; // PROPOSED: read an edge by type + require canonical == input.basisHeadId else text.BasisNotCanonical; + + let headRef = echo.ref(input.basisHeadId); + let head = headRef.read() else text.FactMissing; + let textId = echo.edge(headRef) + .target() else text.FactMissing; + let old = echo.ref(textId).read() else text.FactMissing; + require len(old.bytes) == head.byteLength else text.MalformedRope; + + require input.endByte <= len(old.bytes) else text.RangeOutOfBounds; + require v2.isCharBoundary(old.bytes, input.startByte) else text.Utf8BoundaryInvalid; + require v2.isCharBoundary(old.bytes, input.endByte) else text.Utf8BoundaryInvalid; + require core.bytes.isUtf8(input.replacement) else text.Utf8BoundaryInvalid; // PROPOSED + require slice(old.bytes, input.startByte, input.endByte) != input.replacement + else text.NoOp; + + let bytes = slice(old.bytes, 0u64, input.startByte) + + input.replacement + + slice(old.bytes, input.endByte, len(old.bytes)); + require len(bytes) <= 1048576u64 else text.RangeOutOfBounds; // needs a bound proof + let fact = { bytes, lineBreaks: v2.lineBreaks(bytes) }; + let newTextId = v2.nodeId("text", core.cbor.encode(fact), []); // PROPOSED encode + echo.ref(newTextId).ensure(fact) else text.ContentIdentityMismatch; + + let newHead = { + byteLength: len(bytes), + lineCount: fact.lineBreaks + 1u64, // needs checked + + sequence: head.sequence + 1u64, + }; + let newHeadId = v2.nodeId("head", core.cbor.encode(newHead), [newTextId, input.basisHeadId]); + let newHeadRef = echo.ref(newHeadId); + newHeadRef.ensure(newHead) else text.ContentIdentityMismatch; + echo.edge(newHeadRef) + .ensure(newTextId) else text.ContentIdentityMismatch; // PROPOSED: edge ensure + echo.edge(newHeadRef) + .ensure(input.basisHeadId) else text.ContentIdentityMismatch; + + echo.edge(bufferRef) + .replace(input.basisHeadId, newHeadId) else text.BasisNotCanonical; // PROPOSED: compare-and-retarget + bufferRef.replace({ ...buffer, version: buffer.version + 1u64 }) else text.BasisNotCanonical; + + return { + headId: newHeadId, + byteLength: newHead.byteLength, + lineCount: newHead.lineCount, + sequence: newHead.sequence, + }; +} diff --git a/edict/replace-range/draft/ReplaceRange.edict b/edict/replace-range/draft/ReplaceRange.edict new file mode 100644 index 00000000..ea09445f --- /dev/null +++ b/edict/replace-range/draft/ReplaceRange.edict @@ -0,0 +1,165 @@ +// Draft: persistent-rope ReplaceRange intent (acceptance target 2). +// +// Reads the boundary closure of the edit in one bounded read, computes the +// path-copied tree with the pure law in Rope.edict, and proposes `ensure` +// effects for every fresh node and edge plus one compare-and-retarget of the +// canonical head. Echo validates and commits the proposal atomically or +// obstructs with no patch (Echo: Authored Operation Effects, proposed). +// +// Not compiled by the application gate. See README.md for the status of each +// construct. Lines marked PROPOSED use syntax the Edict spec does not define. +package jedit.text.replace_range@2; + +use lawpack jedit.text@2 as text; +use target echo.dpo@1 as echo; +use module jedit.text.v2@1 as v2; // PROPOSED: source-module import +use module jedit.text.rope@1 as rope; + +type Input = { + bufferId: text.BufferId, + basisHeadId: text.HeadId, + startByte: U64, + endByte: U64, + replacement: Bytes, +}; + +type Result = { + headId: text.HeadId, + rootNodeId: Option, + byteLength: U64, + lineCount: U64, + sequence: U64, + createdLeaves: U64, + createdBranches: U64, +}; + +// ---- Boundary closure selector ---- +// +// The closure read starts at the head's root and asks this pure function, at +// each expanded branch, which children to expand. It expands: +// - every node whose byte interval contains `start` or `end` (the boundary +// paths split descends); +// - the right spine of each left sibling and the left spine of each right +// sibling hanging off a boundary path, because join and rebalance descend +// exactly those spines; +// - every node inside [start, end) when the range length equals the +// replacement length, so the no-op check can materialize the old bytes. +// Every other child stays a stub and is reused by identity. + +type Spine = enum { Boundary, RightSpine, LeftSpine, Range }; +type Visit = { lo: U64, hi: U64, spine: Spine }; +type Want = { start: U64, end: U64, needRange: Bool }; +type Expansion = { left: Option, right: Option }; + +fn contains(lo: U64, hi: U64, at: U64) -> Bool { return lo <= at && at <= hi; } + +fn expand(want: Want, visit: Visit, leftLength: U64) -> Expansion { + let mid = visit.lo + leftLength; // needs checked + + let left = { lo: visit.lo, hi: mid, spine: Spine::Boundary }; + let right = { lo: mid, hi: visit.hi, spine: Spine::Boundary }; + return match visit.spine { + RightSpine => { left: none(), right: some({ ...right, spine: Spine::RightSpine }) }, + LeftSpine => { left: some({ ...left, spine: Spine::LeftSpine }), right: none() }, + Range => { left: some({ ...left, spine: Spine::Range }), right: some({ ...right, spine: Spine::Range }) }, + Boundary => { + left: some(if touches(want, left) then left else { ...left, spine: sideSpine(want, left, Spine::RightSpine) }), + right: some(if touches(want, right) then right else { ...right, spine: sideSpine(want, right, Spine::LeftSpine) }), + }, + }; +} + +fn touches(want: Want, v: Visit) -> Bool { + return contains(v.lo, v.hi, want.start) || contains(v.lo, v.hi, want.end); +} + +fn sideSpine(want: Want, v: Visit, outside: Spine) -> Spine { + return if want.needRange && want.start <= v.lo && v.hi <= want.end then Spine::Range else outside; +} + +// ---- Operation ---- + +intent replaceRange(input: Input) returns Result + profile text.replaceRange + basis input.basisHeadId + footprint <= text.replaceRangeFootprint + budget <= text.replaceRangeBudget + where input.startByte <= input.endByte +{ + let bufferRef = echo.ref(input.bufferId); + let buffer = bufferRef.read() else text.FactMissing; + let canonical = echo.edge(bufferRef) + .target() else text.FactMissing; // PROPOSED: read an edge by type + require canonical == input.basisHeadId else text.BasisNotCanonical; + + let headRef = echo.ref(input.basisHeadId); + let head = headRef.read() else text.FactMissing; + require input.endByte <= head.byteLength else text.RangeOutOfBounds; + require core.bytes.isUtf8(input.replacement) else text.Utf8BoundaryInvalid; // PROPOSED + + let want = { + start: input.startByte, + end: input.endByte, + needRange: input.endByte - input.startByte == len(input.replacement), + }; + let root = echo.closure( // PROPOSED generic guided closure read + echo.edge(headRef), + { lo: 0u64, hi: head.byteLength, spine: Spine::Boundary }, + expand(want, _, _), // PROPOSED partial application + maxNodes: text.maxClosureNodes, + maxDepth: text.maxTreeHeight, + ).read() else text.MalformedRope; + require rope.byteLength(root) == head.byteLength else text.MalformedRope; + + require rope.isCharBoundaryIn(root, input.startByte) else text.Utf8BoundaryInvalid; + require rope.isCharBoundaryIn(root, input.endByte) else text.Utf8BoundaryInvalid; + require !want.needRange + || rope.rangeBytes(root, input.startByte, input.endByte) != input.replacement + else text.NoOp; + + let next = rope.replace(root, input.startByte, input.endByte, input.replacement) + else { ClosureTooSmall => text.MalformedRope }; // PROPOSED: map a pure failure + let fresh = rope.created(next); + + for leaf in fresh.leaves bounded text.maxCreatedLeaves { + echo.ref(leaf.id).ensure(leaf.fact) else text.ContentIdentityMismatch; + } + for node in fresh.branches bounded text.maxCreatedBranches { + let nodeRef = echo.ref(node.id); + nodeRef.ensure(node.fact) else text.ContentIdentityMismatch; + echo.edge(nodeRef) + .ensure(rope.idOf(node.left)) else text.ContentIdentityMismatch; // PROPOSED: edge ensure + echo.edge(nodeRef) + .ensure(rope.idOf(node.right)) else text.ContentIdentityMismatch; + } + + let m = rope.metrics(next); + let newHead = { + byteLength: m.byteLength, + lineCount: m.lineBreaks + 1u64, // needs checked + + sequence: head.sequence + 1u64, + }; + let rootId = if m.byteLength == 0u64 then none() else some(rope.idOf(next)); + let newHeadId = v2.nodeId("head", core.cbor.encode({ newHead, rootId }), [input.basisHeadId]); + let newHeadRef = echo.ref(newHeadId); + newHeadRef.ensure(newHead) else text.ContentIdentityMismatch; + if isSome(rootId) { + echo.edge(newHeadRef) + .ensure(unwrap(rootId)) else text.ContentIdentityMismatch; + } + echo.edge(newHeadRef) + .ensure(input.basisHeadId) else text.ContentIdentityMismatch; + + echo.edge(bufferRef) + .replace(input.basisHeadId, newHeadId) else text.BasisNotCanonical; // PROPOSED: compare-and-retarget + bufferRef.replace({ ...buffer, version: buffer.version + 1u64 }) else text.BasisNotCanonical; + + return { + headId: newHeadId, + rootNodeId: rootId, + byteLength: m.byteLength, + lineCount: newHead.lineCount, + sequence: newHead.sequence, + createdLeaves: len(fresh.leaves), + createdBranches: len(fresh.branches), + }; +} diff --git a/edict/replace-range/draft/Rope.edict b/edict/replace-range/draft/Rope.edict new file mode 100644 index 00000000..1d8193da --- /dev/null +++ b/edict/replace-range/draft/Rope.edict @@ -0,0 +1,278 @@ +// Draft: persistent AVL rope law, pure (acceptance target 2). +// +// Every function here is pure. The intent in ReplaceRange.edict reads the +// region an edit touches, calls `replace`, and turns the fresh nodes it +// returns into `ensure` effects. Unchanged subtrees appear as `Stub`s and are +// reused by identity, never re-created: that is the path copy. +// +// Not compiled by the application gate. See README.md for the status of each +// construct. Lines marked PROPOSED use syntax the Edict spec does not define. +package jedit.text.rope@1; + +use lawpack jedit.text@2 as text; +use module jedit.text.v2@1 as v2; // PROPOSED: source-module import + +// ---- Local view of a rope region ---- + +// A tree read by the boundary closure (ReplaceRange.edict) or built by this +// edit. `fresh` marks nodes this edit creates. +type Tree = variant { + Empty, + Leaf(LeafView), + Branch(BranchView), + Stub(StubView), +} depth <= text.maxTreeHeight; // PROPOSED: depth-bounded recursion + +type LeafView = { id: NodeId, fact: v2.LeafFact, fresh: Bool }; +type BranchView = { id: NodeId, fact: v2.BranchFact, left: Tree, right: Tree, fresh: Bool }; +type StubView = { id: NodeId, byteLength: U64, lineBreaks: U64, height: U8 }; + +type Metrics = { byteLength: U64, lineBreaks: U64, height: U8 }; +type Pair = { left: Tree, right: Tree }; +type Created = { + leaves: List, + branches: List, +}; + +// A pure function may fail only with a declared, typed failure. The caller +// maps it to an obstruction. // PROPOSED: `fails` / `expect` +failure ClosureTooSmall; + +// ---- Metrics and constructors ---- + +fn metrics(t: Tree) -> Metrics { + return match t { + Empty => { byteLength: 0u64, lineBreaks: 0u64, height: 0u8 }, + Leaf(l) => { byteLength: len(l.fact.bytes), lineBreaks: l.fact.lineBreaks, height: 1u8 }, + Branch(b) => { byteLength: b.fact.byteLength, lineBreaks: b.fact.lineBreaks, height: b.fact.height }, + Stub(s) => { byteLength: s.byteLength, lineBreaks: s.lineBreaks, height: s.height }, + }; +} + +fn height(t: Tree) -> U8 { return metrics(t).height; } +fn byteLength(t: Tree) -> U64 { return metrics(t).byteLength; } + +fn idOf(t: Tree) -> NodeId fails ClosureTooSmall { + return match t { + Empty => fail ClosureTooSmall, // callers never pass Empty + Leaf(l) => l.id, + Branch(b) => b.id, + Stub(s) => s.id, + }; +} + +fn leaf(bytes: Bytes) -> Tree { + let fact = { bytes, lineBreaks: v2.lineBreaks(bytes) }; + return Tree::Leaf({ id: v2.nodeId("leaf", core.cbor.encode(fact), []), fact, fresh: true }); +} + +// Both sides must be non-empty. Heights must differ by at most one. +fn branch(l: Tree, r: Tree) -> Tree fails ClosureTooSmall { + let ml = metrics(l); + let mr = metrics(r); + let fact = { + byteLength: ml.byteLength + mr.byteLength, // needs checked + + lineBreaks: ml.lineBreaks + mr.lineBreaks, + height: max(ml.height, mr.height) + 1u8, // PROPOSED max + }; + let id = v2.nodeId("branch", core.cbor.encode(fact), [expect idOf(l), expect idOf(r)]); + return Tree::Branch({ id, fact, left: l, right: r, fresh: true }); +} + +fn expanded(t: Tree) -> BranchView fails ClosureTooSmall { + return match t { + Branch(b) => b, + _ => fail ClosureTooSmall, // the closure read must expand this node + }; +} + +// ---- AVL balance ---- + +// `l` and `r` are AVL trees whose heights differ by at most two. +fn balance(l: Tree, r: Tree) -> Tree fails ClosureTooSmall { + return if height(l) > height(r) + 1u8 then expect rotateRight(expect expanded(l), r) + else if height(r) > height(l) + 1u8 then expect rotateLeft(l, expect expanded(r)) + else expect branch(l, r); +} + +fn rotateRight(lb: BranchView, r: Tree) -> Tree fails ClosureTooSmall { + return if height(lb.left) >= height(lb.right) + then expect branch(lb.left, expect branch(lb.right, r)) + else expect doubleRight(lb, expect expanded(lb.right), r); +} + +fn doubleRight(lb: BranchView, lrb: BranchView, r: Tree) -> Tree fails ClosureTooSmall { + return expect branch(expect branch(lb.left, lrb.left), expect branch(lrb.right, r)); +} + +fn rotateLeft(l: Tree, rb: BranchView) -> Tree fails ClosureTooSmall { + return if height(rb.right) >= height(rb.left) + then expect branch(expect branch(l, rb.left), rb.right) + else expect doubleLeft(l, rb, expect expanded(rb.left)); +} + +fn doubleLeft(l: Tree, rb: BranchView, rlb: BranchView) -> Tree fails ClosureTooSmall { + return expect branch(expect branch(l, rlb.left), expect branch(rlb.right, rb.right)); +} + +// ---- Join: concatenate two AVL trees ---- + +fn join(l: Tree, r: Tree) -> Tree fails ClosureTooSmall + decreases height(l) + height(r) // PROPOSED termination measure +{ + return match (l, r) { // PROPOSED tuple match + (Empty, _) => r, + (_, Empty) => l, + _ => if height(l) > height(r) + 1u8 then expect joinIntoLeft(expect expanded(l), r) + else if height(r) > height(l) + 1u8 then expect joinIntoRight(l, expect expanded(r)) + else expect branch(l, r), + }; +} + +fn joinIntoLeft(lb: BranchView, r: Tree) -> Tree fails ClosureTooSmall { + return expect balance(lb.left, expect join(lb.right, r)); +} + +fn joinIntoRight(l: Tree, rb: BranchView) -> Tree fails ClosureTooSmall { + return expect balance(expect join(l, rb.left), rb.right); +} + +// ---- Split at a byte offset (a checked character boundary) ---- + +fn split(t: Tree, at: U64) -> Pair fails ClosureTooSmall + where at <= byteLength(t) // PROPOSED: function preconditions + decreases height(t) +{ + return match t { + Empty => { left: Tree::Empty, right: Tree::Empty }, + Leaf(l) => splitLeaf(l, at), + Branch(b) => expect splitBranch(b, at), + Stub(s) => if at == 0u64 then { left: Tree::Empty, right: t } + else if at == s.byteLength then { left: t, right: Tree::Empty } + else fail ClosureTooSmall, + }; +} + +fn splitLeaf(l: LeafView, at: U64) -> Pair + where at <= len(l.fact.bytes) +{ + return if at == 0u64 then { left: Tree::Empty, right: Tree::Leaf(l) } + else if at == len(l.fact.bytes) then { left: Tree::Leaf(l), right: Tree::Empty } + else { + left: leaf(slice(l.fact.bytes, 0u64, at)), + right: leaf(slice(l.fact.bytes, at, len(l.fact.bytes))), + }; +} + +fn splitBranch(b: BranchView, at: U64) -> Pair fails ClosureTooSmall + where at <= b.fact.byteLength +{ + let leftLength = byteLength(b.left); + return if at < leftLength then expect splitLeftChild(b, at) + else if at > leftLength then expect splitRightChild(b, at - leftLength) // needs flow-sensitive proof + else { left: b.left, right: b.right }; +} + +fn splitLeftChild(b: BranchView, at: U64) -> Pair fails ClosureTooSmall { + let p = expect split(b.left, at); + return { left: p.left, right: expect join(p.right, b.right) }; +} + +fn splitRightChild(b: BranchView, at: U64) -> Pair fails ClosureTooSmall { + let p = expect split(b.right, at); + return { left: expect join(b.left, p.left), right: p.right }; +} + +// ---- Build a balanced tree from replacement bytes ---- + +fn fromBytes(bytes: Bytes) -> Tree fails ClosureTooSmall + decreases len(bytes) +{ + return if len(bytes) == 0u64 then Tree::Empty + else if len(bytes) <= 4096u64 then leaf(bytes) + else expect halves(bytes, boundaryAtOrBefore(bytes, len(bytes) / 2u64)); // PROPOSED U64 / +} + +fn halves(bytes: Bytes, mid: U64) -> Tree fails ClosureTooSmall { + return expect branch( + expect fromBytes(slice(bytes, 0u64, mid)), + expect fromBytes(slice(bytes, mid, len(bytes))), + ); +} + +// A UTF-8 scalar is at most four bytes, so a boundary lies within three bytes +// before any position in valid UTF-8. +fn boundaryAtOrBefore(bytes: Bytes, at: U64) -> U64 { + return if v2.isCharBoundary(bytes, at) then at + else if v2.isCharBoundary(bytes, at - 1u64) then at - 1u64 + else if v2.isCharBoundary(bytes, at - 2u64) then at - 2u64 + else at - 3u64; +} + +// ---- Character boundaries in a tree ---- + +// Leaves end on character boundaries, so a leaf edge is always a boundary and +// only offsets inside a leaf need its bytes. The closure expands every leaf +// that contains `start` or `end`. +fn isCharBoundaryIn(t: Tree, at: U64) -> Bool fails ClosureTooSmall + decreases height(t) +{ + return match t { + Empty => at == 0u64, + Leaf(l) => v2.isCharBoundary(l.fact.bytes, at), + Branch(b) => if at == byteLength(b.left) then true + else if at < byteLength(b.left) then expect isCharBoundaryIn(b.left, at) + else expect isCharBoundaryIn(b.right, at - byteLength(b.left)), + Stub(s) => if at == 0u64 || at == s.byteLength then true else fail ClosureTooSmall, + }; +} + +// ---- Replace and collect ---- + +fn replace(root: Tree, start: U64, end: U64, replacement: Bytes) -> Tree + fails ClosureTooSmall + where start <= end, end <= byteLength(root) +{ + let head = expect split(root, start); + let tail = expect split(head.right, end - start); + return expect join(expect join(head.left, expect fromBytes(replacement)), tail.right); +} + +// Fresh nodes only. A node that is not fresh heads an unchanged subtree, so +// nothing below it is fresh either. +fn created(t: Tree) -> Created + decreases height(t) +{ + return match t { + Leaf(l) => if l.fresh then { leaves: [l], branches: [] } else { leaves: [], branches: [] }, + Branch(b) => if b.fresh + then { + leaves: created(b.left).leaves ++ created(b.right).leaves, // PROPOSED list concat + branches: [b] ++ created(b.left).branches ++ created(b.right).branches, + } + else { leaves: [], branches: [] }, + _ => { leaves: [], branches: [] }, + }; +} + +// The bytes in [start, end), for the no-op check. Leaves in the range must be +// expanded; the closure read expands them only when the range length equals +// the replacement length, because otherwise the edit cannot be a no-op. +fn rangeBytes(t: Tree, start: U64, end: U64) -> Bytes fails ClosureTooSmall + decreases height(t) +{ + return match t { + Empty => b"", + Leaf(l) => slice(l.fact.bytes, start, end), + Branch(b) => expect rangeBytesBranch(b, start, end), + Stub(s) => if start == end then b"" else fail ClosureTooSmall, + }; +} + +fn rangeBytesBranch(b: BranchView, start: U64, end: U64) -> Bytes + fails ClosureTooSmall +{ + let mid = byteLength(b.left); + return (if start < mid then expect rangeBytes(b.left, start, min(end, mid)) else b"") + + (if end > mid then expect rangeBytes(b.right, max(start, mid) - mid, end - mid) else b""); +} diff --git a/edict/replace-range/draft/Text.edict b/edict/replace-range/draft/Text.edict new file mode 100644 index 00000000..f44fb9c4 --- /dev/null +++ b/edict/replace-range/draft/Text.edict @@ -0,0 +1,71 @@ +// Draft: jedit.text.schema@2 shared definitions (DL-0159). +// Not compiled by the application gate. See README.md for the status of each +// construct. Lines marked PROPOSED use syntax the Edict spec does not define. +package jedit.text.v2@1; + +use lawpack jedit.text@2 as text; +use target echo.dpo@1 as echo; + +// ---- Stored facts (alpha atoms, canonical CBOR v1) ---- + +type BufferFact = { + bufferKey: String, + version: U64, +}; + +type HeadFact = { + byteLength: U64, + lineCount: U64, + sequence: U64, +}; + +type BranchFact = { + byteLength: U64, + lineBreaks: U64, + height: U8, +}; + +type LeafFact = { + bytes: Bytes, + lineBreaks: U64, +}; + +type ImportFact = { + fileCoordinate: String, + hostDigest: Bytes, +}; + +// ---- Edge types (no payload; one edge per source node and type) ---- + +type CanonicalHead = Unit; // Buffer -> Head +type Root = Unit; // Head -> Branch | Leaf +type Basis = Unit; // Head -> Head +type Anchor = Unit; // Head -> Import +type Left = Unit; // Branch -> Branch | Leaf +type Right = Unit; // Branch -> Branch | Leaf + +// ---- Identity law ---- + +fn nodeId(kind: String, atom: Bytes, children: List) -> NodeId { + return hash("jedit.text.node.v2", { kind, atom, children }); +} + +fn edgeId(from: NodeId, edgeType: String) -> EdgeId { + return hash("jedit.text.edge.v2", { from, edgeType }); +} + +// ---- Text metrics ---- + +fn lineBreaks(bytes: Bytes) -> U64 { + return core.bytes.count(bytes, b"\n"); // PROPOSED generic primitive +} + +// A position is a character boundary when it is an end of the text or the +// byte there is not a UTF-8 continuation byte (10xxxxxx). +fn isCharBoundary(bytes: Bytes, at: U64) -> Bool + where at <= len(bytes) +{ + return at == 0u64 || at == len(bytes) + || core.bytes.at(bytes, at) < 0x80u8 // PROPOSED generic primitive + || core.bytes.at(bytes, at) >= 0xC0u8; +} From 22376d6a417b6c334aa6ee3c441270b6c6c23cfb Mon Sep 17 00:00:00 2001 From: James Ross Date: Thu, 15 Oct 2026 20:03:54 -0700 Subject: [PATCH 23/30] docs(edict): keep only the current rope in DL-0159; reopen UTF-16 Remove the head-to-predecessor basis edge from DL-0159 and the drafts. It made every version of every buffer permanently reachable, so the state root and retention grew with editing history, and it duplicated the causal history Echo's ticks and receipts already own. The graph now holds the current Buffer, Head, Import, and rope; superseded nodes leave the reachable graph, and their retention and any reconstruction of past states are Echo's retention and replay contract. Every new head copies the anchor edge instead of reaching its Import through a chain, and head identity no longer includes the predecessor. Undo and redo are forward operations. Replace 'UTF-16 length is dropped' with an explicit coordinate contract: byte offsets are authoritative, and whether UTF-16 offsets are derived, cached, or retained is an open decision driven by the interoperability surfaces Jim commits to, not by today's consumers. Refs #296, #302 --- CHANGELOG.md | 5 +- docs/design/0159-edict-rope-representation.md | 103 +++++++++++++----- edict/replace-range/draft/README.md | 4 +- edict/replace-range/draft/Reference.edict | 8 +- edict/replace-range/draft/ReplaceRange.edict | 8 +- edict/replace-range/draft/Text.edict | 4 +- 6 files changed, 90 insertions(+), 42 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 662b6432..5cc95389 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,8 +4,9 @@ - Added DL-0159, a draft representation for the Edict-authored rope: schema 2 with typed Echo edges for every structural relation, canonical CBOR facts, - content-addressed immutable nodes, a basis chain that keeps every version - inside Echo's state root, and an import anchor tying a head to its file. + content-addressed immutable nodes, and an import anchor tying every head to + its file. The graph holds only the current rope; Echo's ticks and receipts + own history, and retention of superseded nodes is Echo's policy. - Added complete, not-yet-compiling drafts of `ReplaceRange` in Edict source under `edict/replace-range/draft/`: a flat-text semantic reference and the persistent AVL rope. Their README classifies every blocker by owner and diff --git a/docs/design/0159-edict-rope-representation.md b/docs/design/0159-edict-rope-representation.md index b5bbe67f..a3b696a9 100644 --- a/docs/design/0159-edict-rope-representation.md +++ b/docs/design/0159-edict-rope-representation.md @@ -28,10 +28,14 @@ The rope that Jim's Edict source reads and writes uses a new text schema, `jedit.text.schema@2`. Every structural relation is an Echo edge; atoms carry only scalar facts. Atom payloads use Echo's canonical CBOR v1. Immutable nodes are content-addressed over their facts and their ordered children, so unchanged -subtrees keep their identity across edits. Each head links to its basis head, so -every retained version stays reachable from the worldline root and therefore -inside the state root. An imported head is anchored to the file coordinate and -the host digest of the bytes it was built from. +subtrees keep their identity across edits. Every head is anchored to the file +coordinate and the host digest of the bytes its lineage was imported from. + +The graph holds the **current** rope only. Echo's ticks and receipts are the +causal history of how it got there; Jim does not duplicate that history as a +chain of reachable heads. Whether superseded nodes stay retained, and how far +back a past state can be reconstructed, is Echo's retention and replay +contract, not a property of rope topology. This replaces nothing in production yet. `jedit.text.schema@1` (DL-0158), the native planner, and its oracle remain the current truth. Schema 2 is the @@ -45,15 +49,15 @@ cannot see. ## Sponsored Agent -An agent needs every rope version, and the file bytes each version came from, -to be reachable through typed graph structure, so it can explain or replay an -edit without decoding application JSON. +An agent needs the current rope, and the file bytes it descends from, to be +reachable through typed graph structure, and needs past edits to be explained +by Echo's causal history, so it never decodes application JSON. ## Hill A reviewer can check, from this document and the draft source alone, which -node, edge, and atom an Edict-authored `ReplaceRange` reads and writes, and why -old versions remain visible to the state root. +node, edge, and atom an Edict-authored `ReplaceRange` reads and writes, and +which guarantees about past versions come from Echo rather than from the rope. ## Current Truth @@ -77,8 +81,8 @@ Echo facts that constrain the choice (Echo main `9b3b9396`): - Nothing is garbage-collected; reachability decides only what the state root commits. -So schema 1 rope versions persist in the store but are invisible to the state -root, and Edict would have to parse JSON to follow a child. +So schema 1's current rope is itself invisible to the state root, and Edict +would have to parse JSON to follow a child. ## Problem @@ -118,8 +122,7 @@ Edges (no payload; one edge per source node and type): | --- | --- | --- | | `jedit.text.canonicalHead` | Buffer → Head | current head; retargeted by each edit | | `jedit.text.root` | Head → Branch or Leaf | the head's tree; absent for empty text | -| `jedit.text.basis` | Head → Head | the head this one was derived from | -| `jedit.text.anchor` | Head → Import | the imported bytes a head descends from | +| `jedit.text.anchor` | Head → Import | the imported bytes this head's lineage descends from | | `jedit.text.left`, `jedit.text.right` | Branch → Branch or Leaf | ordered children | Identity law: @@ -141,18 +144,42 @@ Rope law (unchanged from schema 1 except where noted): Nothing is deleted. - Leaves hold their bytes inline. Schema 1's Blob indirection is dropped; content addressing already deduplicates equal leaves. -- UTF-16 length is dropped from stored metrics. No consumer outside the native - rope reads it; a reading may derive it. -History reachability: worldline root → Buffer → `canonicalHead` → Head → -`basis` → older Head → … Every retained version is reachable, so the state root -commits all of them. +Coordinate contract: + +- Byte offsets into the UTF-8 text are the only authoritative coordinates. + Every operation takes and returns byte offsets. +- UTF-16 code-unit offsets matter for interoperability (language servers, + browser selection, external editing protocols), even though no Jim code reads + them today. Whether they are derived on demand, cached in readings, or + retained as a per-node witnessed metric is an open decision (see Follow-On + Debt). Until it is made, schema 2 does not store them, and nothing may treat + their absence as a decision that they are unneeded. + +History, current state, and retained material are three different things: + +| | Owner | What it guarantees | +| --- | --- | --- | +| Causal history | Echo ticks and receipts | what happened, in which causal context, with which outcome | +| Current state | this graph | the Buffer, its canonical Head, and the nodes reachable from that Head | +| Retained material | Echo retention and replay | which past states can be reconstructed, from checkpoints or replay inputs | + +The graph keeps no edge from a head to the head it replaced. After an edit, +the state root covers the current rope only. Superseded nodes leave the +reachable graph. Whether their bytes remain available is Echo's retention +policy; a tick witnessing a transition does not by itself promise that the +bytes needed to reconstruct the earlier state are still retained. + +Undo and redo are forward operations: Jim proposes a new edit whose target +state derives from a past witnessed state, subject to the evidence Echo still +retains and to admission. Nothing moves history backward. Head-to-file identity (anchored refinement): - Importing a file creates an `Import` node for its coordinate and the host digest of the imported bytes, and anchors the import head to it. -- Every later head reaches its `Import` through the `basis` chain. +- Every edit copies the `anchor` edge from the basis head to the new head, so + the current head always names its `Import` directly. - Reopening compares the current host digest with the anchored digest. A mismatch is a typed obstruction or an explicit, witnessed external-edit transition, never silent reuse (#350). @@ -166,8 +193,10 @@ The authored `ReplaceRange` operation, in schema 2 terms: 2. Read the bounded closure of nodes the edit touches: both boundary paths and the spines a join may descend. 3. Compute, purely, the new nodes and edges. -4. `ensure` each new immutable node and edge; replace the `canonicalHead` edge - and bump `Buffer.version`. All or nothing. +4. `ensure` each new immutable node and edge, including the new head's `root` + and copied `anchor` edges; replace the `canonicalHead` edge and bump + `Buffer.version`. All or nothing. No edge points from the new head to the + old one. Generic capabilities this needs, none of which exists today: @@ -195,8 +224,9 @@ only, as in schema 1. ## Agent Inspectability / Explainability Posture -Every relation an agent needs is a typed edge, so an agent can traverse rope -history without decoding application payloads. +Every relation in the current rope is a typed edge, so an agent can traverse it +without decoding application payloads. Past edits are explained from Echo's +causal history and receipts, not from rope topology. ## Linked Invariants @@ -216,8 +246,12 @@ history without decoding application payloads. byte-by-byte (the #302 Buffer-decoder probe) and admits several spellings. - **Keep Blob slices.** Rejected for schema 2: adds an indirection and a slice read per leaf; content-addressed leaves already deduplicate. -- **Keep UTF-16 length.** Deferred: adds a Unicode-counting primitive to the - critical path for a metric nothing outside the native rope reads. +- **Link each head to its basis head.** Rejected: it would make every version + of every buffer permanently reachable, so the state root and retention would + grow with editing history, and it duplicates the causal history Echo's ticks + and receipts already own. History is not state. +- **Drop UTF-16 coordinates.** Rejected as a decision: no current consumer is + not a reason to discard an interoperability coordinate. Left open instead. ## Decision @@ -239,8 +273,10 @@ and the Echo evaluation-to-effect design. non-canonical encodings. - Identity: equal subtrees produce equal ids; any atom or child change changes the id. -- Reachability: after N edits, all N+1 heads are reachable and inside the state - root. +- Reachability: after an edit, the state root covers exactly the current Buffer, + Head, Import, and rope; nodes only the superseded head used are unreachable. +- Reconstruction: a past state is rebuilt from Echo's checkpoints and replay, + and the test states which retention guarantee it relies on. - Anchor: reopen with a changed host digest obstructs (#350). ## Acceptance Criteria @@ -261,9 +297,12 @@ None yet. This is a representation decision. ## Risks - **State-root cost.** Echo recomputes the root by walking the whole reachable - graph on every commit. Keeping all history reachable makes that walk grow - with history. This is a generic Echo cost (an incremental or Merkle root - would fix it), not a reason to hide history. Recorded; deferred. + graph on every commit, so an edit costs in proportion to the current rope, + not to its history. That is still more than the edit itself; an incremental + root is Echo's open state-root decision. Recorded; deferred. +- **Unreclaimed nodes.** Echo has no garbage collection today, so superseded + nodes stay in the store after they leave the reachable graph. Reclaiming them + is Echo's retention policy, not Jim's. - **Patch size.** About `(depth + 1) × (node + atom + up to 2 edges)` operations per edit, against Echo's 128 operations per tick. Depth stays near `1.44 × log2(leaves)`; to be measured. @@ -271,6 +310,10 @@ None yet. This is a representation decision. ## Follow-On Debt +- Open: Jim's UTF-16 coordinate contract: derive on demand, cache in readings, + or retain as a witnessed per-node metric. Decide from the interoperability + surfaces Jim commits to (language server, external protocols), not from + today's consumers. - Open: which hash Edict source exposes for identities. - Open: whether Head should carry a content digest of its full text, so a reopen check need not materialize the rope. diff --git a/edict/replace-range/draft/README.md b/edict/replace-range/draft/README.md index 0a185afe..6099ec05 100644 --- a/edict/replace-range/draft/README.md +++ b/edict/replace-range/draft/README.md @@ -89,8 +89,8 @@ All are covered by the proposed Echo design - Closure size: two boundary paths plus their inner spines, `O(h²)` nodes, with `h ≤ 1.44 log2(leaves)`. Bounded by `text.maxClosureNodes`. - Patch size: about `(h + 1)` new branches, up to 2 new leaves plus - `replacement / 4096` leaves, two edges per branch, one head, three head - edges. Echo caps a Tick at 128 operations, which a 1 MiB replacement exceeds; + `replacement / 4096` leaves, two edges per branch, one head with its `root` + and `anchor` edges, and one retargeted `canonicalHead` edge. Echo caps a Tick at 128 operations, which a 1 MiB replacement exceeds; the cap or the replacement bound must move, and that is a measured decision. - Echo's state root walks all reachable history on every commit (DL-0159 risk). - Echo charges a full copy for every local read; `Tree` values are large. diff --git a/edict/replace-range/draft/Reference.edict b/edict/replace-range/draft/Reference.edict index 82009749..37538f03 100644 --- a/edict/replace-range/draft/Reference.edict +++ b/edict/replace-range/draft/Reference.edict @@ -49,6 +49,8 @@ intent replaceRange(input: Input) returns Result let head = headRef.read() else text.FactMissing; let textId = echo.edge(headRef) .target() else text.FactMissing; + let importId = echo.edge(headRef) + .target() else text.FactMissing; let old = echo.ref(textId).read() else text.FactMissing; require len(old.bytes) == head.byteLength else text.MalformedRope; @@ -72,13 +74,13 @@ intent replaceRange(input: Input) returns Result lineCount: fact.lineBreaks + 1u64, // needs checked + sequence: head.sequence + 1u64, }; - let newHeadId = v2.nodeId("head", core.cbor.encode(newHead), [newTextId, input.basisHeadId]); + let newHeadId = v2.nodeId("head", core.cbor.encode(newHead), [newTextId, importId]); let newHeadRef = echo.ref(newHeadId); newHeadRef.ensure(newHead) else text.ContentIdentityMismatch; echo.edge(newHeadRef) .ensure(newTextId) else text.ContentIdentityMismatch; // PROPOSED: edge ensure - echo.edge(newHeadRef) - .ensure(input.basisHeadId) else text.ContentIdentityMismatch; + echo.edge(newHeadRef) + .ensure(importId) else text.ContentIdentityMismatch; echo.edge(bufferRef) .replace(input.basisHeadId, newHeadId) else text.BasisNotCanonical; // PROPOSED: compare-and-retarget diff --git a/edict/replace-range/draft/ReplaceRange.edict b/edict/replace-range/draft/ReplaceRange.edict index ea09445f..8df2154c 100644 --- a/edict/replace-range/draft/ReplaceRange.edict +++ b/edict/replace-range/draft/ReplaceRange.edict @@ -93,6 +93,8 @@ intent replaceRange(input: Input) returns Result let headRef = echo.ref(input.basisHeadId); let head = headRef.read() else text.FactMissing; + let importId = echo.edge(headRef) + .target() else text.FactMissing; require input.endByte <= head.byteLength else text.RangeOutOfBounds; require core.bytes.isUtf8(input.replacement) else text.Utf8BoundaryInvalid; // PROPOSED @@ -139,15 +141,15 @@ intent replaceRange(input: Input) returns Result sequence: head.sequence + 1u64, }; let rootId = if m.byteLength == 0u64 then none() else some(rope.idOf(next)); - let newHeadId = v2.nodeId("head", core.cbor.encode({ newHead, rootId }), [input.basisHeadId]); + let newHeadId = v2.nodeId("head", core.cbor.encode({ newHead, rootId }), [importId]); let newHeadRef = echo.ref(newHeadId); newHeadRef.ensure(newHead) else text.ContentIdentityMismatch; if isSome(rootId) { echo.edge(newHeadRef) .ensure(unwrap(rootId)) else text.ContentIdentityMismatch; } - echo.edge(newHeadRef) - .ensure(input.basisHeadId) else text.ContentIdentityMismatch; + echo.edge(newHeadRef) + .ensure(importId) else text.ContentIdentityMismatch; echo.edge(bufferRef) .replace(input.basisHeadId, newHeadId) else text.BasisNotCanonical; // PROPOSED: compare-and-retarget diff --git a/edict/replace-range/draft/Text.edict b/edict/replace-range/draft/Text.edict index f44fb9c4..f2eeeee2 100644 --- a/edict/replace-range/draft/Text.edict +++ b/edict/replace-range/draft/Text.edict @@ -39,8 +39,8 @@ type ImportFact = { type CanonicalHead = Unit; // Buffer -> Head type Root = Unit; // Head -> Branch | Leaf -type Basis = Unit; // Head -> Head -type Anchor = Unit; // Head -> Import +type Anchor = Unit; // Head -> Import, copied to every new head +// No head-to-predecessor edge: Echo's ticks and receipts own history (DL-0159). type Left = Unit; // Branch -> Branch | Leaf type Right = Unit; // Branch -> Branch | Leaf From 63e8230f296d81e92e217f0118138bf284a2b382 Mon Sep 17 00:00:00 2001 From: James Ross Date: Thu, 15 Oct 2026 20:06:19 -0700 Subject: [PATCH 24/30] docs(edict): separate import provenance from host synchronization Copying the import anchor to every head preserves where the text came from; it must not imply the rope still matches the file. DL-0159 now keeps three facts apart: import provenance (Import, anchor edge), the current logical content (digest computed over the rope at a crossing, not on every edit), and host synchronization (an Export node with the logical and resulting host digests, reached by a lastExport edge that each save retargets). Save requires the file's host digest to equal the last exported digest, or the import digest if never exported; a mismatch is a typed conflict that needs explicit reconciliation. Reopen compares host digests against the last export, so it never materializes the rope. Refs #296, #302, #350 --- docs/design/0159-edict-rope-representation.md | 47 ++++++++++++++----- edict/replace-range/draft/Text.edict | 11 +++++ 2 files changed, 45 insertions(+), 13 deletions(-) diff --git a/docs/design/0159-edict-rope-representation.md b/docs/design/0159-edict-rope-representation.md index a3b696a9..f22c25a6 100644 --- a/docs/design/0159-edict-rope-representation.md +++ b/docs/design/0159-edict-rope-representation.md @@ -115,6 +115,7 @@ Facts (alpha atoms, canonical CBOR v1 via `echo-edict-canonical`): | `Branch` | `byteLength: U64`, `lineBreaks: U64`, `height: U8` | no | | `Leaf` | `bytes: Bytes`, `lineBreaks: U64` | no | | `Import` | `fileCoordinate`, `hostDigest: Bytes` | no | +| `Export` | `fileCoordinate`, `logicalDigest: Bytes`, `hostDigest: Bytes` | no | Edges (no payload; one edge per source node and type): @@ -122,7 +123,9 @@ Edges (no payload; one edge per source node and type): | --- | --- | --- | | `jedit.text.canonicalHead` | Buffer → Head | current head; retargeted by each edit | | `jedit.text.root` | Head → Branch or Leaf | the head's tree; absent for empty text | -| `jedit.text.anchor` | Head → Import | the imported bytes this head's lineage descends from | +| `jedit.text.anchor` | Head → Import | the imported bytes this head's lineage descends from (provenance only) | +| `jedit.text.lastExport` | Buffer → Export | the last witnessed write of this buffer to its file; retargeted by each save | +| `jedit.text.exportedHead` | Export → Head | the head whose bytes that save wrote | | `jedit.text.left`, `jedit.text.right` | Branch → Branch or Leaf | ordered children | Identity law: @@ -174,16 +177,31 @@ Undo and redo are forward operations: Jim proposes a new edit whose target state derives from a past witnessed state, subject to the evidence Echo still retains and to admission. Nothing moves history backward. -Head-to-file identity (anchored refinement): - -- Importing a file creates an `Import` node for its coordinate and the host - digest of the imported bytes, and anchors the import head to it. -- Every edit copies the `anchor` edge from the basis head to the new head, so - the current head always names its `Import` directly. -- Reopening compares the current host digest with the anchored digest. A - mismatch is a typed obstruction or an explicit, witnessed external-edit - transition, never silent reuse (#350). -- Export to the file is a separate witnessed crossing, designed later. +Head-to-file identity (anchored refinement). Three facts are kept apart: + +| Fact | Where | Claims | Never claims | +| --- | --- | --- | --- | +| Import provenance | `Import` node, `anchor` edge | these contents descend from the bytes imported from this file, with this host digest | that the rope still matches the file | +| Current logical content | computed from the current rope | the bytes Jim represents now | anything about the file | +| Host synchronization | `Export` node, Buffer `lastExport` edge | these exact bytes were written to this file, with this resulting host digest | that the file is unchanged since | + +- Importing a file creates an `Import` node and anchors the import head to it. + Every edit copies the `anchor` edge to the new head. The anchor is + provenance only; after an unsaved edit it says nothing about the file. +- The current logical digest is computed over the rope's bytes when a crossing + needs it (save, reopen, reconciliation), not on every edit, so edits stay + path-copies. The root node id is not that digest: it depends on tree shape. +- Save is a witnessed crossing. It requires the file's current host digest to + equal the last exported digest (or the import digest, if never exported), + writes the bytes, and records an `Export` with the head, the logical digest, + and the resulting host digest. A mismatch is a typed conflict that needs an + explicit reconciliation decision; save never overwrites silently. +- Reopening compares the file's current host digest with the last exported + digest, or the import digest if the buffer was never exported. A mismatch + means the file changed outside Jim: a typed obstruction or an explicit, + witnessed external-edit transition, never silent reuse (#350). +- The `Export` node and `lastExport` edge are part of schema 2; the save + operation itself is designed separately. ## Runtime / API Contract @@ -315,8 +333,11 @@ None yet. This is a representation decision. surfaces Jim commits to (language server, external protocols), not from today's consumers. - Open: which hash Edict source exposes for identities. -- Open: whether Head should carry a content digest of its full text, so a - reopen check need not materialize the rope. +- Open: `Export → Head` keeps the last exported head reachable, which is one + deliberately retained snapshot (the saved state). Confirm that is wanted, or + record only the logical digest and leave the bytes to Echo's retention. +- Settled by the anchor split: a reopen check compares host digests only, so + it never materializes the rope; the logical digest is computed at save. - Open: Rewrite and Diff facts in schema 2. ## Retrospective diff --git a/edict/replace-range/draft/Text.edict b/edict/replace-range/draft/Text.edict index f2eeeee2..6d5a6206 100644 --- a/edict/replace-range/draft/Text.edict +++ b/edict/replace-range/draft/Text.edict @@ -30,16 +30,27 @@ type LeafFact = { lineBreaks: U64, }; +// Provenance only: the bytes a head's lineage was imported from. Copying the +// anchor forward never claims the rope still matches the file. type ImportFact = { fileCoordinate: String, hostDigest: Bytes, }; +// Synchronization: one witnessed write of a buffer's bytes to its file. +type ExportFact = { + fileCoordinate: String, + logicalDigest: Bytes, + hostDigest: Bytes, +}; + // ---- Edge types (no payload; one edge per source node and type) ---- type CanonicalHead = Unit; // Buffer -> Head type Root = Unit; // Head -> Branch | Leaf type Anchor = Unit; // Head -> Import, copied to every new head +type LastExport = Unit; // Buffer -> Export, retargeted by each save +type ExportedHead = Unit; // Export -> Head written by that save // No head-to-predecessor edge: Echo's ticks and receipts own history (DL-0159). type Left = Unit; // Branch -> Branch | Leaf type Right = Unit; // Branch -> Branch | Leaf From 2338e4adc483bdf05c60ab9f92e0286ded2f0e7c Mon Sep 17 00:00:00 2001 From: James Ross Date: Thu, 15 Oct 2026 20:10:39 -0700 Subject: [PATCH 25/30] docs(edict): handle third-party file changes and the save race DL-0159 drops the Export -> Head edge: an Export is evidence of one crossing (file, logical digest, resulting host digest, and the causal event that witnessed it), not a reason to keep a historical rope reachable, and never file authority. A pinned saved snapshot would be an explicit retention lease. Save is now spelled out as a foreign crossing: export intent, host write, read-back observation as witnessed ingress, export outcome, and recovery by re-observation under the same occurrence key. The design no longer claims a digest check prevents a concurrent writer; without a host-side concurrency protocol the guarantee is detection at observation. Add third-party file changes: a buffer's synchronization basis, detection only through witnessed observation, an external change admitted as a new Import, adoption for a clean buffer, and for a dirty buffer an explicit, witnessed keep-mine, take-theirs, merge, or defer. Merge needs the base bytes; when retention no longer has them it refuses with MergeBaseUnavailable. Refs #296, #302, #350 --- docs/design/0159-edict-rope-representation.md | 108 ++++++++++++++++-- edict/replace-range/draft/Text.edict | 4 +- 2 files changed, 101 insertions(+), 11 deletions(-) diff --git a/docs/design/0159-edict-rope-representation.md b/docs/design/0159-edict-rope-representation.md index f22c25a6..75601406 100644 --- a/docs/design/0159-edict-rope-representation.md +++ b/docs/design/0159-edict-rope-representation.md @@ -115,7 +115,7 @@ Facts (alpha atoms, canonical CBOR v1 via `echo-edict-canonical`): | `Branch` | `byteLength: U64`, `lineBreaks: U64`, `height: U8` | no | | `Leaf` | `bytes: Bytes`, `lineBreaks: U64` | no | | `Import` | `fileCoordinate`, `hostDigest: Bytes` | no | -| `Export` | `fileCoordinate`, `logicalDigest: Bytes`, `hostDigest: Bytes` | no | +| `Export` | `fileCoordinate`, `logicalDigest: Bytes`, `hostDigest: Bytes`, `exportEvent: Bytes` | no | Edges (no payload; one edge per source node and type): @@ -125,7 +125,6 @@ Edges (no payload; one edge per source node and type): | `jedit.text.root` | Head → Branch or Leaf | the head's tree; absent for empty text | | `jedit.text.anchor` | Head → Import | the imported bytes this head's lineage descends from (provenance only) | | `jedit.text.lastExport` | Buffer → Export | the last witnessed write of this buffer to its file; retargeted by each save | -| `jedit.text.exportedHead` | Export → Head | the head whose bytes that save wrote | | `jedit.text.left`, `jedit.text.right` | Branch → Branch or Leaf | ordered children | Identity law: @@ -191,11 +190,41 @@ Head-to-file identity (anchored refinement). Three facts are kept apart: - The current logical digest is computed over the rope's bytes when a crossing needs it (save, reopen, reconciliation), not on every edit, so edits stay path-copies. The root node id is not that digest: it depends on tree shape. -- Save is a witnessed crossing. It requires the file's current host digest to - equal the last exported digest (or the import digest, if never exported), - writes the bytes, and records an `Export` with the head, the logical digest, - and the resulting host digest. A mismatch is a typed conflict that needs an - explicit reconciliation decision; save never overwrites silently. +- An `Export` is evidence of one crossing: the file, the logical digest of the + bytes written, the resulting host digest, and `exportEvent`, the identity of + the causal event that witnessed it. It names the exported head only through + that event and the logical digest; there is no edge to the head, so a save + does not keep a historical rope reachable. A pinned saved snapshot, if one is + ever wanted, is an explicit retention lease with its own lifetime. +- The `Export` reachable through `lastExport` witnesses the last successful + export. It is never file authority: the filesystem's current bytes are, and + every crossing re-observes them. +- Save is a crossing to a foreign system, so its steps stay separate + (`docs/jim-component-ownership.md`, `ExportIntent` and `ExportObserved`): + 1. **Export intent.** An admitted Jim operation records the head to write, + its logical digest, the expected prior host digest (the last export's, + or the import's if never exported), and an occurrence key. + 2. **Host write.** A host effector writes the bytes. Its own concurrency + protocol decides how close it gets to compare-and-write; see below. + 3. **Observation.** The effector reads back the resulting host digest. That + reading enters Echo as witnessed ingress. + 4. **Export outcome.** An admitted Jim operation records the `Export` and + retargets `lastExport` only when the observed digest equals the intended + bytes' digest. Any other observation is a typed conflict that needs an + explicit reconciliation decision. + 5. **Recovery.** An intent without an outcome is resolved by re-observing + the file under the same occurrence key: the intended digest means the + write happened; the expected prior digest means it did not and may be + retried under the same key; anything else is an external change and a + conflict. +- What this does and does not guarantee: comparing digests before writing + detects most external modifications, but a writer that changes the file + between that check and the write is not prevented by it. Echo's atomic + commit does not make the host write atomic with it. Preventing that race + needs a host-side concurrency protocol (an exclusive lock, or an atomic + compare-and-replace the filesystem actually provides). Until one is chosen, + the claim is detection after the fact, and step 3's observation is what + makes it detectable. - Reopening compares the file's current host digest with the last exported digest, or the import digest if the buffer was never exported. A mismatch means the file changed outside Jim: a typed obstruction or an explicit, @@ -203,6 +232,53 @@ Head-to-file identity (anchored refinement). Three facts are kept apart: - The `Export` node and `lastExport` edge are part of schema 2; the save operation itself is designed separately. +Third-party file changes. Another process (an editor, `git checkout`, a +formatter, a sync client) can write the file while Jim holds a buffer for it. +Jim's view of the file is always a past observation, so this is an ordinary +case, not an error: + +- **Synchronization basis.** A buffer's synchronization basis is the host + digest of its last export, or of its import if it was never exported. It + says what the file held the last time Jim and the file agreed. +- **Detection.** Jim learns of a change only by observing the file: a watcher + event (best effort; missed or coalesced events are reported as gaps), focus + or explicit refresh, reopen (#350), or the save protocol's step 1 and + step 3. Each observation enters Echo as witnessed ingress. A file whose host + digest differs from the synchronization basis has changed outside Jim; an + unobserved file is `Unknown`, never assumed unchanged. +- **External change record.** An observed change is admitted as a new + `Import` for the same file coordinate with the observed host digest. It is + provenance for the external bytes, not yet a decision about the buffer. +- **Clean buffer** (the current logical digest equals the synchronization + basis's content). Jim may adopt the external bytes as a new head anchored to + the new `Import`, by an admitted operation, either automatically under a + declared policy or on request. Adoption is a forward edit; the old head stays + in causal history. +- **Dirty buffer** (unsaved edits since the synchronization basis). The buffer + and the file have diverged from a common base. Jim never resolves this + silently. The decision is explicit and witnessed, and the choices are: + 1. **Keep mine.** Save anyway: an export whose expected prior digest is the + *observed external* digest, recorded as overwriting a known third-party + change. + 2. **Take theirs.** Adopt the external bytes as a new head. The unsaved head + remains in causal history, and retention decides how long its bytes stay + reconstructible; Jim may offer it as a recoverable alternative. + 3. **Merge.** A three-way merge with base = the synchronization basis's + bytes, ours = the current head, theirs = the external bytes. A clean merge + is a new head with both `Import`s in its provenance. An overlapping merge + is a `Plural` outcome the user resolves, never a guess. + 4. **Defer.** Keep editing; the divergence stays recorded, and save is + obstructed until one of the above is chosen. +- **Merge base availability.** A merge needs the base bytes. Without an + `Export → Head` edge they live only in causal history, so whether they are + still reconstructible is Echo's retention decision. If they are not, merge is + refused with a typed `MergeBaseUnavailable` and only keep-mine and + take-theirs remain. A retention lease on the last synchronized head would + guarantee the base; that is an open decision below. +- **Save during divergence.** The save protocol's expected prior digest makes + an unresolved divergence a conflict at step 1, and a change that lands + between check and write a conflict at step 3. Neither overwrites silently. + ## Runtime / API Contract The authored `ReplaceRange` operation, in schema 2 terms: @@ -296,6 +372,17 @@ and the Echo evaluation-to-effect design. - Reconstruction: a past state is rebuilt from Echo's checkpoints and replay, and the test states which retention guarantee it relies on. - Anchor: reopen with a changed host digest obstructs (#350). +- Third-party change, clean buffer: adoption produces a head anchored to the + new `Import` with exactly the external bytes. +- Third-party change, dirty buffer: save is obstructed until keep-mine, + take-theirs, or merge is chosen; each choice leaves the expected head and + provenance; overlapping merges are `Plural`. +- Merge base gone: with the base bytes unretained, merge refuses with + `MergeBaseUnavailable` and the other choices still work. +- Race: a file changed between the save's check and its write is reported as a + conflict at observation, never recorded as a successful export. +- Recovery: a crash between export intent and outcome resolves to written, + not written, or external change by re-observation. ## Acceptance Criteria @@ -333,9 +420,10 @@ None yet. This is a representation decision. surfaces Jim commits to (language server, external protocols), not from today's consumers. - Open: which hash Edict source exposes for identities. -- Open: `Export → Head` keeps the last exported head reachable, which is one - deliberately retained snapshot (the saved state). Confirm that is wanted, or - record only the logical digest and leave the bytes to Echo's retention. +- Open: whether the last synchronized head gets a retention lease so a + three-way merge always has its base (see Third-party file changes), and that + lease's lifetime and release. +- Open: the host-side concurrency protocol for the export write. - Settled by the anchor split: a reopen check compares host digests only, so it never materializes the rope; the logical digest is computed at save. - Open: Rewrite and Diff facts in schema 2. diff --git a/edict/replace-range/draft/Text.edict b/edict/replace-range/draft/Text.edict index 6d5a6206..806444c9 100644 --- a/edict/replace-range/draft/Text.edict +++ b/edict/replace-range/draft/Text.edict @@ -38,10 +38,13 @@ type ImportFact = { }; // Synchronization: one witnessed write of a buffer's bytes to its file. +// Evidence of the crossing, not file authority. `exportEvent` names the causal +// event that witnessed the write; the exported head is not reachable from it. type ExportFact = { fileCoordinate: String, logicalDigest: Bytes, hostDigest: Bytes, + exportEvent: Bytes, }; // ---- Edge types (no payload; one edge per source node and type) ---- @@ -50,7 +53,6 @@ type CanonicalHead = Unit; // Buffer -> Head type Root = Unit; // Head -> Branch | Leaf type Anchor = Unit; // Head -> Import, copied to every new head type LastExport = Unit; // Buffer -> Export, retargeted by each save -type ExportedHead = Unit; // Export -> Head written by that save // No head-to-predecessor edge: Echo's ticks and receipts own history (DL-0159). type Left = Unit; // Branch -> Branch | Leaf type Right = Unit; // Branch -> Branch | Leaf From e0662500cf6f0b82f215d9917b245ed761a733a1 Mon Sep 17 00:00:00 2001 From: James Ross Date: Thu, 15 Oct 2026 20:11:36 -0700 Subject: [PATCH 26/30] docs(edict): make external file reconciliation a first-class contract Replace the third-party change notes with an explicit reconciliation contract between Base (last agreed host contents), Local (the current rope), and Host (the latest validated observation), with a decision table. Watchers are hints; decisions use a validated, stable re-read. ObserveExternalFileChange is separate from adoption. Divergence preserves both sides: Reload keeps Local recoverable, Keep local does not grant an overwrite, Overwrite is its own explicit choice against a specific Host, and Reconcile is a forward edit that never invents the external editor's history. Offering Reconcile requires B's bytes, not just its digest. Classify modification, atomic-save rename, deletion, replacement, symlinks, permission changes, and unstable reads; support ordinary files first and refuse ambiguous crossings. Save revalidates and claims detection, not prevention, until a host concurrency protocol exists. Refs #296, #302, #350 --- docs/design/0159-edict-rope-representation.md | 150 +++++++++++------- 1 file changed, 95 insertions(+), 55 deletions(-) diff --git a/docs/design/0159-edict-rope-representation.md b/docs/design/0159-edict-rope-representation.md index 75601406..a38bd683 100644 --- a/docs/design/0159-edict-rope-representation.md +++ b/docs/design/0159-edict-rope-representation.md @@ -232,52 +232,91 @@ Head-to-file identity (anchored refinement). Three facts are kept apart: - The `Export` node and `lastExport` edge are part of schema 2; the save operation itself is designed separately. -Third-party file changes. Another process (an editor, `git checkout`, a -formatter, a sync client) can write the file while Jim holds a buffer for it. -Jim's view of the file is always a past observation, so this is an ordinary -case, not an error: - -- **Synchronization basis.** A buffer's synchronization basis is the host - digest of its last export, or of its import if it was never exported. It - says what the file held the last time Jim and the file agreed. -- **Detection.** Jim learns of a change only by observing the file: a watcher - event (best effort; missed or coalesced events are reported as gaps), focus - or explicit refresh, reopen (#350), or the save protocol's step 1 and - step 3. Each observation enters Echo as witnessed ingress. A file whose host - digest differs from the synchronization basis has changed outside Jim; an - unobserved file is `Unknown`, never assumed unchanged. -- **External change record.** An observed change is admitted as a new - `Import` for the same file coordinate with the observed host digest. It is - provenance for the external bytes, not yet a decision about the buffer. -- **Clean buffer** (the current logical digest equals the synchronization - basis's content). Jim may adopt the external bytes as a new head anchored to - the new `Import`, by an admitted operation, either automatically under a - declared policy or on request. Adoption is a forward edit; the old head stays - in causal history. -- **Dirty buffer** (unsaved edits since the synchronization basis). The buffer - and the file have diverged from a common base. Jim never resolves this - silently. The decision is explicit and witnessed, and the choices are: - 1. **Keep mine.** Save anyway: an export whose expected prior digest is the - *observed external* digest, recorded as overwriting a known third-party - change. - 2. **Take theirs.** Adopt the external bytes as a new head. The unsaved head - remains in causal history, and retention decides how long its bytes stay - reconstructible; Jim may offer it as a recoverable alternative. - 3. **Merge.** A three-way merge with base = the synchronization basis's - bytes, ours = the current head, theirs = the external bytes. A clean merge - is a new head with both `Import`s in its provenance. An overlapping merge - is a `Plural` outcome the user resolves, never a guess. - 4. **Defer.** Keep editing; the divergence stays recorded, and save is - obstructed until one of the above is chosen. -- **Merge base availability.** A merge needs the base bytes. Without an - `Export → Head` edge they live only in causal history, so whether they are - still reconstructible is Echo's retention decision. If they are not, merge is - refused with a typed `MergeBaseUnavailable` and only keep-mine and - take-theirs remain. A retention lease on the last synchronized head would - guarantee the base; that is an open decision below. -- **Save during divergence.** The save protocol's expected prior digest makes - an unresolved divergence a conflict at step 1, and a change that lands - between check and write a conflict at step 3. Neither overwrites silently. +### External file reconciliation + +The filesystem is another authority, not an extension of Jim's memory. Another +process (an editor, `git checkout`, a formatter, a sync client) can write the +file while Jim holds a buffer for it. That is an ordinary case of two states +evolving independently, so it is part of the file model, not an edge case of +save. This contract is Jim-owned; Echo supplies generic observation, admission, +history, and effect mechanisms, never merge semantics. + +Three logical versions, compared by digest: + +| Version | Meaning | +| --- | --- | +| Base B | the file contents Jim last imported or exported successfully (the synchronization basis) | +| Local L | the current rope, including unsaved edits | +| Host H | the file contents in the latest validated observation | + +| Condition | Jim's behavior | +| --- | --- | +| H = B, L = B | nothing changed | +| H = B, L ≠ B | local edits only; ordinary save | +| H ≠ B, L = B | external change only; Jim may adopt H as a forward transition | +| H = L, H ≠ B | the same bytes on both sides; mark synchronized after validating the observation | +| H ≠ B, L ≠ B, H ≠ L | divergence; preserve both and require an explicit decision | + +Requirements: + +1. **Watchers are hints.** A watcher event, focus, refresh, reopen (#350), or + save only prompts an observation. Every decision uses a validated host + observation: the file re-read with a stable result. A file read that + changes during the read is an unstable observation and decides nothing. An + unobserved file is `Unknown`, never assumed unchanged. +2. **Observing is not adopting.** `ObserveExternalFileChange` is its own + admitted operation. It records the file coordinate, B's digest, the newly + observed digest, and the evidence of the read, and admits the observed + bytes as a new `Import`. It changes no head. +3. **External-only change.** When L = B, Jim may adopt H by a separate + admitted operation that creates a head anchored to the new `Import`. It is a + forward transition; the old head stays in causal history. Automatic adoption + is allowed only under a declared policy, and is still witnessed. +4. **Divergence preserves both sides.** When H ≠ B and L ≠ B and H ≠ L, Jim + never resolves silently. The explicit choices are: + - **Reload from disk:** adopt H; keep L recoverable as a branch or + checkpoint while its material is retained. + - **Keep local:** keep editing L. This does not grant permission to + overwrite H; save stays obstructed by the divergence. + - **Overwrite:** a separate, explicit save whose expected prior digest is + H's, recorded as overwriting a known third-party change. + - **Reconcile:** build a new version from B, L, and H and submit it as a + forward edit. +5. **Reconciliation is a forward intent.** It never rewrites existing ticks. + Jim witnesses H as observed bytes; it does not invent the external editor's + edit sequence or causal history. +6. **Base material is required to promise a three-way merge.** A digest of B is + not enough. Jim offers Reconcile only when B's bytes are retained: a + retention lease on the last synchronized head while the buffer is open, or + Echo's retention otherwise. Without them, Reconcile is refused with a typed + `MergeBaseUnavailable`, and Reload, Keep local, and Overwrite remain. +7. **Distinguish what happened to the path.** A validated observation + classifies the change before any decision: + + | Observed | Classification | Initial support | + | --- | --- | --- | + | same file, new bytes | modification | supported | + | file replaced through a temporary file and rename (atomic save) | modification, if the result is an ordinary file | supported | + | path absent | deletion | divergence-style decision; no implicit save recreates it | + | different file identity at the path | replacement | refused as ambiguous; explicit decision required | + | path became a symlink, directory, or special file | not an ordinary file | refused | + | permissions forbid reading or writing | permission change | obstruction naming the permission | + | bytes changed during the read | unstable read | no decision; observe again | + + The first version supports ordinary files only and refuses ambiguous + crossings rather than pretending the filesystem offers compare-and-swap. +8. **Save revalidates.** Save observes H first and is obstructed unless H = B, + or the user chose Overwrite against exactly this H. A change between that + check and the write is caught by the save protocol's read-back (step 3) and + reported as a conflict, never as a successful export. The guarantee is + detection; prevention needs the host-side concurrency protocol (open + decision), and Jim reports when it cannot establish the guarantee. + +Scope of the first version: detect divergence, preserve both sides, and require +explicit resolution. Automatic three-way reconciliation proposals come later, +once the observation evidence and base retention contracts hold. Then Jim can +materialize B, L, and H, compute a deterministic three-way proposal, present +overlaps as a `Plural` outcome, and submit the accepted result through Echo. ## Runtime / API Contract @@ -372,13 +411,14 @@ and the Echo evaluation-to-effect design. - Reconstruction: a past state is rebuilt from Echo's checkpoints and replay, and the test states which retention guarantee it relies on. - Anchor: reopen with a changed host digest obstructs (#350). -- Third-party change, clean buffer: adoption produces a head anchored to the - new `Import` with exactly the external bytes. -- Third-party change, dirty buffer: save is obstructed until keep-mine, - take-theirs, or merge is chosen; each choice leaves the expected head and - provenance; overlapping merges are `Plural`. -- Merge base gone: with the base bytes unretained, merge refuses with +- Each row of the B/L/H decision table, including H = L with H ≠ B. +- Observation without adoption: `ObserveExternalFileChange` changes no head. +- Divergence: save is obstructed under Keep local; Reload keeps L recoverable; + Overwrite records the overwritten H; Reconcile is a forward edit. +- Base gone: with B's bytes unretained, Reconcile refuses with `MergeBaseUnavailable` and the other choices still work. +- Each path classification: atomic-save rename, deletion, replacement, + symlink, permission change, and an unstable read that decides nothing. - Race: a file changed between the save's check and its write is reported as a conflict at observation, never recorded as a successful export. - Recovery: a crash between export intent and outcome resolves to written, @@ -420,9 +460,9 @@ None yet. This is a representation decision. surfaces Jim commits to (language server, external protocols), not from today's consumers. - Open: which hash Edict source exposes for identities. -- Open: whether the last synchronized head gets a retention lease so a - three-way merge always has its base (see Third-party file changes), and that - lease's lifetime and release. +- Open: the retention lease on the last synchronized head that Reconcile + requires (External file reconciliation, requirement 6): its owner, + lifetime, and release. - Open: the host-side concurrency protocol for the export write. - Settled by the anchor split: a reopen check compares host digests only, so it never materializes the rope; the logical digest is computed at save. From e424ec2bb46f44f0204e7710ef28103ffc357b46 Mon Sep 17 00:00:00 2001 From: James Ross Date: Thu, 15 Oct 2026 20:13:12 -0700 Subject: [PATCH 27/30] docs(edict): treat external file changes as causal transport An external write is testimony from another authority, not an editor event. DL-0159 now routes it through Echo's existing contracts instead of a filesystem-specific model: a filesystem adapter turns a validated observation into an import proposal under the Continuum Transport import law, and the observation is held, judged, and applied as Participant History as a Braid describes. Jim's Edict-authored law judges B, L, and H into Derived, Plural, Conflict, or Obstruction; divergence is a Conflict that bars dependent operations until settled; only a witnessed forward commit changes the buffer. Each observation carries Echo's Continuum occurrence identity and an explicit receiving context. Re-delivery is idempotent; distinct observations stay distinct; and a digest identifies observed content, not the write that produced it, so the adapter never invents distinct external writes. Filesystem-specific work stays at the adapter boundary. Refs #296, #302, #350 --- docs/design/0159-edict-rope-representation.md | 72 ++++++++++++++----- 1 file changed, 56 insertions(+), 16 deletions(-) diff --git a/docs/design/0159-edict-rope-representation.md b/docs/design/0159-edict-rope-representation.md index a38bd683..0fb38d2c 100644 --- a/docs/design/0159-edict-rope-representation.md +++ b/docs/design/0159-edict-rope-representation.md @@ -236,10 +236,33 @@ Head-to-file identity (anchored refinement). Three facts are kept apart: The filesystem is another authority, not an extension of Jim's memory. Another process (an editor, `git checkout`, a formatter, a sync client) can write the -file while Jim holds a buffer for it. That is an ordinary case of two states -evolving independently, so it is part of the file model, not an edge case of -save. This contract is Jim-owned; Echo supplies generic observation, admission, -history, and effect mechanisms, never merge semantics. +file while Jim holds a buffer for it. That is an ordinary case of two +authorities evolving independently, so it is part of the file model, not an +edge case of save. + +This is causal transport, not a new mechanism. The filesystem testifies; it +does not edit Jim's history: + +- A filesystem adapter turns a validated observation into ingress, following + Echo's [Continuum Transport](https://github.com/flyingrobots/echo/blob/main/docs/architecture/continuum-transport.md) + import law: the adapter forms an import proposal, and only an admitted import + Intent affects history. +- What arrives is held, judged, and applied as + [Participant History as a Braid](https://github.com/flyingrobots/echo/blob/main/docs/architecture/participant-history-as-a-braid.md) + describes. **Hold:** the observation is retained as evidence and staged; + no reading of the buffer changes. **Judge:** Jim, as the receiving + authority, compares B, L, and H under its own Edict-authored law, with + outcome Derived, Plural, Conflict, or Obstruction. **Apply:** only a + witnessed forward commit on an explicit basis changes the buffer. +- The evidence is the observation, not the external editor's history. Unless + the other writer takes part in the protocol, Jim knows only the bytes and + metadata seen at one crossing, and never fabricates the writer's edit + sequence. + +The filesystem-specific work stays at the adapter boundary: stable reads, path +identity, rename and replacement detection, permissions, and safe export. The +judging law is Jim-owned Edict; Echo supplies observation, admission, history, +and effects, never merge semantics. Three logical versions, compared by digest: @@ -264,16 +287,28 @@ Requirements: observation: the file re-read with a stable result. A file read that changes during the read is an unstable observation and decides nothing. An unobserved file is `Unknown`, never assumed unchanged. -2. **Observing is not adopting.** `ObserveExternalFileChange` is its own - admitted operation. It records the file coordinate, B's digest, the newly - observed digest, and the evidence of the read, and admits the observed - bytes as a new `Import`. It changes no head. -3. **External-only change.** When L = B, Jim may adopt H by a separate +2. **Observing is not adopting.** `ObserveExternalFileChange` is the admitted + import Intent for one observation. It records the file coordinate, B's + digest, the newly observed digest, and the evidence of the read, and admits + the observed bytes as a new `Import`. It changes no head; it is the Hold + step. +3. **Occurrence identity is the adapter's, and honest.** Each observation gets + a stable occurrence identity (Echo's Continuum occurrence identity at + ingress) and an explicit receiving context: buffer, file coordinate, and B. + Re-delivering the same occurrence is idempotent and returns the retained + outcome. Distinct observations stay distinct evidence, never collapsed. A + digest identifies observed content, not the event that produced it: two + external writes can leave identical bytes. Where the adapter can tell writes + apart (file identity, change tokens), it records that; where it cannot, it + records only distinct observations and does not invent distinct writes. +4. **External-only change.** When L = B, Jim may adopt H by a separate admitted operation that creates a head anchored to the new `Import`. It is a forward transition; the old head stays in causal history. Automatic adoption is allowed only under a declared policy, and is still witnessed. -4. **Divergence preserves both sides.** When H ≠ B and L ≠ B and H ≠ L, Jim - never resolves silently. The explicit choices are: +5. **Divergence preserves both sides.** When H ≠ B and L ≠ B and H ≠ L, Jim's + judgment is Conflict at the buffer, and nothing that depends on the file is + admitted until it is settled. Jim never resolves silently. The explicit + settlements are: - **Reload from disk:** adopt H; keep L recoverable as a branch or checkpoint while its material is retained. - **Keep local:** keep editing L. This does not grant permission to @@ -282,15 +317,15 @@ Requirements: H's, recorded as overwriting a known third-party change. - **Reconcile:** build a new version from B, L, and H and submit it as a forward edit. -5. **Reconciliation is a forward intent.** It never rewrites existing ticks. +6. **Reconciliation is a forward intent.** It never rewrites existing ticks. Jim witnesses H as observed bytes; it does not invent the external editor's edit sequence or causal history. -6. **Base material is required to promise a three-way merge.** A digest of B is +7. **Base material is required to promise a three-way merge.** A digest of B is not enough. Jim offers Reconcile only when B's bytes are retained: a retention lease on the last synchronized head while the buffer is open, or Echo's retention otherwise. Without them, Reconcile is refused with a typed `MergeBaseUnavailable`, and Reload, Keep local, and Overwrite remain. -7. **Distinguish what happened to the path.** A validated observation +8. **Distinguish what happened to the path.** A validated observation classifies the change before any decision: | Observed | Classification | Initial support | @@ -305,7 +340,7 @@ Requirements: The first version supports ordinary files only and refuses ambiguous crossings rather than pretending the filesystem offers compare-and-swap. -8. **Save revalidates.** Save observes H first and is obstructed unless H = B, +9. **Save revalidates.** Save observes H first and is obstructed unless H = B, or the user chose Overwrite against exactly this H. A change between that check and the write is caught by the save protocol's read-back (step 3) and reported as a conflict, never as a successful export. The guarantee is @@ -413,6 +448,11 @@ and the Echo evaluation-to-effect design. - Anchor: reopen with a changed host digest obstructs (#350). - Each row of the B/L/H decision table, including H = L with H ≠ B. - Observation without adoption: `ObserveExternalFileChange` changes no head. +- Occurrence idempotence: re-delivering one observation returns the retained + outcome; two observations of identical bytes stay two pieces of evidence and + are not reported as two distinct external writes. +- Barrier: while the buffer's divergence is an unsettled Conflict, an + operation that depends on the file is not admitted; unrelated work is. - Divergence: save is obstructed under Keep local; Reload keeps L recoverable; Overwrite records the overwritten H; Reconcile is a forward edit. - Base gone: with B's bytes unretained, Reconcile refuses with @@ -461,7 +501,7 @@ None yet. This is a representation decision. today's consumers. - Open: which hash Edict source exposes for identities. - Open: the retention lease on the last synchronized head that Reconcile - requires (External file reconciliation, requirement 6): its owner, + requires (External file reconciliation, requirement 7): its owner, lifetime, and release. - Open: the host-side concurrency protocol for the export write. - Settled by the anchor split: a reopen check compares host digests only, so From 2b27f6dcf26474ca2714c7c2ee1fd5a8afb42445 Mon Sep 17 00:00:00 2001 From: James Ross Date: Thu, 15 Oct 2026 20:15:16 -0700 Subject: [PATCH 28/30] docs(edict): ground DL-0159 in AION Paper VII Cite Paper VII directly, checked against the paper: transport precedes judgment, so an observed file version is re-expressed at Jim's receiving frontier, with B as the comparable basis the adapter can actually support (section 4.3); a braid is a comparison carrier, not a merge, and observing, braiding, judging, and admitting are separate acts (Definition 2.4, Remark 2.6), with plurality a lawful outcome (section 4.2); and the optic Psi = (Omega, chi, rho, Pi, Lambda) is Jim's (Definition 3.1). Commitment, folding, and revelation stay separate (section 3.3), the section 6.2 hot-text optic matches the draft's closure read and single head retarget, and section 8 names app-authored optic compilation and export semantics as open seams, which is what this document attempts. The paper is cited as foundation, not as evidence of implementation. Refs #296, #302 --- docs/design/0159-edict-rope-representation.md | 37 ++++++++++++++++++- 1 file changed, 35 insertions(+), 2 deletions(-) diff --git a/docs/design/0159-edict-rope-representation.md b/docs/design/0159-edict-rope-representation.md index 0fb38d2c..217c857f 100644 --- a/docs/design/0159-edict-rope-representation.md +++ b/docs/design/0159-edict-rope-representation.md @@ -240,8 +240,28 @@ file while Jim holds a buffer for it. That is an ordinary case of two authorities evolving independently, so it is part of the file model, not an edge case of save. -This is causal transport, not a new mechanism. The filesystem testifies; it -does not edit Jim's history: +This is causal transport, not a new mechanism, and AIΩN Paper VII ("WARP: +Optics, Holograms, and Worldlines over Shared Causal History") already gives +its shape: "Distribution changes the slice boundary; it does not change the +downstream law." Jim observes a transported claim, takes part in constructing +a comparable braid, and authors the law under which that braid may be lowered. +The filesystem testifies; it does not edit Jim's history: + +- **Transport precedes judgment** (Paper VII §4.3). An observed file version + must be re-expressed at Jim's receiving frontier before it can be judged. B + is that comparable basis. The adapter establishes only the basis it can + actually support; it cannot manufacture ancestry the external writer never + supplied. +- **A braid is not a merge** (Definition 2.4, Remark 2.6). Observing (holding + the claim), braiding (presenting L and H over B), judging, and admitting are + separate acts. Under Jim's law a divergence may lawfully stay `Plural` + (§4.2) until a settlement is chosen. +- **The optic** (Definition 3.1, Ψ = (Ω, χ, Ï, Π, Λ)) is Jim's: the slice χ is + the buffer's file site, Ï presents B, L, and H as comparable claims, Π is + Jim's Edict-authored admissibility law, and Λ is the retention contract that + decides whether B's bytes remain available for a merge. + +In Echo's current contracts: - A filesystem adapter turns a validated observation into ingress, following Echo's [Continuum Transport](https://github.com/flyingrobots/echo/blob/main/docs/architecture/continuum-transport.md) @@ -402,6 +422,19 @@ causal history and receipts, not from rope topology. - History Over State ch. 21 and 42: a rope head is the workspace coordinate, an anchored refinement of it, or the source of a witnessed crossing. - DL-0158: codec or edge migration is a separately admitted operation. +- AIΩN Paper VII ("WARP: Optics, Holograms, and Worldlines over Shared Causal + History"), as an architectural foundation, not as evidence that anything + below is implemented: + - §3.3, commitment, folding, and revelation are separate: the graph commits + the current rope; what stays retained is the contract Λ, not rope topology. + - §4.2 and §4.3, braid plurality and transport before import: the external + file reconciliation contract above. + - §6.2, the authored hot-text optic: its `replaceRangeAsTick` surface declares + a `ropeRangeClosure` slice closure and updates only `canonicalHead`. The + draft's guided closure read and the single head retarget follow that shape. + - §8 lists app-authored optic compilation and export semantics at the + causal-medium boundary as open engineering seams. This document's + Edict-authored rope and save crossing are attempts at exactly those seams. ## Design Alternatives Considered From 9e6466150e43afc83966f9fe67c6ddce2f58d5bc Mon Sep 17 00:00:00 2001 From: James Ross Date: Thu, 15 Oct 2026 20:18:29 -0700 Subject: [PATCH 29/30] docs(edict): bound the reconciliation slice to the smallest closure The slice chi in Jim's reconciliation optic is the smallest lawful comparison closure within the file site. A whole-file comparison is acceptable at first and is not a permanent requirement. Refs #296, #302 --- docs/design/0159-edict-rope-representation.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/design/0159-edict-rope-representation.md b/docs/design/0159-edict-rope-representation.md index 217c857f..312bc578 100644 --- a/docs/design/0159-edict-rope-representation.md +++ b/docs/design/0159-edict-rope-representation.md @@ -257,7 +257,9 @@ The filesystem testifies; it does not edit Jim's history: separate acts. Under Jim's law a divergence may lawfully stay `Plural` (§4.2) until a settlement is chosen. - **The optic** (Definition 3.1, Ψ = (Ω, χ, Ï, Π, Λ)) is Jim's: the slice χ is - the buffer's file site, Ï presents B, L, and H as comparable claims, Π is + the smallest lawful comparison closure within the buffer's file site. A + whole-file comparison is acceptable at first, but it is not a requirement; + the optic is bounded. Ï presents B, L, and H as comparable claims, Π is Jim's Edict-authored admissibility law, and Λ is the retention contract that decides whether B's bytes remain available for a merge. From 6155218f98b6d857e658a8a5ed4adb86eafe9d0e Mon Sep 17 00:00:00 2001 From: James Ross Date: Sun, 18 Oct 2026 21:26:45 -0700 Subject: [PATCH 30/30] Prove authored flat-text replacement at merged UTF-8 toolchains --- docs/BEARING.md | 5 + edict/replace-range/README.md | 67 +++---- edict/replace-range/edict.build-lock.json | 58 +++--- .../edict.executable-subject-lock.json | 10 +- edict/replace-range/edict.lawpack.json | 9 +- edict/replace-range/edict.toolchain-lock.json | 12 +- edict/replace-range/src/ReplaceRange.edict | 10 +- .../tests/assert-build-output.mjs | 1 + edict/replace-range/tests/package-chain.mjs | 55 +++--- edict/replace-range/tests/runtime/Cargo.lock | 12 +- edict/replace-range/tests/runtime/Cargo.toml | 8 +- .../tests/runtime/compiled_boundary.rs | 11 +- .../replace-range/tests/runtime/flat_text.rs | 178 ++++++++++++++++++ .../vendor/jedit-text/adapter.cbor | Bin 446 -> 534 bytes .../vendor/jedit-text/adapter.sha256 | 2 +- .../jedit-text/edict.lawpack-output.json | 12 +- .../vendor/jedit-text/exports.cbor | Bin 2362 -> 2367 bytes .../vendor/jedit-text/exports.sha256 | 2 +- .../vendor/jedit-text/manifest.cbor | Bin 787 -> 787 bytes .../vendor/jedit-text/manifest.sha256 | 2 +- 20 files changed, 328 insertions(+), 126 deletions(-) create mode 100644 edict/replace-range/tests/runtime/flat_text.rs diff --git a/docs/BEARING.md b/docs/BEARING.md index fd96a38c..3b2f4995 100644 --- a/docs/BEARING.md +++ b/docs/BEARING.md @@ -124,6 +124,11 @@ or support-policy logic. ## Immediate Roadmap +- [x] Execute compiler-produced flat-text replacement against literal UTF-8 + cases, then range, UTF-8, no-op and resource refusals. This is the logical-text + reference for the persistent-rope differential gate, not graph admission or + recovery evidence. + - [x] Make the pinned Edict package-chain harness discover Cargo's actual executable when its output is redirected. Preserve producer pins and verify the emitted pure package in Echo; this does not complete the authored rope diff --git a/edict/replace-range/README.md b/edict/replace-range/README.md index 9129306a..79eaaca2 100644 --- a/edict/replace-range/README.md +++ b/edict/replace-range/README.md @@ -17,45 +17,34 @@ the authored, built, and evidentiary artifact classes separate: ## Current executable boundary -The checked-in source is the first compiler-pressure slice, not a completed -text mutation. It binds exact-length nominal identities, the selected basis, -range, replacement bytes, operation profile, budget, imported helper -implementation, and a pure conditional into Edict Core. It intentionally does -not claim to traverse or rewrite a rope yet. - -With the merged Edict #201, the public application build lowers those Core `let` -nodes into generic, source-ordered Target IR and independently verifies the compiler-owned -result projection. The pinned Echo provider emits a distinct -`compiler-produced-bounded-pure/v1` executable package containing the exact -Core, lawpack exports, Target IR, and result projection. Echo's structurally -separate verifier independently reconstructs that package relation and emits an -accepted report bound to retained canonical `echo.executable-subject/v1` bytes. - -The compiler pin is Edict main `e60411fc6eb93c55468cc8c728f7fa9166207a6d`, -which includes merged source functions (#228), proven unsigned subtraction -(#211, #214), and bounded byte length, slice, and concatenation (#217, #221, -#223). -Core retains the imported nominal definitions and their shared exact-length -`NodeId` representation; record fields refer to those named definitions. -The nominal identity test follows that reference chain, and repeated public -builds must reproduce identical Core, Target, package, and verifier-report bytes. -The Echo provider is pinned to Echo main -`9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a`; this evidence does not claim that -this Jedit application has landed on Jedit's main branch. Repinning from the -earlier #724 provider and #726 evaluator candidates left the executable-subject -lock byte-identical; only the build closure changed. - -The application gate passes that accepted package unchanged to Echo's generic -pure evaluator at Echo main `9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a`, which -includes the merged pure and bounded-read source-function evaluator (#753). -A separate test-only Rust host consumes the fresh public-build -output, not the fixture retained in Echo. It checks both conditional branches, -the imported helper result, exact projected bytes, deterministic repetition, -the reversed-range constraint, malformed identity bytes, and package-pin -substitution. Its dependencies and their full resolution are pinned in -`tests/runtime/Cargo.toml` and `Cargo.lock` and bound into the build closure. - -This is pure computation only. No graph or rope is mutated, no Tick is settled, +The authored source computes flat-text replacement as prefix + replacement + +suffix. Its ordered guard checks the range before slicing, validates the full +original text and replacement as UTF-8, validates both offset prefixes as +UTF-8, and rejects byte-identical replacements. The guard reports a generic +input-constraint refusal; it does not yet produce the domain's typed outcomes. + +The imported constant helper has its own small cost declaration. The operation +budget separately includes bounded UTF-8 scan work. Reusing the operation's +entire budget as the constant helper's cost would consume that budget before +accounting for the scans. + +The standalone test host supplies bytes to the freshly compiled package. It +checks nine literal replacements, thirteen range, UTF-8 and no-op refusals, +and five host-resource refusals. It performs no native replacement and links +no native rope planner. The package-chain harness runs both the boundary and +flat-text targets, and the build closure includes both test sources. + +The toolchain pins Edict main `2b4832efe62de75e1f204cec72f9fe7d00ef9551` +and Echo main `b314f7fd071985edad1f9876df383a85fb491205`. The generated +build and executable-subject locks bind the changed source, vendor publication, +provider and test closure. Public macOS and Linux builds emit identical package +and verifier-report bytes. The package identity is +`sha256:4c2b7859f291e97b6b38fb265086e6cb0581ed030d54d38152b0585152120397`. +The Docker package-chain gate checks the exact clean Git toolchains, rebuilds +through the public CLI, verifies the locks, runs both runtime targets and +refuses mutation of authoritative inputs. + +This is pure computation. No graph or rope is mutated, no Tick is settled, and no WAL or recovery evidence is produced. The test host enables Echo's trusted-host API only in this standalone unpublished test crate. It is not a production dependency or an alternate editor route. The authored rope algorithm diff --git a/edict/replace-range/edict.build-lock.json b/edict/replace-range/edict.build-lock.json index 23cdad44..edff7325 100644 --- a/edict/replace-range/edict.build-lock.json +++ b/edict/replace-range/edict.build-lock.json @@ -2,10 +2,10 @@ "schema": "jedit.edict-build-lock/v1", "applicationCoordinate": "jedit.text.replace_range@1", "operationCoordinate": "jedit.text.replace_range@1.replaceRange", - "toolchainLockSha256": "93237fa565b0b6fc76bf73af21011c1fb96fafad00f853a648090d37608f03df", + "toolchainLockSha256": "55020f1231cfdac71b05c9618ac922a587cfaf546e84c0db7a97784712518408", "sourceClosure": { "schema": "jedit.edict-source-closure/v1", - "digest": "sha256:99a6b580413d31a35c92753cc32466a66bf1939e241b8c957bf7b04927cf2b89", + "digest": "sha256:e0df3b5d5acefab1ff931da52f5cd98c97ea2fd3258c80e608b0b7f41a4e34be", "files": [ { "path": "application/edict.application.json", @@ -13,19 +13,19 @@ }, { "path": "application/edict.lawpack.json", - "sha256": "150abd5971b40ed70d2b1a1765a1a690e120ad9e44239dae732dc54e6ae04f99" + "sha256": "ce13d5993e9b80517538e85bad39ed825ecaf466692063ffd99d17248a68cc66" }, { "path": "application/edict.toolchain-lock.json", - "sha256": "93237fa565b0b6fc76bf73af21011c1fb96fafad00f853a648090d37608f03df" + "sha256": "55020f1231cfdac71b05c9618ac922a587cfaf546e84c0db7a97784712518408" }, { "path": "application/src/ReplaceRange.edict", - "sha256": "51797e77062585a9f59083ee8a1da3faaf486ef7691e1b62203369a9d9356ee0" + "sha256": "61978fd2b7463da772c52a121891523b1669816440a25111af5834d121b86b60" }, { "path": "application/tests/assert-build-output.mjs", - "sha256": "e862848d2e3fdc0acb10b0e31fef4c6481ba9ed94ce6fb28a090b30fb47f43a2" + "sha256": "a0c7f290269edca53e639ac26b1f0cfc749d85285a2c025ce32d361ffed45009" }, { "path": "application/tests/build.sh", @@ -33,7 +33,7 @@ }, { "path": "application/tests/package-chain.mjs", - "sha256": "26f1bbc543a6e7fcb4bab3add0ed63e4fc7f7848df62b7a38f0e8da467dc33ef" + "sha256": "7df3a8f2fd74e9e4719a8c0afce40ce8aa29bec66230607538c0ad1f82dbe0bc" }, { "path": "application/tests/proof-harness.spec.mjs", @@ -41,15 +41,19 @@ }, { "path": "application/tests/runtime/Cargo.toml", - "sha256": "697408353a165e21ca51e887af492af30f6a2359911d0a0296fa981335f0d3c6" + "sha256": "17b7943ca35ed8485ce8b6d3660b79486a655604b5098a7c5ee8a98f230f8790" }, { "path": "application/tests/runtime/Cargo.lock", - "sha256": "1831cd4a0a2fcabb8559734a778be6db2d074a5fc7c43dcab20610ff23b7e65a" + "sha256": "597f102c65285960e80d22277adfa903f67e84fb54ae33ccb2578981e4f7cfb2" }, { "path": "application/tests/runtime/compiled_boundary.rs", - "sha256": "0bef519a74dbc9383dad7c1408d1fdaf962842c3f4df17bd3de58699154d818d" + "sha256": "eb8c482f5d0205843248580f4d21bf8bbcf14a185fa3b35f0a95af3879f34b91" + }, + { + "path": "application/tests/runtime/flat_text.rs", + "sha256": "24b63c5dbbc8b5863a30aa88cfc38a0dfb0fb0a0e41b97c3cf584ecc3dcb65e6" }, { "path": "application/tests/verification-evidence.mjs", @@ -57,23 +61,23 @@ }, { "path": "application/vendor/jedit-text/edict.lawpack-output.json", - "sha256": "141c0000932ba19cff687e4173e40b0a38410f70bd511c9bc51f3fb3f73ee62b" + "sha256": "81a65d2569a3d8513fcefb2de87c816c7364c280205aec42c83f64377f9755f4" }, { "path": "application/vendor/jedit-text/exports.cbor", - "sha256": "cab9c575da49cb33289e45fc45afb9d7f05558dada734be7eb3acfbbabb1d4db" + "sha256": "3a4438fc0a6faed371c5aebfe512299b464fc08f70b4640454538772750644e1" }, { "path": "application/vendor/jedit-text/exports.sha256", - "sha256": "9bb11d9f8153c18af53b484526d9980b05c27eb20aa97e7623d1bf1ed5a69aea" + "sha256": "42f20048fdedb25fdb8700790bae1dd009de8a0f677da300d93016abee8ab7ac" }, { "path": "application/vendor/jedit-text/manifest.cbor", - "sha256": "0323ed8e9510e473d329166d421dc7d8e1da353065c1cd2dee77e6313ba9bf91" + "sha256": "4f05a239948e6e7a7efd08f6b20a9249319769eaeac1e67bd8902206299d71bc" }, { "path": "application/vendor/jedit-text/manifest.sha256", - "sha256": "316cf602502a45cbab89b77b6344854edee750eaf1f0c8167da48d19ead75c22" + "sha256": "e0cacb05c16d70f33f2381c5785e906f1763aa555b667b6e52b84f43b709a842" }, { "path": "project/.github/workflows/ci.yml", @@ -91,50 +95,50 @@ }, "lawpackRelease": { "coordinate": "jedit.text@1", - "digest": "sha256:95758c1605894672cc9069fde01bb8b6e11842b053102660c9cd4f4d6f34d64e" + "digest": "sha256:f385072314ea57af5b66cad9eb4119b51e456df2050ea0c9a6302c7693212dc1" }, "provider": { "coordinate": "echo.edict-provider@1", - "digest": "sha256:5650d1d272c78d11a3eee1191c21d7f5cc136c71b163f2398fed42cd6d082c9f" + "digest": "sha256:cba96816605f54dc5e675ab6f473adf858bdaebdceae985f955e930711c8a4f9" }, "artifacts": { "core": { "coordinate": "jedit.text.replace_range@1", "domain": "edict.core.module/v1", - "digest": "sha256:8150aeee1766bde5b2c416a3c9ef9dd4960bde140e9d1b190a966d00bbdf7787" + "digest": "sha256:f878c563d3e22720366faba02c1c964ecf2fb8250acf346e6454d7cd340068ef" }, "targetIr": { "coordinate": "echo.span-ir/v1", "domain": "edict.target-ir.artifact/v1", - "digest": "sha256:2c18d7d5e7d3bf9689e66e7b04c07824641836f6e23ed8396099ca8e24e79ff9" + "digest": "sha256:4b4049ae9730091d9450a489a22c88519fd8f84c5b74895f07cf86a250afcf86" }, "resultProjection": { "coordinate": "jedit.text.replace_range@1.replaceRange", "domain": "edict.result-projection.artifact/v1", - "digest": "sha256:f804baa01c357e5ed54e86f752ea7f8201e454ad0b47c10813fde8c7dc2aeba6" + "digest": "sha256:80d1580fac6effe2d4001364ba2d554db5317e2c324ec30965fe866f79ab6348" }, "executablePackage": { "coordinate": "executable-operation-package.echo", "domain": "echo.operation-package/v1", - "digest": "sha256:b9052d3c40878a9fcba7768be67c8dba50cf0f751682339dfcdd04155871415b", - "rawSha256": "1860ab8a6cb9a4bfd63a1db99d1c2bc00aa53dae52a9d1998295654379a95d85" + "digest": "sha256:4c2b7859f291e97b6b38fb265086e6cb0581ed030d54d38152b0585152120397", + "rawSha256": "31ed2bf3121d8ada879e2f1dee15e793a0106cd8c034beaad4dd3c4995e9629a" }, "verificationReportArtifact": { "coordinate": "verifier-report.echo-operation", "domain": "echo.operation-package-verifier-report/v1", - "digest": "sha256:12afbc22ce618b4e40b712235191657f7451a9dfc397531bd0448fbde5f3ae5c", - "rawSha256": "d96e5d21eecbc1e5bbf6ce76ab438d55cc8e74f6843121d4ffb0f4343e648267" + "digest": "sha256:fc4452e6aa91f541641cf4c070317ec7f24b05b48aeb1c6d8911a7f20a547c04", + "rawSha256": "3dab6a7de887acb0422a881c58130932819d16ecf8577a503d33031036732c86" }, "verificationReport": { "coordinate": "jedit.edict-verification-evidence/v1", "domain": "jedit.edict-verification-evidence/v1", - "digest": "sha256:4e76cca44d48e258ea8ca271f859e8ffe986dd4a6ee33b6e069c51bf6e247a9b", - "rawSha256": "c3e641fb7cdcddd5e70ef362333a06ec42cefbdd23b43e3c7754d2111e37d824" + "digest": "sha256:4005c65e03fdc960883fff68b2eea292cb1a50bd78d95eb4ced41b0d03bf471d", + "rawSha256": "70e100bfd97fc2c09ac45582b01297dddace8cf07b67c79ae5a205d7b3f0b906" }, "executableSubject": { "coordinate": "echo.executable-subject/v1", "domain": "echo.executable-subject/v1", - "digest": "sha256:93d1c2ee6b9798648f2706ef6ffbb0c426afd886331d23d452605fbc3bcdaccb" + "digest": "sha256:ea65a7bfa2055644c99783ef5097bdaa84c03245866f20126816b4c33f75d8cf" } } } diff --git a/edict/replace-range/edict.executable-subject-lock.json b/edict/replace-range/edict.executable-subject-lock.json index d4edbb3d..0c84e5bb 100644 --- a/edict/replace-range/edict.executable-subject-lock.json +++ b/edict/replace-range/edict.executable-subject-lock.json @@ -2,19 +2,19 @@ "schema": "jedit.edict-executable-subject-lock/v1", "reference": { "coordinate": "echo.executable-subject/v1", - "digest": "sha256:93d1c2ee6b9798648f2706ef6ffbb0c426afd886331d23d452605fbc3bcdaccb" + "digest": "sha256:ea65a7bfa2055644c99783ef5097bdaa84c03245866f20126816b4c33f75d8cf" }, - "rawSha256": "b36bf152e5bd5693f02e6eb1a58e698e332830218cf306719f11529422e74486", + "rawSha256": "7d08ef912c7f294c949abddf255423b3f7145d2accf64794dec5acf225e85cf7", "package": { "coordinate": "executable-operation-package.echo", - "digest": "sha256:b9052d3c40878a9fcba7768be67c8dba50cf0f751682339dfcdd04155871415b" + "digest": "sha256:4c2b7859f291e97b6b38fb265086e6cb0581ed030d54d38152b0585152120397" }, "targetIr": { "coordinate": "echo.span-ir/v1", - "digest": "sha256:2c18d7d5e7d3bf9689e66e7b04c07824641836f6e23ed8396099ca8e24e79ff9" + "digest": "sha256:4b4049ae9730091d9450a489a22c88519fd8f84c5b74895f07cf86a250afcf86" }, "resultProjection": { "coordinate": "jedit.text.replace_range@1.replaceRange", - "digest": "sha256:f804baa01c357e5ed54e86f752ea7f8201e454ad0b47c10813fde8c7dc2aeba6" + "digest": "sha256:80d1580fac6effe2d4001364ba2d554db5317e2c324ec30965fe866f79ab6348" } } diff --git a/edict/replace-range/edict.lawpack.json b/edict/replace-range/edict.lawpack.json index 2652d166..8db4e6ea 100644 --- a/edict/replace-range/edict.lawpack.json +++ b/edict/replace-range/edict.lawpack.json @@ -52,7 +52,7 @@ "typeParameters": [], "parameterTypes": [], "returnType": "U64", - "costTemplate": "jedit.text@1.replaceRangeBudget", + "costTemplate": "jedit.text@1.maxCreatedLeafCountCost", "determinismClass": "total", "body": { "params": [], @@ -166,9 +166,14 @@ "effectImplementations": {}, "budgets": { "jedit.text@1.replaceRangeBudget": { - "maxSteps": 1048576, + "maxSteps": 8388608, "maxAllocatedBytes": 16777216, "maxOutputBytes": 8388608 + }, + "jedit.text@1.maxCreatedLeafCountCost": { + "maxSteps": 64, + "maxAllocatedBytes": 1024, + "maxOutputBytes": 64 } } } diff --git a/edict/replace-range/edict.toolchain-lock.json b/edict/replace-range/edict.toolchain-lock.json index a9ef7916..3a961e59 100644 --- a/edict/replace-range/edict.toolchain-lock.json +++ b/edict/replace-range/edict.toolchain-lock.json @@ -29,26 +29,26 @@ ] }, "edict": { - "commit": "e60411fc6eb93c55468cc8c728f7fa9166207a6d", + "commit": "2b4832efe62de75e1f204cec72f9fe7d00ef9551", "cliVersion": "0.11.0-alpha.1" }, "echo": { - "commit": "9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a", + "commit": "b314f7fd071985edad1f9876df383a85fb491205", "provider": { "coordinate": "echo.edict-provider@1", - "digest": "sha256:5650d1d272c78d11a3eee1191c21d7f5cc136c71b163f2398fed42cd6d082c9f", - "manifestSha256": "196ba049ec8ae1c421547c937957983a42c538327d2b980075a8b313dcc76044", + "digest": "sha256:cba96816605f54dc5e675ab6f473adf858bdaebdceae985f955e930711c8a4f9", + "manifestSha256": "d9ec3c528d0b27434606ecef27a552eb466034866cbb3cb04d169241f772a6df", "targetProfile": { "coordinate": "echo.dpo@1", "digest": "sha256:2e2494121aecf5e6a2d920f5fb85408825d394765fad41484c416397c920fb04" }, "lowerer": { "coordinate": "echo.dpo.lowerer/component@1", - "sha256": "ec0debac21c4398b73598c5b5a15a08079ee1f03b8d9d77860d929dd801751b8" + "sha256": "79066cfc740da4463fd20baec36fe18c6cfb346917fed475b4ef7119fda9408a" }, "verifier": { "coordinate": "echo.dpo.verifier/component@1", - "sha256": "c262841549c088dbf8892c16e15515a17a2575dcc3e011b1b414b6fe63105790", + "sha256": "577c69937594c0aff2461dd60d43507e1f6ce0903ca2b17ff02919d73efd9b28", "contract": { "coordinate": "echo.dpo.verifier/v1", "digest": "sha256:ca96b190728de3d668072ec1bd37d24e5197e7bd9bd54f70966d8c566b9b67f2" diff --git a/edict/replace-range/src/ReplaceRange.edict b/edict/replace-range/src/ReplaceRange.edict index 6079dbeb..565bd877 100644 --- a/edict/replace-range/src/ReplaceRange.edict +++ b/edict/replace-range/src/ReplaceRange.edict @@ -1,16 +1,18 @@ package jedit.text.replace_range@1; -use lawpack jedit.text@1 digest "sha256:95758c1605894672cc9069fde01bb8b6e11842b053102660c9cd4f4d6f34d64e" as text; +use lawpack jedit.text@1 digest "sha256:f385072314ea57af5b66cad9eb4119b51e456df2050ea0c9a6302c7693212dc1" as text; type ReplaceRangeInput = { bufferId: text.BufferId, basisHeadId: text.HeadId, + text: Bytes, startByte: U64, endByte: U64, replacement: text.ReplacementBytes, }; type ReplaceRangeBoundary = { + updatedText: Bytes, bufferId: text.BufferId, basisHeadId: text.HeadId, startByte: U64, @@ -24,12 +26,16 @@ intent replaceRange(input: ReplaceRangeInput) returns ReplaceRangeBoundary profile text.replaceRange basis input.basisHeadId budget <= text.replaceRangeBudget - where input.startByte <= input.endByte + where input.startByte <= input.endByte && input.endByte <= len(input.text) && input.startByte <= len(input.text) && isUtf8(input.text) && isUtf8(input.replacement) && isUtf8(slice(input.text, 0u64, input.startByte)) && isUtf8(slice(input.text, 0u64, input.endByte)) && !(slice(input.text, input.startByte, input.endByte) == input.replacement) { + let prefix = slice(input.text, 0u64, input.startByte); + let suffix = slice(input.text, input.endByte, len(input.text)); + let updatedText = prefix + input.replacement + suffix; let createdLeafCeiling: U64 = text.maxCreatedLeafCount(); let rangeIsEmpty = if input.startByte == input.endByte then 1u32 else 0u32; return { + updatedText, bufferId: input.bufferId, basisHeadId: input.basisHeadId, startByte: input.startByte, diff --git a/edict/replace-range/tests/assert-build-output.mjs b/edict/replace-range/tests/assert-build-output.mjs index 7eb4a87d..6c7b6b6c 100644 --- a/edict/replace-range/tests/assert-build-output.mjs +++ b/edict/replace-range/tests/assert-build-output.mjs @@ -31,6 +31,7 @@ const SOURCE_CLOSURE_INPUTS = [ ["application/tests/runtime/Cargo.toml", "tests/runtime/Cargo.toml"], ["application/tests/runtime/Cargo.lock", "tests/runtime/Cargo.lock"], ["application/tests/runtime/compiled_boundary.rs", "tests/runtime/compiled_boundary.rs"], + ["application/tests/runtime/flat_text.rs", "tests/runtime/flat_text.rs"], [ "application/tests/verification-evidence.mjs", "tests/verification-evidence.mjs", diff --git a/edict/replace-range/tests/package-chain.mjs b/edict/replace-range/tests/package-chain.mjs index 6f03f41b..8dbfbd63 100644 --- a/edict/replace-range/tests/package-chain.mjs +++ b/edict/replace-range/tests/package-chain.mjs @@ -302,32 +302,37 @@ async function build() { const buildLock = JSON.parse( await readFile(path.join(applicationRoot, "edict.build-lock.json"), "utf8"), ); - const runtimeOutput = run( - "cargo", - [ - `+${lock.rust.toolchain}`, "test", "--locked", "--manifest-path", - path.join(testsDirectory, "runtime", "Cargo.toml"), - "--test", "compiled_boundary", "freshly_compiled_boundary_executes", - "--", "--exact", "--nocapture", - ], - { - cwd: applicationRoot, - timeout: 600_000, - env: { - CARGO_TARGET_DIR: process.env.CARGO_TARGET_DIR - ?? path.join(buildRoot, "runtime-target"), - JEDIT_VERIFIED_PACKAGE: path.join( - applicationOutput, "executable-operation-package.cbor", - ), - JEDIT_VERIFIED_PACKAGE_PIN: - buildLock.artifacts.executablePackage.digest.slice("sha256:".length), + for (const [target, marker] of [ + ["compiled_boundary", "JEDIT_EDICT_PURE_RUNTIME_OK"], + ["flat_text", "JEDIT_EDICT_FLAT_TEXT_RUNTIME_OK"], + ]) { + const runtimeOutput = run( + "cargo", + [ + `+${lock.rust.toolchain}`, "test", "--locked", "--manifest-path", + path.join(testsDirectory, "runtime", "Cargo.toml"), + "--test", target, + "--", "--nocapture", + ], + { + cwd: applicationRoot, + timeout: 600_000, + env: { + CARGO_TARGET_DIR: process.env.CARGO_TARGET_DIR + ?? path.join(buildRoot, "runtime-target"), + JEDIT_VERIFIED_PACKAGE: path.join( + applicationOutput, "executable-operation-package.cbor", + ), + JEDIT_VERIFIED_PACKAGE_PIN: + buildLock.artifacts.executablePackage.digest.slice("sha256:".length), + }, }, - }, - ); - assert.ok( - runtimeOutput.includes("JEDIT_EDICT_PURE_RUNTIME_OK"), - "runtime conformance witness did not execute", - ); + ); + assert.ok( + runtimeOutput.includes(marker), + "runtime conformance witness did not execute", + ); + } } catch (error) { failure = error; } diff --git a/edict/replace-range/tests/runtime/Cargo.lock b/edict/replace-range/tests/runtime/Cargo.lock index 678e9613..8025a9d4 100644 --- a/edict/replace-range/tests/runtime/Cargo.lock +++ b/edict/replace-range/tests/runtime/Cargo.lock @@ -218,7 +218,7 @@ dependencies = [ [[package]] name = "echo-edict-canonical" version = "0.1.0" -source = "git+https://github.com/flyingrobots/echo?rev=9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a#9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a" +source = "git+https://github.com/flyingrobots/echo?rev=b314f7fd071985edad1f9876df383a85fb491205#b314f7fd071985edad1f9876df383a85fb491205" dependencies = [ "hex", "sha2", @@ -227,17 +227,17 @@ dependencies = [ [[package]] name = "echo-registry-api" version = "0.1.0" -source = "git+https://github.com/flyingrobots/echo?rev=9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a#9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a" +source = "git+https://github.com/flyingrobots/echo?rev=b314f7fd071985edad1f9876df383a85fb491205#b314f7fd071985edad1f9876df383a85fb491205" [[package]] name = "echo-runtime-schema" version = "0.1.0" -source = "git+https://github.com/flyingrobots/echo?rev=9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a#9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a" +source = "git+https://github.com/flyingrobots/echo?rev=b314f7fd071985edad1f9876df383a85fb491205#b314f7fd071985edad1f9876df383a85fb491205" [[package]] name = "echo-wasm-abi" version = "0.1.0" -source = "git+https://github.com/flyingrobots/echo?rev=9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a#9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a" +source = "git+https://github.com/flyingrobots/echo?rev=b314f7fd071985edad1f9876df383a85fb491205#b314f7fd071985edad1f9876df383a85fb491205" dependencies = [ "blake3", "ciborium", @@ -573,7 +573,7 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" [[package]] name = "warp-core" version = "0.1.1" -source = "git+https://github.com/flyingrobots/echo?rev=9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a#9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a" +source = "git+https://github.com/flyingrobots/echo?rev=b314f7fd071985edad1f9876df383a85fb491205#b314f7fd071985edad1f9876df383a85fb491205" dependencies = [ "blake3", "bytemuck", @@ -594,7 +594,7 @@ dependencies = [ [[package]] name = "warp-math" version = "0.1.0" -source = "git+https://github.com/flyingrobots/echo?rev=9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a#9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a" +source = "git+https://github.com/flyingrobots/echo?rev=b314f7fd071985edad1f9876df383a85fb491205#b314f7fd071985edad1f9876df383a85fb491205" dependencies = [ "bunny-num", "libm", diff --git a/edict/replace-range/tests/runtime/Cargo.toml b/edict/replace-range/tests/runtime/Cargo.toml index a8fc5372..4ae0432f 100644 --- a/edict/replace-range/tests/runtime/Cargo.toml +++ b/edict/replace-range/tests/runtime/Cargo.toml @@ -8,9 +8,13 @@ publish = false [workspace] [dev-dependencies] -echo-edict-canonical = { git = "https://github.com/flyingrobots/echo", rev = "9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a" } -warp-core = { git = "https://github.com/flyingrobots/echo", rev = "9b3b9396b635cb0cda6b894ab4804f0c93bf7b6a", features = ["trusted_runtime"] } +echo-edict-canonical = { git = "https://github.com/flyingrobots/echo", rev = "b314f7fd071985edad1f9876df383a85fb491205" } +warp-core = { git = "https://github.com/flyingrobots/echo", rev = "b314f7fd071985edad1f9876df383a85fb491205", features = ["trusted_runtime"] } [[test]] name = "compiled_boundary" path = "compiled_boundary.rs" + +[[test]] +name = "flat_text" +path = "flat_text.rs" diff --git a/edict/replace-range/tests/runtime/compiled_boundary.rs b/edict/replace-range/tests/runtime/compiled_boundary.rs index 8d229fb1..7433d790 100644 --- a/edict/replace-range/tests/runtime/compiled_boundary.rs +++ b/edict/replace-range/tests/runtime/compiled_boundary.rs @@ -9,10 +9,10 @@ use warp_core::edict_pure::{evaluate, EvaluationError, EvaluationLimits}; const ID_BYTES: usize = 32; const MAX_PACKAGE_BYTES: usize = 32_768; -const MAX_INPUT_BYTES: usize = 2_097_152; +const MAX_INPUT_BYTES: usize = 4_194_304; const MAX_STEPS: u64 = 10_000; const MAX_ALLOCATED_BYTES: u64 = 16_777_216; -const MAX_OUTPUT_BYTES: u64 = 2_097_152; +const MAX_OUTPUT_BYTES: u64 = 4_194_304; fn record(fields: impl IntoIterator) -> Value { Value::Map( @@ -27,6 +27,7 @@ fn input(start: u64, end: u64, buffer_id_size: usize) -> Vec { encode(&record([ ("bufferId", Value::Bytes(vec![1; buffer_id_size])), ("basisHeadId", Value::Bytes(vec![2; ID_BYTES])), + ("text", Value::Bytes(b"0123456789abcdef".to_vec())), ("startByte", Value::Integer(start.into())), ("endByte", Value::Integer(end.into())), ("replacement", Value::Bytes("λ\r\n".as_bytes().to_vec())), @@ -60,10 +61,14 @@ fn freshly_compiled_boundary_executes() { // Literal expectations catch a skipped helper, constant result, wrong // branch, or changed field projection without reproducing the evaluator. - for (start, end, range_is_empty) in [(7, 7, 1), (7, 11, 0)] { + for (start, end, range_is_empty, updated) in [ + (7, 7, 1, "0123456λ\r\n789abcdef"), + (7, 11, 0, "0123456λ\r\nbcdef"), + ] { let supplied = input(start, end, ID_BYTES); let result = evaluate(&package, pin, &supplied, limits()).expect("pure result"); let expected = record([ + ("updatedText", Value::Bytes(updated.as_bytes().to_vec())), ("bufferId", Value::Bytes(vec![1; ID_BYTES])), ("basisHeadId", Value::Bytes(vec![2; ID_BYTES])), ("startByte", Value::Integer(start.into())), diff --git a/edict/replace-range/tests/runtime/flat_text.rs b/edict/replace-range/tests/runtime/flat_text.rs new file mode 100644 index 00000000..b96f3a6f --- /dev/null +++ b/edict/replace-range/tests/runtime/flat_text.rs @@ -0,0 +1,178 @@ +// SPDX-License-Identifier: Apache-2.0 OR LicenseRef-MIND-UCAL-1.0 +// © James Ross Ω FLYING•ROBOTS +//! Logical-text reference. This host supplies bytes and checks literal results; +//! it does not perform replacement or link the native rope planner. +use echo_edict_canonical::{ + decode_canonical_cbor_v1 as decode, encode_canonical_cbor_v1 as encode, + CanonicalValueV1 as Value, +}; +use std::{env, fs}; +use warp_core::edict_pure::{evaluate, EvaluationError, EvaluationLimits}; +const ID_BYTES: usize = 32; + +fn package() -> (Vec, [u8; ID_BYTES]) { + let bytes = + fs::read(env::var("JEDIT_VERIFIED_PACKAGE").expect("package path")).expect("fresh package"); + let text = env::var("JEDIT_VERIFIED_PACKAGE_PIN").expect("independently verified pin"); + assert_eq!(text.len(), ID_BYTES * 2); + let mut pin = [0; ID_BYTES]; + for (index, byte) in pin.iter_mut().enumerate() { + *byte = u8::from_str_radix(&text[index * 2..index * 2 + 2], 16).expect("pin hex"); + } + (bytes, pin) +} +fn limits() -> EvaluationLimits { + EvaluationLimits { + max_package_bytes: 32_768, + max_input_bytes: 4_194_304, + max_steps: 8_388_608, + max_allocated_bytes: 16_777_216, + max_output_bytes: 4_194_304, + } +} +fn input(original: &[u8], start: u64, end: u64, replacement: &[u8]) -> Vec { + encode(&Value::Map(vec![ + ( + Value::Text("bufferId".into()), + Value::Bytes(vec![1; ID_BYTES]), + ), + ( + Value::Text("basisHeadId".into()), + Value::Bytes(vec![2; ID_BYTES]), + ), + (Value::Text("text".into()), Value::Bytes(original.to_vec())), + ( + Value::Text("startByte".into()), + Value::Integer(start.into()), + ), + (Value::Text("endByte".into()), Value::Integer(end.into())), + ( + Value::Text("replacement".into()), + Value::Bytes(replacement.to_vec()), + ), + ])) + .expect("canonical input") +} +fn updated_text(output: &[u8]) -> Vec { + let Value::Map(fields) = decode(output).expect("canonical result") else { + panic!("record result") + }; + let value = fields + .into_iter() + .find(|(key, _)| *key == Value::Text("updatedText".into())) + .expect("authored replacement result") + .1; + let Value::Bytes(bytes) = value else { + panic!("bounded byte result") + }; + bytes +} +#[test] +fn compiled_flat_text_replacement_matches_literal_utf8_cases() { + let (package, pin) = package(); + for (name, before, start, end, replacement, expected) in [ + ("empty", "", 0, 0, "λ\r\n", "λ\r\n"), + ("prefix", "world", 0, 0, "hello ", "hello world"), + ("suffix", "hello", 5, 5, " ðŸŒ", "hello ðŸŒ"), + ("replace", "hello world", 6, 11, "λ", "hello λ"), + ("delete", "AλB", 1, 3, "", "AB"), + ("crlf", "one\r\ntwo\r\n", 5, 8, "three", "one\r\nthree\r\n"), + ("whole", "αβ", 0, 4, "🙂", "🙂"), + ("multibyte", "a🙂z", 1, 5, "é", "aéz"), + ("nul", "A\0B", 1, 2, "λ", "AλB"), + ] { + let supplied = input(before.as_bytes(), start, end, replacement.as_bytes()); + let result = evaluate(&package, pin, &supplied, limits()) + .unwrap_or_else(|error| panic!("{name}: {error:?}")); + assert_eq!(updated_text(&result.output), expected.as_bytes(), "{name}"); + assert_eq!( + result, + evaluate(&package, pin, &supplied, limits()).expect("repeat"), + "{name}" + ); + assert!(result.steps > 0 && result.allocated_bytes > 0); + } + println!("JEDIT_EDICT_FLAT_TEXT_RUNTIME_OK"); +} + +#[test] +fn compiled_flat_text_replacement_refuses_invalid_utf8_boundaries_and_noops() { + let (package, pin) = package(); + for (name, before, start, end, replacement) in [ + ("invalid-original", &b"A\xffB"[..], 0, 0, &b"X"[..]), + ("invalid-replacement", &b"ABC"[..], 1, 2, &b"\xff"[..]), + ("overlong", &[0xc0, 0x80][..], 0, 0, &b"X"[..]), + ("surrogate", &[0xed, 0xa0, 0x80][..], 0, 0, &b"X"[..]), + ( + "past-unicode", + &[0xf4, 0x90, 0x80, 0x80][..], + 0, + 0, + &b"X"[..], + ), + ("truncated", &[0xe2, 0x82][..], 0, 0, &b"X"[..]), + ("start-inside-lambda", "aλz".as_bytes(), 2, 3, &b"X"[..]), + ("end-inside-lambda", "aλz".as_bytes(), 1, 2, &b"X"[..]), + ("inside-emoji", "a🙂z".as_bytes(), 2, 4, &b"X"[..]), + ("unchanged-lambda", "AλB".as_bytes(), 1, 3, "λ".as_bytes()), + ("empty-noop", &b""[..], 0, 0, &b""[..]), + ("reversed", &b"ABC"[..], 2, 1, &b"X"[..]), + ("past-end", &b"ABC"[..], 1, 4, &b"X"[..]), + ] { + assert_eq!( + evaluate( + &package, + pin, + &input(before, start, end, replacement), + limits() + ), + Err(warp_core::edict_pure::EvaluationError::InputConstraintFailed("where.0".into())), + "{name}" + ); + } +} + +#[test] +fn public_utf8_replacement_refuses_each_host_resource_aperture() { + let (package, pin) = package(); + let input = input(b"abc", 1, 2, b"X"); + for (limits, error) in [ + ( + EvaluationLimits { + max_steps: 1, + ..limits() + }, + EvaluationError::StepBudgetExceeded, + ), + ( + EvaluationLimits { + max_allocated_bytes: 1, + ..limits() + }, + EvaluationError::AllocationBudgetExceeded, + ), + ( + EvaluationLimits { + max_output_bytes: 1, + ..limits() + }, + EvaluationError::OutputBudgetExceeded, + ), + ( + EvaluationLimits { + max_input_bytes: input.len() - 1, + ..limits() + }, + EvaluationError::InputTooLarge, + ), + ( + EvaluationLimits { + max_package_bytes: package.len() - 1, + ..limits() + }, + EvaluationError::PackageTooLarge, + ), + ] { + assert_eq!(evaluate(&package, pin, &input, limits), Err(error)); + } +} diff --git a/edict/replace-range/vendor/jedit-text/adapter.cbor b/edict/replace-range/vendor/jedit-text/adapter.cbor index 99e3ce6283224b6b1bcd4fa3d52055c2d893d555..2e225d2c64fcf20667ec4f99727286ee6c93476e 100644 GIT binary patch delta 117 zcmdnTJdI_7H1nbg`H34PC+jh?O|<1dFGP;Zc6TNgdo_A*i07DiAWB>pF diff --git a/edict/replace-range/vendor/jedit-text/adapter.sha256 b/edict/replace-range/vendor/jedit-text/adapter.sha256 index 4260e281..c3c01fab 100644 --- a/edict/replace-range/vendor/jedit-text/adapter.sha256 +++ b/edict/replace-range/vendor/jedit-text/adapter.sha256 @@ -1 +1 @@ -sha256:b8d9f15ef18dc99691ab1e034ca40a8b8ac52a1bc1b27597284f1edbaf84f049 +sha256:d8af5523ee2ddfca241b75cf077f282249727a31cae1984e22cc76b12a72f59c diff --git a/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json b/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json index 59079533..97825429 100644 --- a/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json +++ b/edict/replace-range/vendor/jedit-text/edict.lawpack-output.json @@ -7,25 +7,25 @@ "path": "manifest.cbor", "kind": "manifest", "coordinate": "edict.lawpack/v1", - "digest": "sha256:95758c1605894672cc9069fde01bb8b6e11842b053102660c9cd4f4d6f34d64e" + "digest": "sha256:f385072314ea57af5b66cad9eb4119b51e456df2050ea0c9a6302c7693212dc1" }, { "path": "manifest.sha256", "kind": "manifestDigest", "coordinate": "edict.lawpack/v1", - "digest": "sha256:95758c1605894672cc9069fde01bb8b6e11842b053102660c9cd4f4d6f34d64e" + "digest": "sha256:f385072314ea57af5b66cad9eb4119b51e456df2050ea0c9a6302c7693212dc1" }, { "path": "exports.cbor", "kind": "exports", "coordinate": "jedit.text.exports/v1", - "digest": "sha256:cbbc79fd92f09f341a1fae221a2a869bb64e15c511af39333e0453cd87fe456a" + "digest": "sha256:fb43312b13f840174fc89a0a3a6f3b3a4df53a96c4fca7d6c672214d9d703e85" }, { "path": "exports.sha256", "kind": "exportsDigest", "coordinate": "jedit.text.exports/v1", - "digest": "sha256:cbbc79fd92f09f341a1fae221a2a869bb64e15c511af39333e0453cd87fe456a" + "digest": "sha256:fb43312b13f840174fc89a0a3a6f3b3a4df53a96c4fca7d6c672214d9d703e85" }, { "path": "echo-operation-configuration.cbor", @@ -55,13 +55,13 @@ "path": "adapter.cbor", "kind": "adapter", "coordinate": "jedit.text.echo-adapter/v1", - "digest": "sha256:b8d9f15ef18dc99691ab1e034ca40a8b8ac52a1bc1b27597284f1edbaf84f049" + "digest": "sha256:d8af5523ee2ddfca241b75cf077f282249727a31cae1984e22cc76b12a72f59c" }, { "path": "adapter.sha256", "kind": "adapterDigest", "coordinate": "jedit.text.echo-adapter/v1", - "digest": "sha256:b8d9f15ef18dc99691ab1e034ca40a8b8ac52a1bc1b27597284f1edbaf84f049" + "digest": "sha256:d8af5523ee2ddfca241b75cf077f282249727a31cae1984e22cc76b12a72f59c" } ] } diff --git a/edict/replace-range/vendor/jedit-text/exports.cbor b/edict/replace-range/vendor/jedit-text/exports.cbor index 80925499a5d53b13815dd48e3ed972c3deffd6cb..552386def3d5186a4cdeeb3afa1cf0f0059bd60d 100644 GIT binary patch delta 26 icmdlbv|ngLGCQNn^m3%Ui1f& diff --git a/edict/replace-range/vendor/jedit-text/exports.sha256 b/edict/replace-range/vendor/jedit-text/exports.sha256 index 87a0814b..e90199e6 100644 --- a/edict/replace-range/vendor/jedit-text/exports.sha256 +++ b/edict/replace-range/vendor/jedit-text/exports.sha256 @@ -1 +1 @@ -sha256:cbbc79fd92f09f341a1fae221a2a869bb64e15c511af39333e0453cd87fe456a +sha256:fb43312b13f840174fc89a0a3a6f3b3a4df53a96c4fca7d6c672214d9d703e85 diff --git a/edict/replace-range/vendor/jedit-text/manifest.cbor b/edict/replace-range/vendor/jedit-text/manifest.cbor index 7bbc2c452f94541ff049a5d8b88f272775da67f6..0e9e2ef1aefa4cd597191231732725a1ddfc6e01 100644 GIT binary patch delta 81 zcmV-X0IvU&29pMmLLmD?F)I`JKo?KQnhH8^J33AEI+n!zr`E=DAx)idK83MjRRJK_ nuT>-NE#Jx{8+FeIe<&hJa(Xe!;h0V$%yzLVa`l|E*8w~MeD5P) delta 81 zcmV-X0IvU&29pMmLLke$dHs^`pEMdDt|A&LhMTrd6~z&+IWs;4Q_Y9|MQX8PRRJKl n+3{ZSjmeggs~!VPqza3Q#VQ-YvUQgzPafN^gz!nT*8w~My^thi diff --git a/edict/replace-range/vendor/jedit-text/manifest.sha256 b/edict/replace-range/vendor/jedit-text/manifest.sha256 index be4e2d8b..3b2b10e7 100644 --- a/edict/replace-range/vendor/jedit-text/manifest.sha256 +++ b/edict/replace-range/vendor/jedit-text/manifest.sha256 @@ -1 +1 @@ -sha256:95758c1605894672cc9069fde01bb8b6e11842b053102660c9cd4f4d6f34d64e +sha256:f385072314ea57af5b66cad9eb4119b51e456df2050ea0c9a6302c7693212dc1