@world-engines/scenario-review-snapshot 0.0.0

package/dist/artifact-digest.js

@@ -0,0 +1,831 @@
+import { canonicalJson, compareUtf8, sha256Hex, toJsonValue } from "./canonical.js";
+import { parseViewInteractionManifestV3, } from "@world-engines/tmw/view-interaction-manifest-v3";
+import { parseMusicCandidateSourceV3, } from "@world-engines/tmw/music-candidate-set";
+import { ARTIFACT_COMPILER_WITNESS_OBJECTS, ARTIFACT_COMPILER_WITNESS_PATHS, ARTIFACT_COMPILER_WITNESS_RESERVED_PREFIX, ARTIFACT_MANIFEST_VERSION_V5, ARTIFACT_PACKAGE_FORMAT_VERSION_V5, CAPTURED_REVISION_SCHEMA_VERSION, FROZEN_PUBLISH_INPUT_SCHEMA_VERSION, FROZEN_ARTIFACT_OBJECT_COUNT, FROZEN_DATABASE_DELIVERY_CODEC, FROZEN_DATABASE_DELIVERY_MEDIA_TYPE, FROZEN_DATABASE_DELIVERY_MAGIC, FROZEN_DATABASE_DELIVERY_RELATIVE_PATH, LEGACY_ARTIFACT_PACKAGE_FORMAT_VERSION_V5, PUBLISHED_ARTIFACT_HEAD_SCHEMA_VERSION, } from "./artifact.js";
+const encoder = new TextEncoder();
+const strictDecoder = new TextDecoder("utf-8", { fatal: true });
+const SHA256_PATTERN = /^[0-9a-f]{64}$/u;
+export function canonicalBytes(value) {
+    return encoder.encode(canonicalJson(value));
+}
+export function canonicalSha256(value) {
+    return sha256Hex(canonicalBytes(value));
+}
+export function buildArtifactV5(input) {
+    const normalized = normalizeFrozenPublishInput(input);
+    const metadata = jsonIdentity(normalized.metadata);
+    const protagonist = jsonIdentity(normalized.protagonist);
+    const promptsValue = toJsonValue(normalized.system_prompts);
+    const system_prompts = jsonIdentity(promptsValue);
+    const database = binaryIdentity(normalized.database_bytes);
+    const database_delivery = databaseDeliveryIdentity(normalized.database_delivery.bytes);
+    const trigger_document = jsonIdentity(normalized.trigger_document);
+    const compiled_plan = jsonIdentity(normalized.compiled_plan);
+    const source = binaryIdentity(normalized.view_source_bytes);
+    const publish_mobile = binaryIdentity(normalized.view_publish_mobile_bytes);
+    const publish_pc = binaryIdentity(normalized.view_publish_pc_bytes);
+    const viewInteractionMobileValue = toJsonValue(normalized.view_interaction_mobile);
+    const viewInteractionPcValue = toJsonValue(normalized.view_interaction_pc);
+    const musicCandidateSourceValue = toJsonValue(normalized.music_candidate_source);
+    const view_interaction = {
+        mobile: jsonIdentity(viewInteractionMobileValue),
+        pc: jsonIdentity(viewInteractionPcValue),
+    };
+    const music_candidate_source = jsonIdentity(musicCandidateSourceValue);
+    const retrieval = jsonIdentity(normalized.retrieval);
+    const resourceEntries = normalized.resources.map((resource) => ({
+        path: resource.path,
+        media_type: resource.media_type,
+        ...binaryIdentity(resource.bytes),
+    }));
+    const resourceManifestValue = toJsonValue(resourceEntries);
+    const resourceManifest = jsonIdentity(resourceManifestValue);
+    const runtimeValue = toJsonValue(normalized.runtime_identity);
+    const runtimeCanonical = jsonIdentity(runtimeValue);
+    const archive = binaryIdentity(normalized.archive_bytes);
+    const frozenInputCore = toJsonValue({
+        input_schema_version: normalized.input_schema_version,
+        captured_revision: normalized.captured_revision,
+        runtime_contract_hash: normalized.runtime_contract_hash,
+        metadata,
+        protagonist,
+        system_prompts,
+        database,
+        database_delivery,
+        trigger_document,
+        compiled_plan,
+        views: { source, publish_mobile, publish_pc },
+        view_interaction,
+        music_candidate_source,
+        retrieval,
+        resources: { manifest: resourceManifest, entries: resourceEntries },
+        runtime: { identity: normalized.runtime_identity, canonical: runtimeCanonical },
+        archive,
+    });
+    const core = {
+        manifest_version: ARTIFACT_MANIFEST_VERSION_V5,
+        package_format_version: ARTIFACT_PACKAGE_FORMAT_VERSION_V5,
+        scenario_id: normalized.captured_revision.scenario_id,
+        epoch: normalized.captured_revision.epoch,
+        runtime_contract_hash: normalized.runtime_contract_hash,
+        captured_revision: normalized.captured_revision,
+        frozen_input_sha256: canonicalSha256(frozenInputCore),
+        metadata,
+        protagonist,
+        system_prompts,
+        database,
+        database_delivery,
+        trigger_document,
+        compiled_plan,
+        views: { source, publish_mobile, publish_pc },
+        view_interaction,
+        music_candidate_source,
+        retrieval,
+        resources: { manifest: resourceManifest, entries: resourceEntries },
+        runtime: { identity: normalized.runtime_identity, canonical: runtimeCanonical },
+        archive,
+    };
+    return deepFreeze({ ...core, canonical_digest: digestArtifactV5Core(core) });
+}
+export function buildFrozenArtifactBundle(input) {
+    const normalized = normalizeFrozenPublishInput(input);
+    const artifact = buildArtifactV5(normalized);
+    const compilerWitnesses = requireCompilerWitnessResources(normalized.resources);
+    const objects = [
+        frozenObject("database", FROZEN_DATABASE_DELIVERY_RELATIVE_PATH, FROZEN_DATABASE_DELIVERY_MEDIA_TYPE, normalized.database_delivery.bytes),
+        frozenObject("trigger_document", "trigger-document-v3.json", "application/json", canonicalBytes(normalized.trigger_document)),
+        frozenObject("compiled_plan", "compiled-plan-v3.json", "application/json", canonicalBytes(normalized.compiled_plan)),
+        frozenObject("view_interaction_mobile", "view-interaction-mobile-v3.json", "application/json", canonicalBytes(toJsonValue(normalized.view_interaction_mobile))),
+        frozenObject("view_interaction_pc", "view-interaction-pc-v3.json", "application/json", canonicalBytes(toJsonValue(normalized.view_interaction_pc))),
+        frozenObject("music_candidate_source", "music-candidate-source-v3.json", "application/json", canonicalBytes(toJsonValue(normalized.music_candidate_source))),
+        frozenObject(ARTIFACT_COMPILER_WITNESS_OBJECTS.source_manifest.kind, ARTIFACT_COMPILER_WITNESS_OBJECTS.source_manifest.relative_path, ARTIFACT_COMPILER_WITNESS_OBJECTS.source_manifest.media_type, compilerWitnesses.source_manifest.bytes),
+        frozenObject(ARTIFACT_COMPILER_WITNESS_OBJECTS.target_profile.kind, ARTIFACT_COMPILER_WITNESS_OBJECTS.target_profile.relative_path, ARTIFACT_COMPILER_WITNESS_OBJECTS.target_profile.media_type, compilerWitnesses.target_profile.bytes),
+        frozenObject(ARTIFACT_COMPILER_WITNESS_OBJECTS.compiler_receipt.kind, ARTIFACT_COMPILER_WITNESS_OBJECTS.compiler_receipt.relative_path, ARTIFACT_COMPILER_WITNESS_OBJECTS.compiler_receipt.media_type, compilerWitnesses.compiler_receipt.bytes),
+    ].sort((left, right) => compareUtf8(left.relative_path, right.relative_path));
+    assertStrictlySortedUnique(objects.map((object) => object.relative_path), "frozen_artifact_object_path_duplicate");
+    assertBundleMatchesArtifact(artifact, objects);
+    return parseFrozenArtifactBundle({ artifact, objects });
+}
+export function parseFrozenArtifactBundle(value) {
+    const root = plainObject(value, "frozen_artifact_bundle_object_required");
+    exactKeys(root, ["artifact", "objects"], "frozen_artifact_bundle");
+    const artifact = parseArtifactV5(root.artifact);
+    if (!Array.isArray(root.objects))
+        throw new Error("frozen_artifact_bundle_objects_invalid");
+    const objects = root.objects.map(parseFrozenArtifactObject);
+    assertStrictlySortedUnique(objects.map((object) => object.relative_path), "frozen_artifact_object_order_invalid");
+    assertBundleMatchesArtifact(artifact, objects);
+    assertCanonicalBundlePayloads(artifact, objects);
+    return Object.freeze({ artifact, objects: Object.freeze(objects) });
+}
+function canonicalArtifactV5CoreBytes(core) {
+    return canonicalBytes(toJsonValue(core));
+}
+export function canonicalArtifactV5Bytes(artifact) {
+    const verified = parseArtifactV5(artifact);
+    return canonicalBytes(toJsonValue(verified));
+}
+export function artifactV5ManifestSha256(artifact) {
+    return sha256Hex(canonicalArtifactV5Bytes(artifact));
+}
+function digestArtifactV5Core(core) {
+    return sha256Hex(canonicalArtifactV5CoreBytes(core));
+}
+export function parseArtifactV5(value) {
+    const root = plainObject(value, "artifact_v5_object_required");
+    const manifestVersion = root.manifest_version;
+    if (manifestVersion !== ARTIFACT_MANIFEST_VERSION_V5) {
+        throw new Error("artifact_v5_required");
+    }
+    if (root.package_format_version === LEGACY_ARTIFACT_PACKAGE_FORMAT_VERSION_V5) {
+        throw new Error("artifact_v5_legacy_package_reader_required");
+    }
+    exactKeys(root, [
+        "manifest_version", "package_format_version", "scenario_id", "captured_revision",
+        "frozen_input_sha256", "metadata", "protagonist", "system_prompts", "database",
+        "database_delivery",
+        "trigger_document", "compiled_plan", "views", "view_interaction", "music_candidate_source",
+        "retrieval", "resources", "runtime", "archive",
+        "epoch", "runtime_contract_hash",
+        "canonical_digest",
+    ], "artifact_v5");
+    const capturedRevision = parseCapturedRevision(root.captured_revision);
+    const resources = plainObject(root.resources, "artifact_v5_resources_object_required");
+    exactKeys(resources, ["manifest", "entries"], "artifact_v5.resources");
+    if (!Array.isArray(resources.entries))
+        throw new Error("artifact_v5_resources_entries_invalid");
+    const resourceEntries = resources.entries.map(parseFrozenResourceIdentity);
+    assertStrictlySortedUnique(resourceEntries.map((entry) => entry.path), "artifact_v5_resource_order_invalid");
+    const views = plainObject(root.views, "artifact_v5_views_object_required");
+    exactKeys(views, ["source", "publish_mobile", "publish_pc"], "artifact_v5.views");
+    const viewInteraction = plainObject(root.view_interaction, "artifact_v5_view_interaction_object_required");
+    exactKeys(viewInteraction, ["mobile", "pc"], "artifact_v5.view_interaction");
+    const runtime = plainObject(root.runtime, "artifact_v5_runtime_object_required");
+    exactKeys(runtime, ["identity", "canonical"], "artifact_v5.runtime");
+    const artifact = {
+        manifest_version: ARTIFACT_MANIFEST_VERSION_V5,
+        package_format_version: requireExactInteger(root.package_format_version, ARTIFACT_PACKAGE_FORMAT_VERSION_V5, "artifact_v5_package_format_version_invalid"),
+        scenario_id: requireIdentifier(root.scenario_id, "artifact_v5_scenario_id_invalid"),
+        epoch: requirePositiveInteger(root.epoch, "artifact_v5_epoch_invalid"),
+        runtime_contract_hash: requireSha256(root.runtime_contract_hash, "artifact_v5_runtime_contract_hash_invalid"),
+        captured_revision: capturedRevision,
+        frozen_input_sha256: requireSha256(root.frozen_input_sha256, "artifact_v5_frozen_input_hash_invalid"),
+        metadata: parseJsonIdentity(root.metadata),
+        protagonist: parseJsonIdentity(root.protagonist),
+        system_prompts: parseJsonIdentity(root.system_prompts),
+        database: parseBinaryIdentity(root.database),
+        database_delivery: parseDatabaseDeliveryIdentity(root.database_delivery),
+        trigger_document: parseJsonIdentity(root.trigger_document),
+        compiled_plan: parseJsonIdentity(root.compiled_plan),
+        views: {
+            source: parseBinaryIdentity(views.source),
+            publish_mobile: parseBinaryIdentity(views.publish_mobile),
+            publish_pc: parseBinaryIdentity(views.publish_pc),
+        },
+        view_interaction: {
+            mobile: parseJsonIdentity(viewInteraction.mobile),
+            pc: parseJsonIdentity(viewInteraction.pc),
+        },
+        music_candidate_source: parseJsonIdentity(root.music_candidate_source),
+        retrieval: parseJsonIdentity(root.retrieval),
+        resources: {
+            manifest: parseJsonIdentity(resources.manifest),
+            entries: resourceEntries,
+        },
+        runtime: {
+            identity: parseRuntimeIdentity(runtime.identity),
+            canonical: parseJsonIdentity(runtime.canonical),
+        },
+        archive: parseBinaryIdentity(root.archive),
+        canonical_digest: requireSha256(root.canonical_digest, "artifact_v5_canonical_digest_invalid"),
+    };
+    if (artifact.scenario_id !== artifact.captured_revision.scenario_id) {
+        throw new Error("artifact_v5_capture_scenario_mismatch");
+    }
+    if (artifact.epoch !== artifact.captured_revision.epoch)
+        throw new Error("artifact_v5_capture_epoch_mismatch");
+    if (artifact.runtime_contract_hash !== artifact.runtime.identity.runtime_contract_hash) {
+        throw new Error("runtime_contract_hash_mismatch");
+    }
+    if (digestFrozenInputIdentity(artifact) !== artifact.frozen_input_sha256) {
+        throw new Error("artifact_v5_frozen_input_hash_mismatch");
+    }
+    const { canonical_digest: _digest, ...core } = artifact;
+    if (digestArtifactV5Core(core) !== artifact.canonical_digest) {
+        throw new Error("artifact_v5_canonical_digest_mismatch");
+    }
+    if (canonicalSha256(toJsonValue(artifact.resources.entries)) !== artifact.resources.manifest.sha256) {
+        throw new Error("artifact_v5_resource_manifest_hash_mismatch");
+    }
+    if (canonicalBytes(toJsonValue(artifact.resources.entries)).byteLength !== artifact.resources.manifest.size_bytes) {
+        throw new Error("artifact_v5_resource_manifest_size_mismatch");
+    }
+    const runtimeBytes = canonicalBytes(toJsonValue(artifact.runtime.identity));
+    if (sha256Hex(runtimeBytes) !== artifact.runtime.canonical.sha256
+        || runtimeBytes.byteLength !== artifact.runtime.canonical.size_bytes) {
+        throw new Error("artifact_v5_runtime_identity_mismatch");
+    }
+    return deepFreeze(artifact);
+}
+export function parseLegacyArtifactV5Package2(value) {
+    const root = plainObject(value, "artifact_v5_legacy_object_required");
+    if (root.manifest_version !== ARTIFACT_MANIFEST_VERSION_V5
+        || root.package_format_version !== LEGACY_ARTIFACT_PACKAGE_FORMAT_VERSION_V5) {
+        throw new Error("artifact_v5_legacy_package2_required");
+    }
+    exactKeys(root, [
+        "manifest_version", "package_format_version", "scenario_id", "captured_revision",
+        "frozen_input_sha256", "metadata", "protagonist", "system_prompts", "database",
+        "trigger_document", "compiled_plan", "views", "view_interaction", "music_candidate_source",
+        "retrieval", "resources", "runtime", "archive", "epoch", "runtime_contract_hash",
+        "canonical_digest",
+    ], "artifact_v5_legacy_package2");
+    const scenarioId = requireIdentifier(root.scenario_id, "artifact_v5_legacy_scenario_id_invalid");
+    const canonicalDigest = requireSha256(root.canonical_digest, "artifact_v5_legacy_canonical_digest_invalid");
+    const rawManifest = toJsonValue(root);
+    const rawObject = rawManifest;
+    const { canonical_digest: _canonicalDigest, ...core } = rawObject;
+    if (canonicalSha256(toJsonValue(core)) !== canonicalDigest) {
+        throw new Error("artifact_v5_legacy_canonical_digest_mismatch");
+    }
+    return deepFreeze({
+        verification: "legacy_unverified",
+        manifest_version: ARTIFACT_MANIFEST_VERSION_V5,
+        package_format_version: LEGACY_ARTIFACT_PACKAGE_FORMAT_VERSION_V5,
+        scenario_id: scenarioId,
+        canonical_digest: canonicalDigest,
+        raw_manifest: rawManifest,
+    });
+}
+export function buildPublishedArtifactHead(core) {
+    const normalized = parsePublishedArtifactHeadCore(core);
+    return Object.freeze({ ...normalized, head_digest: digestPublishedArtifactHeadCore(normalized) });
+}
+export function canonicalPublishedArtifactHeadCoreBytes(core) {
+    return canonicalBytes(toJsonValue(parsePublishedArtifactHeadCore(core)));
+}
+export function digestPublishedArtifactHeadCore(core) {
+    return sha256Hex(canonicalPublishedArtifactHeadCoreBytes(core));
+}
+export function parsePublishedArtifactHead(value) {
+    const root = plainObject(value, "published_artifact_head_object_required");
+    exactKeys(root, [
+        "head_schema_version", "scenario_id", "epoch", "runtime_contract_hash", "source_revision_digest", "head_revision", "artifact_canonical_digest",
+        "artifact_manifest_sha256", "review_ticket_id", "review_snapshot_hash",
+        "review_coverage_hash", "published_at", "previous_head_digest", "head_digest",
+    ], "published_artifact_head");
+    const core = parsePublishedArtifactHeadCore(root);
+    const head_digest = requireSha256(root.head_digest, "published_artifact_head_digest_invalid");
+    if (digestPublishedArtifactHeadCore(core) !== head_digest) {
+        throw new Error("published_artifact_head_digest_mismatch");
+    }
+    return Object.freeze({ ...core, head_digest });
+}
+function requireCompilerWitnessResources(resources) {
+    for (const resource of resources) {
+        if (resource.path.startsWith(ARTIFACT_COMPILER_WITNESS_RESERVED_PREFIX)
+            && !Object.values(ARTIFACT_COMPILER_WITNESS_PATHS).includes(resource.path))
+            throw new Error("frozen_publish_compiler_witness_reserved_path_invalid");
+    }
+    const requireOne = (descriptor) => {
+        const matches = resources.filter((resource) => resource.path === descriptor.resource_path);
+        if (matches.length !== 1) {
+            throw new Error(`frozen_publish_compiler_witness_count_invalid:${descriptor.kind}`);
+        }
+        const resource = matches[0];
+        if (resource === undefined) {
+            throw new Error(`frozen_publish_compiler_witness_missing:${descriptor.kind}`);
+        }
+        if (resource.media_type !== descriptor.media_type) {
+            throw new Error(`frozen_publish_compiler_witness_media_type_invalid:${descriptor.kind}`);
+        }
+        return resource;
+    };
+    return Object.freeze({
+        source_manifest: requireOne(ARTIFACT_COMPILER_WITNESS_OBJECTS.source_manifest),
+        target_profile: requireOne(ARTIFACT_COMPILER_WITNESS_OBJECTS.target_profile),
+        compiler_receipt: requireOne(ARTIFACT_COMPILER_WITNESS_OBJECTS.compiler_receipt),
+    });
+}
+function normalizeFrozenPublishInput(input) {
+    if (input.input_schema_version !== FROZEN_PUBLISH_INPUT_SCHEMA_VERSION) {
+        throw new Error("frozen_publish_input_schema_version_invalid");
+    }
+    const captured_revision = parseCapturedRevision(input.captured_revision);
+    const runtimeContractHash = requireSha256(input.runtime_contract_hash, "frozen_publish_runtime_contract_hash_invalid");
+    const prompts = input.system_prompts.map(normalizePrompt).sort((left, right) => left.order - right.order || compareUtf8(left.prompt_id, right.prompt_id));
+    assertUnique(prompts.map((prompt) => prompt.prompt_id), "frozen_publish_prompt_id_duplicate");
+    const resources = input.resources.map((resource) => ({
+        path: normalizeResourcePath(resource.path),
+        media_type: requireIdentifier(resource.media_type, "frozen_publish_resource_media_type_invalid"),
+        bytes: requireBytes(resource.bytes, "frozen_publish_resource_bytes_invalid"),
+    })).sort((left, right) => compareUtf8(left.path, right.path));
+    assertStrictlySortedUnique(resources.map((resource) => resource.path), "frozen_publish_resource_path_duplicate");
+    requireCompilerWitnessResources(resources);
+    const runtimeIdentity = parseRuntimeIdentity(input.runtime_identity);
+    if (runtimeIdentity.runtime_contract_hash !== runtimeContractHash) {
+        throw new Error("runtime_contract_hash_mismatch");
+    }
+    const viewPublishMobileBytes = requireBytes(input.view_publish_mobile_bytes, "frozen_publish_view_mobile_bytes_invalid");
+    const viewPublishPcBytes = requireBytes(input.view_publish_pc_bytes, "frozen_publish_view_pc_bytes_invalid");
+    const viewInteractionMobile = normalizeViewInteractionManifest(input.view_interaction_mobile, captured_revision.epoch, runtimeContractHash, sha256Hex(viewPublishMobileBytes), "mobile");
+    const viewInteractionPc = normalizeViewInteractionManifest(input.view_interaction_pc, captured_revision.epoch, runtimeContractHash, sha256Hex(viewPublishPcBytes), "pc");
+    const musicCandidateSource = parseMusicCandidateSourceV3(input.music_candidate_source);
+    if (musicCandidateSource === null)
+        throw new Error("music_candidate_source_v3_invalid");
+    if (input.database_delivery?.codec !== FROZEN_DATABASE_DELIVERY_CODEC) {
+        throw new Error("frozen_publish_database_delivery_codec_invalid");
+    }
+    const databaseDeliveryBytes = requireBytes(input.database_delivery.bytes, "frozen_publish_database_delivery_bytes_invalid");
+    if (databaseDeliveryBytes.byteLength === 0
+        || databaseDeliveryBytes[0] !== FROZEN_DATABASE_DELIVERY_MAGIC) {
+        throw new Error("frozen_publish_database_delivery_bytes_invalid");
+    }
+    return {
+        input_schema_version: FROZEN_PUBLISH_INPUT_SCHEMA_VERSION,
+        captured_revision,
+        metadata: toJsonValue(input.metadata),
+        protagonist: toJsonValue(input.protagonist),
+        system_prompts: prompts,
+        database_bytes: requireBytes(input.database_bytes, "frozen_publish_database_bytes_invalid"),
+        database_delivery: Object.freeze({
+            codec: FROZEN_DATABASE_DELIVERY_CODEC,
+            bytes: databaseDeliveryBytes,
+        }),
+        runtime_contract_hash: runtimeContractHash,
+        trigger_document: toJsonValue(input.trigger_document),
+        compiled_plan: toJsonValue(input.compiled_plan),
+        view_source_bytes: requireBytes(input.view_source_bytes, "frozen_publish_view_source_bytes_invalid"),
+        view_publish_mobile_bytes: viewPublishMobileBytes,
+        view_publish_pc_bytes: viewPublishPcBytes,
+        view_interaction_mobile: viewInteractionMobile,
+        view_interaction_pc: viewInteractionPc,
+        music_candidate_source: deepFreeze(musicCandidateSource),
+        retrieval: toJsonValue(input.retrieval),
+        resources,
+        runtime_identity: runtimeIdentity,
+        archive_bytes: requireBytes(input.archive_bytes, "frozen_publish_archive_bytes_invalid"),
+    };
+}
+function normalizeViewInteractionManifest(value, expectedEpoch, expectedRuntimeContractHash, expectedViewArtifactHash, target) {
+    if (value === null)
+        return null;
+    const parsed = parseViewInteractionManifestV3(value);
+    if (parsed === null)
+        throw new Error(`view_interaction_${target}_v3_invalid`);
+    if (parsed.epoch !== expectedEpoch)
+        throw new Error("stale_content_epoch");
+    if (parsed.runtime_contract_hash !== expectedRuntimeContractHash) {
+        throw new Error("runtime_contract_hash_mismatch");
+    }
+    if (parsed.artifact_digest !== expectedViewArtifactHash) {
+        throw new Error(`view_interaction_${target}_artifact_mismatch`);
+    }
+    return deepFreeze(parsed);
+}
+function normalizePrompt(value) {
+    return {
+        prompt_id: requireIdentifier(value.prompt_id, "frozen_publish_prompt_id_invalid"),
+        order: requireNonNegativeInteger(value.order, "frozen_publish_prompt_order_invalid"),
+        content: toJsonValue(value.content),
+    };
+}
+function parseCapturedRevision(value) {
+    const object = plainObject(value, "captured_revision_object_required");
+    exactKeys(object, [
+        "schema_version", "owner_id", "scenario_id", "epoch", "revision_number", "revision_id",
+        "source_sha256", "revision_digest",
+    ], "captured_revision");
+    return Object.freeze({
+        schema_version: requireExactInteger(object.schema_version, CAPTURED_REVISION_SCHEMA_VERSION, "captured_revision_schema_version_invalid"),
+        owner_id: requireIdentifier(object.owner_id, "captured_revision_owner_id_invalid"),
+        scenario_id: requireIdentifier(object.scenario_id, "captured_revision_scenario_id_invalid"),
+        epoch: requirePositiveInteger(object.epoch, "captured_revision_epoch_invalid"),
+        revision_number: requireNonNegativeInteger(object.revision_number, "captured_revision_number_invalid"),
+        revision_id: requireIdentifier(object.revision_id, "captured_revision_id_invalid"),
+        source_sha256: requireSha256(object.source_sha256, "captured_revision_source_hash_invalid"),
+        revision_digest: requireSha256(object.revision_digest, "captured_revision_digest_invalid"),
+    });
+}
+function parseRuntimeIdentity(value) {
+    const object = plainObject(value, "frozen_runtime_identity_object_required");
+    exactKeys(object, [
+        "runtime_generation", "runtime_contract_hash", "runtime_major", "runtime_patch",
+        "runtime_release_id", "protocol_version", "sdk_schema_version",
+    ], "frozen_runtime_identity");
+    return Object.freeze({
+        runtime_generation: requireExactInteger(object.runtime_generation, 3, "frozen_runtime_generation_invalid"),
+        runtime_contract_hash: requireSha256(object.runtime_contract_hash, "frozen_runtime_contract_hash_invalid"),
+        runtime_major: requirePositiveInteger(object.runtime_major, "frozen_runtime_major_invalid"),
+        runtime_patch: requireNonNegativeInteger(object.runtime_patch, "frozen_runtime_patch_invalid"),
+        runtime_release_id: requireIdentifier(object.runtime_release_id, "frozen_runtime_release_id_invalid"),
+        protocol_version: requirePositiveInteger(object.protocol_version, "frozen_runtime_protocol_version_invalid"),
+        sdk_schema_version: requirePositiveInteger(object.sdk_schema_version, "frozen_runtime_sdk_schema_version_invalid"),
+    });
+}
+function parseJsonIdentity(value) {
+    const object = plainObject(value, "artifact_v5_json_identity_invalid");
+    exactKeys(object, ["encoding", "size_bytes", "sha256"], "artifact_v5_json_identity");
+    if (object.encoding !== "canonical-json-v1")
+        throw new Error("artifact_v5_json_encoding_invalid");
+    return Object.freeze({
+        encoding: "canonical-json-v1",
+        size_bytes: requireNonNegativeInteger(object.size_bytes, "artifact_v5_json_size_invalid"),
+        sha256: requireSha256(object.sha256, "artifact_v5_json_hash_invalid"),
+    });
+}
+function parseBinaryIdentity(value) {
+    const object = plainObject(value, "artifact_v5_binary_identity_invalid");
+    exactKeys(object, ["encoding", "size_bytes", "sha256"], "artifact_v5_binary_identity");
+    if (object.encoding !== "bytes")
+        throw new Error("artifact_v5_binary_encoding_invalid");
+    return Object.freeze({
+        encoding: "bytes",
+        size_bytes: requireNonNegativeInteger(object.size_bytes, "artifact_v5_binary_size_invalid"),
+        sha256: requireSha256(object.sha256, "artifact_v5_binary_hash_invalid"),
+    });
+}
+function parseDatabaseDeliveryIdentity(value) {
+    const object = plainObject(value, "artifact_v5_database_delivery_identity_invalid");
+    exactKeys(object, ["codec", "media_type", "encoding", "size_bytes", "sha256"], "artifact_v5_database_delivery");
+    if (object.codec !== FROZEN_DATABASE_DELIVERY_CODEC) {
+        throw new Error("artifact_v5_database_delivery_codec_invalid");
+    }
+    if (object.media_type !== FROZEN_DATABASE_DELIVERY_MEDIA_TYPE) {
+        throw new Error("artifact_v5_database_delivery_media_type_invalid");
+    }
+    const binary = parseBinaryIdentity({
+        encoding: object.encoding,
+        size_bytes: object.size_bytes,
+        sha256: object.sha256,
+    });
+    if (binary.size_bytes === 0)
+        throw new Error("artifact_v5_database_delivery_empty");
+    return Object.freeze({
+        codec: FROZEN_DATABASE_DELIVERY_CODEC,
+        media_type: FROZEN_DATABASE_DELIVERY_MEDIA_TYPE,
+        ...binary,
+    });
+}
+function parseFrozenResourceIdentity(value) {
+    const object = plainObject(value, "artifact_v5_resource_identity_invalid");
+    exactKeys(object, ["path", "media_type", "encoding", "size_bytes", "sha256"], "artifact_v5_resource");
+    const binary = parseBinaryIdentity({
+        encoding: object.encoding,
+        size_bytes: object.size_bytes,
+        sha256: object.sha256,
+    });
+    return Object.freeze({
+        path: normalizeResourcePath(object.path),
+        media_type: requireIdentifier(object.media_type, "artifact_v5_resource_media_type_invalid"),
+        ...binary,
+    });
+}
+function parsePublishedArtifactHeadCore(value) {
+    const object = plainObject(value, "published_artifact_head_core_object_required");
+    const allowed = [
+        "head_schema_version", "scenario_id", "epoch", "runtime_contract_hash", "source_revision_digest",
+        "head_revision", "artifact_canonical_digest",
+        "artifact_manifest_sha256", "review_ticket_id", "review_snapshot_hash",
+        "review_coverage_hash", "published_at", "previous_head_digest",
+    ];
+    const keys = Object.keys(object).filter((key) => key !== "head_digest");
+    if (keys.length !== allowed.length || keys.sort(compareUtf8).some((key, index) => key !== [...allowed].sort(compareUtf8)[index])) {
+        throw new Error("published_artifact_head_core_fields_mismatch");
+    }
+    const previous = object.previous_head_digest;
+    return Object.freeze({
+        head_schema_version: requireExactInteger(object.head_schema_version, PUBLISHED_ARTIFACT_HEAD_SCHEMA_VERSION, "published_artifact_head_schema_version_invalid"),
+        scenario_id: requireIdentifier(object.scenario_id, "published_artifact_head_scenario_id_invalid"),
+        epoch: requirePositiveInteger(object.epoch, "published_artifact_head_epoch_invalid"),
+        runtime_contract_hash: requireSha256(object.runtime_contract_hash, "published_artifact_head_runtime_contract_hash_invalid"),
+        source_revision_digest: requireSha256(object.source_revision_digest, "published_artifact_head_source_revision_digest_invalid"),
+        head_revision: requirePositiveInteger(object.head_revision, "published_artifact_head_revision_invalid"),
+        artifact_canonical_digest: requireSha256(object.artifact_canonical_digest, "published_artifact_head_artifact_digest_invalid"),
+        artifact_manifest_sha256: requireSha256(object.artifact_manifest_sha256, "published_artifact_head_manifest_hash_invalid"),
+        review_ticket_id: requireIdentifier(object.review_ticket_id, "published_artifact_head_ticket_id_invalid"),
+        review_snapshot_hash: requireSha256(object.review_snapshot_hash, "published_artifact_head_snapshot_hash_invalid"),
+        review_coverage_hash: requireSha256(object.review_coverage_hash, "published_artifact_head_coverage_hash_invalid"),
+        published_at: requirePositiveInteger(object.published_at, "published_artifact_head_time_invalid"),
+        previous_head_digest: previous === null
+            ? null
+            : requireSha256(previous, "published_artifact_head_previous_digest_invalid"),
+    });
+}
+function jsonIdentity(value) {
+    const bytes = canonicalBytes(value);
+    return Object.freeze({
+        encoding: "canonical-json-v1",
+        size_bytes: bytes.byteLength,
+        sha256: sha256Hex(bytes),
+    });
+}
+function digestFrozenInputIdentity(artifact) {
+    return canonicalSha256(toJsonValue({
+        input_schema_version: FROZEN_PUBLISH_INPUT_SCHEMA_VERSION,
+        captured_revision: artifact.captured_revision,
+        runtime_contract_hash: artifact.runtime_contract_hash,
+        metadata: artifact.metadata,
+        protagonist: artifact.protagonist,
+        system_prompts: artifact.system_prompts,
+        database: artifact.database,
+        database_delivery: artifact.database_delivery,
+        trigger_document: artifact.trigger_document,
+        compiled_plan: artifact.compiled_plan,
+        views: artifact.views,
+        view_interaction: artifact.view_interaction,
+        music_candidate_source: artifact.music_candidate_source,
+        retrieval: artifact.retrieval,
+        resources: artifact.resources,
+        runtime: artifact.runtime,
+        archive: artifact.archive,
+    }));
+}
+function binaryIdentity(value) {
+    return Object.freeze({ encoding: "bytes", size_bytes: value.byteLength, sha256: sha256Hex(value) });
+}
+function databaseDeliveryIdentity(value) {
+    return Object.freeze({
+        codec: FROZEN_DATABASE_DELIVERY_CODEC,
+        media_type: FROZEN_DATABASE_DELIVERY_MEDIA_TYPE,
+        ...binaryIdentity(value),
+    });
+}
+function frozenObject(kind, relativePath, mediaType, value) {
+    const bytes = requireBytes(value, "frozen_artifact_object_bytes_invalid");
+    return Object.freeze({
+        kind,
+        relative_path: normalizeArtifactRelativePath(relativePath),
+        media_type: requireIdentifier(mediaType, "frozen_artifact_object_media_type_invalid"),
+        ...binaryIdentity(bytes),
+        bytes,
+    });
+}
+function parseFrozenArtifactObject(value) {
+    const object = plainObject(value, "frozen_artifact_object_invalid");
+    exactKeys(object, [
+        "kind",
+        "relative_path",
+        "media_type",
+        "encoding",
+        "size_bytes",
+        "sha256",
+        "bytes",
+    ], "frozen_artifact_object");
+    if (!FROZEN_ARTIFACT_OBJECT_KINDS.has(String(object.kind))) {
+        throw new Error("frozen_artifact_object_kind_invalid");
+    }
+    if (object.encoding !== "bytes")
+        throw new Error("frozen_artifact_object_encoding_invalid");
+    const bytes = requireBytes(object.bytes, "frozen_artifact_object_bytes_invalid");
+    const identity = binaryIdentity(bytes);
+    if (object.size_bytes !== identity.size_bytes
+        || object.sha256 !== identity.sha256)
+        throw new Error("frozen_artifact_object_readback_mismatch");
+    return Object.freeze({
+        kind: object.kind,
+        relative_path: validateArtifactObjectPath(object.kind, object.relative_path),
+        media_type: validateArtifactObjectMediaType(object.kind, object.media_type),
+        ...identity,
+        bytes,
+    });
+}
+const FROZEN_ARTIFACT_OBJECT_KINDS = new Set([
+    "database",
+    "trigger_document",
+    "compiled_plan",
+    "view_interaction_mobile",
+    "view_interaction_pc",
+    "music_candidate_source",
+    "source_manifest",
+    "compile_target_profile",
+    "compiler_receipt",
+]);
+const FROZEN_SINGLETON_PATHS = {
+    database: FROZEN_DATABASE_DELIVERY_RELATIVE_PATH,
+    trigger_document: "trigger-document-v3.json",
+    compiled_plan: "compiled-plan-v3.json",
+    view_interaction_mobile: "view-interaction-mobile-v3.json",
+    view_interaction_pc: "view-interaction-pc-v3.json",
+    music_candidate_source: "music-candidate-source-v3.json",
+    source_manifest: ARTIFACT_COMPILER_WITNESS_OBJECTS.source_manifest.relative_path,
+    compile_target_profile: ARTIFACT_COMPILER_WITNESS_OBJECTS.target_profile.relative_path,
+    compiler_receipt: ARTIFACT_COMPILER_WITNESS_OBJECTS.compiler_receipt.relative_path,
+};
+const FROZEN_SINGLETON_MEDIA_TYPES = {
+    database: FROZEN_DATABASE_DELIVERY_MEDIA_TYPE,
+    trigger_document: "application/json",
+    compiled_plan: "application/json",
+    view_interaction_mobile: "application/json",
+    view_interaction_pc: "application/json",
+    music_candidate_source: "application/json",
+    source_manifest: ARTIFACT_COMPILER_WITNESS_OBJECTS.source_manifest.media_type,
+    compile_target_profile: ARTIFACT_COMPILER_WITNESS_OBJECTS.target_profile.media_type,
+    compiler_receipt: ARTIFACT_COMPILER_WITNESS_OBJECTS.compiler_receipt.media_type,
+};
+function assertBundleMatchesArtifact(artifact, objects) {
+    const byKind = new Map();
+    for (const object of objects) {
+        const list = byKind.get(object.kind) ?? [];
+        list.push(object);
+        byKind.set(object.kind, list);
+    }
+    const requireOne = (kind) => {
+        const selected = byKind.get(kind) ?? [];
+        if (selected.length !== 1)
+            throw new Error(`frozen_artifact_object_kind_count_invalid:${kind}`);
+        const object = selected[0];
+        if (object === undefined) {
+            throw new Error(`frozen_artifact_object_kind_missing:${kind}`);
+        }
+        return object;
+    };
+    const assertIdentity = (object, identity, field) => {
+        if (object.sha256 !== identity.sha256 || object.size_bytes !== identity.size_bytes) {
+            throw new Error(`frozen_artifact_object_identity_mismatch:${field}`);
+        }
+    };
+    assertIdentity(requireOne("database"), artifact.database_delivery, "database_delivery");
+    assertIdentity(requireOne("trigger_document"), artifact.trigger_document, "trigger_document");
+    assertIdentity(requireOne("compiled_plan"), artifact.compiled_plan, "compiled_plan");
+    assertIdentity(requireOne("view_interaction_mobile"), artifact.view_interaction.mobile, "view_interaction_mobile");
+    assertIdentity(requireOne("view_interaction_pc"), artifact.view_interaction.pc, "view_interaction_pc");
+    assertIdentity(requireOne("music_candidate_source"), artifact.music_candidate_source, "music_candidate_source");
+    const resourcesByPath = new Map(artifact.resources.entries.map((resource) => [resource.path, resource]));
+    const assertWitness = (descriptor) => {
+        const object = requireOne(descriptor.kind);
+        const resource = resourcesByPath.get(descriptor.resource_path);
+        if (resource === undefined
+            || object.relative_path !== descriptor.relative_path
+            || object.media_type !== descriptor.media_type
+            || resource.media_type !== descriptor.media_type
+            || object.sha256 !== resource.sha256
+            || object.size_bytes !== resource.size_bytes) {
+            throw new Error(`frozen_artifact_compiler_witness_binding_mismatch:${descriptor.kind}`);
+        }
+    };
+    assertWitness(ARTIFACT_COMPILER_WITNESS_OBJECTS.source_manifest);
+    assertWitness(ARTIFACT_COMPILER_WITNESS_OBJECTS.target_profile);
+    assertWitness(ARTIFACT_COMPILER_WITNESS_OBJECTS.compiler_receipt);
+    if (FROZEN_ARTIFACT_OBJECT_KINDS.size !== FROZEN_ARTIFACT_OBJECT_COUNT
+        || objects.length !== FROZEN_ARTIFACT_OBJECT_COUNT) {
+        throw new Error("frozen_artifact_object_count_invalid");
+    }
+}
+function assertCanonicalBundlePayloads(artifact, objects) {
+    const one = (kind) => {
+        const selected = objects.filter((object) => object.kind === kind);
+        if (selected.length !== 1)
+            throw new Error(`frozen_artifact_object_kind_count_invalid:${kind}`);
+        const object = selected[0];
+        if (object === undefined) {
+            throw new Error(`frozen_artifact_object_kind_missing:${kind}`);
+        }
+        return object;
+    };
+    assertCanonicalJsonObject(one("trigger_document"));
+    assertCanonicalJsonObject(one("compiled_plan"));
+    const viewInteractionMobile = assertCanonicalJsonObject(one("view_interaction_mobile"));
+    const viewInteractionPc = assertCanonicalJsonObject(one("view_interaction_pc"));
+    const musicCandidateSource = assertCanonicalJsonObject(one("music_candidate_source"));
+    assertCanonicalJsonObject(one("compile_target_profile"));
+    assertCanonicalJsonObject(one("compiler_receipt"));
+    normalizeViewInteractionManifest(viewInteractionMobile, artifact.epoch, artifact.runtime_contract_hash, artifact.views.publish_mobile.sha256, "mobile");
+    normalizeViewInteractionManifest(viewInteractionPc, artifact.epoch, artifact.runtime_contract_hash, artifact.views.publish_pc.sha256, "pc");
+    if (parseMusicCandidateSourceV3(musicCandidateSource) === null) {
+        throw new Error("music_candidate_source_v3_invalid");
+    }
+}
+function assertCanonicalJsonObject(object) {
+    let text;
+    try {
+        text = strictDecoder.decode(object.bytes);
+    }
+    catch {
+        throw new Error(`frozen_artifact_canonical_json_utf8_invalid:${object.kind}`);
+    }
+    let decoded;
+    try {
+        decoded = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`frozen_artifact_canonical_json_parse_invalid:${object.kind}`);
+    }
+    const normalized = toJsonValue(decoded);
+    if (!bytesEqual(object.bytes, canonicalBytes(normalized))) {
+        throw new Error(`frozen_artifact_canonical_json_bytes_mismatch:${object.kind}`);
+    }
+    return normalized;
+}
+function bytesEqual(left, right) {
+    if (left.byteLength !== right.byteLength)
+        return false;
+    let difference = 0;
+    for (let index = 0; index < left.byteLength; index += 1) {
+        difference |= (left[index] ?? 0) ^ (right[index] ?? 0);
+    }
+    return difference === 0;
+}
+function requireBytes(value, code) {
+    if (!(value instanceof Uint8Array))
+        throw new Error(code);
+    return value.slice();
+}
+function normalizeResourcePath(value) {
+    const path = requireIdentifier(value, "frozen_publish_resource_path_invalid").normalize("NFC");
+    if (path.startsWith("/")
+        || path.endsWith("/")
+        || path.includes("\\")
+        || path.split("/").some((part) => part.length === 0 || part === "." || part === "..")) {
+        throw new Error("frozen_publish_resource_path_invalid");
+    }
+    return path;
+}
+function normalizeArtifactRelativePath(value) {
+    const path = requireIdentifier(value, "frozen_artifact_object_path_invalid");
+    if (path.startsWith("/")
+        || path.endsWith("/")
+        || path.includes("\\")
+        || path.split("/").some((part) => part.length === 0 || part === "." || part === ".."))
+        throw new Error("frozen_artifact_object_path_invalid");
+    return path;
+}
+function validateArtifactObjectPath(kind, value) {
+    const path = normalizeArtifactRelativePath(value);
+    if (path !== FROZEN_SINGLETON_PATHS[kind]) {
+        throw new Error(`frozen_artifact_singleton_path_mismatch:${kind}`);
+    }
+    return path;
+}
+function validateArtifactObjectMediaType(kind, value) {
+    const mediaType = requireIdentifier(value, "frozen_artifact_object_media_type_invalid");
+    if (mediaType !== FROZEN_SINGLETON_MEDIA_TYPES[kind]) {
+        throw new Error(`frozen_artifact_singleton_media_type_mismatch:${kind}`);
+    }
+    return mediaType;
+}
+function requireIdentifier(value, code) {
+    if (typeof value !== "string")
+        throw new Error(code);
+    const normalized = value.trim().normalize("NFC");
+    if (normalized.length === 0 || normalized !== value)
+        throw new Error(code);
+    return normalized;
+}
+function requireSha256(value, code) {
+    if (typeof value !== "string" || !SHA256_PATTERN.test(value))
+        throw new Error(code);
+    return value;
+}
+function requireNonNegativeInteger(value, code) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+        throw new Error(code);
+    return value;
+}
+function requirePositiveInteger(value, code) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0)
+        throw new Error(code);
+    return value;
+}
+function requireExactInteger(value, expected, code) {
+    if (value !== expected)
+        throw new Error(code);
+    return expected;
+}
+function plainObject(value, code) {
+    if (typeof value !== "object"
+        || value === null
+        || Array.isArray(value)
+        || Object.getPrototypeOf(value) !== Object.prototype)
+        throw new Error(code);
+    return value;
+}
+function exactKeys(value, expected, field) {
+    const actual = Object.keys(value).sort(compareUtf8);
+    const canonical = [...expected].sort(compareUtf8);
+    if (actual.length !== canonical.length || actual.some((key, index) => key !== canonical[index])) {
+        throw new Error(`${field}_fields_mismatch`);
+    }
+}
+function assertUnique(values, code) {
+    if (new Set(values).size !== values.length)
+        throw new Error(code);
+}
+function assertStrictlySortedUnique(values, code) {
+    for (let index = 1; index < values.length; index += 1) {
+        const previous = values[index - 1];
+        const current = values[index];
+        if (previous === undefined
+            || current === undefined
+            || compareUtf8(previous, current) >= 0)
+            throw new Error(code);
+    }
+}
+function deepFreeze(value) {
+    if (typeof value !== "object" || value === null || Object.isFrozen(value))
+        return value;
+    Object.freeze(value);
+    for (const nested of Object.values(value))
+        deepFreeze(nested);
+    return value;
+}