@world-engines/scenario-author-source 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,46 @@
+WorldEngine 官方作者工具许可证
+
+版权所有 (c) 2026 Nixdorfer。保留所有权利。
+
+本仓库的源代码、构建材料及附带资源（统称“本作品”）不是开源软件，
+不适用任何 OSI 认证的开源许可证。
+
+一、官方作者工具分发许可
+
+版权所有者可以通过其官方网站、npm registry、签名安装包或其他官方渠道，
+复制并分发由本作品构建的 WorldEngine 作者工具及其必要运行资源
+（统称“官方作者工具”）。仅版权所有者或其书面指定的发布者享有此分发权。
+
+二、作者用户许可
+
+从官方渠道取得官方作者工具的作者用户，可以：
+
+1. 安装和运行官方作者工具；
+2. 使用官方作者工具创作、编辑、预览、导入、导出和提交其有权处理的内容；
+3. 为上述使用目的制作合理必要的本地备份副本。
+
+三、未授予的权利
+
+除第二条明确允许的行为外，本许可证不授予作者用户或其他第三方以下权利：
+
+1. 修改、改编、反编译、反汇编或制作官方作者工具的派生作品；
+2. 复制、镜像、转发、再上传、出售、出租、再分发或再许可官方作者工具；
+3. 使用本作品的源代码、构建材料或任何部分开发、提供或训练其他产品或服务；
+4. 删除或规避版权、许可、签名、访问控制或其他权利管理信息。
+
+法律强制允许且合同不得排除的权利不受上述限制影响。
+
+四、源代码查看
+
+第三方可以在已获合法访问权限的范围内查看本作品，用于审查、安全研究或学习参考；
+查看不授予运行、复制、修改、分发、再许可或用于其他产品与服务的权利。
+
+五、无担保与责任限制
+
+本作品与官方作者工具均按“现状”提供，不附带任何明示或暗示的担保。
+在适用法律允许的最大范围内，版权所有者不对因访问或使用本作品或官方作者工具
+造成的任何损失承担责任。
+
+六、终止
+
+违反本许可证将立即终止相应的访问与使用权；终止不影响版权所有者已经产生的权利和救济。

package/dist/author-source.d.ts

@@ -0,0 +1,12 @@
+import type { NeutralScenarioSource, ScenarioSourceManifest, ScenarioSourceSection, ScenarioSourceSectionIdentity } from "@world-engines/protocol-ts/v1/neutral_scenario_source";
+export declare const NEUTRAL_SCENARIO_SOURCE_SCHEMA_VERSION: 1;
+export declare const SCENARIO_SOURCE_MANIFEST_SCHEMA_VERSION: 1;
+export declare const REQUIRED_SCENARIO_SOURCE_SECTION_KEYS: readonly ["metadata", "logical_graph", "trigger_semantics", "layout", "view_project", "resource_refs", "prompt_retrieval"];
+export type RequiredScenarioSourceSectionKey = typeof REQUIRED_SCENARIO_SOURCE_SECTION_KEYS[number];
+export type { NeutralScenarioSource, ScenarioSourceManifest, ScenarioSourceSection, ScenarioSourceSectionIdentity, };
+export type ScenarioSourceUnknownFields = Readonly<Record<number, readonly Uint8Array[]>>;
+export declare class ScenarioSourceIntegrityError extends Error {
+    readonly code: string;
+    readonly path: string;
+    constructor(code: string, path: string);
+}

package/dist/author-source.js

@@ -0,0 +1,21 @@
+export const NEUTRAL_SCENARIO_SOURCE_SCHEMA_VERSION = 1;
+export const SCENARIO_SOURCE_MANIFEST_SCHEMA_VERSION = 1;
+export const REQUIRED_SCENARIO_SOURCE_SECTION_KEYS = Object.freeze([
+    "metadata",
+    "logical_graph",
+    "trigger_semantics",
+    "layout",
+    "view_project",
+    "resource_refs",
+    "prompt_retrieval",
+]);
+export class ScenarioSourceIntegrityError extends Error {
+    code;
+    path;
+    constructor(code, path) {
+        super(`${code}:${path}`);
+        this.name = "ScenarioSourceIntegrityError";
+        this.code = code;
+        this.path = path;
+    }
+}

package/dist/canonicalize.d.ts

