@world-engines/scenario-review-snapshot 0.0.0

package/dist/neutral-artifact-assembler.js

@@ -0,0 +1,1050 @@
+import { canonicalScenarioSourceManifestDigestInputBytes, } from "@world-engines/scenario-author-source";
+import { CURRENT_NEUTRAL_COMPILER_STAGE_VERSIONS, NEUTRAL_SPATIAL_WORLD_STAGE_ID, NEUTRAL_SPATIAL_WORLD_STAGE_VERSION, canonicalCompileTargetProfileBytes, canonicalNeutralSourceCompilerReceiptBytes, compileTargetProfileDigest, digestViewInteractionManifestV3, materializeTmw3TriggerDocument, initialTmwSceneFromMetadata, parseMusicCandidateSourceV3, parseViewInteractionManifestV3, parseViewInteractionSourceV3, } from "@world-engines/tmw";
+import { canonicalLadybugRelationId, createViewAccessPolicySubject, sealViewAccessPolicy, VIEW_ACCESS_POLICY_DENY_ROOT, VIEW_ACCESS_POLICY_ROOT_SUBJECT_ID, } from "@world-engines/ladybug-bridge";
+import { validateRoadGeneration } from "@world-engines/spatial-authoring/road-generation";
+import { validateSpatialTemplateConfiguration } from "@world-engines/spatial-authoring/spatial-templates";
+import { canonicalJson, sha256Hex, toJsonValue } from "./canonical.js";
+import { ARTIFACT_COMPILER_WITNESS_PATHS, ARTIFACT_COMPILER_WITNESS_RESERVED_PREFIX, FROZEN_PUBLISH_INPUT_SCHEMA_VERSION, } from "./artifact.js";
+import { buildArtifactV5 } from "./artifact-digest.js";
+export const NEUTRAL_ARTIFACT_EMBEDDING_INDEX_PATH = "__derived__/embedding-index-v1.json";
+export const FRESH_RUNTIME3_PLAYER_TURN_POLICY_SCHEMA_VERSION = 1;
+export const FROZEN_DATABASE_VIEW_ACCESS_POLICY_SCHEMA_VERSION = 3;
+export const NEUTRAL_ARTIFACT_DERIVED_RESOURCE_PREFIX = "__derived__/";
+const SHA256 = /^[0-9a-f]{64}$/u;
+const encoder = new TextEncoder();
+const MAX_EMBEDDING_SOURCE_TEXT_CHARACTERS = 32_000;
+const canonicalBytes = (value) => encoder.encode(canonicalJson(value));
+/** 既有 embedding index 的 source vector hash：JSON number array，不是 packed bytes hash。 */
+const vectorSourceJsonSha256 = (vector) => sha256Hex(encoder.encode(JSON.stringify([...vector])));
+function record(value, code) {
+    if (value === null || Array.isArray(value) || typeof value !== "object")
+        throw new Error(code);
+    return value;
+}
+function text(value, code) {
+    if (typeof value !== "string" || value.length === 0 || value !== value.trim().normalize("NFC")) {
+        throw new Error(code);
+    }
+    return value;
+}
+function names(value) {
+    const values = typeof value === "string" ? [value] : Array.isArray(value) ? value : [];
+    return values.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+}
+function stableText(value) {
+    if (value === undefined || value === null)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    return new TextDecoder().decode(canonicalBytes(value));
+}
+function effectivePropText(value) {
+    if (value === null || Array.isArray(value) || typeof value !== "object")
+        return stableText(value);
+    const prop = value;
+    if (Array.isArray(prop.states) && prop.states.length > 0) {
+        const active = prop.states.find((state) => {
+            if (state === null || Array.isArray(state) || typeof state !== "object")
+                return false;
+            const candidate = state;
+            return candidate.active === true || candidate.is_active === true;
+        });
+        if (active !== undefined && active !== null && !Array.isArray(active) && typeof active === "object") {
+            return stableText(active.value);
+        }
+        return "";
+    }
+    return stableText(prop.value);
+}
+function disabledEntity(entity) {
+    if (entity.disabled === true)
+        return true;
+    const props = record(entity.props ?? {}, "neutral_artifact_embedding_entity_props_invalid");
+    const values = Object.values(props);
+    return values.length > 0 && values.every((value) => {
+        if (value === null || Array.isArray(value) || typeof value !== "object")
+            return false;
+        const prop = value;
+        return prop.dead === true || prop.deleted === true;
+    });
+}
+function retrievalExcludedEntity(entity) {
+    const props = record(entity.props ?? {}, "neutral_artifact_embedding_entity_props_invalid");
+    const value = props.retrieval_excluded;
+    if (value === true)
+        return true;
+    return value !== null && value !== undefined && !Array.isArray(value) && typeof value === "object"
+        && value.value === true;
+}
+function retrievalSearchableEntity(entity) {
+    const kind = entity.kind;
+    return !disabledEntity(entity) && !retrievalExcludedEntity(entity)
+        && kind !== "world_source_document" && kind !== "source_document"
+        && kind !== "world_ingestion_batch" && kind !== "world_ingestion_source_control"
+        && kind !== "world_document_ingestion_source_control";
+}
+function embeddingSafeField(key) {
+    const compact = key.toLocaleLowerCase("en-US").replaceAll(/[^a-z0-9]/gu, "");
+    return !/(?:raw|original|archive|source|binary|blob).*(?:base64|bytes)|(?:base64|bytes).*(?:raw|original|archive|source|binary|blob)/u.test(compact);
+}
+function relationSourceText(relation) {
+    const props = record(relation.props ?? {}, "neutral_artifact_embedding_relation_props_invalid");
+    const fields = relation.fields === undefined
+        ? {}
+        : record(relation.fields, "neutral_artifact_embedding_relation_fields_invalid");
+    const from = text(relation.from_id, "neutral_artifact_embedding_relation_from_invalid");
+    const to = text(relation.to_id, "neutral_artifact_embedding_relation_to_invalid");
+    const kind = text(relation.kind, "neutral_artifact_embedding_relation_kind_invalid");
+    const propText = Object.keys(props).filter(embeddingSafeField).sort().map((key) => {
+        const value = props[key];
+        const rendered = value === undefined ? "" : stableText(value);
+        return rendered.length === 0 ? "" : `${key}=${rendered}`;
+    }).filter(Boolean).join(" ");
+    const fieldText = Object.keys(fields).sort().map((key) => {
+        const value = fields[key];
+        const rendered = value === undefined ? "" : effectivePropText(value);
+        return rendered.length === 0 ? "" : `${key}=${rendered}`;
+    }).filter(Boolean).join(" ");
+    return [`${kind} ${from} -> ${to} ${propText}`.trim(), fieldText].filter(Boolean).join(" ");
+}
+function buildNeutralArtifactEmbeddingSourceTextIndex(graph) {
+    const entityById = new Map();
+    for (const value of graph.entities) {
+        const entity = record(value, "neutral_artifact_embedding_entity_invalid");
+        if (entity.entity_id === undefined && disabledEntity(entity))
+            continue;
+        const entityId = text(entity.entity_id, "neutral_artifact_embedding_entity_id_invalid");
+        if (entityById.has(entityId))
+            throw new Error(`neutral_artifact_embedding_entity_id_duplicate:${entityId}`);
+        entityById.set(entityId, entity);
+    }
+    const mutableIncident = new Map();
+    const append = (entityId, relation) => {
+        const values = mutableIncident.get(entityId);
+        if (values === undefined)
+            mutableIncident.set(entityId, [relation]);
+        else
+            values.push(relation);
+    };
+    for (const value of graph.relations) {
+        const relation = record(value, "neutral_artifact_embedding_relation_invalid");
+        if (relation.disabled === true)
+            continue;
+        const from = relation.from_id;
+        const to = relation.to_id;
+        if (typeof from === "string")
+            append(from, relation);
+        if (typeof to === "string" && to !== from)
+            append(to, relation);
+    }
+    const incidentByEntityId = new Map();
+    for (const [entityId, relations] of mutableIncident) {
+        incidentByEntityId.set(entityId, Object.freeze(relations.sort((left, right) => String(left.relation_id).localeCompare(String(right.relation_id)))));
+    }
+    return Object.freeze({ entityById, incidentByEntityId });
+}
+function deriveNeutralArtifactEntityEmbeddingSourceTextFromIndex(entityValue, index) {
+    const entity = record(entityValue, "neutral_artifact_embedding_entity_invalid");
+    const entityId = text(entity.entity_id, "neutral_artifact_embedding_entity_id_invalid");
+    const kind = text(entity.kind, "neutral_artifact_embedding_entity_kind_invalid");
+    const props = record(entity.props ?? {}, "neutral_artifact_embedding_entity_props_invalid");
+    const baseProps = Object.keys(props).filter(embeddingSafeField).sort().map((key) => {
+        const value = props[key];
+        const rendered = value === undefined ? "" : effectivePropText(value);
+        return rendered.length === 0 ? "" : `${key}=${rendered}`;
+    }).filter(Boolean).join(" ");
+    const base = `names=${names(entity.name).join("|")} ${kind} ${entityId} ${baseProps}`.trim();
+    const incident = (index.incidentByEntityId.get(entityId) ?? []).map((relation) => {
+        const outgoing = relation.from_id === entityId;
+        const counterpartId = text(outgoing ? relation.to_id : relation.from_id, "neutral_artifact_embedding_counterpart_invalid");
+        const counterpart = index.entityById.get(counterpartId);
+        return [
+            `relation=${text(relation.relation_id, "neutral_artifact_embedding_relation_id_invalid")}`,
+            `direction=${outgoing ? "outgoing" : "incoming"}`,
+            `counterpart=${counterpartId}`,
+            `counterpart_names=${counterpart === undefined ? counterpartId : names(counterpart.name).join("|")}`,
+            `title=${typeof relation.title === "string" ? relation.title : ""}`,
+            `content=${typeof relation.content === "string" ? relation.content : ""}`,
+            relationSourceText(relation),
+        ].filter((segment) => segment.length > 0).join(" ");
+    });
+    return [base, ...incident].join("\n");
+}
+/** ADR-0148 canonical source text: enabled incident relations enrich both endpoint entities. */
+export function deriveNeutralArtifactEntityEmbeddingSourceText(entityValue, graph) {
+    return deriveNeutralArtifactEntityEmbeddingSourceTextFromIndex(entityValue, buildNeutralArtifactEmbeddingSourceTextIndex(graph));
+}
+export async function compileCapturedNeutralSource(source, profile, compiler) {
+    return Object.freeze({ source, compilation: await compiler.compile(source, profile) });
+}
+const strictDecoder = new TextDecoder("utf-8", { fatal: true });
+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 parseCanonicalJson(bytes, field) {
+    let parsed;
+    try {
+        parsed = JSON.parse(strictDecoder.decode(bytes));
+    }
+    catch {
+        throw new Error(`neutral_artifact_${field}_json_invalid`);
+    }
+    const value = toJsonValue(parsed);
+    if (!bytesEqual(canonicalBytes(value), bytes))
+        throw new Error(`neutral_artifact_${field}_not_canonical`);
+    return value;
+}
+function exactKeys(value, expected, field) {
+    const actual = Object.keys(value).sort();
+    const canonical = [...expected].sort();
+    if (actual.length !== canonical.length || actual.some((key, index) => key !== canonical[index])) {
+        throw new Error(`neutral_artifact_${field}_fields_mismatch`);
+    }
+}
+function array(value, field) {
+    if (!Array.isArray(value))
+        throw new Error(`neutral_artifact_${field}_array_required`);
+    return value;
+}
+function base64Bytes(value, field) {
+    const encoded = text(value, field);
+    let decoded;
+    try {
+        decoded = atob(encoded);
+    }
+    catch {
+        throw new Error(`neutral_artifact_${field}_base64_invalid`);
+    }
+    if (btoa(decoded) !== encoded)
+        throw new Error(`neutral_artifact_${field}_base64_noncanonical`);
+    return Uint8Array.from(decoded, (character) => character.charCodeAt(0));
+}
+function derivedObjectMap(objects) {
+    const byStage = new Map(objects.map((object) => [object.stage_id, object]));
+    const spatial = byStage.get(NEUTRAL_SPATIAL_WORLD_STAGE_ID);
+    const expectedSize = CURRENT_NEUTRAL_COMPILER_STAGE_VERSIONS.length + (spatial === undefined ? 0 : 1);
+    if (byStage.size !== expectedSize) {
+        throw new Error("neutral_artifact_derived_object_set_mismatch");
+    }
+    for (const stage of CURRENT_NEUTRAL_COMPILER_STAGE_VERSIONS) {
+        const object = byStage.get(stage.stage_id);
+        if (object === undefined || object.stage_version !== stage.stage_version) {
+            throw new Error(`neutral_artifact_derived_object_missing:${stage.stage_id}`);
+        }
+    }
+    if (spatial !== undefined && spatial.stage_version !== NEUTRAL_SPATIAL_WORLD_STAGE_VERSION) {
+        throw new Error(`neutral_artifact_derived_object_missing:${NEUTRAL_SPATIAL_WORLD_STAGE_ID}`);
+    }
+    return byStage;
+}
+function requiredDerivedJson(byStage, stageId) {
+    const object = byStage.get(stageId);
+    if (object === undefined)
+        throw new Error(`neutral_artifact_derived_object_missing:${stageId}`);
+    return parseCanonicalJson(object.bytes, stageId.replaceAll(".", "_"));
+}
+function optionalSpatialBase(byStage) {
+    const object = byStage.get(NEUTRAL_SPATIAL_WORLD_STAGE_ID);
+    if (object === undefined)
+        return null;
+    const root = record(parseCanonicalJson(object.bytes, "neutral_spatial_world"), "neutral_artifact_spatial_world_object_required");
+    if (root.player_programmatic_supported === false) {
+        exactKeys(root, ["player_programmatic_supported", "reason"], "spatial_world_unsupported");
+        if (root.reason !== "topology_missing"
+            && root.reason !== "topology_not_plane"
+            && root.reason !== "generation_missing"
+            && root.reason !== "procedural_missing") {
+            throw new Error("neutral_artifact_spatial_world_unsupported_reason_invalid");
+        }
+        return null;
+    }
+    exactKeys(root, [
+        "generation",
+        "procedural",
+        "baseDigest",
+        ...(root.roadGeneration === undefined ? [] : ["roadGeneration"]),
+        ...(root.templates === undefined ? [] : ["templates"]),
+        ...(root.controlledActorId === undefined ? [] : ["controlledActorId"]),
+    ], "spatial_world");
+    const baseDigest = text(root.baseDigest, "neutral_artifact_spatial_world_base_digest_invalid");
+    if (!SHA256.test(baseDigest))
+        throw new Error("neutral_artifact_spatial_world_base_digest_invalid");
+    const digestInput = toJsonValue({
+        generation: root.generation,
+        procedural: root.procedural,
+        ...(root.roadGeneration === undefined ? {} : { roadGeneration: root.roadGeneration }),
+        ...(root.templates === undefined ? {} : { templates: root.templates }),
+        ...(root.controlledActorId === undefined ? {} : { controlledActorId: root.controlledActorId }),
+    });
+    if (sha256Hex(canonicalBytes(digestInput)) !== baseDigest) {
+        throw new Error("neutral_artifact_spatial_world_base_digest_mismatch");
+    }
+    const roadGeneration = root.roadGeneration === undefined
+        ? undefined
+        : validateRoadGeneration(root.roadGeneration);
+    const templates = root.templates === undefined
+        ? undefined
+        : validateSpatialTemplateConfiguration(root.templates);
+    return Object.freeze({
+        generation: root.generation,
+        procedural: root.procedural,
+        ...(roadGeneration === undefined ? {} : {
+            roadGeneration,
+        }),
+        ...(templates === undefined ? {} : { templates }),
+        ...(root.controlledActorId === undefined ? {} : { controlledActorId: text(root.controlledActorId, "neutral_artifact_controlled_actor_invalid") }),
+        baseDigest,
+    });
+}
+function parseMetadataModel(value) {
+    const root = record(value, "neutral_artifact_metadata_object_required");
+    exactKeys(root, ["metadata", "protagonist", "system_prompts", "source_metadata"], "metadata");
+    const systemPrompts = array(root.system_prompts, "system_prompts").map((value, index) => {
+        const prompt = record(value, `neutral_artifact_system_prompt_${index}_object_required`);
+        exactKeys(prompt, ["prompt_id", "order", "content"], `system_prompt_${index}`);
+        if (typeof prompt.order !== "number" || !Number.isSafeInteger(prompt.order) || prompt.order < 0) {
+            throw new Error(`neutral_artifact_system_prompt_order_invalid:${index}`);
+        }
+        return Object.freeze({
+            prompt_id: text(prompt.prompt_id, `neutral_artifact_system_prompt_id_invalid:${index}`),
+            order: prompt.order,
+            content: prompt.content ?? null,
+        });
+    });
+    return Object.freeze({
+        metadata: root.metadata ?? null,
+        protagonist: root.protagonist ?? null,
+        system_prompts: Object.freeze(systemPrompts),
+        source_metadata: record(root.source_metadata ?? null, "neutral_artifact_source_metadata_object_required"),
+    });
+}
+/**
+ * Runtime3 的 player turn 只消费已编译计划中的 policy 段；不回读 ArtifactV5 中
+ * 已退役的 metadata/system_prompts identity pair。policy digest 只覆盖可执行作者语义
+ * 与 runtime contract，Artifact/head/five-object identity 由 Edge verified reader 再绑定。
+ */
+export function attachFreshRuntime3PlayerTurnPolicy(compiledPlan, prompts, runtimeContractHash) {
+    if (!SHA256.test(runtimeContractHash))
+        throw new Error("fresh_runtime3_policy_runtime_contract_invalid");
+    const plan = record(compiledPlan, "fresh_runtime3_policy_compiled_plan_object_required");
+    if (plan.runtime_contract_hash !== runtimeContractHash) {
+        throw new Error("fresh_runtime3_policy_compiled_plan_contract_mismatch");
+    }
+    if (plan.player_turn_policy !== undefined)
+        throw new Error("fresh_runtime3_policy_duplicate");
+    const author_prompts = prompts.map((prompt, index) => {
+        if (typeof prompt.content !== "string") {
+            throw new Error(`fresh_runtime3_policy_prompt_content_string_required:${index}`);
+        }
+        return Object.freeze({ prompt_id: prompt.prompt_id, order: prompt.order, content: prompt.content });
+    }).sort((left, right) => left.order - right.order || left.prompt_id.localeCompare(right.prompt_id));
+    const core = Object.freeze({
+        schema_version: FRESH_RUNTIME3_PLAYER_TURN_POLICY_SCHEMA_VERSION,
+        runtime_contract_hash: runtimeContractHash,
+        author_prompts: Object.freeze(author_prompts),
+    });
+    const player_turn_policy = Object.freeze({
+        ...core,
+        policy_sha256: sha256Hex(canonicalBytes(core)),
+    });
+    return toJsonValue(Object.freeze({ ...plan, player_turn_policy }));
+}
+function parseGraphModel(value) {
+    const root = record(value, "neutral_artifact_logical_graph_object_required");
+    exactKeys(root, ["entities", "relations"], "logical_graph");
+    return Object.freeze({
+        entities: array(root.entities, "graph_entities"),
+        relations: array(root.relations, "graph_relations"),
+    });
+}
+function parseLayoutModel(value) {
+    const root = record(value, "neutral_artifact_layout_object_required");
+    exactKeys(root, ["view_interaction_mobile", "view_interaction_pc"], "layout");
+    const mobile = root.view_interaction_mobile === null ? null : parseViewInteractionSourceV3(root.view_interaction_mobile);
+    const pc = root.view_interaction_pc === null ? null : parseViewInteractionSourceV3(root.view_interaction_pc);
+    if ((root.view_interaction_mobile !== null && mobile === null)
+        || (root.view_interaction_pc !== null && pc === null)) {
+        throw new Error("neutral_artifact_view_interaction_source_invalid");
+    }
+    return Object.freeze({ view_interaction_mobile: mobile, view_interaction_pc: pc });
+}
+function parsePromptRetrievalModel(value) {
+    const root = record(value, "neutral_artifact_prompt_retrieval_object_required");
+    exactKeys(root, ["retrieval", "music_candidates", "runtime_definitions"], "prompt_retrieval");
+    const retrieval = record(root.retrieval ?? null, "neutral_artifact_retrieval_object_required");
+    exactKeys(retrieval, ["world_time", "play_config", "retrieval_config", "style_guide_selections", "attr_mutex_keys"], "retrieval");
+    const runtime = record(root.runtime_definitions ?? null, "neutral_artifact_runtime_definitions_object_required");
+    exactKeys(runtime, ["triggers", "trigger_variables_schema", "cg_defs", "achievement_defs", "transaction_defs"], "runtime_definitions");
+    const music = parseMusicCandidateSourceV3(Object.freeze({
+        schema: "music-candidate-source.v3",
+        generation: 3,
+        candidates: array(root.music_candidates, "music_candidates"),
+    }));
+    if (music === null)
+        throw new Error("neutral_artifact_music_candidate_source_invalid");
+    return Object.freeze({
+        retrieval: retrieval.retrieval_config ?? null,
+        music_candidate_source: music,
+        runtime_definitions: Object.freeze({
+            triggers: array(runtime.triggers, "runtime_triggers"),
+            trigger_variables_schema: array(runtime.trigger_variables_schema, "runtime_trigger_variables_schema"),
+            cg_defs: array(runtime.cg_defs, "runtime_cg_defs"),
+            achievement_defs: array(runtime.achievement_defs, "runtime_achievement_defs"),
+            transaction_defs: array(runtime.transaction_defs, "runtime_transaction_defs"),
+        }),
+    });
+}
+function parseResourcesModel(value) {
+    return Object.freeze(array(value, "resource_refs").map((value, index) => {
+        const entry = record(value, `neutral_artifact_resource_${index}_object_required`);
+        exactKeys(entry, ["path", "media_type", "bytes_base64"], `resource_${index}`);
+        const path = text(entry.path, `neutral_artifact_resource_path_${index}_invalid`);
+        if (path.startsWith(ARTIFACT_COMPILER_WITNESS_RESERVED_PREFIX)
+            || path.startsWith(NEUTRAL_ARTIFACT_DERIVED_RESOURCE_PREFIX)) {
+            throw new Error("neutral_artifact_reserved_resource_prefix");
+        }
+        return Object.freeze({
+            path,
+            media_type: text(entry.media_type, `neutral_artifact_resource_media_type_${index}_invalid`),
+            bytes: base64Bytes(entry.bytes_base64, `resource_bytes_${index}`),
+        });
+    }));
+}
+/**
+ * 把一次成功 compiler outcome 物化为 Browser/Node 共用的发布模型。
+ * gzip-tar 解包是唯一外部 seam；调用方不能重写 compiler derived-object 解释规则。
+ */
+export async function materializeNeutralArtifactCompilation(source, profile, outcome, unpackViewProject) {
+    const byStage = derivedObjectMap(outcome.derived_objects);
+    const metadata = parseMetadataModel(requiredDerivedJson(byStage, "neutral.metadata"));
+    const graph = parseGraphModel(requiredDerivedJson(byStage, "neutral.logical-graph"));
+    const layout = parseLayoutModel(requiredDerivedJson(byStage, "neutral.layout"));
+    const promptRetrieval = parsePromptRetrievalModel(requiredDerivedJson(byStage, "neutral.prompt-retrieval"));
+    const spatialWorld = optionalSpatialBase(byStage);
+    const triggerSection = source.sections.find((section) => section.section_key === "trigger_semantics");
+    if (triggerSection === undefined)
+        throw new Error("neutral_artifact_trigger_semantics_missing");
+    const viewSection = source.sections.find((section) => section.section_key === "view_project");
+    if (viewSection === undefined
+        || viewSection.media_type !== "application/vnd.chat.view-project+gzip"
+        || viewSection.canonical_encoding !== "gzip-tar-v1") {
+        throw new Error("neutral_artifact_view_project_encoding_invalid");
+    }
+    const viewSourceBytes = viewSection.payload.slice();
+    const profileBytes = canonicalCompileTargetProfileBytes(profile);
+    const profileDigest = await compileTargetProfileDigest(profile);
+    const receiptBytes = canonicalNeutralSourceCompilerReceiptBytes(outcome.receipt);
+    const witnessResources = await buildNeutralArtifactWitnessResources({
+        source,
+        target_profile_bytes: profileBytes,
+        target_profile_digest: profileDigest,
+        compiler_receipt_bytes: receiptBytes,
+        compiler_receipt_digest: outcome.receipt.receipt_sha256,
+    });
+    return Object.freeze({
+        profile,
+        profile_digest: profileDigest,
+        receipt: outcome.receipt,
+        model: Object.freeze({
+            ...metadata,
+            graph,
+            trigger_document: await materializeTmw3TriggerDocument(parseCanonicalJson(triggerSection.payload, "trigger_semantics")),
+            compiled_plan: requiredDerivedJson(byStage, "tmw.trigger-semantics"),
+            view_project: await unpackViewProject(viewSourceBytes.slice()),
+            view_source_bytes: viewSourceBytes,
+            ...layout,
+            ...promptRetrieval,
+            resources: parseResourcesModel(requiredDerivedJson(byStage, "neutral.resource-refs")),
+            spatial_world: spatialWorld,
+        }),
+        witness_resources: witnessResources,
+    });
+}
+export async function buildNeutralArtifactWitnessResources(input) {
+    const manifestBytes = canonicalScenarioSourceManifestDigestInputBytes(input.source.manifest);
+    if (sha256Hex(manifestBytes) !== input.source.witness.manifest_digest) {
+        throw new Error("neutral_artifact_source_manifest_digest_mismatch");
+    }
+    if (sha256Hex(input.target_profile_bytes) !== input.target_profile_digest) {
+        throw new Error("neutral_artifact_target_profile_digest_mismatch");
+    }
+    if (sha256Hex(input.compiler_receipt_bytes) !== input.compiler_receipt_digest) {
+        throw new Error("neutral_artifact_compiler_receipt_digest_mismatch");
+    }
+    return Object.freeze([
+        Object.freeze({ path: ARTIFACT_COMPILER_WITNESS_PATHS.source_manifest, media_type: "application/x-protobuf", bytes: manifestBytes }),
+        Object.freeze({ path: ARTIFACT_COMPILER_WITNESS_PATHS.target_profile, media_type: "application/json", bytes: input.target_profile_bytes.slice() }),
+        Object.freeze({ path: ARTIFACT_COMPILER_WITNESS_PATHS.compiler_receipt, media_type: "application/json", bytes: input.compiler_receipt_bytes.slice() }),
+    ]);
+}
+export function mergeNeutralArtifactResources(authorResources, witnessResources, derivedResources = []) {
+    if (authorResources.some((resource) => resource.path.startsWith(ARTIFACT_COMPILER_WITNESS_RESERVED_PREFIX)
+        || resource.path.startsWith(NEUTRAL_ARTIFACT_DERIVED_RESOURCE_PREFIX))) {
+        throw new Error("neutral_artifact_reserved_resource_prefix");
+    }
+    if (derivedResources.length > 1 || derivedResources.some((resource) => resource.path !== NEUTRAL_ARTIFACT_EMBEDDING_INDEX_PATH
+        || resource.media_type !== "application/vnd.chat.embedding-index.v1+json")) {
+        throw new Error("neutral_artifact_derived_resource_invalid");
+    }
+    const paths = new Set(witnessResources.map((resource) => resource.path));
+    const required = new Set(Object.values(ARTIFACT_COMPILER_WITNESS_PATHS));
+    if (paths.size !== required.size || [...required].some((path) => !paths.has(path))) {
+        throw new Error("neutral_artifact_compiler_witness_incomplete");
+    }
+    const clone = (resource) => Object.freeze({
+        ...resource,
+        bytes: resource.bytes.slice(),
+    });
+    return Object.freeze([...authorResources.map(clone), ...derivedResources.map(clone), ...witnessResources.map(clone)]);
+}
+/**
+ * 编译产物取得最终 epoch/artifact identity 时，保留 source 中的完整下行声明。
+ * source digest 先验证，避免 compiler 以未签名声明扩展 View SDK 面。
+ */
+export async function bindViewInteractionManifestForFrozenArtifact(source, epoch, runtimeContractHash, artifactBytes) {
+    if (source === null)
+        return null;
+    if (await digestViewInteractionManifestV3(source.manifest) !== source.manifest_digest) {
+        throw new Error("neutral_artifact_view_interaction_source_digest_mismatch");
+    }
+    const bound = parseViewInteractionManifestV3({
+        ...source.manifest,
+        epoch,
+        runtime_contract_hash: runtimeContractHash,
+        artifact_digest: sha256Hex(artifactBytes),
+    });
+    if (bound === null)
+        throw new Error("neutral_artifact_view_interaction_manifest_invalid");
+    return bound;
+}
+const PROP_ENVELOPE_MARKER = "_system_prop_envelope_v1";
+const PROP_METADATA_KEYS = ["trigger", "states", "title", "initial_available", "source_refs", "view_access"];
+function prop(value, field) {
+    return record(value, field);
+}
+function serializePropValue(value, field) {
+    if (Array.isArray(value))
+        return value.map((entry, index) => serializeProp(entry, `${field}_${index}`));
+    if (value !== null && typeof value === "object") {
+        const output = {};
+        for (const [key, entry] of Object.entries(value))
+            output[key] = serializeProp(entry, `${field}_${key}`);
+        return output;
+    }
+    return value;
+}
+function serializeProp(value, field) {
+    const input = prop(value, field);
+    if (!("value" in input))
+        throw new Error(`neutral_artifact_${field}_value_missing`);
+    const serializedValue = serializePropValue(input.value ?? null, `${field}_value`);
+    const hasMetadata = PROP_METADATA_KEYS.some((key) => input[key] !== undefined)
+        && !(input.states !== undefined && Array.isArray(input.states) && input.states.length === 0
+            && PROP_METADATA_KEYS.every((key) => key === "states" || input[key] === undefined));
+    if (!hasMetadata)
+        return serializedValue;
+    const output = { [PROP_ENVELOPE_MARKER]: true, value: serializedValue };
+    for (const key of PROP_METADATA_KEYS) {
+        const metadata = input[key];
+        if (metadata !== undefined && !(key === "states" && Array.isArray(metadata) && metadata.length === 0)
+            && !(key === "source_refs" && Array.isArray(metadata) && metadata.length === 0)) {
+            output[key] = metadata;
+        }
+    }
+    return output;
+}
+function serializeProps(value, field) {
+    const input = record(value ?? {}, field);
+    const output = {};
+    for (const [key, entry] of Object.entries(input))
+        output[key] = serializeProp(entry, `${field}_${key}`);
+    return output;
+}
+function viewAccess(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (value !== "inherit" && value !== "deny" && value !== "read" && value !== "read_write") {
+        throw new Error(`neutral_artifact_${field}_invalid`);
+    }
+    return value;
+}
+const DELIVERY_RESERVED_DERIVED_PROP_KEYS = new Set([
+    "embedding",
+    "embedding_provider_id",
+    "embedding_model_id",
+    "embedding_dimensions",
+]);
+function propPayload(value) {
+    if (value === undefined || value === null || Array.isArray(value) || typeof value !== "object")
+        return value;
+    return "value" in value ? value.value : value;
+}
+function derivedEmbeddingDisposition(props) {
+    const vector = propPayload(props.embedding);
+    const provider = propPayload(props.embedding_provider_id);
+    const model = propPayload(props.embedding_model_id);
+    const dimension = propPayload(props.embedding_dimensions);
+    const metadata = typeof provider === "string" && provider.length > 0
+        && typeof model === "string" && model.length > 0
+        && Number.isSafeInteger(dimension) && Number(dimension) > 0;
+    const derivedVector = metadata && Array.isArray(vector)
+        && vector.length === dimension
+        && vector.every((value) => {
+            const scalar = propPayload(value);
+            return typeof scalar === "number" && Number.isFinite(scalar);
+        });
+    return { metadata, vector: derivedVector };
+}
+/**
+ * 发布 database 的图只保留作者业务属性。旧 WESP 会把检索向量及其 identity
+ * 放进 props；这些值已由 embedding index/vector section 单独承载，不是玩家可见
+ * 属性，也不得扩张 view-access policy。始终复制，不能改写同一次 capture 的 source。
+ */
+function deliveryGraphEntities(values) {
+    return Object.freeze(values.map((value, index) => {
+        const entity = record(value, `neutral_artifact_delivery_entity_${index}_invalid`);
+        const props = record(entity.props ?? {}, `neutral_artifact_delivery_entity_props_${index}_invalid`);
+        const derived = derivedEmbeddingDisposition(props);
+        const deliveryProps = {};
+        for (const [key, entry] of Object.entries(props)) {
+            const strip = key === "embedding"
+                ? derived.vector
+                : derived.metadata && DELIVERY_RESERVED_DERIVED_PROP_KEYS.has(key);
+            if (!strip)
+                deliveryProps[key] = entry;
+        }
+        if (!retrievalSearchableEntity(entity) && !retrievalExcludedEntity(entity)) {
+            deliveryProps.retrieval_excluded = Object.freeze({ value: true });
+        }
+        return Object.freeze({ ...entity, props: Object.freeze(deliveryProps) });
+    }));
+}
+function snapshotEntities(values) {
+    const ids = new Set();
+    return Object.freeze(values.map((value, index) => {
+        const entity = record(value, `neutral_artifact_entity_${index}_invalid`);
+        if (entity.disabled === true)
+            return null;
+        const id = text(entity.entity_id, `neutral_artifact_entity_id_${index}_invalid`);
+        if (ids.has(id))
+            throw new Error(`neutral_artifact_entity_id_duplicate:${id}`);
+        ids.add(id);
+        const rawNames = Array.isArray(entity.name) ? entity.name : [];
+        if (rawNames.length === 0 || rawNames.some((name) => typeof name !== "string"
+            || name.length === 0 || name !== name.trim().normalize("NFC"))) {
+            throw new Error(`neutral_artifact_entity_name_invalid:${id}`);
+        }
+        const mode = viewAccess(entity.view_access, `entity_view_access_${id}`);
+        return Object.freeze({
+            id,
+            kind: text(entity.kind, `neutral_artifact_entity_kind_${index}_invalid`),
+            name: Object.freeze([...rawNames]),
+            props: serializeProps(entity.props, `entity_props_${id}`),
+            ...(mode === undefined ? {} : { view_access: mode }),
+            ...(entity.trigger === undefined ? {} : { trigger: entity.trigger }),
+            ...(entity.source_refs === undefined ? {} : { source_refs: entity.source_refs }),
+            ...(entity.position === undefined ? {} : { position: entity.position }),
+        });
+    }).filter((entity) => entity !== null));
+}
+function snapshotRelations(values) {
+    const ids = new Set();
+    return Object.freeze(values.map((value, index) => {
+        const relation = record(value, `neutral_artifact_relation_${index}_invalid`);
+        if (relation.disabled === true)
+            return null;
+        const src = text(relation.from_id, `neutral_artifact_relation_from_${index}_invalid`);
+        const dst = text(relation.to_id, `neutral_artifact_relation_to_${index}_invalid`);
+        const kind = text(relation.kind, `neutral_artifact_relation_kind_${index}_invalid`);
+        const relationId = canonicalLadybugRelationId(src, dst, kind);
+        if (relation.relation_id !== relationId || ids.has(relationId)) {
+            throw new Error(`neutral_artifact_relation_id_invalid:${index}`);
+        }
+        ids.add(relationId);
+        const mode = viewAccess(relation.view_access, `relation_view_access_${relationId}`);
+        return Object.freeze({
+            relation_id: relationId,
+            src,
+            dst,
+            kind,
+            props: record(relation.props ?? {}, `neutral_artifact_relation_props_${index}_invalid`),
+            ...(mode === undefined ? {} : { view_access: mode }),
+            ...(relation.title === undefined ? {} : { title: text(relation.title, `relation_title_${index}`) }),
+            ...(relation.content === undefined ? {} : { content: text(relation.content, `relation_content_${index}`) }),
+            ...(relation.fields === undefined ? {} : { fields: serializeProps(relation.fields, `relation_fields_${relationId}`) }),
+            ...(relation.initial_available === undefined ? {} : { initial_available: relation.initial_available === true }),
+            ...(relation.trigger === undefined ? {} : { trigger: relation.trigger }),
+            ...(relation.source_refs === undefined ? {} : { source_refs: relation.source_refs }),
+        });
+    }).filter((relation) => relation !== null));
+}
+function appendPropPolicy(subjects, owner, path, value, parent) {
+    const input = prop(value, `policy_prop_${path.join("_")}`);
+    const subject = createViewAccessPolicySubject({ kind: "attr", owner, path: [...path] }, parent, viewAccess(input.view_access, "prop_view_access") ?? "inherit");
+    subjects.push(subject);
+    const child = input.value;
+    if (Array.isArray(child)) {
+        child.forEach((entry, index) => appendPropPolicy(subjects, owner, [...path, String(index)], entry, subject.id));
+    }
+    else if (child !== null && typeof child === "object") {
+        for (const [key, entry] of Object.entries(child))
+            appendPropPolicy(subjects, owner, [...path, key], entry, subject.id);
+    }
+}
+function buildViewAccessPolicy(graphEntities, entities, graphRelations, relations) {
+    const subjects = [];
+    const entityById = new Map(entities.map((entity) => [entity.id, entity]));
+    for (const value of graphEntities) {
+        const input = record(value, "neutral_artifact_policy_entity_invalid");
+        if (input.disabled === true)
+            continue;
+        const id = text(input.entity_id, "neutral_artifact_policy_entity_id_invalid");
+        const entity = entityById.get(id);
+        if (entity === undefined)
+            throw new Error(`neutral_artifact_policy_entity_missing:${id}`);
+        const subject = createViewAccessPolicySubject({ kind: "node", nodeId: id }, VIEW_ACCESS_POLICY_ROOT_SUBJECT_ID, entity.view_access ?? "inherit");
+        subjects.push(subject);
+        const props = record(input.props ?? {}, "neutral_artifact_policy_entity_props_invalid");
+        for (const [key, entry] of Object.entries(props))
+            appendPropPolicy(subjects, { kind: "node", nodeId: id }, [key], entry, subject.id);
+    }
+    const relationById = new Map(relations.map((relation) => [relation.relation_id, relation]));
+    for (const value of graphRelations) {
+        const input = record(value, "neutral_artifact_policy_relation_invalid");
+        if (input.disabled === true)
+            continue;
+        const src = text(input.from_id, "neutral_artifact_policy_relation_from_invalid");
+        const dst = text(input.to_id, "neutral_artifact_policy_relation_to_invalid");
+        const kind = text(input.kind, "neutral_artifact_policy_relation_kind_invalid");
+        if (!entityById.has(src) || !entityById.has(dst))
+            throw new Error("neutral_artifact_policy_relation_endpoint_missing");
+        const id = canonicalLadybugRelationId(src, dst, kind);
+        const relation = relationById.get(id);
+        if (relation === undefined)
+            throw new Error(`neutral_artifact_policy_relation_missing:${id}`);
+        const owner = { kind: "edge", sourceNodeId: src, destinationNodeId: dst, relationKind: kind };
+        const subject = createViewAccessPolicySubject(owner, VIEW_ACCESS_POLICY_ROOT_SUBJECT_ID, relation.view_access ?? "inherit");
+        subjects.push(subject);
+        if (input.fields !== undefined) {
+            const fields = record(input.fields, "neutral_artifact_policy_relation_fields_invalid");
+            for (const [key, entry] of Object.entries(fields))
+                appendPropPolicy(subjects, owner, [key], entry, subject.id);
+        }
+    }
+    return sealViewAccessPolicy([VIEW_ACCESS_POLICY_DENY_ROOT, ...subjects]);
+}
+function buildDerivedViewAccessPolicyV3(graphEntities, entities, graphRelations, relations) {
+    const policy = buildViewAccessPolicy(graphEntities, entities, graphRelations, relations);
+    return Object.freeze({
+        schemaVersion: FROZEN_DATABASE_VIEW_ACCESS_POLICY_SCHEMA_VERSION,
+        derivation: "graph-v5",
+        policySha256: Object.freeze([...policy.policySha256]),
+    });
+}
+function databaseVectorValues(graphEntities, entities, embedding) {
+    const resource = embedding.index_resource;
+    if (resource.path !== NEUTRAL_ARTIFACT_EMBEDDING_INDEX_PATH
+        || resource.media_type !== "application/vnd.chat.embedding-index.v1+json") {
+        throw new Error("neutral_artifact_database_embedding_index_invalid");
+    }
+    const root = record(parseCanonicalJson(resource.bytes, "database_embedding_index"), "neutral_artifact_database_embedding_index_object_required");
+    const descriptor = embedding.descriptor;
+    if (root.schema_version !== 1
+        || root.provider !== descriptor.provider
+        || root.model !== descriptor.model
+        || root.dimension !== descriptor.dimension
+        || root.descriptor_sha256 !== descriptor.descriptor_sha256
+        || root.source_revision !== descriptor.source_revision
+        || root.source_revision_digest !== descriptor.source_revision_digest) {
+        throw new Error("neutral_artifact_database_embedding_descriptor_mismatch");
+    }
+    const entries = array(root.entries, "database_embedding_index_entries");
+    const databaseEntityIds = new Set(entities.map((entity) => entity.id));
+    const searchableIds = new Set(graphEntities
+        .map((value) => record(value, "neutral_artifact_database_embedding_entity_invalid"))
+        .filter(retrievalSearchableEntity)
+        .map((entity) => text(entity.entity_id, "neutral_artifact_database_embedding_entity_id_invalid")));
+    if ([...searchableIds].some((entityId) => !databaseEntityIds.has(entityId))) {
+        throw new Error("neutral_artifact_database_embedding_graph_binding_mismatch");
+    }
+    if (entries.length !== searchableIds.size
+        || embedding.vector_by_entity_id.size !== searchableIds.size) {
+        throw new Error("neutral_artifact_database_embedding_entity_count_mismatch");
+    }
+    const seen = new Set();
+    const scalarCount = entries.length * descriptor.dimension;
+    if (!Number.isSafeInteger(scalarCount) || scalarCount <= 0) {
+        throw new Error("neutral_artifact_database_embedding_scalar_count_invalid");
+    }
+    const values = new Float64Array(scalarCount);
+    let offset = 0;
+    for (const [index, value] of entries.entries()) {
+        const entry = record(value, `neutral_artifact_database_embedding_index_entry_${index}_invalid`);
+        const entityId = text(entry.entity_id, `neutral_artifact_database_embedding_index_entity_${index}_invalid`);
+        const vectorSha256 = text(entry.vector_sha256, `neutral_artifact_database_embedding_index_vector_${index}_invalid`);
+        if (!searchableIds.has(entityId) || seen.has(entityId) || !SHA256.test(vectorSha256)) {
+            throw new Error(`neutral_artifact_database_embedding_index_binding_mismatch:${entityId}`);
+        }
+        const vector = embedding.vector_by_entity_id.get(entityId);
+        if (vector === undefined || vector.length !== descriptor.dimension
+            || vector.some((number) => !Number.isFinite(number))) {
+            throw new Error(`neutral_artifact_database_embedding_vector_invalid:${entityId}`);
+        }
+        if (vectorSourceJsonSha256(vector) !== vectorSha256) {
+            throw new Error(`neutral_artifact_database_embedding_vector_hash_mismatch:${entityId}`);
+        }
+        for (const number of vector)
+            values[offset++] = number;
+        seen.add(entityId);
+    }
+    for (const entityId of embedding.vector_by_entity_id.keys()) {
+        if (!searchableIds.has(entityId)) {
+            throw new Error(`neutral_artifact_database_embedding_vector_unexpected:${entityId}`);
+        }
+    }
+    if (offset !== values.length || seen.size !== searchableIds.size) {
+        throw new Error("neutral_artifact_database_embedding_vector_order_incomplete");
+    }
+    return values;
+}
+/**
+ * 由 compiler materialization 直接生成 fresh-only compact database v1；Browser
+ * 与 Node 必须注入同一 Rust/WASM adapter，禁止在 JS 内先拼出含向量的完整 JSON。
+ */
+export async function encodeNeutralReviewDatabaseSnapshot(input) {
+    if (!Number.isSafeInteger(input.content_epoch) || input.content_epoch <= 0) {
+        throw new Error("neutral_artifact_database_epoch_invalid");
+    }
+    const model = input.compilation.model;
+    const graphEntities = deliveryGraphEntities(model.graph.entities);
+    const entities = snapshotEntities(graphEntities);
+    const relations = snapshotRelations(model.graph.relations);
+    const entityIds = new Set(entities.map((entity) => entity.id));
+    for (const relation of relations) {
+        if (!entityIds.has(relation.src) || !entityIds.has(relation.dst)) {
+            throw new Error(`neutral_artifact_relation_endpoint_missing:${relation.relation_id}`);
+        }
+    }
+    const witness = input.source.witness;
+    const graph = toJsonValue({
+        v: 5,
+        entities,
+        relations,
+    });
+    const sidecar = toJsonValue({
+        initial_scene: initialTmwSceneFromMetadata(model.metadata == null ? {} : record(model.metadata, "neutral_artifact_metadata_object_required")),
+        retrieval_config: model.retrieval,
+        triggers: model.runtime_definitions.triggers,
+        trigger_variables_schema: model.runtime_definitions.trigger_variables_schema,
+        cg_defs: model.runtime_definitions.cg_defs,
+        achievement_defs: model.runtime_definitions.achievement_defs,
+        transaction_defs: model.runtime_definitions.transaction_defs,
+        ...(model.spatial_world == null ? {} : { spatial_world: model.spatial_world }),
+        tmw_source: {
+            schema_version: 3,
+            runtime_generation: 3,
+            owner_id: witness.owner_id,
+            scenario_id: witness.scenario_id,
+            epoch: input.content_epoch,
+            source_revision: witness.source_revision,
+            previous_revision_digest: null,
+            trigger_document: model.trigger_document,
+            view_interaction_mobile: model.view_interaction_mobile,
+            view_interaction_pc: model.view_interaction_pc,
+            music_candidate_source: model.music_candidate_source,
+            source_metadata: model.source_metadata,
+        },
+        view_access_policy: buildDerivedViewAccessPolicyV3(graphEntities, entities, model.graph.relations, relations),
+    });
+    const result = await input.packFrozenDatabase(Object.freeze({
+        graph_v5_json: canonicalBytes(graph),
+        embedding_index_v1_json: input.embedding.index_resource.bytes.slice(),
+        vector_values: databaseVectorValues(graphEntities, entities, input.embedding),
+        sidecar_v5_json: canonicalBytes(sidecar),
+    }));
+    if (result.codec !== "frozen-database-v1"
+        || (result.vector_dtype !== "f32-le" && result.vector_dtype !== "f64-le")
+        || !(result.bytes instanceof Uint8Array)
+        || result.bytes.byteLength === 0) {
+        throw new Error("neutral_artifact_database_pack_result_invalid");
+    }
+    if (result.vector_dtype === "f64-le") {
+        throw new Error("neutral_artifact_database_vector_dtype_runtime_unsupported:f64-le");
+    }
+    return result.bytes.slice();
+}
+/** 最终 FrozenPublishInput 唯一共享装配点；返回前执行 ArtifactV5 全量 normalization。 */
+export async function assembleNeutralFrozenPublishInput(input) {
+    const { source, compilation, embedding } = input;
+    const witness = source.witness;
+    if (!Number.isSafeInteger(input.content_epoch) || input.content_epoch <= 0
+        || embedding.descriptor.source_revision !== witness.source_revision
+        || embedding.descriptor.source_revision_digest !== witness.revision_digest
+        || input.runtime_identity.runtime_contract_hash !== compilation.model.trigger_document.runtime_contract_hash) {
+        throw new Error("neutral_artifact_frozen_binding_mismatch");
+    }
+    const [mobile, pc] = await Promise.all([
+        bindViewInteractionManifestForFrozenArtifact(compilation.model.view_interaction_mobile, input.content_epoch, input.runtime_identity.runtime_contract_hash, input.view_publish_mobile_bytes),
+        bindViewInteractionManifestForFrozenArtifact(compilation.model.view_interaction_pc, input.content_epoch, input.runtime_identity.runtime_contract_hash, input.view_publish_pc_bytes),
+    ]);
+    const frozen = Object.freeze({
+        input_schema_version: FROZEN_PUBLISH_INPUT_SCHEMA_VERSION,
+        captured_revision: Object.freeze({
+            schema_version: 3,
+            owner_id: witness.owner_id,
+            scenario_id: witness.scenario_id,
+            epoch: input.content_epoch,
+            revision_number: witness.source_revision,
+            revision_id: witness.head_digest,
+            source_sha256: witness.source_digest,
+            revision_digest: witness.revision_digest,
+        }),
+        runtime_contract_hash: input.runtime_identity.runtime_contract_hash,
+        metadata: compilation.model.metadata,
+        protagonist: compilation.model.protagonist,
+        system_prompts: compilation.model.system_prompts,
+        database_bytes: input.database_bytes.slice(),
+        database_delivery: Object.freeze({ codec: "scnb-v2", bytes: input.database_delivery_bytes.slice() }),
+        trigger_document: compilation.model.trigger_document,
+        compiled_plan: attachFreshRuntime3PlayerTurnPolicy(compilation.model.compiled_plan, compilation.model.system_prompts, input.runtime_identity.runtime_contract_hash),
+        view_source_bytes: compilation.model.view_source_bytes.slice(),
+        view_publish_mobile_bytes: input.view_publish_mobile_bytes.slice(),
+        view_publish_pc_bytes: input.view_publish_pc_bytes.slice(),
+        view_interaction_mobile: mobile,
+        view_interaction_pc: pc,
+        music_candidate_source: compilation.model.music_candidate_source,
+        retrieval: compilation.model.retrieval,
+        resources: mergeNeutralArtifactResources(compilation.model.resources, compilation.witness_resources, [embedding.index_resource]),
+        runtime_identity: Object.freeze({ ...input.runtime_identity }),
+        archive_bytes: source.source_bytes.slice(),
+    });
+    buildArtifactV5(frozen);
+    return frozen;
+}
+function sourceOf(entity, sourceTextIndex) {
+    if (entity.source_kind === undefined && entity.source_text === undefined) {
+        const kind = text(entity.kind, "neutral_artifact_embedding_entity_kind_invalid");
+        const props = record(entity.props ?? {}, "neutral_artifact_embedding_entity_props_invalid");
+        const documentText = (value, code) => {
+            if (typeof value !== "string")
+                throw new Error(code);
+            const normalized = value.normalize("NFC").trim();
+            if (normalized.length === 0)
+                throw new Error(code);
+            return normalized;
+        };
+        if (kind === "world_source_chunk")
+            return {
+                source_kind: "chunk",
+                source_text: documentText(props.index_text, "neutral_artifact_embedding_chunk_index_text_invalid"),
+            };
+        if (kind === "world_document_statement")
+            return {
+                source_kind: "statement",
+                source_text: documentText(props.assertion, "neutral_artifact_embedding_statement_assertion_invalid"),
+            };
+        if (kind === "world_document_edge_assertion")
+            return {
+                source_kind: "edge_assertion",
+                source_text: documentText(props.assertion, "neutral_artifact_embedding_edge_assertion_invalid"),
+            };
+        return {
+            source_kind: "entity",
+            source_text: deriveNeutralArtifactEntityEmbeddingSourceTextFromIndex(entity, sourceTextIndex),
+        };
+    }
+    const kind = entity.source_kind;
+    if (kind !== "entity" && kind !== "chunk" && kind !== "statement" && kind !== "edge_assertion") {
+        throw new Error("neutral_artifact_embedding_source_kind_invalid");
+    }
+    return { source_kind: kind, source_text: text(entity.source_text, "neutral_artifact_embedding_source_text_invalid") };
+}
+/** Formal freeze 与本地 authoring recall 共用的唯一 corpus 文本投影；关系索引每批只构建一次。 */
+export function projectNeutralArtifactEmbeddingSources(graph) {
+    const sourceTextIndex = buildNeutralArtifactEmbeddingSourceTextIndex(graph);
+    const entities = graph.entities.map((value) => record(value, "neutral_artifact_embedding_entity_invalid"))
+        .filter(retrievalSearchableEntity)
+        .sort((left, right) => text(left.entity_id, "neutral_artifact_embedding_entity_id_invalid")
+        .localeCompare(text(right.entity_id, "neutral_artifact_embedding_entity_id_invalid")));
+    return Object.freeze(entities.map((entity) => {
+        const derived = sourceOf(entity, sourceTextIndex);
+        if (derived.source_text.length > MAX_EMBEDDING_SOURCE_TEXT_CHARACTERS) {
+            throw new Error(`neutral_artifact_embedding_source_text_too_long:${String(entity.entity_id)}`);
+        }
+        return Object.freeze({
+            entity_id: text(entity.entity_id, "neutral_artifact_embedding_entity_id_invalid"),
+            ...derived,
+        });
+    }));
+}
+export async function prepareNeutralArtifactEmbeddingSnapshot(graph, source, runBatch, signal) {
+    if (!source.owner_id || !source.scenario_id || !Number.isSafeInteger(source.source_revision)
+        || source.source_revision <= 0 || !SHA256.test(source.revision_digest)) {
+        throw new Error("neutral_artifact_embedding_source_identity_invalid");
+    }
+    const projected = projectNeutralArtifactEmbeddingSources(graph);
+    if (projected.length === 0)
+        throw new Error("neutral_artifact_embedding_searchable_entity_required");
+    const requests = await Promise.all(projected.map(async (entity) => {
+        return Object.freeze({
+            ...entity,
+            source_text_sha256: sha256Hex(new TextEncoder().encode(entity.source_text)),
+        });
+    }));
+    const result = await runBatch(Object.freeze({ source, entities: Object.freeze(requests), ...(signal === undefined ? {} : { signal }) }));
+    const descriptor = result.descriptor;
+    if (!descriptor.provider || !descriptor.model || !Number.isSafeInteger(descriptor.dimension) || descriptor.dimension <= 0
+        || !SHA256.test(descriptor.descriptor_sha256) || descriptor.source_revision !== source.source_revision
+        || descriptor.source_revision_digest !== source.revision_digest || result.entries.length !== requests.length) {
+        throw new Error("neutral_artifact_embedding_descriptor_mismatch");
+    }
+    const expected = new Map(requests.map((request) => [request.entity_id, request]));
+    const vectors = new Map();
+    for (const entry of result.entries) {
+        const request = expected.get(entry.entity_id);
+        if (request === undefined || vectors.has(entry.entity_id) || entry.source_kind !== request.source_kind
+            || entry.source_text_sha256 !== request.source_text_sha256 || entry.vector.length !== descriptor.dimension
+            || entry.vector.some((value) => !Number.isFinite(value))) {
+            throw new Error(`neutral_artifact_embedding_entry_mismatch:${entry.entity_id}`);
+        }
+        vectors.set(entry.entity_id, Object.freeze([...entry.vector]));
+    }
+    const entries = requests.map((request) => {
+        const vector = vectors.get(request.entity_id);
+        if (vector === undefined)
+            throw new Error(`neutral_artifact_embedding_entry_missing:${request.entity_id}`);
+        return { entity_id: request.entity_id, source_kind: request.source_kind, source_text_sha256: request.source_text_sha256,
+            vector_sha256: vectorSourceJsonSha256(vector) };
+    });
+    const materialization = Object.freeze({
+        descriptor: Object.freeze({ ...descriptor }),
+        vector_by_entity_id: vectors,
+        index_resource: Object.freeze({
+            path: NEUTRAL_ARTIFACT_EMBEDDING_INDEX_PATH,
+            media_type: "application/vnd.chat.embedding-index.v1+json",
+            bytes: canonicalBytes(toJsonValue({ schema_version: 1, ...descriptor, entries })),
+        }),
+    });
+    return Object.freeze({
+        source: Object.freeze({ ...source }),
+        batch: Object.freeze({
+            descriptor: Object.freeze({ ...descriptor }),
+            entries: Object.freeze(result.entries.map((entry) => Object.freeze({
+                ...entry,
+                vector: Object.freeze([...entry.vector]),
+            }))),
+        }),
+        materialization,
+    });
+}
+export async function materializeNeutralArtifactEmbeddings(graph, source, runBatch, signal) {
+    return (await prepareNeutralArtifactEmbeddingSnapshot(graph, source, runBatch, signal)).materialization;
+}