@world-engines/scenario-review-snapshot 0.0.0

package/dist/artifact.d.ts

@@ -0,0 +1,225 @@
+import type { JsonValue } from "./types.js";
+import type { ViewInteractionManifestV3 } from "@world-engines/tmw/view-interaction-manifest-v3";
+import type { MusicCandidateSourceV3 } from "@world-engines/tmw/music-candidate-set";
+export declare const FROZEN_PUBLISH_INPUT_SCHEMA_VERSION: 1;
+export declare const CAPTURED_REVISION_SCHEMA_VERSION: 3;
+export declare const ARTIFACT_MANIFEST_VERSION_V5: 5;
+export declare const ARTIFACT_PACKAGE_FORMAT_VERSION_V5: 3;
+export declare const LEGACY_ARTIFACT_PACKAGE_FORMAT_VERSION_V5: 2;
+export declare const PUBLISHED_ARTIFACT_HEAD_SCHEMA_VERSION: 1;
+export declare const FROZEN_ARTIFACT_OBJECT_COUNT: 9;
+export declare const FROZEN_DATABASE_DELIVERY_CODEC: "scnb-v2";
+export declare const FROZEN_DATABASE_DELIVERY_MAGIC: 16;
+export declare const FROZEN_DATABASE_DELIVERY_MEDIA_TYPE: "application/vnd.chat.scenario-database.scnb-v2";
+export declare const FROZEN_DATABASE_DELIVERY_RELATIVE_PATH: "database.origin";
+export declare const ARTIFACT_COMPILER_WITNESS_PATHS: Readonly<{
+    readonly source_manifest: "__tmw3__/source-manifest.pb";
+    readonly target_profile: "__tmw3__/compile-target-profile.json";
+    readonly compiler_receipt: "__tmw3__/compiler-receipt.json";
+}>;
+export declare const ARTIFACT_COMPILER_WITNESS_RESERVED_PREFIX: "__tmw3__/";
+export declare const ARTIFACT_COMPILER_WITNESS_OBJECTS: Readonly<{
+    readonly source_manifest: Readonly<{
+        kind: "source_manifest";
+        relative_path: "source-manifest.pb";
+        media_type: "application/x-protobuf";
+        resource_path: "__tmw3__/source-manifest.pb";
+    }>;
+    readonly target_profile: Readonly<{
+        kind: "compile_target_profile";
+        relative_path: "compile-target-profile.json";
+        media_type: "application/json";
+        resource_path: "__tmw3__/compile-target-profile.json";
+    }>;
+    readonly compiler_receipt: Readonly<{
+        kind: "compiler_receipt";
+        relative_path: "compiler-receipt.json";
+        media_type: "application/json";
+        resource_path: "__tmw3__/compiler-receipt.json";
+    }>;
+}>;
+export type Sha256Hex = string;
+/**
+ * Creator 对同一次草稿状态的确定性标识。`revision_number` 来自草稿单调版本，
+ * `revision_id` 由 capture owner 分配；重试同一 capture 时两者都不得改变。
+ */
+export interface CapturedRevision {
+    readonly schema_version: typeof CAPTURED_REVISION_SCHEMA_VERSION;
+    readonly owner_id: string;
+    readonly scenario_id: string;
+    readonly epoch: number;
+    readonly revision_number: number;
+    readonly revision_id: string;
+    readonly source_sha256: Sha256Hex;
+    readonly revision_digest: Sha256Hex;
+}
+export interface FrozenSystemPrompt {
+    readonly prompt_id: string;
+    readonly order: number;
+    readonly content: JsonValue;
+}
+export interface FrozenPublishResource {
+    readonly path: string;
+    readonly media_type: string;
+    readonly bytes: Uint8Array;
+}
+export interface FrozenRuntimeIdentity {
+    readonly runtime_generation: 3;
+    readonly runtime_contract_hash: Sha256Hex;
+    readonly runtime_major: number;
+    readonly runtime_patch: number;
+    readonly runtime_release_id: string;
+    readonly protocol_version: number;
+    readonly sdk_schema_version: number;
+}
+/**
+ * 一次性 capture 的完整输入。生产 assembler 只能消费该值，不得再次读取 live store。
+ */
+export interface FrozenPublishInput {
+    readonly input_schema_version: typeof FROZEN_PUBLISH_INPUT_SCHEMA_VERSION;
+    readonly captured_revision: CapturedRevision;
+    readonly runtime_contract_hash: Sha256Hex;
+    readonly metadata: JsonValue;
+    readonly protagonist: JsonValue;
+    readonly system_prompts: readonly FrozenSystemPrompt[];
+    readonly database_bytes: Uint8Array;
+    /** Player 实际下载的密文；明文 `database_bytes` 只供受信审核与 WASM 校验。 */
+    readonly database_delivery: FrozenDatabaseDelivery;
+    readonly trigger_document: JsonValue;
+    readonly compiled_plan: JsonValue;
+    readonly view_source_bytes: Uint8Array;
+    readonly view_publish_mobile_bytes: Uint8Array;
+    readonly view_publish_pc_bytes: Uint8Array;
+    readonly view_interaction_mobile: ViewInteractionManifestV3 | null;
+    readonly view_interaction_pc: ViewInteractionManifestV3 | null;
+    readonly music_candidate_source: MusicCandidateSourceV3;
+    readonly retrieval: JsonValue;
+    readonly resources: readonly FrozenPublishResource[];
+    readonly runtime_identity: FrozenRuntimeIdentity;
+    readonly archive_bytes: Uint8Array;
+}
+export interface CanonicalJsonIdentity {
+    readonly encoding: "canonical-json-v1";
+    readonly size_bytes: number;
+    readonly sha256: Sha256Hex;
+}
+export interface BinaryIdentity {
+    readonly encoding: "bytes";
+    readonly size_bytes: number;
+    readonly sha256: Sha256Hex;
+}
+export interface FrozenDatabaseDelivery {
+    readonly codec: typeof FROZEN_DATABASE_DELIVERY_CODEC;
+    readonly bytes: Uint8Array;
+}
+export interface FrozenDatabaseDeliveryIdentity extends BinaryIdentity {
+    readonly codec: typeof FROZEN_DATABASE_DELIVERY_CODEC;
+    readonly media_type: typeof FROZEN_DATABASE_DELIVERY_MEDIA_TYPE;
+}
+export interface FrozenResourceIdentity extends BinaryIdentity {
+    readonly path: string;
+    readonly media_type: string;
+}
+export interface ArtifactV5Core {
+    readonly manifest_version: typeof ARTIFACT_MANIFEST_VERSION_V5;
+    readonly package_format_version: typeof ARTIFACT_PACKAGE_FORMAT_VERSION_V5;
+    readonly scenario_id: string;
+    readonly epoch: number;
+    readonly runtime_contract_hash: Sha256Hex;
+    readonly captured_revision: CapturedRevision;
+    readonly frozen_input_sha256: Sha256Hex;
+    readonly metadata: CanonicalJsonIdentity;
+    readonly protagonist: CanonicalJsonIdentity;
+    readonly system_prompts: CanonicalJsonIdentity;
+    readonly database: BinaryIdentity;
+    readonly database_delivery: FrozenDatabaseDeliveryIdentity;
+    readonly trigger_document: CanonicalJsonIdentity;
+    readonly compiled_plan: CanonicalJsonIdentity;
+    readonly views: {
+        readonly source: BinaryIdentity;
+        readonly publish_mobile: BinaryIdentity;
+        readonly publish_pc: BinaryIdentity;
+    };
+    readonly view_interaction: {
+        readonly mobile: CanonicalJsonIdentity;
+        readonly pc: CanonicalJsonIdentity;
+    };
+    readonly music_candidate_source: CanonicalJsonIdentity;
+    readonly retrieval: CanonicalJsonIdentity;
+    readonly resources: {
+        readonly manifest: CanonicalJsonIdentity;
+        readonly entries: readonly FrozenResourceIdentity[];
+    };
+    readonly runtime: {
+        readonly identity: FrozenRuntimeIdentity;
+        readonly canonical: CanonicalJsonIdentity;
+    };
+    readonly archive: BinaryIdentity;
+}
+export interface ArtifactV5 extends ArtifactV5Core {
+    readonly canonical_digest: Sha256Hex;
+}
+/**
+ * Package V2 缺少 immutable database delivery 身份，只能由隔离 legacy reader
+ * 展示；该类型故意不满足 ArtifactV5，禁止进入 verified publish/player seam。
+ */
+export interface LegacyArtifactV5Package2Read {
+    readonly verification: "legacy_unverified";
+    readonly manifest_version: typeof ARTIFACT_MANIFEST_VERSION_V5;
+    readonly package_format_version: typeof LEGACY_ARTIFACT_PACKAGE_FORMAT_VERSION_V5;
+    readonly scenario_id: string;
+    readonly canonical_digest: Sha256Hex;
+    readonly raw_manifest: JsonValue;
+}
+export type FrozenArtifactObjectKind = "database" | "trigger_document" | "compiled_plan" | "view_interaction_mobile" | "view_interaction_pc" | "music_candidate_source" | "source_manifest" | "compile_target_profile" | "compiler_receipt";
+export interface FrozenArtifactObjectIdentity extends BinaryIdentity {
+    readonly kind: FrozenArtifactObjectKind;
+    readonly relative_path: string;
+    readonly media_type: string;
+}
+export interface FrozenArtifactObject extends FrozenArtifactObjectIdentity {
+    readonly bytes: Uint8Array;
+}
+export interface ArtifactCompilerWitnessIdentity {
+    readonly source_manifest: FrozenArtifactObjectIdentity & {
+        readonly kind: "source_manifest";
+        readonly relative_path: "source-manifest.pb";
+        readonly media_type: "application/x-protobuf";
+    };
+    readonly target_profile: FrozenArtifactObjectIdentity & {
+        readonly kind: "compile_target_profile";
+        readonly relative_path: "compile-target-profile.json";
+        readonly media_type: "application/json";
+    };
+    readonly compiler_receipt: FrozenArtifactObjectIdentity & {
+        readonly kind: "compiler_receipt";
+        readonly relative_path: "compiler-receipt.json";
+        readonly media_type: "application/json";
+    };
+}
+/** submit 的唯一 payload；Coordinator 不得要求调用方另行写对象或重读 live source。 */
+export interface FrozenArtifactBundle {
+    readonly artifact: ArtifactV5;
+    readonly objects: readonly FrozenArtifactObject[];
+}
+export interface PublishedArtifactHeadCore {
+    readonly head_schema_version: typeof PUBLISHED_ARTIFACT_HEAD_SCHEMA_VERSION;
+    readonly scenario_id: string;
+    readonly epoch: number;
+    readonly runtime_contract_hash: Sha256Hex;
+    readonly source_revision_digest: Sha256Hex;
+    readonly head_revision: number;
+    readonly artifact_canonical_digest: Sha256Hex;
+    readonly artifact_manifest_sha256: Sha256Hex;
+    readonly review_ticket_id: string;
+    readonly review_snapshot_hash: Sha256Hex;
+    readonly review_coverage_hash: Sha256Hex;
+    readonly published_at: number;
+    readonly previous_head_digest: Sha256Hex | null;
+}
+/**
+ * append-only head 事件。可变 active pointer 只能 CAS 到 `head_digest`，不得改写该对象。
+ */
+export interface PublishedArtifactHead extends PublishedArtifactHeadCore {
+    readonly head_digest: Sha256Hex;
+}