@@ -0,0 +1,8 @@
+import type { NeutralScenarioSource, ScenarioSourceManifest, ScenarioSourceSection, ScenarioSourceSectionIdentity } from "./author-source.js";
+export declare function canonicalizeScenarioSourceSection(section: ScenarioSourceSection): ScenarioSourceSection;
+export declare function canonicalizeScenarioSourceSectionIdentity(identity: ScenarioSourceSectionIdentity): ScenarioSourceSectionIdentity;
+export declare function canonicalizeScenarioSourceManifest(manifest: ScenarioSourceManifest, clearDigest?: boolean): ScenarioSourceManifest;
+export declare function canonicalizeNeutralScenarioSource(source: NeutralScenarioSource): NeutralScenarioSource;
+export declare function canonicalScenarioSourceSectionBytes(section: ScenarioSourceSection): Uint8Array;
+export declare function canonicalScenarioSourceManifestDigestInputBytes(manifest: ScenarioSourceManifest): Uint8Array;
+export declare function canonicalNeutralScenarioSourceBytes(source: NeutralScenarioSource): Uint8Array;

package/dist/canonicalize.js

@@ -0,0 +1,76 @@
+import { NeutralScenarioSource as NeutralScenarioSourceCodec, ScenarioSourceManifest as ScenarioSourceManifestCodec, ScenarioSourceSection as ScenarioSourceSectionCodec, } from "@world-engines/protocol-ts/v1/neutral_scenario_source";
+function compareUtf8(left, right) {
+    const encoder = new TextEncoder();
+    const leftBytes = encoder.encode(left);
+    const rightBytes = encoder.encode(right);
+    const length = Math.min(leftBytes.length, rightBytes.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = (leftBytes[index] ?? 0) - (rightBytes[index] ?? 0);
+        if (difference !== 0)
+            return difference;
+    }
+    return leftBytes.length - rightBytes.length;
+}
+function cloneUnknownFields(fields) {
+    if (fields === undefined)
+        return undefined;
+    return Object.fromEntries(Object.entries(fields)
+        .sort(([left], [right]) => Number(left) - Number(right))
+        .map(([tag, values]) => [tag, values.map((value) => value.slice())]));
+}
+export function canonicalizeScenarioSourceSection(section) {
+    const unknownFields = cloneUnknownFields(section._unknownFields);
+    return Object.freeze({
+        section_key: section.section_key,
+        media_type: section.media_type,
+        canonical_encoding: section.canonical_encoding,
+        payload: section.payload.slice(),
+        ...(unknownFields === undefined ? {} : { _unknownFields: unknownFields }),
+    });
+}
+export function canonicalizeScenarioSourceSectionIdentity(identity) {
+    const unknownFields = cloneUnknownFields(identity._unknownFields);
+    return Object.freeze({
+        section_key: identity.section_key,
+        media_type: identity.media_type,
+        canonical_encoding: identity.canonical_encoding,
+        byte_length: identity.byte_length,
+        sha256: identity.sha256.slice(),
+        ...(unknownFields === undefined ? {} : { _unknownFields: unknownFields }),
+    });
+}
+export function canonicalizeScenarioSourceManifest(manifest, clearDigest = false) {
+    const unknownFields = cloneUnknownFields(manifest._unknownFields);
+    return Object.freeze({
+        manifest_schema_version: manifest.manifest_schema_version,
+        scenario_id: manifest.scenario_id,
+        sections: Object.freeze(manifest.sections
+            .map(canonicalizeScenarioSourceSectionIdentity)
+            .sort((left, right) => compareUtf8(left.section_key, right.section_key))),
+        manifest_sha256: clearDigest ? new Uint8Array(0) : manifest.manifest_sha256.slice(),
+        ...(unknownFields === undefined ? {} : { _unknownFields: unknownFields }),
+    });
+}
+export function canonicalizeNeutralScenarioSource(source) {
+    const unknownFields = cloneUnknownFields(source._unknownFields);
+    return Object.freeze({
+        source_schema_version: source.source_schema_version,
+        scenario_id: source.scenario_id,
+        manifest: source.manifest === undefined
+            ? undefined
+            : canonicalizeScenarioSourceManifest(source.manifest),
+        sections: Object.freeze(source.sections
+            .map(canonicalizeScenarioSourceSection)
+            .sort((left, right) => compareUtf8(left.section_key, right.section_key))),
+        ...(unknownFields === undefined ? {} : { _unknownFields: unknownFields }),
+    });
+}
+export function canonicalScenarioSourceSectionBytes(section) {
+    return ScenarioSourceSectionCodec.encode(canonicalizeScenarioSourceSection(section)).finish();
+}
+export function canonicalScenarioSourceManifestDigestInputBytes(manifest) {
+    return ScenarioSourceManifestCodec.encode(canonicalizeScenarioSourceManifest(manifest, true)).finish();
+}
+export function canonicalNeutralScenarioSourceBytes(source) {
+    return NeutralScenarioSourceCodec.encode(canonicalizeNeutralScenarioSource(source)).finish();
+}

package/dist/compile-input.d.ts

