@aikdna/kdna-core 0.37.6 → 0.37.8

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

@@ -2,8 +2,8 @@
   "candidate_only": true,
   "source": {
     "path": "specs/public-semantic-source.json",
-    "bytes": 1509417,
-    "sha256": "63393386af28f33b19d88fa3acdc98e825e91ee78c3e850a95427a32b6087623"
+    "bytes": 1541192,
+    "sha256": "97019a7d806b8f4be570855f549fa97cb6c293771f6a3d0a439bc03f39fe4367"
   },
   "historical_original_source": {
     "scope": "historical_original_contract_source_identity_not_current_generator_input",

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

@@ -3,14 +3,14 @@
   "candidate_only": true,
   "source": {
     "path": "specs/public-semantic-source.json",
-    "bytes": 1509417,
-    "sha256": "63393386af28f33b19d88fa3acdc98e825e91ee78c3e850a95427a32b6087623"
+    "bytes": 1541192,
+    "sha256": "97019a7d806b8f4be570855f549fa97cb6c293771f6a3d0a439bc03f39fe4367"
   },
   "producer": {
     "recipe": {
       "path": "scripts/public-contract/native-output-recipe.json",
-      "bytes": 164001,
-      "sha256": "22ffb30bdd7a5498913ac041405b3d109f22f6fc79b3972b8ae2a8cf3a83f478"
+      "bytes": 168167,
+      "sha256": "73e48bcebfce225b6a76f1324e152500df2031721e09f72f3a60588db31eb2ac"
     },
     "scripts": [
       {
@@ -20,8 +20,8 @@
       },
       {
         "path": "scripts/public-contract/native-renderer.mjs",
-        "bytes": 21439,
-        "sha256": "750e968d0d88908f7c6b6b3d017039919049e22060203a7c721c3204522c211e"
+        "bytes": 22518,
+        "sha256": "672e3afe5e519f3103345157af721e083a40790769e3878d415534880719b11d"
       },
       {
         "path": "scripts/public-contract/generation-writer.mjs",
@@ -618,7 +618,7 @@
     {
       "path": "packages/kdna-core/src/public-contract/retained/contract.json",
       "bytes": 291233,
-      "sha256": "3f75b5f8cf08d99faccd2dcb3eb7fcba368aacaede889ebb95528f66e1c2535d"
+      "sha256": "0e2f144e27ba4816225ad2946e2851b22a0eeb62d3074eb82689622d36c0948b"
     },
     {
       "path": "packages/kdna-core/src/public-contract/retained/api.d.ts",

package/src/public-contract/retained-browser06/contract.json

@@ -2,8 +2,8 @@
   "candidate_only": true,
   "source": {
     "path": "specs/public-semantic-source.json",
-    "bytes": 1509417,
-    "sha256": "63393386af28f33b19d88fa3acdc98e825e91ee78c3e850a95427a32b6087623"
+    "bytes": 1541192,
+    "sha256": "97019a7d806b8f4be570855f549fa97cb6c293771f6a3d0a439bc03f39fe4367"
   },
   "historical_original_source": {
     "scope": "historical_original_contract_source_identity_not_current_generator_input",

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

@@ -2,8 +2,8 @@
   "candidate_only": true,
   "source": {
     "path": "specs/public-semantic-source.json",
-    "bytes": 1509417,
-    "sha256": "63393386af28f33b19d88fa3acdc98e825e91ee78c3e850a95427a32b6087623"
+    "bytes": 1541192,
+    "sha256": "97019a7d806b8f4be570855f549fa97cb6c293771f6a3d0a439bc03f39fe4367"
   },
   "historical_original_source": {
     "scope": "historical_original_contract_source_identity_not_current_generator_input",

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

@@ -3,14 +3,14 @@
   "candidate_only": true,
   "source": {
     "path": "specs/public-semantic-source.json",
-    "bytes": 1509417,
-    "sha256": "63393386af28f33b19d88fa3acdc98e825e91ee78c3e850a95427a32b6087623"
+    "bytes": 1541192,
+    "sha256": "97019a7d806b8f4be570855f549fa97cb6c293771f6a3d0a439bc03f39fe4367"
   },
   "producer": {
     "recipe": {
       "path": "scripts/public-contract/native-output-recipe.json",
-      "bytes": 164001,
-      "sha256": "22ffb30bdd7a5498913ac041405b3d109f22f6fc79b3972b8ae2a8cf3a83f478"
+      "bytes": 168167,
+      "sha256": "73e48bcebfce225b6a76f1324e152500df2031721e09f72f3a60588db31eb2ac"
     },
     "scripts": [
       {
@@ -20,8 +20,8 @@
       },
       {
         "path": "scripts/public-contract/native-renderer.mjs",
-        "bytes": 21439,
-        "sha256": "750e968d0d88908f7c6b6b3d017039919049e22060203a7c721c3204522c211e"
+        "bytes": 22518,
+        "sha256": "672e3afe5e519f3103345157af721e083a40790769e3878d415534880719b11d"
       },
       {
         "path": "scripts/public-contract/generation-writer.mjs",
@@ -124,7 +124,7 @@
     {
       "path": "packages/kdna-core/src/public-contract/sectionbytes/contract.json",
       "bytes": 31759,
-      "sha256": "adb7c735e68f9bf72b7b3be19c9b38f5940989aae8e2da6ead3a375fcdeeb159"
+      "sha256": "0f2b09ff07731bb77ffb26cf4038bd27346875fd328e4e004146129dbc4e6a0f"
     },
     {
       "path": "packages/kdna-core/src/public-contract/sectionbytes/api.d.ts",

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

@@ -2,8 +2,8 @@
   "candidate_only": true,
   "source": {
     "path": "specs/public-semantic-source.json",
-    "bytes": 1509417,
-    "sha256": "63393386af28f33b19d88fa3acdc98e825e91ee78c3e850a95427a32b6087623"
+    "bytes": 1541192,
+    "sha256": "97019a7d806b8f4be570855f549fa97cb6c293771f6a3d0a439bc03f39fe4367"
   },
   "historical_original_source": {
     "scope": "historical_original_contract_source_identity_not_current_generator_input",
@@ -1119,6 +1119,143 @@
         "No protected range savings or performance claim is implied; every initial mode incurs complete authentication and domain validation cost."
       ],
       "api_typescript_context": "All new generated types are locally declared/exported in this subpath declaration closure; original ProtectedAdmissionOptions/TrustedProtectionProvider imported explicitly from original protection-node. Read imports every local signature type explicitly in addition to reexport. Opaque declarations use independent private unique symbols; no JSON-callable constructor can mint operation/snapshot/delivery authority."
+    },
+    "a22_source_migration": {
+      "candidate_only": true,
+      "counterexample": "A 0.5 payload.kdnab container and a 0.6 sections container are separate generations. Neither admission path converts, dual-reads or falls back for the other; an explicit migration operation is the only bridge, and it must never be produced by an implicit rewrite inside any admission.",
+      "versions": {
+        "migration_route": "kdna.source-migration/0.1.0-candidate",
+        "source_generation": {
+          "container": "0.5.0",
+          "payload_profile": "kdna.payload.judgment",
+          "payload_version": "0.5.1",
+          "core": "kdna.core/0.8.2",
+          "ir": "kdna.canonical-ir/0.6.1",
+          "runtime": "kdna.runtime-capsule/0.3.1",
+          "plan": "kdna.consumption-plan/0.3.1",
+          "host": "kdna.agent-host/0.3.1",
+          "trace": "kdna.judgment-trace/0.3.1",
+          "read": "kdna.read/0.6.4"
+        },
+        "output_tuple": {
+          "container": "0.6.0",
+          "payload_profile": "kdna.payload.judgment",
+          "payload_version": "0.5.1",
+          "core": "kdna.core/0.8.2",
+          "ir": "kdna.canonical-ir/0.6.1",
+          "runtime": "kdna.runtime-capsule/0.3.1",
+          "plan": "kdna.consumption-plan/0.3.1",
+          "host": "kdna.agent-host/0.3.1",
+          "trace": "kdna.judgment-trace/0.3.1",
+          "read": "kdna.read/0.7.0-candidate"
+        },
+        "unchanged": [
+          "Payload profile, payload_version, core, ir, runtime, plan, host and trace keep their existing definitions; only the container representation coordinate and the reading-contract coordinate move, per version_decisions.",
+          "authoring_workflow/2 and the classic 0.5 admission path stay exact and are reused, never re-branded.",
+          "This route never converts the nine historical tuples and never touches protected or encrypted sources; those are named capability refusals here and, if ever wanted, separate later units."
+        ]
+      },
+      "precedence": "This adds an explicit migration operation on its own subpath only. It does not add a decoder, fallback or dual-read to any admission path, does not change 0.5 or 0.6 admission/Read behavior, does not manufacture old-format brands, does not reinterpret field_retention or version_decisions, and does not make representation_origin valid input for other routes. The creation route's rule that it must not manufacture representation_origin stays exact; this route is the declared producer of that slot.",
+      "native_exports": {
+        "@aikdna/kdna-core/source-migration-node": [
+          "admitSourceMigrationRequest",
+          "inspectSourceMigrationRequest",
+          "createNativeSourceMigrationAuthority",
+          "migratePublicSourceNode"
+        ]
+      },
+      "api_typescript": "import type { CandidateVersionTuple06, RepresentationOrigin06 } from './sections/types.js';\nimport type { Payload } from './types.js';\nimport type { SourceOuterCapture06, SourceRouteCoreRejected06, SourceRouteMemberInventory06 } from './types.js';\nexport type SourceMigrationRequest06 = Readonly<{ request_id: string; tuple: CandidateVersionTuple06; operation: 'migrate_public_source'; source_expected_A: string; timeout_ms: number; signature_policy: Readonly<{ requireSignature: false; expectedPublicKeyHex: null }> }>;\nexport type SourceMigrationCaptureRow06 = Readonly<{ name: string; type: 'file'; mode: number; size: number }>;\nexport type SourceMigrationAuthorityContext06 = Readonly<{ contract: SourceMigrationRouteContract06; request: SourceMigrationRequest06; request_digest: string; capture: SourceOuterCapture06; source_inventory: ReadonlyArray<SourceMigrationCaptureRow06>; output_intent: Readonly<{ container: '0.6.0'; read: 'kdna.read/0.7.0-candidate'; adoption: 'not_observed' }> }>;\nexport type SourceMigrationObservation06 = Readonly<{ contract: SourceMigrationRouteContract06; request_digest: string; capture_id: string; tuple: CandidateVersionTuple06; source_A: string; source_content_digest: string; source_inventory: ReadonlyArray<SourceRouteMemberInventory06>; output: Readonly<{ A: string; C: string; E: string }>; E_profile: 'kdna.digest-basis.runtime-entry-set/0.3.0-candidate'; output_ir_digest: string; member_actions: ReadonlyArray<Readonly<{ name: string; action: 'added' | 'removed' | 'replaced' | 'preserved' }>>; origin: RepresentationOrigin06; body_bytes: number }>;\nexport type SourceMigrationFailure06 = Readonly<{ status: 'source_failed'; diagnostic: Readonly<{ code: string; stage: string }>; disclosure: unknown; body: null; body_bytes: 0 }>;\nexport type NativeSourceMigrationProduced06 = Readonly<{ status: 'migrated'; bytes: Uint8Array; observation: SourceMigrationObservation06 }> | SourceMigrationFailure06 | SourceRouteCoreRejected06;\nexport declare function admitSourceMigrationRequest(candidate: unknown): SourceMigrationRequestAdmission06;\nexport declare function inspectSourceMigrationRequest(request: AdmittedSourceMigrationRequest06): Readonly<SourceMigrationRequest06> | null;\nexport declare function createNativeSourceMigrationAuthority(callback: (context: Readonly<SourceMigrationAuthorityContext06>) => boolean | Promise<boolean>): NativeSourceMigrationAuthority06;\nexport declare function migratePublicSourceNode(input: string | Uint8Array, request: AdmittedSourceMigrationRequest06, authority: NativeSourceMigrationAuthority06): Promise<NativeSourceMigrationProduced06>;\nexport type SourceMigrationRouteContract06 = Readonly<{ id: 'kdna.source-migration/0.1.0-candidate'; version: '0.1.0-candidate'; definition_digest: string }>;\n",
+      "generation_roots": {
+        "AdmittedSourceMigrationRequest06": "candidate/migration06/AdmittedSourceMigrationRequest06.schema.json",
+        "NativeSourceMigrationAuthority06": "candidate/migration06/NativeSourceMigrationAuthority06.schema.json",
+        "SourceMigrationAuthorityContext06": "candidate/migration06/SourceMigrationAuthorityContext06.schema.json",
+        "SourceMigrationCaptureRow06": "candidate/migration06/SourceMigrationCaptureRow06.schema.json",
+        "SourceMigrationDiagnostic06": "candidate/migration06/SourceMigrationDiagnostic06.schema.json",
+        "SourceMigrationFailure06": "candidate/migration06/SourceMigrationFailure06.schema.json",
+        "SourceMigrationObservation06": "candidate/migration06/SourceMigrationObservation06.schema.json",
+        "SourceMigrationRequest06": "candidate/migration06/SourceMigrationRequest06.schema.json",
+        "SourceMigrationRequestAdmission06": "candidate/migration06/SourceMigrationRequestAdmission06.schema.json",
+        "SourceMigrationRouteContract06": "candidate/migration06/SourceMigrationRouteContract06.schema.json"
+      },
+      "binary_runtime_carriers": {
+        "validation": "NativeSourceMigrationProduced06 carries actual output bytes as a runtime value, not JSON and not an opaque authority brand. JSON observations are separately validated by the named closed schemas; no generated schema claims to validate a byte-vector carrier.",
+        "ownership": "Input and output byte arrays are owned copies; caller mutation after invocation cannot change the authorized source or the produced result. All binary inputs obey the original accessor/prototype/ownership checks. No filesystem path is opened after the source bytes are owned; a caller-supplied path is read once under the same bounded capture rules as the source route."
+      },
+      "request_and_authority": {
+        "admission": "Closed request shape with the exact output tuple (CandidateVersionTuple06). Malformed request maps SOURCE_INPUT_INVALID/input; a recognized mixed or unsupported tuple maps the original Core rejection arm and produces no authority. operation must equal 'migrate_public_source'. source_expected_A is a required Digest on this route: migration is always bound to one exact source container A. signature_policy on this route is exactly {requireSignature:false,expectedPublicKeyHex:null}; any other value is SOURCE_CAPABILITY_UNAVAILABLE/input, because the current 0.5 generation carries no verified signature policy meaning here.",
+        "capture": "Reuse the approved bounded ZIP metadata probes to observe the outer directory and Manifest of the source only. The full source A is confirmed on the owned bytes after the grant, mirroring the source route; a mismatch is the named SOURCE_EXPECTED_ASSET_MISMATCH refusal with no output. Before the grant the callback sees only the outer capture identity and the mode/type/size member inventory. checksums.json or signature.kdsig members in the source are observed and reported, never verified as authority for migration and never silently dropped: their presence refuses this first slice by name (see refusals).",
+        "grant": "One closed authority callback receives the exact contract, admitted request, request_digest, the outer capture identity (SourceOuterCapture06), the mode/type/size member inventory and the explicit output intent. Only literal true permits production. false maps SOURCE_PERMISSION_REJECTED/authorization; throw/unknown internal failure maps SOURCE_CAPABILITY_UNAVAILABLE at the observed stage. The callback is the native caller's consent to read this exact source and emit the converted representation; it is not an asset entitlement, not a Read grant and not editorial adoption.",
+        "timeout": "request.timeout_ms is required 1..60000, a per-invocation wall-clock deadline using Date.now() capture and the original comparison rule (now > deadline rejects; equality allowed). Checked after capture, after the authority await, before and after output construction, and before returning bytes. Expiry maps SOURCE_DEADLINE_EXCEEDED at the observed checkpoint. A late true cannot start production.",
+        "adoption": "The result is technical bytes plus producer observation. Neither the source nor the output carries adopted identity, ownership or acceptance; the migration neither invents nor transfers adoption, and a successful migration is not a consumer read, publication or endorsement."
+      },
+      "source_verification": {
+        "generation": "Exactly the current 0.5 generation listed in versions.source_generation: Manifest (format_version, compatibility.profile, compatibility.profile_version) equals (0.5.0, kdna.payload.judgment, 0.5.1), the payload's own profile/profile_version equal the Manifest compatibility, and the container validates against the exact 0.5.1 combined Manifest contract already present in this package's schema set. Any other complete old tuple maps the named MIGRATION_SOURCE_UNSUPPORTED_VERSION/input refusal; a mixed tuple maps SOURCE_INPUT_INVALID/input.",
+        "semantic": "Run the original classic 0.5 semantics without weakening: Manifest schema/domain validation, CBOR payload decode, and the original complete payload/interpretation validation the classic admission performs. A genuine original validation failure maps the original Core rejection reason and diagnostics with stage input, body null and no output. Never declare an invalid 0.5 payload valid by stripping declarations or by validating only the reconstructed 0.6 side.",
+        "refusals": [
+          "MIGRATION_SOURCE_UNSUPPORTED_VERSION/input: a complete historical tuple other than the exact current 0.5 generation (including container 0.5.0 with payload 0.5.0 / read 0.6.0-0.6.3 and every older container coordinate). This slice proves the refusal only; migrating historical generations would be its own declared unit.",
+          "MIGRATION_SOURCE_PROTECTED_UNSUPPORTED/input: payload.encrypted true, an encryption/entitlement declaration or a protected logical payload. Protected migration is reserved for a separate unit; the refusal is by name and never degrades to converting the encrypted bytes as if they were plaintext.",
+          "MIGRATION_SOURCE_EXTENSION_UNSUPPORTED/input: checksums.json or signature.kdsig members, or any member outside the exact 0.5 permitted set for this route (mimetype, kdna.json, payload.kdnab plus ordinary attachments that the 0.5 schema permits). Nothing is dropped, rewritten or re-signed silently.",
+          "MIGRATION_SOURCE_CAPABILITY_UNSUPPORTED/input: an unsupported compression or a structure the bounded capture cannot observe exactly."
+        ]
+      },
+      "output_mapping": {
+        "format_version": "Rebind to the exact '0.6.0' coordinate. No 0.5 byte or descriptor is copied through as a predecessor claim; the source remains an external input, not an embedded asset.",
+        "identity": "Copy asset_id, asset_uid, asset_type, title, version, judgment_version, created_at, updated_at, summary, languages, lineage, history, creator, access, license, description, keywords, runtime.mandatory_entries and every other authored field exactly, preserving optional absence and array order. Never regenerate IDs, timestamps or default objects.",
+        "payload": "Replace the whole PayloadDescriptor with the exact SectionPayloadDescriptor06 produced from this build's real frames, tables and pack members, using the current source-route-frame-writer and metadata codec rules. The logical Payload is reconstructed from the verified 0.5 payload and must deep-equal it (see construction gate 3); the shape of the output is never derived from a fabricated old-side encode.",
+        "representation_metadata": "Add the existing metadata codec projection derived from the complete canonical IR of the migrated payload with the real output member routing, exactly as the creation route derives it, including contract, tuple (this route's output tuple), node_order, catalog, references, relationships, mandatory_closures, asset_index, asset_closure, unresolved_external, ir_digest_claim and runtime_entry_names.",
+        "representation_origin": "This route is the declared producer of RepresentationOrigin06 and always writes it: source_format_version is the exact '0.5.0'; source_container_digest is the confirmed source A; source_content_digest is the source content-tree digest computed under the original 0.5 C profile exactly as the classic side derives it (never a new or guessed digest); payload is the source's exact PayloadDescriptor; runtime is the source's exact runtime object; declared_content_digest and declared_authoring_content_digest are copied present-only from the source Manifest's content_digest and authoring.content_digest. The origin is a provenance record, not authority: downstream routes treat it as untrusted claim, exactly as the sections snapshot rules state.",
+        "content_digest": "If the source Manifest declared content_digest, refresh it to the actual output C under the original canonical-content exclusion profile and disclose the refresh; if absent, keep it absent. Same present-only rule for authoring.content_digest. Never invent a claim that the source did not carry.",
+        "runtime": "Map the source runtime mandatory entries: representation-format-dependent entries that named the replaced payload member are mapped to the actual generated pack members; every non-representation entry is preserved exactly in order; duplicates are never silently introduced or removed beyond the declared representation mapping. The exact before/after mapping is disclosed."
+      },
+      "construction_and_validation": {
+        "order": [
+          "Closed request admission, deadlined capture of the exact source bytes, source A confirmation against source_expected_A and the full member inventory.",
+          "Native authority true with the closed context; false/throw/expiry leave no output and no downstream effect.",
+          "Complete 0.5 source verification (generation classification, schema, CBOR decode, original semantics) with the named refusals above.",
+          "Field-mapping construction: identity and authored fields copied exactly; payload rebuilt to real frames/tables/packs; format_version rebound; representation_metadata derived from the complete canonical IR; representation_origin written from confirmed source observations; C claims refreshed present-only.",
+          "Serialize the actual container, then admit the output through the complete native 0.6 source admission on the produced bytes, which re-derives the full Payload and IR and enforces SECTION_DERIVED_IR_MISMATCH and all physical/frame/table rules. Output re-admission refusal returns no bytes.",
+          "Final gates before return: the reconstructed Payload deep-equals the verified source Payload (MIGRATION_PAYLOAD_MISMATCH/semantic, hard, no output); every retained authored Manifest path equals the source exactly and the origin fields equal the confirmed observations (MIGRATION_MANIFEST_MISMATCH/semantic); the source bytes are unchanged and no partial artifact exists on any failure. Recheck the deadline and return owned bytes with the closed observation."
+        ],
+        "fail_delete": "All failures return no bytes (body null, body_bytes 0). The operation is atomic from the caller's view: a failed migration never yields a partial or best-effort container, and never mutates the source bytes or the caller's arguments.",
+        "bootstrap": "Internal adapters may reuse the original classic 0.5 validation algorithms and the current 0.6 construction algorithms in the same instance; no intermediate branded container is admitted or minted, and an internal semantic view is never an admitted snapshot.",
+        "integrity": "The initial output has no checksums.json or signature.kdsig; those may later be added by their own accepted operations on the saved bytes. A/C/E in the observation are actual observations of the produced bytes and their member set under the current profiles (E06 runtime-entry-set), not authorizations."
+      },
+      "evidence": {
+        "bindings": "request_digest is SHA256JCS of the actual admitted request. source_A and source_content_digest are confirmed observations of the exact captured source; output.A/C/E and output_ir_digest come from the complete actual output re-admission. member_actions list every physical member of the output relative to the source with exactly one of added/removed/replaced/preserved, in physical order. No fabricated capture or snapshot IDs.",
+        "claim": "Migrated means technical bytes plus producer observation only: it is not a transferable admitted token, consumer read result, publication, ownership, editorial adoption or an assertion that every consumer can read container 0.6. The reading-route separation remains external truth."
+      },
+      "diagnostics": {
+        "boundary": "This route defines its own closed failure arm, SourceMigrationFailure06 with SourceMigrationDiagnostic06, instead of extending the shared source diagnostic enum: the SOURCE_* codes keep their source meanings and the named MIGRATION_* refusals are this route's own codes, never re-classifications of an original validation failure. Core rejections reuse SourceRouteCoreRejected06 unchanged. No catch-all converts unknown exceptions into authored-invalid or into a successful conversion.",
+        "original_validation": "A genuine 0.5 original schema/domain/interpretation failure keeps the original CoreAdmissionRejected reason/diagnostics in core_rejected with disclosure none and body null; a failure of the internally constructed 0.6 output shape is an internal capability failure (SOURCE_CAPABILITY_UNAVAILABLE/output), not invalid caller data."
+      },
+      "limits": {
+        "physical": {
+          "member": 8388608,
+          "total_decoded": 12582912,
+          "container": 26214400,
+          "entries": 128
+        },
+        "scope": "The four original06 physical limits apply to the actual completed output including generated Manifest, metadata, packs, tables, mimetype and copied attachments. The source is validated under its own original 0.5 bounds; a source that cannot produce a compliant output within these bounds refuses rather than truncating content."
+      },
+      "contract_observation": {
+        "value": "SourceMigrationRouteContract06 is {id:versions.migration_route,version:\"0.1.0-candidate\",definition_digest:computed}.",
+        "definition_digest_preimage": "definition_digest is sha256: followed by lowercase SHA-256 hex of the existing strict canonicalJson UTF-8 encoding of this complete installed public module value, using the same convention as source/creation route contracts. The field states the rule and does not embed a self-referential digest.",
+        "meaning": "The digest identifies the exact route definition of this receipt. It is an observation, not native authority, migration permission, a release or an acceptance decision."
+      },
+      "prospective_runtime_controls": [
+        "Exact current-generation positives: a delivered 0.5 container migrates to an admitted 0.6 container whose reconstructed Payload and IR deep-equal the verified source, whose retained authored Manifest paths equal the source byte-for-byte at the JSON value level, and whose representation_origin carries the confirmed source A/C and prior claims present-only.",
+        "Refusal controls, each by name with its own fixture: historical tuple, protected/encrypted source, checksums/signature members or out-of-set members, unsupported structure, authority false, expired deadline, tampered source (A mismatch and post-capture mutation), and output re-admission constructed-failure.",
+        "No-admission-change controls: the classic 0.5 admission and Read behavior and the native 0.6 admission and Read behavior are byte-for-byte unchanged by this route's presence, including their refusals of the other generation.",
+        "Origin controls: a migrated output passes source-open and complete 0.6 admission with origin present; an existing 0.6 container without origin remains admissible exactly as before; a tampered origin claim never overrides current observations.",
+        "Determinism control: migrating the same source twice in isolated invocations yields byte-identical output containers."
+      ],
+      "not_claimed": [
+        "No legacy decoder, dual read, fallback or automatic conversion inside any admission path; explicit tool discipline is preserved.",
+        "No historical-generation migration, no protected-source migration, no checksum/signature-member migration and no change to the source asset's own bytes or identity.",
+        "No consumer readback of the output by any specific stack is asserted by producing bytes; the reading-route separation remains a separate, externally evidenced matter.",
+        "No publication, release, stable coordinate for container 0.6 or kdna.read/0.7.0-candidate, real adoption or asset-acceptance claim follows from this route.",
+        "No change to field_retention, version_decisions, representation_metadata semantics or any accepted A08-A21 receipt."
+      ]
     }
   },
   "types": {

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

@@ -3,14 +3,14 @@
   "candidate_only": true,
   "source": {
     "path": "specs/public-semantic-source.json",
-    "bytes": 1509417,
-    "sha256": "63393386af28f33b19d88fa3acdc98e825e91ee78c3e850a95427a32b6087623"
+    "bytes": 1541192,
+    "sha256": "97019a7d806b8f4be570855f549fa97cb6c293771f6a3d0a439bc03f39fe4367"
   },
   "producer": {
     "recipe": {
       "path": "scripts/public-contract/native-output-recipe.json",
-      "bytes": 164001,
-      "sha256": "22ffb30bdd7a5498913ac041405b3d109f22f6fc79b3972b8ae2a8cf3a83f478"
+      "bytes": 168167,
+      "sha256": "73e48bcebfce225b6a76f1324e152500df2031721e09f72f3a60588db31eb2ac"
     },
     "scripts": [
       {
@@ -20,8 +20,8 @@
       },
       {
         "path": "scripts/public-contract/native-renderer.mjs",
-        "bytes": 21439,
-        "sha256": "750e968d0d88908f7c6b6b3d017039919049e22060203a7c721c3204522c211e"
+        "bytes": 22518,
+        "sha256": "672e3afe5e519f3103345157af721e083a40790769e3878d415534880719b11d"
       },
       {
         "path": "scripts/public-contract/generation-writer.mjs",
@@ -36,7 +36,7 @@
     ]
   },
   "owner": "sections",
-  "module_digest": "sha256:e81ecfdc9357500275e10767e34a09b3fc8ce2e3d80df35653a639500c3ebf7f",
+  "module_digest": "sha256:38373dc9112c9701cb20d4df23ab9d10e0e47d7ffb0859bf8205f346d0b81fed",
   "roots": [
     "Manifest06Candidate",
     "RepresentationMetadata06",
@@ -657,8 +657,8 @@
     },
     {
       "path": "packages/kdna-core/src/public-contract/sections/contract.json",
-      "bytes": 547981,
-      "sha256": "fcaea073a9d3ae14011a1f849d0508170a79f78dccd7c25d9969eb57d18aec9a"
+      "bytes": 570835,
+      "sha256": "34c8f813f0fa3a46a2ce571d909d22e0d0ec66b5be3162963a0f7372ec2f5643"
     },
     {
       "path": "packages/kdna-core/src/public-contract/protected-sections-node.d.ts",

package/src/public-contract/source-migration-node.d.ts

@@ -0,0 +1,14 @@
+import type { CandidateVersionTuple06, RepresentationOrigin06 } from './sections/types.js';
+import type { Payload } from './types.js';
+import type { SourceOuterCapture06, SourceRouteCoreRejected06, SourceRouteMemberInventory06 } from './types.js';
+export type SourceMigrationRequest06 = Readonly<{ request_id: string; tuple: CandidateVersionTuple06; operation: 'migrate_public_source'; source_expected_A: string; timeout_ms: number; signature_policy: Readonly<{ requireSignature: false; expectedPublicKeyHex: null }> }>;
+export type SourceMigrationCaptureRow06 = Readonly<{ name: string; type: 'file'; mode: number; size: number }>;
+export type SourceMigrationAuthorityContext06 = Readonly<{ contract: SourceMigrationRouteContract06; request: SourceMigrationRequest06; request_digest: string; capture: SourceOuterCapture06; source_inventory: ReadonlyArray<SourceMigrationCaptureRow06>; output_intent: Readonly<{ container: '0.6.0'; read: 'kdna.read/0.7.0-candidate'; adoption: 'not_observed' }> }>;
+export type SourceMigrationObservation06 = Readonly<{ contract: SourceMigrationRouteContract06; request_digest: string; capture_id: string; tuple: CandidateVersionTuple06; source_A: string; source_content_digest: string; source_inventory: ReadonlyArray<SourceRouteMemberInventory06>; output: Readonly<{ A: string; C: string; E: string }>; E_profile: 'kdna.digest-basis.runtime-entry-set/0.3.0-candidate'; output_ir_digest: string; member_actions: ReadonlyArray<Readonly<{ name: string; action: 'added' | 'removed' | 'replaced' | 'preserved' }>>; origin: RepresentationOrigin06; body_bytes: number }>;
+export type SourceMigrationFailure06 = Readonly<{ status: 'source_failed'; diagnostic: Readonly<{ code: string; stage: string }>; disclosure: unknown; body: null; body_bytes: 0 }>;
+export type NativeSourceMigrationProduced06 = Readonly<{ status: 'migrated'; bytes: Uint8Array; observation: SourceMigrationObservation06 }> | SourceMigrationFailure06 | SourceRouteCoreRejected06;
+export declare function admitSourceMigrationRequest(candidate: unknown): SourceMigrationRequestAdmission06;
+export declare function inspectSourceMigrationRequest(request: AdmittedSourceMigrationRequest06): Readonly<SourceMigrationRequest06> | null;
+export declare function createNativeSourceMigrationAuthority(callback: (context: Readonly<SourceMigrationAuthorityContext06>) => boolean | Promise<boolean>): NativeSourceMigrationAuthority06;
+export declare function migratePublicSourceNode(input: string | Uint8Array, request: AdmittedSourceMigrationRequest06, authority: NativeSourceMigrationAuthority06): Promise<NativeSourceMigrationProduced06>;
+export type SourceMigrationRouteContract06 = Readonly<{ id: 'kdna.source-migration/0.1.0-candidate'; version: '0.1.0-candidate'; definition_digest: string }>;

package/src/public-contract/source-migration-node.js

@@ -0,0 +1,253 @@
+'use strict';
+// Candidate explicit 0.5->0.6 source migration route. It reads exactly the
+// current 0.5 generation, writes an adhered 0.6 container with a confirmed
+// representation_origin, and proves refusal-only paths for everything outside
+// that scope. No admission path elsewhere converts, dual-reads or falls back.
+const crypto = require('node:crypto');
+const Ajv = require('ajv/dist/2020.js');
+const S = require('./source-route-common.js');
+const C = require('./section-common.js');
+const D = require('./digests.js');
+const strict = require('./strict-input.js');
+const { rejected } = require('./admit.js');
+const { validate: validateClassic } = require('./validate.js');
+const { parseContainer } = require('./container.js');
+const { decodeValidatedPayload, assertContentBindings } = require('./semantic-admission.js');
+const { openSourceRouteCapture } = require('./source-route-capture.js');
+const { admitPublicBytes } = require('./source-public-admission.js');
+const { buildIR } = require('./canonical-ir.js');
+const { buildFrames } = require('./source-route-frame-writer.js');
+const M = require('./section-metadata-codec.js');
+const { encodeStored } = require('./container-writer.js');
+const { isDeepStrictEqual } = require('node:util');
+const { inflateRawSync } = require('node:zlib');
+
+const M6 = require('./migration06/contract.json');
+const tuple = C.contract.module.versionTuple;
+const routeContract = C.strict.freeze({
+  id: 'kdna.source-migration/0.1.0-candidate',
+  version: '0.1.0-candidate',
+  definition_digest: D.digestCanonical(M6.module),
+});
+const SIGNATURE_POLICY = Object.freeze({ requireSignature: false, expectedPublicKeyHex: null });
+const SOURCE_GENERATION = Object.freeze({
+  format_version: '0.5.0',
+  profile: 'kdna.payload.judgment',
+  profile_version: '0.5.1',
+});
+const HISTORICAL_CONTAINER_VERSIONS = new Set(['0.1.0', '0.2.0', '0.3.0', '0.4.0']);
+const BASE_MEMBERS = Object.freeze(['mimetype', 'kdna.json', 'payload.kdnab']);
+
+const requests = new WeakMap(), authorities = new WeakMap(), migrationFailures = new WeakSet();
+const frozen = v => C.strict.freeze(v);
+const none = () => ({ kind: 'none', external_commit: { state: 'not_invoked' } });
+const isDigest = v => typeof v === 'string' && /^sha256:[0-9a-f]{64}$/u.test(v);
+const ajv = new Ajv({ strict: false, allErrors: false, validateFormats: false });
+const typed = new Map();
+function compiled(name) {
+  if (!typed.has(name)) typed.set(name, ajv.compile({ $schema: 'https://json-schema.org/draft/2020-12/schema', $defs: M6.types, $ref: '#/$defs/' + name }));
+  return typed.get(name);
+}
+function validateTyped(name, value) {
+  if (!compiled(name)(value)) fail('SOURCE_CAPABILITY_UNAVAILABLE', 'output');
+  return value;
+}
+function failure(code, stage) {
+  const out = { status: 'source_failed', diagnostic: { code, stage }, disclosure: none(), body: null, body_bytes: 0 };
+  validateTyped('SourceMigrationFailure06', out);
+  return frozen(out);
+}
+function coreFailure(code, stage, error = null) {
+  const out = { status: 'core_rejected', stage, core: rejected(code, error?.component_failure ?? null, error?.diagnostic ?? null), disclosure: none(), body: null, body_bytes: 0 };
+  validateTyped('SourceRouteCoreRejected06', out);
+  return frozen(out);
+}
+function fail(code, stage) { const e = new Error(code); e.migrationCode = code; e.migrationStage = stage; migrationFailures.add(e); throw e; }
+
+function admitSourceMigrationRequest(candidate) {
+  try {
+    const data = C.strict.copyJson(candidate);
+    S.keys(data, ['request_id', 'tuple', 'operation', 'source_expected_A', 'timeout_ms', 'signature_policy']);
+    C.need(C.strict.identifier(data.request_id), 'READ_INPUT_INVALID');
+    const t = data.tuple;
+    C.need(t && typeof t === 'object' && !Array.isArray(t) && Object.keys(t).every(k => Object.hasOwn(tuple, k) && typeof t[k] === 'string'), 'READ_INPUT_INVALID');
+    if (Object.keys(t).length !== Object.keys(tuple).length || Object.entries(tuple).some(([k, v]) => t[k] !== v)) {
+      const baseline = require('./generated-contract.json');
+      const historical = [baseline.versionTuple, ...baseline.types.UnsupportedVersionTuple.anyOf.map(x => Object.fromEntries(Object.entries(x.properties).map(([k, v]) => [k, v.const])))];
+      const known = historical.some(v => Object.keys(v).length === Object.keys(t).length && Object.entries(v).every(([k, x]) => t[k] === x));
+      return coreFailure(known ? 'READ_UNSUPPORTED_VERSION' : Object.keys(tuple).some(k => k !== 'payload_profile' && t[k] === tuple[k]) ? 'READ_MIXED_VERSION_TUPLE' : 'READ_UNSUPPORTED_VERSION', 'input');
+    }
+    C.need(data.operation === 'migrate_public_source', 'READ_INPUT_INVALID');
+    C.need(isDigest(data.source_expected_A), 'READ_INPUT_INVALID');
+    C.need(Number.isSafeInteger(data.timeout_ms) && data.timeout_ms >= 1 && data.timeout_ms <= 60000, 'READ_INPUT_INVALID');
+    const policy = data.signature_policy;
+    C.need(policy && typeof policy === 'object' && !Array.isArray(policy) && policy.requireSignature === false && policy.expectedPublicKeyHex === null, 'READ_INPUT_INVALID');
+    C.need(compiled('SourceMigrationRequest06')(data), 'READ_INPUT_INVALID');
+    const token = Object.freeze({});
+    requests.set(token, { data: frozen(data), digest: D.digestCanonical(data) });
+    return Object.freeze({ status: 'admitted_request', request: token });
+  } catch (e) {
+    if (e.migrationCode === 'SOURCE_CAPABILITY_UNAVAILABLE') return failure(e.migrationCode, e.migrationStage);
+    if (C.isFailure(e) || S.isFailure(e) || e.reason === 'READ_INPUT_INVALID') return failure('SOURCE_INPUT_INVALID', 'input');
+    return failure('SOURCE_CAPABILITY_UNAVAILABLE', 'input');
+  }
+}
+function inspectSourceMigrationRequest(token) { return requests.get(token)?.data ?? null; }
+function createNativeSourceMigrationAuthority(callback) {
+  if (typeof callback !== 'function') throw new TypeError('Native migration authority callback required');
+  const token = Object.freeze({});
+  authorities.set(token, callback);
+  return token;
+}
+
+function classifySource(manifest, entries) {
+  const version = manifest.format_version;
+  const compatibility = manifest.compatibility ?? {};
+  if (version === SOURCE_GENERATION.format_version) {
+    if (compatibility.profile !== SOURCE_GENERATION.profile || compatibility.profile_version !== SOURCE_GENERATION.profile_version) fail('MIGRATION_SOURCE_UNSUPPORTED_VERSION', 'input');
+  } else if (HISTORICAL_CONTAINER_VERSIONS.has(version)) {
+    fail('MIGRATION_SOURCE_UNSUPPORTED_VERSION', 'input');
+  } else {
+    fail('SOURCE_INPUT_INVALID', 'input');
+  }
+  if (manifest.payload?.encrypted === true || manifest.encryption || Object.hasOwn(manifest, 'entitlement')) fail('MIGRATION_SOURCE_PROTECTED_UNSUPPORTED', 'input');
+  if (Object.hasOwn(entries, 'checksums.json') || Object.hasOwn(entries, 'signature.kdsig')) fail('MIGRATION_SOURCE_EXTENSION_UNSUPPORTED', 'input');
+  const allowed = new Set(BASE_MEMBERS);
+  for (const resource of manifest.payload?.resources ?? []) if (typeof resource?.entry === 'string') allowed.add(resource.entry);
+  for (const name of Object.keys(entries)) if (!allowed.has(name) && !name.startsWith('attachments/')) fail('MIGRATION_SOURCE_EXTENSION_UNSUPPORTED', 'input');
+}
+
+function buildOutput(manifest5, payload5, entries5, sourceA, sourceC, requestDigest, captureId) {
+  const manifest = { ...manifest5, format_version: '0.6.0' };
+  const ir = { ...buildIR(manifest, payload5, entries5), tuple: structuredClone(tuple) };
+  const built = buildFrames(ir);
+  const packNames = Object.keys(built.packs);
+  manifest.payload = { layout: 'sections', encoding: 'strict-cbor-frames', encrypted: false, tables: built.tables, xref_codec: 'frame-local-ordered-scope-dictionary/1' };
+  const origin = {
+    source_format_version: '0.5.0',
+    source_container_digest: sourceA,
+    source_content_digest: sourceC,
+    payload: strict.freeze(structuredClone(manifest5.payload)),
+    runtime: structuredClone(manifest5.runtime),
+  };
+  if (isDigest(manifest5.content_digest)) origin.declared_content_digest = manifest5.content_digest;
+  if (isDigest(manifest5.authoring?.content_digest)) origin.declared_authoring_content_digest = manifest5.authoring.content_digest;
+  manifest.representation_origin = origin;
+  const mapped = [];
+  for (const name of manifest5.runtime?.mandatory_entries ?? []) {
+    if (name === 'payload.kdnab') { for (const pack of packNames) if (!mapped.includes(pack)) mapped.push(pack); }
+    else if (!mapped.includes(name)) mapped.push(name);
+  }
+  manifest.runtime = { ...manifest5.runtime, mandatory_entries: mapped };
+  const { nodes, expansion_targets, ...meta } = ir;
+  meta.node_order = nodes.map(n => n.id);
+  meta.ir_digest_claim = D.digestCanonical(ir);
+  meta.runtime_entry_names = [...new Set(['kdna.json', ...packNames, ...mapped])].sort(C.utf8);
+  manifest.representation_metadata = M.encode(meta);
+  const entries = { mimetype: Buffer.from('application/vnd.kdna.asset'), ...built.packs };
+  if (isDigest(manifest5.content_digest)) {
+    const pre = { ...entries, 'kdna.json': Buffer.from(JSON.stringify(manifest)) };
+    const refreshed = D.digest(D.contentTreePreimage(pre));
+    manifest.content_digest = refreshed;
+    if (isDigest(manifest5.authoring?.content_digest)) manifest.authoring = { ...manifest5.authoring, content_digest: refreshed };
+  }
+  entries['kdna.json'] = Buffer.from(JSON.stringify(manifest));
+  const members = Object.entries(entries).map(([name, bytes]) => ({ name, type: 'file', mode: 0o100644, bytes }));
+  C.need(members.length <= 128, 'READ_CORE_INVALID');
+  const bytes = encodeStored(members);
+  const output = admitPublicBytes(bytes, SIGNATURE_POLICY, captureId, requestDigest);
+  if (!isDeepStrictEqual(output.payload, payload5)) fail('MIGRATION_PAYLOAD_MISMATCH', 'semantic');
+  const retained = ['asset_id', 'asset_uid', 'asset_type', 'title', 'version', 'judgment_version', 'created_at', 'updated_at', 'summary', 'languages', 'history'];
+  for (const key of retained) if (!isDeepStrictEqual(manifest[key], manifest5[key])) fail('MIGRATION_MANIFEST_MISMATCH', 'semantic');
+  if (!origin.source_container_digest || !origin.source_content_digest) fail('MIGRATION_ORIGIN_MISSING', 'semantic');
+  const actions = [];
+  const sourceNames = new Set(Object.keys(entries5));
+  const outputNames = new Set(Object.keys(output.entries));
+  for (const name of outputNames) actions.push({ name, action: sourceNames.has(name) ? 'replaced' : 'added' });
+  for (const name of sourceNames) if (!outputNames.has(name)) actions.push({ name, action: 'removed' });
+  return { bytes, manifest, origin, output, actions };
+}
+
+async function migratePublicSourceNode(input, token, authority) {
+  let capture, stage = 'input';
+  try {
+    const record = requests.get(token), callback = authorities.get(authority);
+    if (!record || !callback) fail('SOURCE_INPUT_INVALID', 'input');
+    const started = Date.now(), deadline = started + record.data.timeout_ms;
+    const current = where => { if (Date.now() > deadline) fail('SOURCE_DEADLINE_EXCEEDED', where); };
+    current('admission'); stage = 'capture'; capture = await openSourceRouteCapture(input); current('admission');
+    const manifestMeta = C.strict.parseJson(capture.manifestBytes);
+    if (manifestMeta.format_version === SOURCE_GENERATION.format_version) {
+      const compatibility = manifestMeta.compatibility ?? {};
+      if (compatibility.profile !== SOURCE_GENERATION.profile || compatibility.profile_version !== SOURCE_GENERATION.profile_version) fail('MIGRATION_SOURCE_UNSUPPORTED_VERSION', 'input');
+    } else if (HISTORICAL_CONTAINER_VERSIONS.has(manifestMeta.format_version)) {
+      fail('MIGRATION_SOURCE_UNSUPPORTED_VERSION', 'input');
+    } else {
+      fail('SOURCE_INPUT_INVALID', 'input');
+    }
+    if (manifestMeta.payload?.encrypted === true || manifestMeta.encryption || Object.hasOwn(manifestMeta, 'entitlement')) fail('MIGRATION_SOURCE_PROTECTED_UNSUPPORTED', 'input');
+    if (capture.rows.some(r => r.name === 'checksums.json' || r.name === 'signature.kdsig')) fail('MIGRATION_SOURCE_EXTENSION_UNSUPPORTED', 'input');
+    C.need(capture.rows.every(r => r.method === 0 || r.method === 8), 'READ_CORE_CAPABILITY_UNAVAILABLE');
+    const inventory = capture.rows.map(r => ({ name: r.name, type: 'file', mode: r.mode, size: r.size })).sort((a, b) => C.utf8(a.name, b.name));
+    const context = {
+      contract: routeContract,
+      request: record.data,
+      request_digest: record.digest,
+      capture: capture.identity,
+      source_inventory: inventory.map(({ name, type, mode, size }) => ({ name, type, mode, size })),
+      output_intent: { container: '0.6.0', read: 'kdna.read/0.7.0-candidate', adoption: 'not_observed' },
+    };
+    validateTyped('SourceMigrationAuthorityContext06', context);
+    stage = 'authorization'; current('authorization');
+    let grant;
+    try { grant = await callback(frozen(structuredClone(context))); } catch { fail('SOURCE_CAPABILITY_UNAVAILABLE', 'authorization'); }
+    current('authorization'); if (grant !== true) fail('SOURCE_PERMISSION_REJECTED', 'authorization');
+    stage = 'admission'; current('admission');
+    const bytes = await capture.wholeAfterAuthorization(); current('admission');
+    const sourceA = D.digest(bytes);
+    if (sourceA !== record.data.source_expected_A) fail('SOURCE_EXPECTED_ASSET_MISMATCH', 'admission');
+    const entries = parseContainer(bytes, (data, maxOutputLength) => inflateRawSync(data, { maxOutputLength }));
+    const rawManifest = C.strict.parseJson(entries['kdna.json']);
+    classifySource(rawManifest, entries);
+    const manifest5 = validateClassic('Manifest', rawManifest);
+    const payload5 = decodeValidatedPayload(manifest5, entries['payload.kdnab']);
+    const sourceC = D.digest(D.contentTreePreimage(entries));
+    assertContentBindings(manifest5, sourceC);
+    const inventoryFull = inventory.map(r => ({ ...r, sha256: D.digest(entries[r.name]) }));
+    await capture.assertUnchanged(); current('semantic');
+    stage = 'output';
+    const produced = buildOutput(manifest5, payload5, entries, sourceA, sourceC, record.digest, capture.identity.capture_id);
+    current('semantic');
+    const observation = validateTyped('SourceMigrationObservation06', {
+      contract: routeContract,
+      request_digest: record.digest,
+      capture_id: capture.identity.capture_id,
+      tuple: structuredClone(tuple),
+      source_A: sourceA,
+      source_content_digest: sourceC,
+      source_inventory: inventoryFull,
+      output: { A: produced.output.observed.A, C: produced.output.observed.C, E: produced.output.observed.E.digest },
+      E_profile: produced.output.observed.E.profile,
+      output_ir_digest: D.digestCanonical(produced.output.ir),
+      member_actions: produced.actions,
+      origin: strict.freeze(produced.origin),
+      body_bytes: produced.bytes.length,
+      proof: 'produced_bytes_with_confirmed_source_observation_not_consumer_read_or_adoption',
+    });
+    await capture.assertUnchanged(); current('return');
+    return Object.freeze({ status: 'migrated', bytes: new Uint8Array(produced.bytes), observation: frozen(observation) });
+  } catch (e) {
+    if (migrationFailures.has(e)) return failure(e.migrationCode, e.migrationStage);
+    if (stage === 'input' && (C.isFailure(e) || S.isFailure(e) || e.reason === 'READ_INPUT_INVALID')) return failure('SOURCE_INPUT_INVALID', 'input');
+    const reason = e?.code === 'MODULE_NOT_FOUND' ? 'READ_CORE_CAPABILITY_UNAVAILABLE' : e?.reason;
+    if (reason) return coreFailure(reason, ['input', 'capture', 'admission', 'output'].includes(stage) ? stage : 'admission', e);
+    return failure('SOURCE_CAPABILITY_UNAVAILABLE', ['input', 'capture', 'admission', 'authorization', 'semantic', 'output', 'return'].includes(stage) ? stage : 'output');
+  } finally { if (capture) await capture.close(); }
+}
+
+module.exports = {
+  admitSourceMigrationRequest,
+  inspectSourceMigrationRequest,
+  createNativeSourceMigrationAuthority,
+  migratePublicSourceNode,
+};

package/src/public-contract/source-migration-node.mjs

@@ -0,0 +1,2 @@
+import api from './source-migration-node.js';
+export const {admitSourceMigrationRequest,inspectSourceMigrationRequest,createNativeSourceMigrationAuthority,migratePublicSourceNode}=api;