mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
222 lines
7.2 KiB
JavaScript
222 lines
7.2 KiB
JavaScript
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 };
|
|
},
|
|
};
|
|
}
|