@series-inc/rundot-syncplay 5.23.0-beta.7

package/dist/cjs/asset-cooking.js

@@ -0,0 +1,372 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cookDeterministicAssets = cookDeterministicAssets;
+exports.stableAssetCookJson = stableAssetCookJson;
+exports.materializePrototypeEntities = materializePrototypeEntities;
+exports.materializeDeterministicMapEntities = materializeDeterministicMapEntities;
+exports.validatePrototypeEntitiesAgainstFrameRuntime = validatePrototypeEntitiesAgainstFrameRuntime;
+exports.assertAssetManifestMatches = assertAssetManifestMatches;
+const canonical_js_1 = require("./canonical.js");
+const engine_runtime_js_1 = require("./engine-runtime.js");
+function cookDeterministicAssets(source) {
+    validateAssetSource(source);
+    const engineVersion = source.engineVersion ?? 'rdm-assets@1';
+    const dependencies = [...(source.dependencies ?? [])]
+        .map((dependency) => (0, canonical_js_1.cloneCanonical)(dependency))
+        .sort(compareDependencies);
+    const schemaHash = (0, canonical_js_1.defaultChecksum)({
+        kind: 'deterministic-asset-schema',
+        schemaVersion: 1,
+        requiredFields: ['id'],
+        optionalFields: ['type', 'references', 'prototype'],
+        numericPolicy: 'integer-only',
+        dependencyVersionPolicy: 'exact',
+    });
+    const dependencyHash = (0, canonical_js_1.defaultChecksum)(dependencies);
+    const assets = source.assets
+        .map((asset) => (0, canonical_js_1.cloneCanonical)(asset))
+        .sort((left, right) => compareStrings(left.id, right.id));
+    const cookedAssets = assets.map((asset) => {
+        const data = (0, canonical_js_1.cloneCanonical)(asset);
+        return {
+            id: asset.id,
+            type: asset.type ?? 'asset',
+            hash: (0, canonical_js_1.defaultChecksum)({ id: asset.id, data }),
+            data,
+        };
+    });
+    const lookup = Object.fromEntries(cookedAssets.map((asset, index) => [asset.id, index]));
+    const prototypeIds = cookedAssets
+        .filter((asset) => asset.data.prototype === true)
+        .map((asset) => asset.id)
+        .sort(compareStrings);
+    const withoutHash = {
+        schemaVersion: 1,
+        schemaHash,
+        engineVersion,
+        dependencyHash,
+        dependencies,
+        lookupHash: (0, canonical_js_1.defaultChecksum)(lookup),
+        prototypeIds,
+        assetCount: cookedAssets.length,
+        assets: cookedAssets.map((asset) => ({
+            id: asset.id,
+            type: asset.type,
+            hash: asset.hash,
+        })),
+    };
+    const manifest = {
+        ...withoutHash,
+        assetDbHash: (0, canonical_js_1.defaultChecksum)({ engineVersion, schemaHash, dependencyHash, dependencies, cookedAssets }),
+    };
+    const bytes = (0, canonical_js_1.canonicalStringify)({
+        manifest,
+        assets: cookedAssets,
+    });
+    return {
+        manifest,
+        cookedAssets,
+        bytes,
+    };
+}
+function stableAssetCookJson(result) {
+    return `${(0, canonical_js_1.canonicalStringify)(result)}\n`;
+}
+function materializePrototypeEntities(cooked, prototypeId, count, options = {}) {
+    if (!Number.isInteger(count) || count < 0) {
+        throw new Error('Prototype count must be a non-negative integer');
+    }
+    const startEntityId = options.startEntityId ?? 1;
+    if (!Number.isInteger(startEntityId) || startEntityId <= 0) {
+        throw new Error('Prototype start entity id must be a positive integer');
+    }
+    const prototype = cooked.cookedAssets.find((asset) => asset.id === prototypeId);
+    if (prototype === undefined) {
+        throw new Error(`Unknown prototype ${prototypeId}`);
+    }
+    if (!cooked.manifest.prototypeIds.includes(prototypeId)) {
+        throw new Error(`Asset ${prototypeId} is not a prototype`);
+    }
+    const components = resolvePrototypeComponents(cooked, prototypeId, new Set());
+    const overrides = options.componentOverrides === undefined
+        ? {}
+        : recordOrThrow(options.componentOverrides, `Prototype ${prototypeId} overrides`);
+    const resolvedComponents = mergeRecords(components, overrides);
+    return Array.from({ length: count }, (_, index) => ({
+        entityId: startEntityId + index,
+        prototypeId,
+        assetDbHash: cooked.manifest.assetDbHash,
+        components: materializeDynamicCollections(resolvedComponents),
+    }));
+}
+function materializeDeterministicMapEntities(cooked, mapId, options = {}) {
+    const mapAsset = cooked.cookedAssets.find((asset) => asset.id === mapId);
+    if (mapAsset === undefined) {
+        throw new Error(`Unknown map ${mapId}`);
+    }
+    if (mapAsset.type !== 'map') {
+        throw new Error(`Asset ${mapId} is not a map`);
+    }
+    const mapData = recordOrThrow(mapAsset.data, `Map ${mapId}`);
+    const spawns = mapData.spawns;
+    if (!Array.isArray(spawns)) {
+        throw new Error(`Map ${mapId} requires a spawns array`);
+    }
+    const materialized = [];
+    const prototypeIds = [];
+    const usedEntityIds = new Set();
+    let nextEntityId = options.startEntityId ?? 1;
+    for (const [index, spawn] of spawns.entries()) {
+        const spawnRecord = recordOrThrow(spawn, `Map ${mapId}.spawns[${index}]`);
+        const prototypeRef = spawnRecord.prototypeRef;
+        if (typeof prototypeRef !== 'string') {
+            throw new Error(`Map ${mapId}.spawns[${index}].prototypeRef must be a string`);
+        }
+        const count = optionalInteger(spawnRecord.count, `Map ${mapId}.spawns[${index}].count`) ?? 1;
+        if (!Number.isInteger(count) || count < 0) {
+            throw new Error(`Map ${mapId}.spawns[${index}].count must be a non-negative integer`);
+        }
+        const startEntityId = optionalInteger(spawnRecord.startEntityId, `Map ${mapId}.spawns[${index}].startEntityId`) ?? nextEntityId;
+        if (!Number.isInteger(startEntityId) || startEntityId <= 0) {
+            throw new Error(`Map ${mapId}.spawns[${index}].startEntityId must be a positive integer`);
+        }
+        const entities = materializePrototypeEntities(cooked, prototypeRef, count, {
+            startEntityId,
+            componentOverrides: spawnRecord.overrides,
+        });
+        for (const entity of entities) {
+            if (usedEntityIds.has(entity.entityId)) {
+                throw new Error(`Map ${mapId}.spawns[${index}] duplicates entityId ${entity.entityId}`);
+            }
+            usedEntityIds.add(entity.entityId);
+        }
+        materialized.push(...entities);
+        prototypeIds.push(prototypeRef);
+        nextEntityId = Math.max(nextEntityId, startEntityId + count);
+    }
+    const withoutChecksum = {
+        mapId,
+        assetDbHash: cooked.manifest.assetDbHash,
+        mapBakeHash: (0, canonical_js_1.defaultChecksum)({ mapId, assetDbHash: cooked.manifest.assetDbHash, materialized }),
+        spawnCount: spawns.length,
+        materializedEntityCount: materialized.length,
+        prototypeIds: [...new Set(prototypeIds)].sort(compareStrings),
+        materializedEntities: materialized,
+    };
+    return {
+        ...withoutChecksum,
+        checksum: (0, canonical_js_1.defaultChecksum)(withoutChecksum),
+    };
+}
+function validatePrototypeEntitiesAgainstFrameRuntime(cooked, prototypeId, descriptor, count = 1) {
+    const runtime = (0, engine_runtime_js_1.createDeterministicFrameRuntime)(descriptor, 0);
+    const entities = materializePrototypeEntities(cooked, prototypeId, count);
+    let injectedComponentCount = 0;
+    for (const materialized of entities) {
+        const runtimeEntity = runtime.createEntity();
+        const components = recordOrThrow(materialized.components, `Prototype ${prototypeId} components`);
+        for (const componentId of Object.keys(components).sort(compareStrings)) {
+            const data = recordOrThrow(components[componentId], `Prototype ${prototypeId}.${componentId}`);
+            runtime.setComponent(runtimeEntity, componentId, (0, canonical_js_1.cloneCanonical)(data));
+            injectedComponentCount += 1;
+        }
+    }
+    const snapshot = runtime.snapshot();
+    const result = {
+        prototypeId,
+        materializedEntityCount: entities.length,
+        injectedComponentCount,
+        descriptorComponentCount: descriptor.components.filter((component) => component.singleton !== true).length,
+        runtimeSnapshotChecksum: snapshot.checksum,
+    };
+    return {
+        ...result,
+        checksum: (0, canonical_js_1.defaultChecksum)(result),
+    };
+}
+function assertAssetManifestMatches(manifest, expected) {
+    if (expected.engineVersion !== undefined && manifest.engineVersion !== expected.engineVersion) {
+        throw new Error(`Stale deterministic asset engine: expected ${expected.engineVersion}, actual ${manifest.engineVersion}`);
+    }
+    if (expected.assetDbHash !== undefined && manifest.assetDbHash !== expected.assetDbHash) {
+        throw new Error(`Stale deterministic asset database hash: expected ${expected.assetDbHash}, actual ${manifest.assetDbHash}`);
+    }
+}
+function validateAssetSource(source) {
+    if (!Array.isArray(source.assets)) {
+        throw new Error('Deterministic asset source requires an assets array');
+    }
+    if (source.schemaVersion !== undefined && source.schemaVersion !== 1) {
+        throw new Error(`Unsupported deterministic asset schema ${source.schemaVersion}`);
+    }
+    validateDependencies(source.dependencies ?? []);
+    const ids = new Set();
+    for (const asset of source.assets) {
+        if (typeof asset.id !== 'string' || asset.id.length === 0) {
+            throw new Error('Every deterministic asset requires a non-empty string id');
+        }
+        if (ids.has(asset.id)) {
+            throw new Error(`Duplicate deterministic asset id ${asset.id}`);
+        }
+        ids.add(asset.id);
+        rejectUnquantizedNumbers(asset, asset.id);
+    }
+    for (const asset of source.assets) {
+        for (const reference of asset.references ?? []) {
+            if (!ids.has(reference)) {
+                throw new Error(`Unresolved deterministic asset reference ${asset.id} -> ${reference}`);
+            }
+        }
+        validateImplicitAssetRefs(asset, ids, asset.id);
+    }
+}
+function validateImplicitAssetRefs(value, ids, path) {
+    if (Array.isArray(value)) {
+        value.forEach((entry, index) => validateImplicitAssetRefs(entry, ids, `${path}[${index}]`));
+        return;
+    }
+    if (value === null || typeof value !== 'object') {
+        return;
+    }
+    for (const key of Object.keys(value).sort(compareStrings)) {
+        const entry = value[key];
+        const entryPath = `${path}.${key}`;
+        if (key.endsWith('Ref') && typeof entry === 'string' && !ids.has(entry)) {
+            throw new Error(`Unresolved deterministic asset ref ${entryPath} -> ${entry}`);
+        }
+        if (key.endsWith('Refs') && Array.isArray(entry)) {
+            for (const [index, ref] of entry.entries()) {
+                if (typeof ref === 'string' && !ids.has(ref)) {
+                    throw new Error(`Unresolved deterministic asset ref ${entryPath}[${index}] -> ${ref}`);
+                }
+            }
+        }
+        validateImplicitAssetRefs(entry, ids, entryPath);
+    }
+}
+function recordOrThrow(value, label) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${label} must be an object`);
+    }
+    return value;
+}
+function resolvePrototypeComponents(cooked, prototypeId, seen) {
+    if (seen.has(prototypeId)) {
+        throw new Error(`Prototype inheritance cycle at ${prototypeId}`);
+    }
+    seen.add(prototypeId);
+    const prototype = cooked.cookedAssets.find((asset) => asset.id === prototypeId);
+    if (prototype === undefined) {
+        throw new Error(`Unknown prototype ${prototypeId}`);
+    }
+    const data = recordOrThrow(prototype.data, `Prototype ${prototypeId}`);
+    const parentRef = data.extendsRef;
+    const parent = parentRef === undefined
+        ? {}
+        : resolvePrototypeComponents(cooked, stringOrThrow(parentRef, `Prototype ${prototypeId}.extendsRef`), seen);
+    const own = data.components === undefined
+        ? {}
+        : recordOrThrow(data.components, `Prototype ${prototypeId} components`);
+    return mergeRecords(parent, own);
+}
+function mergeRecords(base, override) {
+    const merged = {};
+    for (const key of [...new Set([...stableRecordKeys(base), ...stableRecordKeys(override)])].sort(compareStrings)) {
+        const baseValue = base[key];
+        const overrideValue = override[key];
+        if (overrideValue === undefined) {
+            merged[key] = (0, canonical_js_1.cloneCanonical)(baseValue);
+        }
+        else if (isPlainRecord(baseValue) && isPlainRecord(overrideValue) && !isCollectionDescriptor(overrideValue)) {
+            merged[key] = mergeRecords(baseValue, overrideValue);
+        }
+        else {
+            merged[key] = (0, canonical_js_1.cloneCanonical)(overrideValue);
+        }
+    }
+    return merged;
+}
+function materializeDynamicCollections(value) {
+    if (Array.isArray(value)) {
+        return value.map(materializeDynamicCollections);
+    }
+    if (!isPlainRecord(value)) {
+        return (0, canonical_js_1.cloneCanonical)(value);
+    }
+    if (isCollectionDescriptor(value)) {
+        const kind = stringOrThrow(value.collection, 'collection');
+        if (kind === 'list' || kind === 'buffer') {
+            const values = Array.isArray(value.values) ? value.values : [];
+            return values.map(materializeDynamicCollections);
+        }
+        if (kind === 'set') {
+            const values = Array.isArray(value.values) ? value.values : [];
+            return [...new Set(values.map((entry) => (0, canonical_js_1.canonicalStringify)(materializeDynamicCollections(entry))))]
+                .sort(compareStrings)
+                .map((entry) => JSON.parse(entry));
+        }
+        if (kind === 'map' || kind === 'dictionary') {
+            const entries = recordOrThrow(value.entries ?? {}, `${kind} entries`);
+            return Object.fromEntries(Object.keys(entries).sort(compareStrings).map((key) => [key, materializeDynamicCollections(entries[key])]));
+        }
+        throw new Error(`Unsupported deterministic prototype collection ${kind}`);
+    }
+    return Object.fromEntries(Object.keys(value).sort(compareStrings).map((key) => [key, materializeDynamicCollections(value[key])]));
+}
+function isCollectionDescriptor(value) {
+    return typeof value.collection === 'string';
+}
+function isPlainRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function stringOrThrow(value, label) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`${label} must be a non-empty string`);
+    }
+    return value;
+}
+function optionalInteger(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Number.isInteger(value)) {
+        throw new Error(`${label} must be an integer`);
+    }
+    return value;
+}
+function stableRecordKeys(record) {
+    return Reflect.ownKeys(record)
+        .filter((key) => typeof key === 'string')
+        .sort(compareStrings);
+}
+function validateDependencies(dependencies) {
+    for (const dependency of dependencies) {
+        if (/[\^~*xX]/.test(dependency.version) || dependency.version === 'latest') {
+            throw new Error(`Nondeterministic dependency version ${dependency.name}@${dependency.version}`);
+        }
+    }
+}
+function compareDependencies(left, right) {
+    return compareStrings(left.name, right.name) || compareStrings(left.version, right.version);
+}
+function rejectUnquantizedNumbers(value, path) {
+    if (typeof value === 'number') {
+        if (!Number.isInteger(value)) {
+            throw new Error(`Unquantized float at ${path}`);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((entry, index) => rejectUnquantizedNumbers(entry, `${path}[${index}]`));
+        return;
+    }
+    if (value !== null && typeof value === 'object') {
+        for (const key of Object.keys(value).sort(compareStrings)) {
+            const entry = value[key];
+            rejectUnquantizedNumbers(entry, `${path}.${key}`);
+        }
+    }
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}