@@ -0,0 +1,35 @@
+import type { NeutralScenarioSource, ScenarioSourceManifest, ScenarioSourceSection } from "./author-source.js";
+export interface NeutralSourceCaptureWitness {
+    readonly owner_id: string;
+    readonly scenario_id: string;
+    readonly source_revision: number;
+    readonly manifest_digest: string;
+    readonly source_digest: string;
+    readonly revision_digest: string;
+    readonly previous_head_digest: string | null;
+    readonly head_digest: string;
+}
+/**
+ * Complete, immutable input captured from one neutral source head.
+ *
+ * Compiler stages may only consume this value plus a CompileTargetProfile.
+ * They must not retain a callback to the remote source or a Creator working
+ * projection.
+ */
+export interface NeutralSourceCompileInput {
+    readonly witness: NeutralSourceCaptureWitness;
+    readonly source: NeutralScenarioSource;
+    readonly manifest: ScenarioSourceManifest;
+    readonly source_bytes: Uint8Array;
+    readonly sections: readonly ScenarioSourceSection[];
+}
+export interface CaptureNeutralSourceCompileInput {
+    readonly witness: NeutralSourceCaptureWitness;
+    readonly source_bytes: Uint8Array;
+}
+/**
+ * Parses and validates one exact readback. No callback or mutable store is
+ * retained, so all work after this boundary is deterministic from the returned
+ * value.
+ */
+export declare const captureNeutralSourceCompileInput: (input: CaptureNeutralSourceCompileInput, subtle?: SubtleCrypto) => Promise<NeutralSourceCompileInput>;

package/dist/compile-input.js