package/dist/artifact.js

@@ -0,0 +1,37 @@
+export const FROZEN_PUBLISH_INPUT_SCHEMA_VERSION = 1;
+export const CAPTURED_REVISION_SCHEMA_VERSION = 3;
+export const ARTIFACT_MANIFEST_VERSION_V5 = 5;
+export const ARTIFACT_PACKAGE_FORMAT_VERSION_V5 = 3;
+export const LEGACY_ARTIFACT_PACKAGE_FORMAT_VERSION_V5 = 2;
+export const PUBLISHED_ARTIFACT_HEAD_SCHEMA_VERSION = 1;
+export const FROZEN_ARTIFACT_OBJECT_COUNT = 9;
+export const FROZEN_DATABASE_DELIVERY_CODEC = "scnb-v2";
+export const FROZEN_DATABASE_DELIVERY_MAGIC = 0x10;
+export const FROZEN_DATABASE_DELIVERY_MEDIA_TYPE = "application/vnd.chat.scenario-database.scnb-v2";
+export const FROZEN_DATABASE_DELIVERY_RELATIVE_PATH = "database.origin";
+export const ARTIFACT_COMPILER_WITNESS_PATHS = Object.freeze({
+    source_manifest: "__tmw3__/source-manifest.pb",
+    target_profile: "__tmw3__/compile-target-profile.json",
+    compiler_receipt: "__tmw3__/compiler-receipt.json",
+});
+export const ARTIFACT_COMPILER_WITNESS_RESERVED_PREFIX = "__tmw3__/";
+export const ARTIFACT_COMPILER_WITNESS_OBJECTS = Object.freeze({
+    source_manifest: Object.freeze({
+        kind: "source_manifest",
+        relative_path: "source-manifest.pb",
+        media_type: "application/x-protobuf",
+        resource_path: ARTIFACT_COMPILER_WITNESS_PATHS.source_manifest,
+    }),
+    target_profile: Object.freeze({
+        kind: "compile_target_profile",
+        relative_path: "compile-target-profile.json",
+        media_type: "application/json",
+        resource_path: ARTIFACT_COMPILER_WITNESS_PATHS.target_profile,
+    }),
+    compiler_receipt: Object.freeze({
+        kind: "compiler_receipt",
+        relative_path: "compiler-receipt.json",
+        media_type: "application/json",
+        resource_path: ARTIFACT_COMPILER_WITNESS_PATHS.compiler_receipt,
+    }),
+});

