Add Director authoring, import previews and scene bundles

This commit is contained in:
Sameh Khamis committed 2026-09-15 20:15:32 -07:00
1 parent 62f66c4b86
commit 078fc290ec
25 files changed
+1930 -48

No files matched your search

+221
View File
@@ -0,0 +1,221 @@
import { parseSceneDocument, stringifySceneDocument } from '../document.js';
import { withShareSignal } from './lifetime.js';
import { fields, array, fail } from '../documentFields.js';
import { PACK_LIMITS, validateAssetPath } from '../packs/manifest.js';
export const BUNDLE_SOURCE = 'scene-bundle';
export const SHARE_LIMITS = Object.freeze({
bytes: 50 * 1024 * 1024,
assets: 64,
});
const MIME = new Set([
'application/json',
'application/geo+json',
'image/png',
'video/mp4',
'video/webm',
'audio/mpeg',
'audio/ogg',
'audio/wav',
'audio/webm',
]);
const packsOf = (project) =>
project.scenes.flatMap((scene) => scene.dataPacks || []);
const checkAbort = (signal) => signal?.throwIfAborted();
const digest = async (bytes) =>
Array.from(
new Uint8Array(await crypto.subtle.digest('SHA-256', bytes)),
(n) => n.toString(16).padStart(2, '0'),
).join('');
function encode(bytes) {
const chunks = [];
for (let i = 0; i < bytes.length; i += 32768)
chunks.push(String.fromCharCode(...bytes.subarray(i, i + 32768)));
return btoa(chunks.join(''));
}
function decode(value) {
if (
typeof value !== 'string' ||
!value.length ||
value.length > Math.ceil(PACK_LIMITS.bytes / 3) * 4 ||
value.length % 4 !== 0 ||
/[^A-Za-z0-9+/=]/.test(value) ||
(value.includes('=') && !/^[A-Za-z0-9+/]+={1,2}$/.test(value))
)
fail('assets', 'invalid or oversized base64 asset');
return Uint8Array.from(atob(value), (c) => c.charCodeAt(0));
}
function checkBytes(bytes, total) {
if (
!(bytes instanceof Uint8Array) ||
!bytes.length ||
bytes.length > PACK_LIMITS.bytes ||
total > PACK_LIMITS.totalBytes
)
fail('assets', 'asset byte limit exceeded');
}
function checkMime(mimeType) {
if (!MIME.has(mimeType)) fail('assets', 'unsupported media type');
}
/** Read inert scene JSON or a bounded asset bundle, verifying bytes before admission. */
export async function parseSceneShare(text, { signal } = {}) {
checkAbort(signal);
if (
typeof text !== 'string' ||
text.length > SHARE_LIMITS.bytes ||
new TextEncoder().encode(text).length > SHARE_LIMITS.bytes
)
fail('$', 'share exceeds 50 MiB');
let input;
try {
input = JSON.parse(text);
} catch {
fail('$', 'invalid JSON');
}
if (input?.format !== 'gev-scene-bundle')
return { project: parseSceneDocument(text), assets: new Map() };
fields(input, '$', ['format', 'version', 'project', 'assets']);
if (input.version !== 1) fail('version', 'unsupported bundle version');
const project = parseSceneDocument(JSON.stringify(input.project));
array(input.assets, 'assets', SHARE_LIMITS.assets);
const assets = new Map();
let total = 0;
for (const entry of input.assets) {
checkAbort(signal);
fields(entry, 'assets', ['path', 'mimeType', 'base64', 'sha256']);
validateAssetPath(entry.path);
checkMime(entry.mimeType);
if (assets.has(entry.path)) fail('assets', 'duplicate asset path');
const bytes = decode(entry.base64);
total += bytes.length;
checkBytes(bytes, total);
const hash = await digest(bytes);
checkAbort(signal);
if (entry.sha256 !== hash) fail('assets', 'asset integrity mismatch');
assets.set(entry.path, { bytes, mimeType: entry.mimeType, sha256: hash });
}
const used = new Set();
for (const pack of packsOf(project)) {
if (pack.source.adapter !== BUNDLE_SOURCE)
fail('project', 'bundle must include every declared pack');
const asset = assets.get(pack.source.path);
used.add(pack.source.path);
if (
!asset ||
pack.byteLength !== asset.bytes.length ||
pack.sha256 !== asset.sha256
)
fail('project', 'missing or mismatched bundle asset');
}
if (used.size !== assets.size) fail('assets', 'unreferenced bundle asset');
return { project, assets };
}
/** File reads have a known budget before text decoding; large bundles use a distinct suffix. */
export async function readSceneShare(file, options) {
const limit = file.name?.endsWith('.gevbundle.json')
? SHARE_LIMITS.bytes
: 5 * 1024 * 1024;
if (file.size > limit)
fail(
'$',
limit === SHARE_LIMITS.bytes
? 'share exceeds 50 MiB'
: 'file exceeds 5 MiB',
);
checkAbort(options?.signal);
const text = await withShareSignal(file.text(), options?.signal);
checkAbort(options?.signal);
return parseSceneShare(text, options);
}
/** Export only explicitly supplied pack bytes; never fetch external assets or alter the source project. */
export async function createSceneBundle(
project,
resolveAsset,
{ signal } = {},
) {
const copy = parseSceneDocument(stringifySceneDocument(project));
const assets = [],
known = new Map();
let total = 0;
for (const pack of packsOf(copy)) {
checkAbort(signal);
const key = JSON.stringify([pack.source.adapter, pack.source.path]);
let entry = known.get(key);
if (!entry) {
if (assets.length >= SHARE_LIMITS.assets)
fail('assets', 'too many bundled assets');
const asset = await withShareSignal(
resolveAsset(pack, { signal }),
signal,
);
checkAbort(signal);
if (!asset) fail('assets', 'select a file for every declared data pack');
const bytes = asset.bytes;
total += bytes?.length || 0;
checkBytes(bytes, total);
checkMime(asset.mimeType);
const sha256 = await digest(bytes);
checkAbort(signal);
if (
(pack.byteLength && pack.byteLength !== bytes.length) ||
(pack.sha256 && pack.sha256 !== sha256)
)
fail('assets', 'selected file does not match declared integrity');
const path = `files/${assets.length}-${pack.source.path.split('/').at(-1).slice(0, 160)}`;
entry = {
path,
mimeType: asset.mimeType,
base64: encode(bytes),
sha256,
byteLength: bytes.length,
};
known.set(key, entry);
assets.push(entry);
} else if (
(pack.byteLength && pack.byteLength !== entry.byteLength) ||
(pack.sha256 && pack.sha256 !== entry.sha256)
)
fail('assets', 'conflicting shared asset integrity');
pack.source = { adapter: BUNDLE_SOURCE, path: entry.path };
pack.byteLength = entry.byteLength;
pack.sha256 = entry.sha256;
}
const text = JSON.stringify({
format: 'gev-scene-bundle',
version: 1,
project: copy,
assets: assets.map(({ byteLength, ...entry }) => entry),
});
if (new TextEncoder().encode(text).length > SHARE_LIMITS.bytes)
fail('$', 'share exceeds 50 MiB');
return text;
}
/** Keep bundled bytes in this project lifetime only; never fall back to a network source. */
export function createBundleAssets() {
let assets = new Map();
return {
replace(next = new Map()) {
assets = new Map(next);
},
clear() {
assets.clear();
},
snapshot: () => new Map(assets),
getState: () => ({
count: assets.size,
bytes: [...assets.values()].reduce((n, a) => n + a.bytes.length, 0),
}),
source({ path, signal, maxBytes = PACK_LIMITS.bytes }) {
checkAbort(signal);
validateAssetPath(path);
const asset = assets.get(path);
if (!asset || asset.bytes.length > maxBytes)
throw new Error('Bundle asset unavailable — reimport the bundle');
return { bytes: asset.bytes.slice(), mimeType: asset.mimeType };
},
};
}