@@ -0,0 +1,124 @@
+import { NeutralScenarioSource as NeutralScenarioSourceCodec, } from "@world-engines/protocol-ts/v1/neutral_scenario_source";
+import { bytesEqual, sha256Bytes, sha256Hex, } from "./integrity.js";
+import { verifyNeutralScenarioSource, } from "./manifest.js";
+const SHA256_HEX_PATTERN = /^[0-9a-f]{64}$/u;
+const requireIdentity = (value, field) => {
+    const normalized = value.normalize("NFC").trim();
+    if (normalized.length === 0 || normalized !== value) {
+        throw new Error(`neutral_compile_capture_${field}_invalid`);
+    }
+    return normalized;
+};
+const requireDigest = (value, field) => {
+    if (!SHA256_HEX_PATTERN.test(value)) {
+        throw new Error(`neutral_compile_capture_${field}_invalid`);
+    }
+    return value;
+};
+const cloneUnknownFields = (value) => {
+    if (value === undefined)
+        return undefined;
+    return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, entries]) => [
+        key,
+        Object.freeze(entries.map((entry) => entry.slice())),
+    ])));
+};
+const cloneSection = (section) => Object.freeze({
+    section_key: section.section_key,
+    media_type: section.media_type,
+    canonical_encoding: section.canonical_encoding,
+    payload: section.payload.slice(),
+    ...(section._unknownFields === undefined
+        ? {}
+        : { _unknownFields: cloneUnknownFields(section._unknownFields) }),
+});
+const cloneManifest = (manifest) => {
+    const sections = manifest.sections.map((section) => Object.freeze({
+        section_key: section.section_key,
+        media_type: section.media_type,
+        canonical_encoding: section.canonical_encoding,
+        byte_length: section.byte_length,
+        sha256: section.sha256.slice(),
+        ...(section._unknownFields === undefined
+            ? {}
+            : { _unknownFields: cloneUnknownFields(section._unknownFields) }),
+    }));
+    Object.freeze(sections);
+    return Object.freeze({
+        manifest_schema_version: manifest.manifest_schema_version,
+        scenario_id: manifest.scenario_id,
+        sections,
+        manifest_sha256: manifest.manifest_sha256.slice(),
+        ...(manifest._unknownFields === undefined
+            ? {}
+            : { _unknownFields: cloneUnknownFields(manifest._unknownFields) }),
+    });
+};
+const cloneSource = (source, manifest, sections) => {
+    const sourceSections = [...sections];
+    Object.freeze(sourceSections);
+    return Object.freeze({
+        source_schema_version: source.source_schema_version,
+        scenario_id: source.scenario_id,
+        manifest,
+        sections: sourceSections,
+        ...(source._unknownFields === undefined
+            ? {}
+            : { _unknownFields: cloneUnknownFields(source._unknownFields) }),
+    });
+};
+const copyWitness = (witness) => {
+    requireIdentity(witness.owner_id, "owner");
+    requireIdentity(witness.scenario_id, "scenario");
+    if (!Number.isSafeInteger(witness.source_revision)
+        || witness.source_revision < 1) {
+        throw new Error("neutral_compile_capture_revision_invalid");
+    }
+    requireDigest(witness.manifest_digest, "manifest_digest");
+    requireDigest(witness.source_digest, "source_digest");
+    requireDigest(witness.revision_digest, "revision_digest");
+    requireDigest(witness.head_digest, "head_digest");
+    if (witness.previous_head_digest !== null) {
+        requireDigest(witness.previous_head_digest, "previous_head_digest");
+    }
+    return Object.freeze({ ...witness });
+};
+/**
+ * Parses and validates one exact readback. No callback or mutable store is
+ * retained, so all work after this boundary is deterministic from the returned
+ * value.
+ */
+export const captureNeutralSourceCompileInput = async (input, subtle) => {
+    if (!(input.source_bytes instanceof Uint8Array)) {
+        throw new Error("neutral_compile_capture_source_bytes_invalid");
+    }
+    const witness = copyWitness(input.witness);
+    const sourceBytes = input.source_bytes.slice();
+    const sourceDigest = sha256Hex(await sha256Bytes(sourceBytes, subtle));
+    if (sourceDigest !== witness.source_digest) {
+        throw new Error("neutral_compile_capture_source_digest_mismatch");
+    }
+    const parsed = await verifyNeutralScenarioSource(NeutralScenarioSourceCodec.decode(sourceBytes), subtle);
+    const parsedManifest = parsed.manifest;
+    if (parsedManifest === undefined) {
+        throw new Error("neutral_compile_capture_manifest_missing");
+    }
+    if (parsed.scenario_id !== witness.scenario_id
+        || parsedManifest.scenario_id !== witness.scenario_id) {
+        throw new Error("neutral_compile_capture_scenario_mismatch");
+    }
+    const manifestDigest = Uint8Array.from(witness.manifest_digest.match(/../gu) ?? [], (octet) => Number.parseInt(octet, 16));
+    if (!bytesEqual(parsedManifest.manifest_sha256, manifestDigest)) {
+        throw new Error("neutral_compile_capture_manifest_digest_mismatch");
+    }
+    const manifest = cloneManifest(parsedManifest);
+    const sections = Object.freeze(parsed.sections.map(cloneSection));
+    const source = cloneSource(parsed, manifest, sections);
+    return Object.freeze({
+        witness,
+        source,
+        manifest,
+        source_bytes: sourceBytes,
+        sections,
+    });
+};

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import { type ScenarioSourceSection } from "@world-engines/protocol-ts/v1/neutral_scenario_source";
+import { REQUIRED_SCENARIO_SOURCE_SECTION_KEYS, type NeutralScenarioSource } from "./author-source.js";
+import { canonicalNeutralScenarioSourceBytes, canonicalizeNeutralScenarioSource } from "./canonicalize.js";
+export * from "./author-source.js";
+export * from "./canonicalize.js";
+export * from "./compile-input.js";
+export * from "./integrity.js";
+export * from "./manifest.js";
+export interface EmptyScenarioSourceSectionOverride {
+    readonly media_type: string;
+    readonly canonical_encoding: string;
+    readonly payload: Uint8Array;
+}
+export interface CreateCanonicalEmptyNeutralScenarioSourceInput {
+    readonly scenario_id: string;
+    readonly section_overrides?: Partial<Readonly<Record<typeof REQUIRED_SCENARIO_SOURCE_SECTION_KEYS[number], EmptyScenarioSourceSectionOverride>>>;
+}
+export declare function createNeutralScenarioSource(scenarioId: string, sections: readonly ScenarioSourceSection[], subtle?: SubtleCrypto): Promise<NeutralScenarioSource>;
+export declare function parseNeutralScenarioSource(bytes: Uint8Array, subtle?: SubtleCrypto): Promise<NeutralScenarioSource>;
+export declare function decodeNeutralScenarioSource(bytes: Uint8Array, subtle?: SubtleCrypto): Promise<NeutralScenarioSource>;
+export declare function encodeNeutralScenarioSource(source: NeutralScenarioSource, subtle?: SubtleCrypto): Promise<Uint8Array>;
+export declare function createCanonicalEmptyNeutralScenarioSource(input: CreateCanonicalEmptyNeutralScenarioSourceInput, subtle?: SubtleCrypto): Promise<NeutralScenarioSource>;
+export declare function hashNeutralScenarioSource(source: NeutralScenarioSource, subtle?: SubtleCrypto): Promise<string>;
+export { canonicalNeutralScenarioSourceBytes, canonicalizeNeutralScenarioSource, };

package/dist/index.js