package/dist/bound-view-freeze.d.ts

@@ -0,0 +1,43 @@
+import { type NeutralSourceCaptureWitness, type NeutralSourceCompileInput } from "@world-engines/scenario-author-source";
+import type { FrozenArtifactBundle, FrozenRuntimeIdentity } from "./artifact.js";
+import { type NeutralArtifactCompilation, type NeutralArtifactEmbeddingMaterialization } from "./neutral-artifact-assembler.js";
+/**
+ * Bound-copy authority 的 server readback。`bound_source` 必须是替换目标 SVP
+ * 后由 authority 写入的 revision witness，不能复用原 scenario revision identity。
+ */
+export interface BoundCopyPublishReceipt {
+    readonly copy_operation_id: string;
+    readonly base_source_revision_digest: string;
+    readonly target_svp_sha256: string;
+    readonly bound_source: NeutralSourceCaptureWitness;
+}
+/** server-only codec seam；生产实现使用 SVP decoder 与 canonical gzip-tar packer。 */
+export interface ServerBoundViewProjectCodec<TViewProject> {
+    decode_svp(bytes: Uint8Array): TViewProject;
+    pack_gzip_tar(project: TViewProject): Promise<Uint8Array>;
+}
+/** compiler 只消费本模块重建并 capture 的 source，不能接收调用方拼出的 model。 */
+export interface ServerBoundViewCompiler<TViewProject> {
+    compile(source: NeutralSourceCompileInput): Promise<NeutralArtifactCompilation<TViewProject>>;
+}
+export interface BoundViewFreezeInput {
+    readonly bound_copy_receipt: BoundCopyPublishReceipt;
+    /** bound-copy 前的冻结 scenario input；adapter 只替换 view_project section。 */
+    readonly current_compile_input: NeutralSourceCompileInput;
+    /** server-only store 读出的 SVP1 bytes；任何 digest 都不能替代它。 */
+    readonly target_svp_bytes: Uint8Array;
+    readonly platform_html: Readonly<{
+        readonly mobile: Uint8Array;
+        readonly pc: Uint8Array;
+    }>;
+    readonly content_epoch: number;
+    readonly embedding: NeutralArtifactEmbeddingMaterialization;
+    readonly database_bytes: Uint8Array;
+    readonly database_delivery_bytes: Uint8Array;
+    readonly runtime_identity: FrozenRuntimeIdentity;
+}
+/** 单一 server-only publish adapter；不含 Browser build、SVP 读取或任何密钥。 */
+export interface BoundViewFreezeAdapter {
+    freeze(input: BoundViewFreezeInput): Promise<FrozenArtifactBundle>;
+}
+export declare function createBoundViewFreezeAdapter<TViewProject>(codec: ServerBoundViewProjectCodec<TViewProject>, compiler: ServerBoundViewCompiler<TViewProject>): BoundViewFreezeAdapter;

