@aikdna/kdna-core 0.37.0 → 0.37.2

package/README.md

@@ -1,14 +1,29 @@
 # KDNA Core — R2 candidate
+> This package is one coordinate of the combination listed in the [top-level entry](../../README.md); that entry states the exact source versions, registry status and installation route.
 
-Unpublished `R2` source candidate: actual source package `0.37.0`, Core `kdna.core/0.8.2`, Container `0.5.0`, Payload `0.5.1`, Canonical IR `0.6.1`, with native Capsule/Plan/Host/Trace `0.3.1`. The published incumbent is `0.36.0`; this source candidate is not a published replacement. See the [specification index](../../SPEC-INDEX.md), the [execution contract](../../specs/execution-contract-0.3.md) and the [PackageSet node surface](../../specs/package-set-node.md). Implementation, independent byte-bound acceptance, installed consumer rebinding and publication are separate.
 
-This source description follows [`package.json`](package.json).
-Read source `0.11.1` declares this exact Core peer. Runtime CLI
-0.40 and MCP 0.8.1 retain their separate Core 0.34 / Read 0.9 archives; see the
+Stable distribution source candidate: package `0.37.2`, paired with exact Read
+`0.11.3`. The compiled browser/Node tuple is Core `kdna.core/0.8.2`,
+Container `0.5.0`, Payload `0.5.1`, Canonical IR `0.6.1`, Read `0.6.4`,
+and Capsule/Plan/Host/Trace `0.3.1`. Native section subpaths separately use
+Container `0.6.0` and Read `0.7.0-candidate`. See the
+[specification index](../../SPEC-INDEX.md) and
 [matching-delivery guide](../../docs/core-read-current-status.md#choose-and-obtain-one-matching-delivery).
-Editing this source README does not replace a previously fixed archive or
-renew any byte-bound acceptance. Use the manifest and member inventory shipped
-with the exact artifact; do not rebuild or substitute it merely to align prose.
+
+This source follows [`package.json`](package.json). Exact source, package bytes,
+installed dependency identity and registry publication each require their own
+checks. This source candidate does not establish that `latest` has changed;
+select the exact coordinate only after the official registry supplies it.
+Core `0.37.0` and Read `0.11.1` remain earlier published stable coordinates.
+The earlier published Core `0.37.1-rc.browser.1` / Read
+`0.11.2-rc.browser.1` previews retain their own byte identities and tags.
+
+The candidate includes the generated `/public-contract` descriptor exports.
+They expose the fixed public types, diagnostic schema and limits from the same
+semantic source as the runtime; they do not create a caller-defined validator.
+Native path admission preserves `READ_CORE_INVALID` for short ZIP inputs and
+rejects nonregular files through a nonblocking opened descriptor before any
+authorization callback.
 
 Core admits one immutable container, validates its Manifest and typed Payload, resolves the static graph, computes A/C/E and Canonical IR digests, and issues a private snapshot. Risk and noncritical extensions remain authored declarations, with presence and order preserved. Unsupported critical semantics fail closed. Static admission performs no condition evaluation, quality assessment or authorization. The separate execution subpath validates native 0.3.1 objects and coordinates explicitly configured external Host providers; serialized inputs cannot confer trust or permission.
 
@@ -25,6 +40,12 @@ Core admits one immutable container, validates its Manifest and typed Payload, r
 | `/remote-runtime` | `loadRemoteRuntimeAsset` | Preserved explicit legacy 0.1 remote loader; independently declared types, no R2 conversion |
 | `/read-boundary` | `inspectSnapshot`, `isProtectedSnapshot` | Pure private-snapshot probes; availability is not current authority |
 | `/protection-node` | `getProtectionContract`, `admitProtectedNode`, `bindProtectionOperation`, `disposeProtectionOperation`, `protectSourceBytes` | Explicit Node protection, trusted provider and opaque operation |
+| `/protected-browser` | `getProtectionContract`, `admitProtectedBrowser` | Host-supplied container bytes, plaintext Payload and unlock observation; trusted provider |
+| `/protected-sections-browser` | `admitProtectedPayloadRequestJson`, `inspectProtectedPayloadRequest`, `createProtectedPayloadReadAuthorityJson`, `admitProtectedSectionBrowser`, `inspectProtectedPayloadSnapshot`, `bindProtectedPayloadRequest`, `disposeProtectedSectionOperation` | Genuine browser admission snapshot, closed JSON request and independently trusted authority |
+
+The candidate `/protected-sections-browser` entry retains one genuine accepted snapshot from `/protected-browser`'s `admitProtectedBrowser`. Admit the request JSON, create an independently trusted Read authority, then call `admitProtectedSectionBrowser(snapshot, request, authority)` and retain its returned operation and normalized request. Bind later request JSON with `bindProtectedPayloadRequest`; close the operation with `disposeProtectedSectionOperation`. The [generated declarations](src/public-contract/protected-sections-browser.d.ts) define the seven callables and closed inputs.
+
+The original input triple is container bytes, Host-supplied plaintext Payload and an unlock observation. It does not prove decryption or ciphertext/plaintext authentication. This adapter performs no new decryption or physical read; its observation and receipt preserve `host_supplied_triple` and `observation_not_authority`. It uses the independent base tuple above, including container `0.5.0` and Read `kdna.read/0.6.4`; Node native-section witnesses and serialized snapshot copies cannot establish browser origin. Disclosure additionally requires the [Read browser adapter](../kdna-read/README.md#protected-browser-read-candidate) and its independently trusted Host scope.
 
 ```js
 import { admitNode } from '@aikdna/kdna-core/node';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aikdna/kdna-core",
-  "version": "0.37.0",
+  "version": "0.37.2",
   "description": "Public KDNA Core with bounded component interpretation and Canonical IR.",
   "engines": {
     "node": ">=20"
@@ -125,10 +125,20 @@
       "import": "./src/public-contract/sections-bytes-browser.mjs",
       "require": "./src/public-contract/sections-bytes-browser.js"
     },
+    "./public-contract": {
+      "types": "./src/public-contract/public-contract.d.ts",
+      "import": "./src/public-contract/public-contract.mjs",
+      "require": "./src/public-contract/public-contract.js"
+    },
     "./retained-sections-browser": {
       "types": "./src/public-contract/retained-sections-browser.d.ts",
       "import": "./src/public-contract/retained-sections-browser.mjs",
       "require": "./src/public-contract/retained-sections-browser.js"
+    },
+    "./protected-sections-browser": {
+      "types": "./src/public-contract/protected-sections-browser.d.ts",
+      "import": "./src/public-contract/protected-sections-browser.mjs",
+      "require": "./src/public-contract/protected-sections-browser.js"
     }
   },
   "types": "src/public-contract/types.d.ts",

package/src/public-contract/browser-native/generated-contract.json

@@ -809,12 +809,12 @@
     },
     "schema_paths": {
       "CanonicalIR": "specs/canonical-ir-0.6.1.schema.json",
-      "IssuerResultObservation": "specs/external-grant-issuer-r2-binding-7.schema.json",
+      "IssuerResultObservation": "specs/external-grant-issuer-r2-binding-8.schema.json",
       "Manifest": "schema/manifest-container-0.5.0-judgment-0.5.1.schema.json",
       "PackageSetNodeSurface": "specs/package-set-node-0.2.1.schema.json",
       "Payload": "schema/payload-profile-0.5.1.schema.json",
-      "ProtectedSourceObservation": "specs/protected-source-r2-binding-7.schema.json",
-      "ProtectionDefinitionObservation": "specs/protection-admission-r2-binding-7.schema.json",
+      "ProtectedSourceObservation": "specs/protected-source-r2-binding-8.schema.json",
+      "ProtectionDefinitionObservation": "specs/protection-admission-r2-binding-8.schema.json",
       "PublicAgentHostReceipt": "schema/agent-host-receipt-0.3.1.schema.json",
       "PublicAgentHostRequest": "schema/agent-host-request-0.3.1.schema.json",
       "PublicConsumptionPlan": "schema/consumption-plan-0.3.1.schema.json",

package/src/public-contract/browser-native/sections/contract.json

@@ -2,8 +2,8 @@
   "candidate_only": true,
   "source": {
     "path": "specs/public-semantic-source.json",
-    "bytes": 1438087,
-    "sha256": "5ae686be4e7a7d7abcc88967ac3fc67cbbcc7e5f60d8379cc109edd7a581598a"
+    "bytes": 1506715,
+    "sha256": "e1fa081ca757d8ceb2e73910024778e31debe83b16d8b4824a4c66466ec57928"
   },
   "historical_original_source": {
     "scope": "historical_original_contract_source_identity_not_current_generator_input",

package/src/public-contract/browser-native/whole.js

@@ -13,6 +13,35 @@ const checksums=require('./section-checksums.js'),signatures=require('./section-
 const contract=C.strict.freeze(definition),tuple=C.contract.module.versionTuple;
 function typed(name,value){C.strict.assertStrictJson(value);if(!validators[name](value))throw new Error('INTERNAL_BROWSER_BYTE_RESULT_SHAPE');return C.strict.freeze(value);}
 function classify(code){return ['PROTECTION_BINDING_UNIMPLEMENTED','CHECKSUMS_PROFILE_UNSUPPORTED','SIGNATURE_PROFILE_UNSUPPORTED'].includes(code)?'unsupported':'rejected';}
+// F2: one bounded metadata classifier for the three public read entries. It reads
+// only two bounded windows - the EOCD tail and the central directory - never the
+// whole container, and it never mutates a shared module. Empty input (no ZIP
+// structure) is reported as READ_INPUT_INVALID; a container that is recognisable
+// but damaged keeps READ_CORE_INVALID (the published Python contract pins that
+// for damaged member streams); a readable container of another family (a
+// payload-family member set) is reported as READ_UNSUPPORTED_VERSION.
+const INPUT_MARKERS={eocd:Uint8Array.from([80,75,5,6]),payload:Uint8Array.from([112,97,121,108,111,97,100,46,107,100,110,97,98]),frames:Uint8Array.from([115,101,99,116,105,111,110,115,47,112,97,99,107,45])};
+const INPUT_TAIL=65557,DIR_SCAN_CAP=1048576;
+function findBytes(bytes,needle,from=0,to=bytes.length){const last=Math.min(to,bytes.length)-needle.length;outer:for(let i=from;i<=last;i++){for(let j=0;j<needle.length;j++)if(bytes[i+j]!==needle[j])continue outer;return i;}return -1;}
+function containerMeta(bytes){
+ const view=bytes&&bytes.length>=4?bytes:null;
+ const zipMagic=view&&view[0]===0x50&&view[1]===0x4b&&(view[2]===0x03||view[2]===0x05||view[2]===0x07);
+ const tailStart=Math.max(0,bytes.length-INPUT_TAIL),eocd=bytes.length>=22?findBytes(bytes,INPUT_MARKERS.eocd,tailStart):-1;
+ if(!zipMagic&&eocd===-1)return {kind:'not_container'};
+ if(eocd===-1)return {kind:'damaged'};
+ const cdStart=(bytes[eocd+16]|(bytes[eocd+17]<<8)|(bytes[eocd+18]<<16)|(bytes[eocd+19]<<24))>>>0;
+ const cdSize=(bytes[eocd+12]|(bytes[eocd+13]<<8)|(bytes[eocd+14]<<16)|(bytes[eocd+15]<<24))>>>0;
+ if(cdStart+cdSize>bytes.length||cdSize>DIR_SCAN_CAP)return {kind:'damaged'};
+ const hasPayload=findBytes(bytes,INPUT_MARKERS.payload,cdStart,cdStart+cdSize)!==-1;
+ const hasFrames=findBytes(bytes,INPUT_MARKERS.frames,cdStart,cdStart+cdSize)!==-1;
+ return hasPayload&&!hasFrames?{kind:'other_family'}:{kind:'damaged'};
+}
+function inputFailureClass(bytes){
+ const meta=containerMeta(bytes);
+ if(meta.kind==='not_container')return {reason:'READ_INPUT_INVALID',stage:'input',diagnostic:null};
+ if(meta.kind==='other_family')return {reason:'READ_UNSUPPORTED_VERSION',stage:'metadata',diagnostic:{field:'/payload.kdnab',subject:null}};
+ return null;
+}
 async function admitSectionBytesBrowser(input,admitted,authority){
  let capture,owned,length=null,stage='input';const io=[];
  function observation(){if(length===null)return null;return typed('NativeBrowserSectionByteObservation06',{contract,input_kind:'owned_uint8array',input_byte_length:length,ownership_copy:{offset_bytes:0,length_bytes:length},capture:capture?structuredClone(capture.identity):null,access_ranges:structuredClone(io),filesystem_reads:0});}
@@ -45,7 +74,7 @@ async function admitSectionBytesBrowser(input,admitted,authority){
   // Opaque schema is intentionally false for JSON input; the existing private owner mints this token.
   const result=Object.freeze({status:'accepted',snapshot,input_observation});
   snapshots.set(snapshot,view);byteOrigins.add(snapshot);return result;
- }catch(error){const held=F.info(error);return failure(classify(held?.code??'READ_CORE_CAPABILITY_UNAVAILABLE'),held?.code??'READ_CORE_CAPABILITY_UNAVAILABLE',held?.diagnostic??null);}
+ }catch(error){const held=F.info(error),code=held?.code??'READ_CORE_CAPABILITY_UNAVAILABLE';const classified=stage==='input'&&code==='READ_CORE_INVALID'?inputFailureClass(owned):null;if(classified){stage=classified.stage;return failure(classify(classified.reason),classified.reason,classified.diagnostic);}return failure(classify(code),code,held?.diagnostic??null);}
  finally{if(capture)await capture.close();}
 }
 module.exports={admitSectionBytesBrowser};

package/src/public-contract/browser-protected/request.js

@@ -0,0 +1,77 @@
+'use strict';
+const S = require('./state.js'), { C } = S;
+const fixed = n => String(n).padStart(16, '0');
+const count = value => new TextEncoder().encode(C.strict.canonicalJson(value)).length;
+const correlation = id => C.strict.identifier(id) ? {
+    state: 'validated', request_id: id
+} : {
+    state: 'unavailable', request_id: null
+};
+function failure(candidate) {
+    const id = Object.getOwnPropertyDescriptor(candidate ?? {}, 'request_id')?.value, body = {
+        contract: 'kdna.read-admission/0.1.0', code: 'READ_INPUT_INVALID', diagnostic: {
+            stage: 'admission', severity: 'error', reason: 'mode_shape_invalid', field: '$candidate'
+        }, correlation: correlation(id), control_budget: {
+            limit_bytes: 4096, actual_bytes: '0000000000000000'
+        }
+    };
+    body.control_budget.actual_bytes = fixed(count(body));
+    const out = {
+        channel: 'admission_rejection', envelope: null, admission_rejection: body, control: null, transport_failure: null
+    };
+    C.validate('BrowserProtectedRequestAdmission', out);
+    return S.frozen(out);
+}
+function versionRejection(candidate, code) {
+    const envelope = {
+        contract: 'kdna.protected-browser-read/0.1.0-candidate', request_id: candidate.request_id, status: 'rejected', tuple: null, asset: null, snapshot_id: null, digests: null, content: null, states: {
+            core: 'not_evaluated', interpretation: 'not_evaluated', writer: 'not_evaluated', confirmation: 'not_evaluated', read_permission: 'not_evaluated', action_authorization: 'not_evaluated'
+        }, diagnostics: [{
+                code, stage: 'version', severity: 'error', subject: null, field: null
+            }], omissions: [], assessment: {
+            state: 'not_evaluated', kind: null, assessor_id: null, evidence_ref: null
+        }, receipt: {
+            receipt_id: 'receipt:' + candidate.request_id, request_id: candidate.request_id, snapshot_id: null, host_id: null, host_epoch: null, decision_id: null, disclosed_at: null, delivery: 'not_delivered'
+        }, budget: {
+            limit_bytes: candidate.budget_bytes, required_bytes: '0000000000000000', actual_bytes: '0000000000000000'
+        }
+    };
+    const size = count(envelope);
+    envelope.budget.actual_bytes = fixed(size);
+    envelope.budget.required_bytes = fixed(size);
+    const out = size <= candidate.budget_bytes ? {
+        channel: 'read_envelope', envelope, admission_rejection: null, control: null, transport_failure: null
+    } : {
+        channel: 'no_body_control', envelope: null, admission_rejection: null, control: {
+            code: 'READ_RESPONSE_BUDGET_TOO_SMALL', semantic_cause: code, correlation: correlation(candidate.request_id), body_bytes: 0
+        }, transport_failure: null
+    };
+    C.validate('BrowserProtectedRequestAdmission', out);
+    return S.frozen(out);
+}
+function admit(candidateJson) {
+    let candidate;
+    try {
+        candidate = C.parseJsonText(candidateJson);
+        const data = candidate;
+        C.keys(data, ['request_id', 'tuple', 'budget_bytes', 'mode', 'selection', 'handle']);
+        C.need(C.strict.identifier(data.request_id) && C.strict.uint(data.budget_bytes), 'READ_INPUT_INVALID');
+        const t = data.tuple;
+        C.need(t && typeof t === 'object' && !Array.isArray(t) && Object.keys(t).every(k => Object.hasOwn(S.tuple, k) && typeof t[k] === 'string'), 'READ_INPUT_INVALID');
+        if (Object.keys(t).length !== Object.keys(S.tuple).length || Object.entries(S.tuple).some(([k, v]) => t[k] !== v)) {
+            const baseline = require('../generated-contract.json'), old = [baseline.versionTuple, ...baseline.types.UnsupportedVersionTuple.anyOf.map(x => Object.fromEntries(Object.entries(x.properties).map(([k, v]) => [k, v.const])))];
+            const historical = old.some(value => Object.keys(t).length === Object.keys(value).length && Object.entries(value).every(([k, v]) => t[k] === v));
+            return versionRejection(data, historical ? 'READ_UNSUPPORTED_VERSION' : Object.keys(S.tuple).some(k => k !== 'payload_profile' && t[k] === S.tuple[k]) ? 'READ_MIXED_VERSION_TUPLE' : 'READ_UNSUPPORTED_VERSION');
+        }
+        C.validate('BrowserProtectedRequest', data);
+        return Object.freeze({
+            channel: 'admitted_request', request: S.mintRequest(data)
+        });
+    }
+    catch (e) {
+        return failure(candidate);
+    }
+}
+module.exports = {
+    admit, failure
+};

package/src/public-contract/browser-protected/state.js

@@ -0,0 +1,200 @@
+'use strict';
+const strict = require('../browser-native/strict-input.js');
+const { digestCanonical } = require('../digests.js');
+const { inspectSnapshot, markProtectedSnapshot } = require('../brand.js');
+const contract = require('../protected-browser-contract/contract.json');
+const validators = require('../protected-browser-contract/validators.cjs');
+const origins = new WeakMap(), requests = new WeakMap(), authorities = new WeakMap();
+const operations = new WeakMap(), snapshots = new WeakMap(), checkpoints = new WeakMap(), failures = new WeakMap();
+const tuple = require('../generated-contract.json').versionTuple;
+const frozen = strict.freeze;
+function need(ok, code = 'READ_INPUT_INVALID') {
+  if (!ok) { const error = new Error(code); failures.set(error, code); throw error; }
+}
+function validate(name, value) {
+  strict.assertStrictJson(value);
+  need(typeof validators[name] === 'function' && validators[name](value), 'READ_INPUT_INVALID');
+  scalars(value, contract.types[name]);
+  return value;
+}
+function scalars(value, shape, depth = 0) {
+  need(depth <= 64);
+  if (shape.$ref) {
+    const name = shape.$ref.slice(8);
+    if (name === 'Identifier') need(strict.identifier(value));
+    if (['EntryName', 'RuntimeMandatoryEntryName'].includes(name)) need(strict.entryName(value));
+    if (name === 'Timestamp') need(strict.validTimestamp(value));
+    return scalars(value, contract.types[name], depth);
+  }
+  if (typeof value === 'string') need(strict.scalarString(value));
+  if (value && typeof value === 'object') {
+    for (const [key, child] of Object.entries(shape.properties ?? {}))
+      if (Object.hasOwn(value, key)) scalars(value[key], child, depth + 1);
+    if (Array.isArray(value) && shape.items) for (const child of value) scalars(child, shape.items, depth + 1);
+  }
+  for (const child of shape.allOf ?? []) scalars(value, child, depth);
+  for (const child of shape.oneOf ?? shape.anyOf ?? []) {
+    const branch = child.$ref ? contract.types[child.$ref.slice(8)] : child;
+    if (branch.type && (branch.type === 'null' ? value !== null : branch.type === 'array' ? !Array.isArray(value) : typeof value !== branch.type)) continue;
+    if (Object.entries(branch.properties ?? {}).some(([key, field]) => Object.hasOwn(field, 'const') && Object.hasOwn(value ?? {}, key) && value[key] !== field.const)) continue;
+    scalars(value, child, depth);
+  }
+}
+function parseJsonText(value) { need(typeof value === 'string'); return strict.parseJson(value); }
+function keys(value, names) {
+  need(value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === names.length && names.every(k => Object.hasOwn(value, k)));
+}
+const C = { strict, contract, validate, keys, need, parseJsonText, isFailure: e => failures.has(e), failureCode: e => failures.get(e) ?? null };
+function failed(code = 'PROTECTION_OPERATION_UNTRUSTED', stage = 'input') {
+  return frozen({ status: 'protection_failed', diagnostic: { code, stage }, checked_at_ms: null });
+}
+// Registration is private to successful browser admission. Public snapshot fields,
+// JSON copies and Node admissions cannot establish this provenance.
+function register(snapshot, metadata) {
+  const view = inspectSnapshot(snapshot);
+  need(view && strict.canonicalJson(view.tuple) === strict.canonicalJson(tuple), 'READ_SNAPSHOT_UNATTESTED');
+  const origin = { phase: 'available', view, metadata: frozen(metadata) };
+  origins.set(snapshot, origin);
+  markProtectedSnapshot(snapshot, () => origin.phase !== 'closed');
+}
+function mintRequest(data, sourceDigest = null) {
+  const token = Object.freeze({}), copy = frozen(strict.copyJson(data)), digest = digestCanonical(copy);
+  requests.set(token, { data: copy, digest, sourceDigest: sourceDigest ?? digest, operation: null });
+  return token;
+}
+function request(token) { const r = requests.get(token); return r && (!r.operation || operation(r.operation)) ? r : null; }
+function inspectRequest(token) { return request(token)?.data ?? null; }
+function normalized(record, view) {
+  if (record.data.mode !== 'exact_selection') return mintRequest(record.data, record.sourceDigest);
+  const s = record.data.selection;
+  need(s.asset_id === view.asset.asset_id, 'READ_ASSET_MISMATCH');
+  need(s.asset_version === view.asset.asset_version, 'READ_ASSET_VERSION_MISMATCH');
+  const wanted = new Set(s.judgment_ids), ordered = view.ir.catalog.filter(x => wanted.has(x.judgment_id)).map(x => x.judgment_id);
+  need(ordered.length === wanted.size, 'READ_SELECTION_NOT_FOUND');
+  return mintRequest({ ...record.data, selection: { ...s, judgment_ids: ordered } }, record.sourceDigest);
+}
+function createAuthority(callback, policyJson) {
+  if (typeof callback !== 'function') throw new TypeError('PROTECTED_BROWSER_AUTHORITY_CALLBACK');
+  const policy = policyJson === undefined ? { requireSignature: false, expectedPublicKeyHex: null } : parseJsonText(policyJson);
+  validate('BrowserProtectedSignaturePolicy', policy);
+  const token = Object.freeze({}); authorities.set(token, { callback, policy: frozen(policy) }); return token;
+}
+function operation(token) { const record = operations.get(token); return record && !record.disposed ? record : null; }
+function inspectProtectedSnapshot(token) { const record = snapshots.get(token); return record && !record.disposed ? record.view : null; }
+function pairRequest(token, op) {
+  const r = requests.get(token), record = operation(op);
+  need(r && record && !r.operation);
+  r.operation = op; return token;
+}
+function dispose(op) {
+  const record = operations.get(op);
+  if (!record || record.disposed) return;
+  record.disposed = true; record.generation++;
+  record.origin.phase = 'closed'; record.origin.view = null; record.origin.metadata = null;
+  for (const release of record.releases) release();
+  record.releases.clear();
+  record.view = null; record.metadata = null;
+}
+function onDispose(op, release) {
+  const record = operation(op);
+  if (!record) { release(); return () => {}; }
+  record.releases.add(release);
+  return () => record.releases.delete(release);
+}
+function clock(record, stage) {
+  need(!record.disposed, 'PROTECTION_OPERATION_DISPOSED');
+  let now;
+  try { now = record.metadata.provider.clock(); } catch { need(!record.disposed, 'PROTECTION_OPERATION_DISPOSED'); need(false, 'PROTECTION_PROVIDER_FAILED'); }
+  need(!record.disposed, 'PROTECTION_OPERATION_DISPOSED');
+  need(strict.uint(now), 'PROTECTION_PROVIDER_FAILED');
+  need(now >= record.lastTime, 'PROTECTION_STATE_ROLLBACK');
+  record.lastTime = now; return now;
+}
+function receipt(record, now) {
+  return frozen({ contract: 'kdna.protected-browser-observation/0.1.0-candidate', operation_id: record.id,
+    snapshot_id: record.view.snapshot_id, A: record.view.digests.A.observed, C: record.view.digests.C.observed,
+    E: record.view.digests.E.observed, checked_at_ms: now, proof: 'observation_not_authority', provenance: 'host_supplied_triple' });
+}
+function context(record, r, phase, policy) {
+  const view = record.view, read_intent = {
+    operation: phase, operation_id: record.id, capture_id: record.base.capture.capture_id,
+    snapshot_id: view.snapshot_id, request_digest: r.digest, mode: r.data.mode,
+    physical_reads: 'none', provenance: 'host_supplied_triple', new_decryption: false,
+    new_domain_validation: false, new_signature_verification: false
+  };
+  return frozen({ request: r.data, request_digest: r.digest, tuple: view.tuple, asset: view.asset,
+    digests: view.digests, read_intent, read_intent_digest: digestCanonical(read_intent),
+    signature_policy: policy, disclosure: record.metadata.disclosure });
+}
+async function grant(authority, r, record, phase) {
+  const a = authorities.get(authority);
+  need(a && !record.disposed, 'PROTECTION_OPERATION_UNTRUSTED');
+  const integrity = record.metadata.integrity;
+  need(!(a.policy.requireSignature || a.policy.expectedPublicKeyHex !== null) ||
+    integrity.signature !== 'absent' && (a.policy.expectedPublicKeyHex === null || integrity.public_key === a.policy.expectedPublicKeyHex), 'READ_CORE_INVALID');
+  const value = context(record, r, phase, a.policy);
+  validate('BrowserProtectedAuthorityContext', value);
+  let accepted;
+  try { accepted = await a.callback(value); } catch { need(!record.disposed, 'PROTECTION_OPERATION_DISPOSED'); need(false, 'READ_HOST_DENIED'); }
+  need(!record.disposed, 'PROTECTION_OPERATION_DISPOSED');
+  need(accepted === true, 'READ_HOST_DENIED');
+  return value;
+}
+function bind(op, authority, r) {
+  const record = operation(op);
+  if (!record || !r || r.operation !== op) return null;
+  const binding = Object.freeze({
+    observe(phase) {
+      const task = record.queue.then(async () => {
+        try {
+          clock(record, phase);
+          await grant(authority, r, record, phase);
+          const now = clock(record, phase); record.generation++;
+          const checkpoint = Object.freeze({}); checkpoints.set(checkpoint, { record, generation: record.generation, phase });
+          return Object.freeze({ status: 'current', checkpoint, receipt: receipt(record, now) });
+        } catch (e) { return failed(failures.get(e) ?? 'PROTECTION_PROVIDER_FAILED', phase); }
+      });
+      record.queue = task.then(() => undefined, () => undefined); return task;
+    },
+    assertCurrent(checkpoint) {
+      const cp = checkpoints.get(checkpoint);
+      if (!cp || cp.record !== record) return failed();
+      try {
+        const now = clock(record, cp.phase);
+        need(record.generation === cp.generation, 'PROTECTION_STATE_ROLLBACK');
+        return Object.freeze({ status: 'current', receipt: receipt(record, now) });
+      } catch (e) { return failed(failures.get(e) ?? 'PROTECTION_PROVIDER_FAILED', cp.phase); }
+    }
+  });
+  return { record, binding };
+}
+async function admit(snapshot, admitted, authority) {
+  const origin = origins.get(snapshot), raw = request(admitted);
+  if (!origin || origin.phase !== 'available' || !raw || raw.operation || raw.data.mode === 'expand' || !authorities.has(authority)) return failed();
+  // Consume the genuine origin before any clock/authority callback can reenter.
+  origin.phase = 'reserved';
+  let op;
+  try {
+    op = Object.freeze({});
+    const nativeSnapshot = Object.freeze({}), metadata = origin.metadata;
+    const view = frozen({ ...origin.view, observation: metadata.observation });
+    const record = { id: 'browser-protection:' + globalThis.crypto.randomUUID(), origin, view, metadata,
+      base: { capture: { capture_id: 'browser-origin:' + globalThis.crypto.randomUUID() } },
+      disposed: false, generation: 0, lastTime: 0, queue: Promise.resolve(), releases: new Set() };
+    operations.set(op, record); snapshots.set(nativeSnapshot, record);
+    need(strict.canonicalJson(raw.data.tuple) === strict.canonicalJson(view.tuple), 'READ_UNSUPPORTED_VERSION');
+    const token = normalized(raw, view), r = requests.get(token);
+    pairRequest(token, op);
+    await grant(authority, r, record, 'admit_retained_protected_snapshot');
+    const now = clock(record, 'authorization'); origin.phase = 'active';
+    const proof = receipt(record, now); record.receipt = proof;
+    return Object.freeze({ status: 'accepted', request: token, snapshot: nativeSnapshot, operation: op,
+      receipt: proof, observation: view.observation, disclosure: metadata.disclosure, physical_reads: 'none' });
+  } catch (e) {
+    dispose(op);
+    origin.phase = 'closed'; origin.view = null; origin.metadata = null;
+    return failed(failures.get(e) ?? 'READ_CORE_CAPABILITY_UNAVAILABLE', 'authorization');
+  }
+}
+module.exports = { C, tuple, frozen, register, mintRequest, request, inspectRequest, normalized, createAuthority,
+  operation, inspectSnapshot: inspectProtectedSnapshot, pairRequest, dispose, onDispose, grant, bind, admit };

package/src/public-contract/browserwhole06/contract.json

@@ -2,8 +2,8 @@
   "candidate_only": true,
   "source": {
     "path": "specs/public-semantic-source.json",
-    "bytes": 1438087,
-    "sha256": "5ae686be4e7a7d7abcc88967ac3fc67cbbcc7e5f60d8379cc109edd7a581598a"
+    "bytes": 1506715,
+    "sha256": "e1fa081ca757d8ceb2e73910024778e31debe83b16d8b4824a4c66466ec57928"
   },
   "historical_original_source": {
     "scope": "historical_original_contract_source_identity_not_current_generator_input",

package/src/public-contract/creation06/contract.json

@@ -2,8 +2,8 @@
   "candidate_only": true,
   "source": {
     "path": "specs/public-semantic-source.json",
-    "bytes": 1438087,
-    "sha256": "5ae686be4e7a7d7abcc88967ac3fc67cbbcc7e5f60d8379cc109edd7a581598a"
+    "bytes": 1506715,
+    "sha256": "e1fa081ca757d8ceb2e73910024778e31debe83b16d8b4824a4c66466ec57928"
   },
   "historical_original_source": {
     "scope": "historical_original_contract_source_identity_not_current_generator_input",

package/src/public-contract/creation06/generation-manifest.json

@@ -3,14 +3,14 @@
   "candidate_only": true,
   "source": {
     "path": "specs/public-semantic-source.json",
-    "bytes": 1438087,
-    "sha256": "5ae686be4e7a7d7abcc88967ac3fc67cbbcc7e5f60d8379cc109edd7a581598a"
+    "bytes": 1506715,
+    "sha256": "e1fa081ca757d8ceb2e73910024778e31debe83b16d8b4824a4c66466ec57928"
   },
   "producer": {
     "recipe": {
       "path": "scripts/public-contract/native-output-recipe.json",
-      "bytes": 155707,
-      "sha256": "2cf31e27fdd1d8264b41fc7355a5c767c4a28f5cec01a7930f5c8a6851c36c29"
+      "bytes": 164001,
+      "sha256": "f5258627e45d396f9b088e76bdabe699d9ab845678ce1fa6a855b3fdaec21f22"
     },
     "scripts": [
       {
@@ -20,8 +20,8 @@
       },
       {
         "path": "scripts/public-contract/native-renderer.mjs",
-        "bytes": 19534,
-        "sha256": "05a359837c3c61d18ecc3fe109387ade921daf25eb12a8530e7a5b7550dfe1c7"
+        "bytes": 21439,
+        "sha256": "750e968d0d88908f7c6b6b3d017039919049e22060203a7c721c3204522c211e"
       },
       {
         "path": "scripts/public-contract/generation-writer.mjs",
@@ -31,7 +31,7 @@
       {
         "path": "scripts/public-contract/generate.mjs",
         "bytes": 73563,
-        "sha256": "9ed819f22c943fcda69a8df10ea1d49439255fee0fb72f81a8e5a6d5c1a4dd26"
+        "sha256": "73f19333a9fbff08480884d8b35ade372fe8b682ea25a77d9b370dc88c740f86"
       }
     ]
   },
@@ -181,7 +181,7 @@
     {
       "path": "packages/kdna-core/src/public-contract/creation06/contract.json",
       "bytes": 71166,
-      "sha256": "718286a41de672bd934b706ab91fbd77f5075100492aabea061393104e926530"
+      "sha256": "255a9a9eff102f96d49c660c29cc5a291244fff5365dfb251ef66ebe7aaaad0f"
     },
     {
       "path": "packages/kdna-core/src/public-contract/creation06/api.d.ts",

package/src/public-contract/execution06/contract.json

@@ -2,8 +2,8 @@
   "candidate_only": true,
   "source": {
     "path": "specs/public-semantic-source.json",
-    "bytes": 1438087,
-    "sha256": "5ae686be4e7a7d7abcc88967ac3fc67cbbcc7e5f60d8379cc109edd7a581598a"
+    "bytes": 1506715,
+    "sha256": "e1fa081ca757d8ceb2e73910024778e31debe83b16d8b4824a4c66466ec57928"
   },
   "historical_original_source": {
     "scope": "historical_original_contract_source_identity_not_current_generator_input",

package/src/public-contract/execution06/generation-manifest.json

@@ -3,14 +3,14 @@
   "candidate_only": true,
   "source": {
     "path": "specs/public-semantic-source.json",
-    "bytes": 1438087,
-    "sha256": "5ae686be4e7a7d7abcc88967ac3fc67cbbcc7e5f60d8379cc109edd7a581598a"
+    "bytes": 1506715,
+    "sha256": "e1fa081ca757d8ceb2e73910024778e31debe83b16d8b4824a4c66466ec57928"
   },
   "producer": {
     "recipe": {
       "path": "scripts/public-contract/native-output-recipe.json",
-      "bytes": 155707,
-      "sha256": "2cf31e27fdd1d8264b41fc7355a5c767c4a28f5cec01a7930f5c8a6851c36c29"
+      "bytes": 164001,
+      "sha256": "f5258627e45d396f9b088e76bdabe699d9ab845678ce1fa6a855b3fdaec21f22"
     },
     "scripts": [
       {
@@ -20,8 +20,8 @@
       },
       {
         "path": "scripts/public-contract/native-renderer.mjs",
-        "bytes": 19534,
-        "sha256": "05a359837c3c61d18ecc3fe109387ade921daf25eb12a8530e7a5b7550dfe1c7"
+        "bytes": 21439,
+        "sha256": "750e968d0d88908f7c6b6b3d017039919049e22060203a7c721c3204522c211e"
       },
       {
         "path": "scripts/public-contract/generation-writer.mjs",
@@ -31,7 +31,7 @@
       {
         "path": "scripts/public-contract/generate.mjs",
         "bytes": 73563,
-        "sha256": "9ed819f22c943fcda69a8df10ea1d49439255fee0fb72f81a8e5a6d5c1a4dd26"
+        "sha256": "73f19333a9fbff08480884d8b35ade372fe8b682ea25a77d9b370dc88c740f86"
       }
     ]
   },
@@ -518,7 +518,7 @@
     {
       "path": "packages/kdna-core/src/public-contract/execution06/contract.json",
       "bytes": 225481,
-      "sha256": "519572179d40ade61fe7c22337908026aea412d11c231ac22e5aed0eca88e95c"
+      "sha256": "02a62d370315d1cf0a07685b2ef8476d8fb83c1752601feb09e7cb0c4ed41477"
     },
     {
       "path": "packages/kdna-core/src/public-contract/execution06/api.d.ts",

package/src/public-contract/generated-contract.json

@@ -809,12 +809,12 @@
     },
     "schema_paths": {
       "CanonicalIR": "specs/canonical-ir-0.6.1.schema.json",
-      "IssuerResultObservation": "specs/external-grant-issuer-r2-binding-7.schema.json",
+      "IssuerResultObservation": "specs/external-grant-issuer-r2-binding-8.schema.json",
       "Manifest": "schema/manifest-container-0.5.0-judgment-0.5.1.schema.json",
       "PackageSetNodeSurface": "specs/package-set-node-0.2.1.schema.json",
       "Payload": "schema/payload-profile-0.5.1.schema.json",
-      "ProtectedSourceObservation": "specs/protected-source-r2-binding-7.schema.json",
-      "ProtectionDefinitionObservation": "specs/protection-admission-r2-binding-7.schema.json",
+      "ProtectedSourceObservation": "specs/protected-source-r2-binding-8.schema.json",
+      "ProtectionDefinitionObservation": "specs/protection-admission-r2-binding-8.schema.json",
       "PublicAgentHostReceipt": "schema/agent-host-receipt-0.3.1.schema.json",
       "PublicAgentHostRequest": "schema/agent-host-request-0.3.1.schema.json",
       "PublicConsumptionPlan": "schema/consumption-plan-0.3.1.schema.json",

package/src/public-contract/issuer-contract.generated.json

@@ -1,6 +1,6 @@
 {
   "api_typescript": "export type IssuerSecrets = { readonly issuerRootKey: Uint8Array; readonly issuerSigningPrivateKeyPkcs8: Uint8Array; readonly signaturePolicy: IssuerSignaturePolicy };\nexport type IssuanceResult = (IssuerIssuedObservation & { readonly grantBytes: Uint8Array }) | IssuerCoreRejectedObservation | IssuerFailedObservation;\nexport declare function getExternalGrantIssuerContract(): IssuerDescriptor;\nexport declare function issueExternalKeyGrantForAsset(input: string | Uint8Array, options: IssuerOptions, secrets: IssuerSecrets): Promise<IssuanceResult>;\n",
-  "definition_digest": "sha256:ab50c19d28f5c2cffd9f8b20a340aa132ab38f749e6b18852c5aec8771cfd716",
+  "definition_digest": "sha256:f0fe9e8611d14e3b8ce1454a94b08876ff0e353d3651e627c83294978edf1522",
   "derived_runtime_enforcement": {
     "ISSUER-AUTHENTICATION": {
       "generator_machine_check": "none",
@@ -384,8 +384,8 @@
   "runtime_not_implemented": [],
   "schema_binding": {
     "package_versions": {
-      "@aikdna/kdna-core": "0.37.0",
-      "@aikdna/kdna-read": "0.11.1"
+      "@aikdna/kdna-core": "0.37.2",
+      "@aikdna/kdna-read": "0.11.3"
     },
     "version_tuple": {
       "container": "0.5.0",
@@ -400,8 +400,8 @@
       "trace": "kdna.judgment-trace/0.3.1"
     }
   },
-  "schema_id": "urn:kdna:schema:external-grant-issuer:1.0.0:binding:r2:7",
-  "schema_path": "specs/external-grant-issuer-r2-binding-7.schema.json",
+  "schema_id": "urn:kdna:schema:external-grant-issuer:1.0.0:binding:r2:8",
+  "schema_path": "specs/external-grant-issuer-r2-binding-8.schema.json",
   "status": "IMPLEMENTATION_CANDIDATE_NOT_ACCEPTED",
   "types": {
     "IssuerAdmissionObservation": {
@@ -543,7 +543,7 @@
               "type": "string"
             },
             "version": {
-              "const": "0.37.0",
+              "const": "0.37.2",
               "type": "string"
             }
           },