@@ -0,0 +1,48 @@
+import { NeutralScenarioSource as NeutralScenarioSourceCodec, } from "@world-engines/protocol-ts/v1/neutral_scenario_source";
+import { NEUTRAL_SCENARIO_SOURCE_SCHEMA_VERSION, REQUIRED_SCENARIO_SOURCE_SECTION_KEYS, } from "./author-source.js";
+import { canonicalNeutralScenarioSourceBytes, canonicalizeNeutralScenarioSource, } from "./canonicalize.js";
+import { sha256Bytes, sha256Hex, } from "./integrity.js";
+import { buildScenarioSourceManifest, verifyNeutralScenarioSource, } from "./manifest.js";
+export * from "./author-source.js";
+export * from "./canonicalize.js";
+export * from "./compile-input.js";
+export * from "./integrity.js";
+export * from "./manifest.js";
+export async function createNeutralScenarioSource(scenarioId, sections, subtle) {
+    const source = {
+        source_schema_version: NEUTRAL_SCENARIO_SOURCE_SCHEMA_VERSION,
+        scenario_id: scenarioId,
+        manifest: await buildScenarioSourceManifest(scenarioId, sections, subtle),
+        sections: [...sections],
+    };
+    return verifyNeutralScenarioSource(source, subtle);
+}
+export async function parseNeutralScenarioSource(bytes, subtle) {
+    if (!(bytes instanceof Uint8Array))
+        throw new TypeError("neutral_source_bytes_required");
+    return verifyNeutralScenarioSource(NeutralScenarioSourceCodec.decode(bytes), subtle);
+}
+export async function decodeNeutralScenarioSource(bytes, subtle) {
+    return parseNeutralScenarioSource(bytes, subtle);
+}
+export async function encodeNeutralScenarioSource(source, subtle) {
+    const verified = await verifyNeutralScenarioSource(source, subtle);
+    return canonicalNeutralScenarioSourceBytes(verified);
+}
+export async function createCanonicalEmptyNeutralScenarioSource(input, subtle) {
+    const sections = REQUIRED_SCENARIO_SOURCE_SECTION_KEYS.map((sectionKey) => {
+        const override = input.section_overrides?.[sectionKey];
+        return {
+            section_key: sectionKey,
+            media_type: override?.media_type ?? "application/octet-stream",
+            canonical_encoding: override?.canonical_encoding ?? "opaque-bytes-v1",
+            payload: override?.payload.slice() ?? new Uint8Array(0),
+        };
+    });
+    return createNeutralScenarioSource(input.scenario_id, sections, subtle);
+}
+export async function hashNeutralScenarioSource(source, subtle) {
+    const verified = await verifyNeutralScenarioSource(source, subtle);
+    return sha256Hex(await sha256Bytes(canonicalNeutralScenarioSourceBytes(verified), subtle));
+}
+export { canonicalNeutralScenarioSourceBytes, canonicalizeNeutralScenarioSource, };

package/dist/integrity.d.ts

@@ -0,0 +1,13 @@
+export declare function assertStableIdentifier(value: unknown, path: string): asserts value is string;
+export declare function assertSectionKey(value: unknown, path: string): asserts value is string;
+export declare function assertDescriptorText(value: unknown, path: string): asserts value is string;
+export declare function parseCanonicalByteLength(value: unknown, path: string): bigint;
+export declare function assertSha256Bytes(value: unknown, path: string): asserts value is Uint8Array;
+export declare function bytesEqual(left: Uint8Array, right: Uint8Array): boolean;
+export declare function sha256Bytes(bytes: Uint8Array, subtle?: SubtleCrypto): Promise<Uint8Array>;
+export declare function sha256Hex(bytes: Uint8Array): string;
+export declare function assertUnknownFields(value: {
+    readonly _unknownFields?: {
+        [key: number]: Uint8Array[];
+    } | undefined;
+}, path: string): void;

package/dist/integrity.js