package/dist/bound-view-freeze.js

@@ -0,0 +1,114 @@
+import { canonicalScenarioSourceManifestDigestInputBytes, captureNeutralSourceCompileInput, createNeutralScenarioSource, encodeNeutralScenarioSource, } from "@world-engines/scenario-author-source";
+import { sha256Hex } from "./canonical.js";
+import { buildFrozenArtifactBundle } from "./artifact-digest.js";
+import { assembleNeutralFrozenPublishInput, } from "./neutral-artifact-assembler.js";
+const SHA256 = /^[0-9a-f]{64}$/u;
+export function createBoundViewFreezeAdapter(codec, compiler) {
+    return Object.freeze({
+        async freeze(input) {
+            assertInputReceiptBinding(input);
+            const targetProject = codec.decode_svp(input.target_svp_bytes.slice());
+            const targetGzipTar = await codec.pack_gzip_tar(targetProject);
+            if (!(targetGzipTar instanceof Uint8Array) || targetGzipTar.byteLength === 0) {
+                throw new Error("bound_view_freeze_target_project_bytes_invalid");
+            }
+            const source = await rebuildBoundCompileInput(input, targetGzipTar);
+            const compilation = await compiler.compile(source);
+            assertTrustedCompilationMatchesBoundSource(input, source, targetGzipTar, compilation);
+            const frozen = await assembleNeutralFrozenPublishInput({
+                source,
+                content_epoch: input.content_epoch,
+                compilation,
+                embedding: input.embedding,
+                database_bytes: input.database_bytes,
+                database_delivery_bytes: input.database_delivery_bytes,
+                view_publish_mobile_bytes: input.platform_html.mobile,
+                view_publish_pc_bytes: input.platform_html.pc,
+                runtime_identity: input.runtime_identity,
+            });
+            return buildFrozenArtifactBundle(frozen);
+        },
+    });
+}
+async function rebuildBoundCompileInput(input, targetGzipTar) {
+    let replaced = false;
+    const sections = input.current_compile_input.sections.map((section) => {
+        if (section.section_key !== "view_project")
+            return cloneSection(section);
+        replaced = true;
+        return {
+            section_key: "view_project",
+            media_type: "application/vnd.chat.view-project+gzip",
+            canonical_encoding: "gzip-tar-v1",
+            payload: targetGzipTar.slice(),
+        };
+    });
+    if (!replaced)
+        throw new Error("bound_view_freeze_current_view_section_missing");
+    const source = await createNeutralScenarioSource(input.current_compile_input.witness.scenario_id, sections);
+    const sourceBytes = await encodeNeutralScenarioSource(source);
+    const witness = input.bound_copy_receipt.bound_source;
+    const manifest = source.manifest;
+    if (manifest === undefined
+        || sha256Hex(sourceBytes) !== witness.source_digest
+        || sha256Hex(canonicalScenarioSourceManifestDigestInputBytes(manifest)) !== witness.manifest_digest) {
+        throw new Error("bound_view_freeze_rebuilt_source_receipt_mismatch");
+    }
+    return await captureNeutralSourceCompileInput({ witness, source_bytes: sourceBytes });
+}
+function assertInputReceiptBinding(input) {
+    const receipt = input.bound_copy_receipt;
+    const current = input.current_compile_input.witness;
+    if (!nonEmptyText(receipt.copy_operation_id)
+        || !SHA256.test(receipt.base_source_revision_digest)
+        || !SHA256.test(receipt.target_svp_sha256)
+        || !validWitness(receipt.bound_source)) {
+        throw new Error("bound_view_freeze_receipt_invalid");
+    }
+    if (!(input.target_svp_bytes instanceof Uint8Array)
+        || !(input.platform_html.mobile instanceof Uint8Array)
+        || !(input.platform_html.pc instanceof Uint8Array)) {
+        throw new Error("bound_view_freeze_actual_bytes_required");
+    }
+    if (receipt.base_source_revision_digest !== current.revision_digest
+        || receipt.bound_source.scenario_id !== current.scenario_id
+        || receipt.bound_source.owner_id !== current.owner_id
+        || sha256Hex(input.target_svp_bytes) !== receipt.target_svp_sha256) {
+        throw new Error("bound_view_freeze_receipt_current_source_mismatch");
+    }
+}
+function assertTrustedCompilationMatchesBoundSource(input, source, targetGzipTar, compilation) {
+    if (compilation.receipt.scenario_id !== source.witness.scenario_id
+        || compilation.receipt.source_manifest_sha256 !== source.witness.manifest_digest
+        || !sameBytes(compilation.model.view_source_bytes, targetGzipTar)
+        || compilation.model.trigger_document.runtime_contract_hash !== input.runtime_identity.runtime_contract_hash) {
+        throw new Error("bound_view_freeze_trusted_compilation_mismatch");
+    }
+}
+function cloneSection(section) {
+    return {
+        section_key: section.section_key,
+        media_type: section.media_type,
+        canonical_encoding: section.canonical_encoding,
+        payload: section.payload.slice(),
+    };
+}
+function validWitness(witness) {
+    return nonEmptyText(witness.owner_id) && nonEmptyText(witness.scenario_id)
+        && Number.isSafeInteger(witness.source_revision) && witness.source_revision > 0
+        && SHA256.test(witness.manifest_digest) && SHA256.test(witness.source_digest)
+        && SHA256.test(witness.revision_digest) && SHA256.test(witness.head_digest)
+        && (witness.previous_head_digest === null || SHA256.test(witness.previous_head_digest));
+}
+function nonEmptyText(value) {
+    return value.length > 0 && value === value.trim().normalize("NFC");
+}
+function sameBytes(left, right) {
+    if (left.byteLength !== right.byteLength)
+        return false;
+    for (let index = 0; index < left.byteLength; index += 1) {
+        if (left[index] !== right[index])
+            return false;
+    }
+    return true;
+}