@@ -0,0 +1,78 @@
+import { ScenarioSourceIntegrityError } from "./author-source.js";
+const SHA256_BYTE_LENGTH = 32;
+const SECTION_KEY_PATTERN = /^[a-z][a-z0-9_.-]{0,127}$/u;
+const DECIMAL_UINT_PATTERN = /^(?:0|[1-9][0-9]*)$/u;
+const MAX_PROTO_FIELD_NUMBER = 536_870_911;
+export function assertStableIdentifier(value, path) {
+    if (typeof value !== "string" || value.length === 0 || value !== value.trim().normalize("NFC")) {
+        throw new ScenarioSourceIntegrityError("identifier_invalid", path);
+    }
+}
+export function assertSectionKey(value, path) {
+    if (typeof value !== "string" || !SECTION_KEY_PATTERN.test(value) || value !== value.normalize("NFC")) {
+        throw new ScenarioSourceIntegrityError("section_key_invalid", path);
+    }
+}
+export function assertDescriptorText(value, path) {
+    if (typeof value !== "string"
+        || value.length === 0
+        || value.length > 255
+        || value !== value.trim().normalize("NFC")) {
+        throw new ScenarioSourceIntegrityError("section_descriptor_invalid", path);
+    }
+}
+export function parseCanonicalByteLength(value, path) {
+    if (typeof value !== "string" || !DECIMAL_UINT_PATTERN.test(value)) {
+        throw new ScenarioSourceIntegrityError("byte_length_invalid", path);
+    }
+    try {
+        return BigInt(value);
+    }
+    catch {
+        throw new ScenarioSourceIntegrityError("byte_length_invalid", path);
+    }
+}
+export function assertSha256Bytes(value, path) {
+    if (!(value instanceof Uint8Array) || value.byteLength !== SHA256_BYTE_LENGTH) {
+        throw new ScenarioSourceIntegrityError("sha256_invalid", path);
+    }
+}
+export 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;
+}
+export async function sha256Bytes(bytes, subtle = globalThis.crypto.subtle) {
+    const input = bytes.slice();
+    return new Uint8Array(await subtle.digest("SHA-256", input));
+}
+export function sha256Hex(bytes) {
+    return Array.from(bytes, (value) => value.toString(16).padStart(2, "0")).join("");
+}
+export function assertUnknownFields(value, path) {
+    if (value._unknownFields === undefined)
+        return;
+    if (typeof value._unknownFields !== "object" || value._unknownFields === null) {
+        throw new ScenarioSourceIntegrityError("unknown_fields_invalid", path);
+    }
+    for (const [rawTag, buffers] of Object.entries(value._unknownFields)) {
+        if (!/^[1-9][0-9]*$/u.test(rawTag) || !Array.isArray(buffers) || buffers.length === 0) {
+            throw new ScenarioSourceIntegrityError("unknown_fields_invalid", `${path}/${rawTag}`);
+        }
+        const tag = Number(rawTag);
+        const fieldNumber = Math.floor(tag / 8);
+        const wireType = tag & 7;
+        if (!Number.isSafeInteger(tag)
+            || tag > 0xffff_ffff
+            || fieldNumber < 1
+            || fieldNumber > MAX_PROTO_FIELD_NUMBER
+            || ![0, 1, 2, 3, 5].includes(wireType)
+            || buffers.some((buffer) => !(buffer instanceof Uint8Array))) {
+            throw new ScenarioSourceIntegrityError("unknown_fields_invalid", `${path}/${rawTag}`);
+        }
+    }
+}

package/dist/manifest.d.ts

@@ -0,0 +1,4 @@
+import type { NeutralScenarioSource, ScenarioSourceManifest, ScenarioSourceSection } from "./author-source.js";
+export declare function buildScenarioSourceManifest(scenarioId: string, sections: readonly ScenarioSourceSection[], subtle?: SubtleCrypto): Promise<ScenarioSourceManifest>;
+export declare function verifyScenarioSourceManifest(manifest: ScenarioSourceManifest, sections: readonly ScenarioSourceSection[], expectedScenarioId?: string, subtle?: SubtleCrypto): Promise<ScenarioSourceManifest>;
+export declare function verifyNeutralScenarioSource(source: NeutralScenarioSource, subtle?: SubtleCrypto): Promise<NeutralScenarioSource>;

package/dist/manifest.js