package/dist/canonical.d.ts

@@ -0,0 +1,10 @@
+import type { JsonValue } from "./types.js";
+export declare function utf8ByteLength(value: string): number;
+export declare function escapeJsonPointerToken(token: string): string;
+export declare function unescapeJsonPointerToken(token: string): string;
+export declare function appendJsonPointer(pointer: string, token: string | number): string;
+export declare function parseJsonPointer(pointer: string): string[];
+export declare function compareUtf8(a: string, b: string): number;
+export declare function canonicalJson(value: JsonValue): string;
+export declare function toJsonValue(value: unknown, maxDepth?: number): JsonValue;
+export declare function sha256Hex(value: string | Uint8Array): string;

package/dist/canonical.js

@@ -0,0 +1,184 @@
+const encoder = new TextEncoder();
+export function utf8ByteLength(value) {
+    return encoder.encode(value).byteLength;
+}
+export function escapeJsonPointerToken(token) {
+    return token.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+export function unescapeJsonPointerToken(token) {
+    if (/~(?:[^01]|$)/u.test(token)) {
+        throw new Error("scenario_review_json_pointer_escape_invalid");
+    }
+    return token.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+export function appendJsonPointer(pointer, token) {
+    if (pointer !== "" && !pointer.startsWith("/")) {
+        throw new Error("scenario_review_json_pointer_invalid");
+    }
+    return `${pointer}/${escapeJsonPointerToken(String(token))}`;
+}
+export function parseJsonPointer(pointer) {
+    if (pointer === "")
+        return [];
+    if (!pointer.startsWith("/"))
+        throw new Error("scenario_review_json_pointer_invalid");
+    return pointer.slice(1).split("/").map(unescapeJsonPointerToken);
+}
+export function compareUtf8(a, b) {
+    const left = encoder.encode(a);
+    const right = encoder.encode(b);
+    const length = Math.min(left.length, right.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = left[index] - right[index];
+        if (difference !== 0)
+            return difference;
+    }
+    return left.length - right.length;
+}
+export function canonicalJson(value) {
+    return encodeCanonical(value, new Set());
+}
+function encodeCanonical(value, ancestors) {
+    if (value === null)
+        return "null";
+    if (typeof value === "string" || typeof value === "boolean")
+        return JSON.stringify(value);
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new Error("scenario_review_json_number_invalid");
+        return JSON.stringify(Object.is(value, -0) ? 0 : value);
+    }
+    if (ancestors.has(value))
+        throw new Error("scenario_review_json_cycle");
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value)) {
+            assertDenseArray(value);
+            return `[${value.map((item) => encodeCanonical(item, ancestors)).join(",")}]`;
+        }
+        const keys = Object.keys(value).sort(compareUtf8);
+        return `{${keys
+            .map((key) => `${JSON.stringify(key)}:${encodeCanonical(value[key], ancestors)}`)
+            .join(",")}}`;
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+export function toJsonValue(value, maxDepth = 256) {
+    if (!Number.isSafeInteger(maxDepth) || maxDepth < 0) {
+        throw new Error("scenario_review_json_depth_limit_invalid");
+    }
+    return normalizeJson(value, new Set(), 0, maxDepth);
+}
+function normalizeJson(value, ancestors, depth, maxDepth) {
+    if (depth > maxDepth)
+        throw new Error("scenario_review_value_depth_limit_exceeded");
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new Error("scenario_review_json_number_invalid");
+        return Object.is(value, -0) ? 0 : value;
+    }
+    if (typeof value !== "object")
+        throw new Error("scenario_review_json_value_invalid");
+    if (ancestors.has(value))
+        throw new Error("scenario_review_json_cycle");
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value)) {
+            assertDenseArray(value);
+            return Array.from(value, (item) => normalizeJson(item, ancestors, depth + 1, maxDepth));
+        }
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && prototype !== null) {
+            throw new Error("scenario_review_json_object_invalid");
+        }
+        const source = value;
+        const result = {};
+        for (const key of Object.keys(source).sort(compareUtf8)) {
+            result[key] = normalizeJson(source[key], ancestors, depth + 1, maxDepth);
+        }
+        return result;
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+function assertDenseArray(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        if (!Object.prototype.hasOwnProperty.call(value, index)) {
+            throw new Error("scenario_review_json_sparse_array_invalid");
+        }
+    }
+}
+export function sha256Hex(value) {
+    const bytes = typeof value === "string" ? encoder.encode(value) : value;
+    const words = new Uint32Array(64);
+    const hash = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const bitLength = BigInt(bytes.length) * 8n;
+    const paddedLength = Math.ceil((bytes.length + 9) / 64) * 64;
+    const padded = new Uint8Array(paddedLength);
+    padded.set(bytes);
+    padded[bytes.length] = 0x80;
+    for (let index = 0; index < 8; index += 1) {
+        padded[paddedLength - 1 - index] = Number((bitLength >> BigInt(index * 8)) & 0xffn);
+    }
+    for (let offset = 0; offset < padded.length; offset += 64) {
+        for (let index = 0; index < 16; index += 1) {
+            const at = offset + index * 4;
+            words[index] = ((padded[at] << 24) | (padded[at + 1] << 16) |
+                (padded[at + 2] << 8) | padded[at + 3]) >>> 0;
+        }
+        for (let index = 16; index < 64; index += 1) {
+            const a = words[index - 15];
+            const b = words[index - 2];
+            const s0 = rotateRight(a, 7) ^ rotateRight(a, 18) ^ (a >>> 3);
+            const s1 = rotateRight(b, 17) ^ rotateRight(b, 19) ^ (b >>> 10);
+            words[index] = (words[index - 16] + s0 + words[index - 7] + s1) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, h] = hash;
+        for (let index = 0; index < 64; index += 1) {
+            const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+            const choice = (e & f) ^ (~e & g);
+            const t1 = (h + sum1 + choice + SHA256_K[index] + words[index]) >>> 0;
+            const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+            const majority = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (sum0 + majority) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        hash[0] = (hash[0] + a) >>> 0;
+        hash[1] = (hash[1] + b) >>> 0;
+        hash[2] = (hash[2] + c) >>> 0;
+        hash[3] = (hash[3] + d) >>> 0;
+        hash[4] = (hash[4] + e) >>> 0;
+        hash[5] = (hash[5] + f) >>> 0;
+        hash[6] = (hash[6] + g) >>> 0;
+        hash[7] = (hash[7] + h) >>> 0;
+    }
+    return [...hash].map((word) => word.toString(16).padStart(8, "0")).join("");
+}
+function rotateRight(value, count) {
+    return (value >>> count) | (value << (32 - count));
+}
+const SHA256_K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { appendJsonPointer, canonicalJson, compareUtf8, escapeJsonPointerToken, parseJsonPointer, sha256Hex, toJsonValue, unescapeJsonPointerToken, utf8ByteLength, } from "./canonical.js";
+export { buildScenarioReviewSnapshot, DEFAULT_SCENARIO_REVIEW_SNAPSHOT_LIMITS, reconstructRecordPayload, stableRelationId, } from "./snapshot.js";
+export { ARTIFACT_MANIFEST_VERSION_V5, ARTIFACT_PACKAGE_FORMAT_VERSION_V5, LEGACY_ARTIFACT_PACKAGE_FORMAT_VERSION_V5, CAPTURED_REVISION_SCHEMA_VERSION, FROZEN_PUBLISH_INPUT_SCHEMA_VERSION, FROZEN_DATABASE_DELIVERY_CODEC, FROZEN_DATABASE_DELIVERY_MEDIA_TYPE, FROZEN_DATABASE_DELIVERY_MAGIC, FROZEN_DATABASE_DELIVERY_RELATIVE_PATH, PUBLISHED_ARTIFACT_HEAD_SCHEMA_VERSION, } from "./artifact.js";
+export { artifactV5ManifestSha256, buildArtifactV5, buildFrozenArtifactBundle, buildPublishedArtifactHead, canonicalArtifactV5Bytes, canonicalBytes, canonicalPublishedArtifactHeadCoreBytes, canonicalSha256, digestPublishedArtifactHeadCore, parseArtifactV5, parseFrozenArtifactBundle, parseLegacyArtifactV5Package2, parsePublishedArtifactHead, } from "./artifact-digest.js";
+export type { CoverageManifest, CoverageManifestCore, CoverageRecordEntry, CoverageSectionEntry, JsonPrimitive, JsonValue, ReviewFragmentValueKind, ReviewRecordKind, ReviewSection, ScenarioReviewChunk, ScenarioReviewFragment, ScenarioReviewRecord, ScenarioReviewSnapshot, ScenarioReviewSnapshotCore, ScenarioReviewSnapshotInput, ScenarioReviewSnapshotLimits, ScenarioReviewSupplementalRecordInput, } from "./types.js";
+export type { ArtifactV5, ArtifactV5Core, BinaryIdentity, CanonicalJsonIdentity, CapturedRevision, FrozenPublishInput, FrozenDatabaseDelivery, FrozenDatabaseDeliveryIdentity, FrozenArtifactBundle, FrozenArtifactObject, FrozenArtifactObjectIdentity, FrozenArtifactObjectKind, FrozenPublishResource, FrozenResourceIdentity, FrozenRuntimeIdentity, FrozenSystemPrompt, LegacyArtifactV5Package2Read, PublishedArtifactHead, PublishedArtifactHeadCore, Sha256Hex, } from "./artifact.js";
+export type { ArtifactObjectReadbackReceipt, FinalizeApprovedArtifactInput, FinalizeApprovedArtifactResult, PublishOperationKey, PublishAttemptState, PublishAttemptCoordinator, PublishedArtifactObjectReader, ResolvePublishedArtifactInput, ResolvedPublishedArtifact, SubmitFrozenArtifactInput, SubmittedPublishAttempt, WriteOnceArtifactObject, WriteOnceArtifactStore, WriteOncePutResult, } from "./publish-attempt.js";
+export { buildFrozenArtifactObjectKey, publishOperationKey, } from "./publish-attempt.js";
+export * from "./neutral-artifact-assembler.js";
+export * from "./bound-view-freeze.js";
+export * from "./server-bound-view-compiler.js";
+export type { ViewInteractionManifestV3, ViewInteractionSourceV3, } from "@world-engines/tmw/view-interaction-manifest-v3";
+export type { MusicCandidateSourceV3, } from "@world-engines/tmw/music-candidate-set";

package/dist/index.js

@@ -0,0 +1,8 @@
+export { appendJsonPointer, canonicalJson, compareUtf8, escapeJsonPointerToken, parseJsonPointer, sha256Hex, toJsonValue, unescapeJsonPointerToken, utf8ByteLength, } from "./canonical.js";
+export { buildScenarioReviewSnapshot, DEFAULT_SCENARIO_REVIEW_SNAPSHOT_LIMITS, reconstructRecordPayload, stableRelationId, } from "./snapshot.js";
+export { ARTIFACT_MANIFEST_VERSION_V5, ARTIFACT_PACKAGE_FORMAT_VERSION_V5, LEGACY_ARTIFACT_PACKAGE_FORMAT_VERSION_V5, CAPTURED_REVISION_SCHEMA_VERSION, FROZEN_PUBLISH_INPUT_SCHEMA_VERSION, FROZEN_DATABASE_DELIVERY_CODEC, FROZEN_DATABASE_DELIVERY_MEDIA_TYPE, FROZEN_DATABASE_DELIVERY_MAGIC, FROZEN_DATABASE_DELIVERY_RELATIVE_PATH, PUBLISHED_ARTIFACT_HEAD_SCHEMA_VERSION, } from "./artifact.js";
+export { artifactV5ManifestSha256, buildArtifactV5, buildFrozenArtifactBundle, buildPublishedArtifactHead, canonicalArtifactV5Bytes, canonicalBytes, canonicalPublishedArtifactHeadCoreBytes, canonicalSha256, digestPublishedArtifactHeadCore, parseArtifactV5, parseFrozenArtifactBundle, parseLegacyArtifactV5Package2, parsePublishedArtifactHead, } from "./artifact-digest.js";
+export { buildFrozenArtifactObjectKey, publishOperationKey, } from "./publish-attempt.js";
+export * from "./neutral-artifact-assembler.js";
+export * from "./bound-view-freeze.js";
+export * from "./server-bound-view-compiler.js";