@@ -0,0 +1,131 @@
+import { NeutralScenarioSource as NeutralScenarioSourceCodec, ScenarioSourceSection as ScenarioSourceSectionCodec, } from "@world-engines/protocol-ts/v1/neutral_scenario_source";
+import { NEUTRAL_SCENARIO_SOURCE_SCHEMA_VERSION, REQUIRED_SCENARIO_SOURCE_SECTION_KEYS, SCENARIO_SOURCE_MANIFEST_SCHEMA_VERSION, ScenarioSourceIntegrityError, } from "./author-source.js";
+import { canonicalizeNeutralScenarioSource, canonicalizeScenarioSourceManifest, canonicalNeutralScenarioSourceBytes, canonicalScenarioSourceManifestDigestInputBytes, canonicalScenarioSourceSectionBytes, } from "./canonicalize.js";
+import { assertDescriptorText, assertSectionKey, assertSha256Bytes, assertStableIdentifier, assertUnknownFields, bytesEqual, parseCanonicalByteLength, sha256Bytes, } from "./integrity.js";
+function assertUniqueCompleteSectionKeys(keys, path) {
+    const seen = new Set();
+    for (const [index, key] of keys.entries()) {
+        assertSectionKey(key, `${path}/${index}/section_key`);
+        if (seen.has(key)) {
+            throw new ScenarioSourceIntegrityError("section_key_duplicate", `${path}/${index}/section_key`);
+        }
+        seen.add(key);
+    }
+    for (const required of REQUIRED_SCENARIO_SOURCE_SECTION_KEYS) {
+        if (!seen.has(required)) {
+            throw new ScenarioSourceIntegrityError("required_section_missing", `${path}/${required}`);
+        }
+    }
+}
+function validateSection(section, index) {
+    const path = `$/sections/${index}`;
+    assertSectionKey(section.section_key, `${path}/section_key`);
+    assertDescriptorText(section.media_type, `${path}/media_type`);
+    assertDescriptorText(section.canonical_encoding, `${path}/canonical_encoding`);
+    if (!(section.payload instanceof Uint8Array)) {
+        throw new ScenarioSourceIntegrityError("section_payload_invalid", `${path}/payload`);
+    }
+    assertUnknownFields(section, `${path}/_unknownFields`);
+    try {
+        ScenarioSourceSectionCodec.decode(canonicalScenarioSourceSectionBytes(section));
+    }
+    catch {
+        throw new ScenarioSourceIntegrityError("section_wire_invalid", path);
+    }
+}
+async function buildSectionIdentity(section, subtle) {
+    const bytes = canonicalScenarioSourceSectionBytes(section);
+    return Object.freeze({
+        section_key: section.section_key,
+        media_type: section.media_type,
+        canonical_encoding: section.canonical_encoding,
+        byte_length: String(bytes.byteLength),
+        sha256: await sha256Bytes(bytes, subtle),
+    });
+}
+export async function buildScenarioSourceManifest(scenarioId, sections, subtle) {
+    assertStableIdentifier(scenarioId, "$/scenario_id");
+    sections.forEach(validateSection);
+    assertUniqueCompleteSectionKeys(sections.map((section) => section.section_key), "$/sections");
+    const identities = await Promise.all(sections.map((section) => buildSectionIdentity(section, subtle)));
+    const core = {
+        manifest_schema_version: SCENARIO_SOURCE_MANIFEST_SCHEMA_VERSION,
+        scenario_id: scenarioId,
+        sections: identities,
+        manifest_sha256: new Uint8Array(0),
+    };
+    const canonicalCore = canonicalizeScenarioSourceManifest(core, true);
+    return canonicalizeScenarioSourceManifest({
+        ...canonicalCore,
+        manifest_sha256: await sha256Bytes(canonicalScenarioSourceManifestDigestInputBytes(canonicalCore), subtle),
+    });
+}
+export async function verifyScenarioSourceManifest(manifest, sections, expectedScenarioId = manifest.scenario_id, subtle) {
+    assertUnknownFields(manifest, "$/manifest/_unknownFields");
+    if (manifest.manifest_schema_version !== SCENARIO_SOURCE_MANIFEST_SCHEMA_VERSION) {
+        throw new ScenarioSourceIntegrityError("manifest_schema_version_invalid", "$/manifest/manifest_schema_version");
+    }
+    assertStableIdentifier(manifest.scenario_id, "$/manifest/scenario_id");
+    assertStableIdentifier(expectedScenarioId, "$/scenario_id");
+    if (manifest.scenario_id !== expectedScenarioId) {
+        throw new ScenarioSourceIntegrityError("manifest_scenario_mismatch", "$/manifest/scenario_id");
+    }
+    assertSha256Bytes(manifest.manifest_sha256, "$/manifest/manifest_sha256");
+    sections.forEach(validateSection);
+    assertUniqueCompleteSectionKeys(sections.map((section) => section.section_key), "$/sections");
+    assertUniqueCompleteSectionKeys(manifest.sections.map((identity) => identity.section_key), "$/manifest/sections");
+    if (manifest.sections.length !== sections.length) {
+        throw new ScenarioSourceIntegrityError("manifest_section_count_mismatch", "$/manifest/sections");
+    }
+    const sectionByKey = new Map(sections.map((section) => [section.section_key, section]));
+    for (const [index, identity] of manifest.sections.entries()) {
+        const path = `$/manifest/sections/${index}`;
+        assertDescriptorText(identity.media_type, `${path}/media_type`);
+        assertDescriptorText(identity.canonical_encoding, `${path}/canonical_encoding`);
+        assertUnknownFields(identity, `${path}/_unknownFields`);
+        assertSha256Bytes(identity.sha256, `${path}/sha256`);
+        const byteLength = parseCanonicalByteLength(identity.byte_length, `${path}/byte_length`);
+        const section = sectionByKey.get(identity.section_key);
+        if (section === undefined) {
+            throw new ScenarioSourceIntegrityError("manifest_section_missing", `${path}/section_key`);
+        }
+        if (identity.media_type !== section.media_type
+            || identity.canonical_encoding !== section.canonical_encoding) {
+            throw new ScenarioSourceIntegrityError("manifest_section_descriptor_mismatch", path);
+        }
+        const sectionBytes = canonicalScenarioSourceSectionBytes(section);
+        const sectionSha256 = await sha256Bytes(sectionBytes, subtle);
+        if (byteLength !== BigInt(sectionBytes.byteLength)
+            || !bytesEqual(identity.sha256, sectionSha256)) {
+            throw new ScenarioSourceIntegrityError("manifest_section_identity_mismatch", path);
+        }
+    }
+    const expectedDigest = await sha256Bytes(canonicalScenarioSourceManifestDigestInputBytes(manifest), subtle);
+    if (!bytesEqual(manifest.manifest_sha256, expectedDigest)) {
+        throw new ScenarioSourceIntegrityError("manifest_digest_mismatch", "$/manifest/manifest_sha256");
+    }
+    return canonicalizeScenarioSourceManifest(manifest);
+}
+export async function verifyNeutralScenarioSource(source, subtle) {
+    assertUnknownFields(source, "$/_unknownFields");
+    if (source.source_schema_version !== NEUTRAL_SCENARIO_SOURCE_SCHEMA_VERSION) {
+        throw new ScenarioSourceIntegrityError("source_schema_version_invalid", "$/source_schema_version");
+    }
+    assertStableIdentifier(source.scenario_id, "$/scenario_id");
+    if (source.manifest === undefined) {
+        throw new ScenarioSourceIntegrityError("source_manifest_missing", "$/manifest");
+    }
+    await verifyScenarioSourceManifest(source.manifest, source.sections, source.scenario_id, subtle);
+    const canonical = canonicalizeNeutralScenarioSource(source);
+    const canonicalBytes = canonicalNeutralScenarioSourceBytes(canonical);
+    try {
+        const decoded = NeutralScenarioSourceCodec.decode(canonicalBytes);
+        if (!bytesEqual(canonicalBytes, canonicalNeutralScenarioSourceBytes(decoded))) {
+            throw new Error("non_exact");
+        }
+    }
+    catch {
+        throw new ScenarioSourceIntegrityError("source_wire_invalid", "$");
+    }
+    return canonical;
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@world-engines/scenario-author-source",
+  "private": false,
+  "version": "0.1.0-alpha.0",
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@world-engines/protocol-ts": "0.1.0-alpha.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "worldengine_source_sha256": "004d61441204b40d0272737cad6611562a9b4d3786cc9e1f0d516e5d452097bf",
+  "worldengine_source_identity_provenance": {
+    "schema": "worldengine-public-namespace-projection/v1",
+    "kind": "composite-source-identity; namespace projection; not-full-source-recompile",
+    "original_name": "@chat/scenario-author-source",
+    "original_archive_sha256": "3769ee18906b258e4028bbf5f1ad01b81055ca6a86cd9dee08ef921147e1f743",
+    "original_source_sha256": "13c4e329bd8dd47c90550b434f1aba0f8436afc32c7cdef2786ce12e394fd706",
+    "projected_name": "@world-engines/scenario-author-source",
+    "package_name_mapping": {
+      "@chat/blocks-editor": "@world-engines/blocks-editor",
+      "@chat/ladybug-bridge": "@world-engines/ladybug-bridge",
+      "@chat/monaco-host": "@world-engines/monaco-host",
+      "@chat/protocol-ts": "@world-engines/protocol-ts",
+      "@chat/scenario-author-source": "@world-engines/scenario-author-source",
+      "@chat/scenario-review-snapshot": "@world-engines/scenario-review-snapshot",
+      "@chat/tmw": "@world-engines/tmw",
+      "@chat/view-exposure": "@world-engines/view-exposure",
+      "@world-engines/chatplay-vite-plugin": "@world-engines/chatplay-vite-plugin",
+      "@worldengine/agent-kit": "@world-engines/agent-kit",
+      "@worldengine/authoring-bridge": "@world-engines/authoring-bridge",
+      "@worldengine/authoring-ui": "@world-engines/authoring-ui",
+      "@worldengine/create-project": "@world-engines/create-project",
+      "@worldengine/project-format": "@world-engines/project-format",
+      "@worldengine/project-host": "@world-engines/project-host",
+      "@worldengine/project-setup": "@world-engines/project-setup",
+      "@worldengine/spatial-authoring": "@world-engines/spatial-authoring",
+      "@worldengine/view-sdk": "@world-engines/view-sdk"
+    }
+  }
+}