@aelionsdk/material-sdk 0.1.0-beta.1

package/dist/package.js

@@ -0,0 +1,244 @@
+import { canonicalMaterialBytes, sha256Hex } from './canonical.js';
+import { addMaterialPackageBytes, inspectPackedMaterialPackage, materialPackageBudgetExceeded, materialUint8ArrayByteLength, resolveMaterialPackageByteLimits, validMaterialPackagePath, } from './package-limits.js';
+import { assertMaterialDefinitionShape, assertMaterialGraphShape, assertMaterialPackageManifestShape, } from './package-shape.js';
+import { MATERIAL_PACKAGE_SCHEMA, MATERIAL_PROTOCOL_VERSION, } from './types.js';
+import { validateAuthoredMaterial } from './validation.js';
+import { createDeterministicMaterialArchive } from './zip.js';
+import { snapshotMaterialPackage } from './package-snapshot.js';
+const encoder = new TextEncoder();
+const decoder = new TextDecoder('utf-8', { fatal: true });
+const MEDIA_TYPE_DEFINITION = 'application/vnd.aelion.material+json';
+const MEDIA_TYPE_GRAPH = 'application/vnd.aelion.material-graph+json';
+function denseArraySnapshot(value, name, maximum) {
+    if (!Array.isArray(value)) {
+        throw new TypeError(`MATERIAL_PACKAGE_INVALID: ${name} must be an array`);
+    }
+    const length = value.length;
+    if (!Number.isSafeInteger(length) || length < 0 || length > maximum) {
+        throw new RangeError(`MATERIAL_PACKAGE_BUDGET_EXCEEDED: ${name} has more than ${maximum.toString()} entries`);
+    }
+    const snapshot = [];
+    for (let index = 0; index < length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, index.toString());
+        if (descriptor === undefined || !('value' in descriptor)) {
+            throw new TypeError(`MATERIAL_PACKAGE_INVALID: ${name}[${index.toString()}] must be a dense data entry`);
+        }
+        snapshot.push(descriptor.value);
+    }
+    return snapshot;
+}
+function bytes(data, path) {
+    if (typeof data === 'string')
+        return encoder.encode(data);
+    const byteLength = materialUint8ArrayByteLength(data, `input file ${path}`);
+    const output = new Uint8Array(byteLength);
+    Uint8Array.prototype.set.call(output, data);
+    return output;
+}
+function inputByteLength(data, path) {
+    if (typeof data === 'string')
+        return encoder.encode(data).byteLength;
+    return materialUint8ArrayByteLength(data, `input file ${path}`);
+}
+function asJsonValue(value) {
+    return value;
+}
+function addFile(files, file, limits) {
+    if (!validMaterialPackagePath(file.path) ||
+        file.path === 'manifest.json' ||
+        file.path === 'signature.json') {
+        throw new TypeError(`Unsafe or reserved Material package path ${file.path}`);
+    }
+    if (files.has(file.path))
+        throw new TypeError(`Duplicate Material package path ${file.path}`);
+    if (files.size + 2 > limits.maxFiles) {
+        throw new RangeError(`MATERIAL_PACKAGE_BUDGET_EXCEEDED: package would have ${files.size + 2} files; limit is ${limits.maxFiles}`);
+    }
+    if (typeof file.mediaType !== 'string' || file.mediaType.length === 0) {
+        throw new TypeError(`MATERIAL_PACKAGE_INVALID: file ${file.path} requires a media type`);
+    }
+    const byteLength = inputByteLength(file.data, file.path);
+    if (byteLength > limits.maxFileBytes) {
+        materialPackageBudgetExceeded(`file ${file.path}`, byteLength, limits.maxFileBytes);
+    }
+    const data = bytes(file.data, file.path);
+    if (data.byteLength !== byteLength) {
+        throw new TypeError(`MATERIAL_PACKAGE_INVALID: file ${file.path} changed during snapshot`);
+    }
+    files.set(file.path, { mediaType: file.mediaType, data });
+}
+/**
+ * Creates a deterministic virtual AMP package. ZIP transport can be layered on top without
+ * changing manifest hashes, canonical bytes, or registry semantics.
+ */
+export async function packMaterialPackage(options) {
+    const materials = denseArraySnapshot(options.materials, 'materials', 256);
+    if (materials.length === 0)
+        throw new TypeError('A Material package cannot be empty');
+    const limits = resolveMaterialPackageByteLimits(options.limits);
+    const packageFiles = new Map();
+    for (const material of materials) {
+        // Authoring and installation share one protocol contract. Reject values
+        // here rather than creating a signed deterministic package that the same
+        // SDK's registry is guaranteed to reject later.
+        assertMaterialDefinitionShape(material.definition);
+        if (material.graph !== undefined)
+            assertMaterialGraphShape(material.graph);
+        const validation = validateAuthoredMaterial(material);
+        if (!validation.valid) {
+            const codes = validation.diagnostics.map(value => value.code).join(', ');
+            throw new TypeError(`Material ${material.definition.id} is invalid: ${codes}`);
+        }
+        const definitionPath = material.definitionPath ?? `materials/${material.definition.id}.material.json`;
+        addFile(packageFiles, {
+            path: definitionPath,
+            mediaType: MEDIA_TYPE_DEFINITION,
+            data: canonicalMaterialBytes(asJsonValue(material.definition)),
+        }, limits);
+        if (material.graph !== undefined) {
+            const implementationPath = material.definition.implementations.find(value => value.type === 'graph')?.graph;
+            const graphPath = material.graphPath ?? implementationPath;
+            if (graphPath === undefined || graphPath !== implementationPath) {
+                throw new TypeError(`Material ${material.definition.id} Graph path does not match Definition`);
+            }
+            addFile(packageFiles, {
+                path: graphPath,
+                mediaType: MEDIA_TYPE_GRAPH,
+                data: canonicalMaterialBytes(asJsonValue(material.graph)),
+            }, limits);
+        }
+    }
+    const inputFiles = denseArraySnapshot(options.files ?? [], 'files', Math.max(0, limits.maxFiles - 1));
+    // Iteration is safe over our new intrinsic Array snapshot, not caller input.
+    for (const file of inputFiles) {
+        addFile(packageFiles, file, limits);
+    }
+    let payloadBytes = 0;
+    for (const [path, file] of packageFiles) {
+        payloadBytes = addMaterialPackageBytes(payloadBytes, file.data.byteLength, `file ${path}`);
+        if (payloadBytes > limits.maxPackageBytes) {
+            materialPackageBudgetExceeded('package payloads', payloadBytes, limits.maxPackageBytes);
+        }
+    }
+    const paths = [...packageFiles.keys()].sort();
+    const fileEntries = await Promise.all(paths.map(async (path) => {
+        const file = packageFiles.get(path);
+        if (file === undefined)
+            throw new ReferenceError(`Missing package file ${path}`);
+        return {
+            path,
+            mediaType: file.mediaType,
+            bytes: file.data.byteLength,
+            sha256: await sha256Hex(file.data),
+        };
+    }));
+    const manifest = {
+        $schema: MATERIAL_PACKAGE_SCHEMA,
+        protocolVersion: MATERIAL_PROTOCOL_VERSION,
+        package: options.metadata,
+        materials: materials.map(material => ({
+            id: material.definition.id,
+            kind: material.definition.kind,
+            definition: material.definitionPath ?? `materials/${material.definition.id}.material.json`,
+        })),
+        files: fileEntries,
+    };
+    assertMaterialPackageManifestShape(manifest);
+    const manifestBytes = canonicalMaterialBytes(asJsonValue(manifest));
+    if (manifestBytes.byteLength > limits.maxManifestBytes) {
+        materialPackageBudgetExceeded('manifestBytes', manifestBytes.byteLength, limits.maxManifestBytes);
+    }
+    const packageBytes = addMaterialPackageBytes(payloadBytes, manifestBytes.byteLength, 'package files');
+    if (packageBytes > limits.maxPackageBytes) {
+        materialPackageBudgetExceeded('package files', packageBytes, limits.maxPackageBytes);
+    }
+    const integrity = `sha256:${await sha256Hex(manifestBytes)}`;
+    const output = new Map();
+    output.set('manifest.json', manifestBytes);
+    for (const path of paths) {
+        const data = packageFiles.get(path)?.data;
+        if (data !== undefined)
+            output.set(path, new Uint8Array(data));
+    }
+    const archiveBytes = createDeterministicMaterialArchive(output, limits);
+    return {
+        manifest,
+        manifestBytes,
+        files: output,
+        archiveBytes,
+        integrity,
+    };
+}
+export async function verifyMaterialPackage(packed, expectedIntegrity, options = {}) {
+    // Validation is asynchronous. Snapshot synchronously so caller mutations
+    // cannot change the package halfway through an integrity/trust decision.
+    const inspection = inspectPackedMaterialPackage(packed, options);
+    packed = snapshotMaterialPackage(packed, options, inspection);
+    await verifyMaterialPackageSnapshot(packed, expectedIntegrity, inspection.limits);
+}
+/** Internal verification path for a package that is already ownership-isolated. */
+/** @internal Ownership-isolated verification path; not exported by the package entrypoint. */
+export async function verifyMaterialPackageSnapshot(packed, expectedIntegrity, options) {
+    const limits = resolveMaterialPackageByteLimits(options);
+    assertMaterialPackageManifestShape(packed.manifest);
+    const manifestBytes = canonicalMaterialBytes(asJsonValue(packed.manifest));
+    if (manifestBytes.byteLength > limits.maxManifestBytes) {
+        materialPackageBudgetExceeded('canonical manifest', manifestBytes.byteLength, limits.maxManifestBytes);
+    }
+    const storedManifest = packed.files.get('manifest.json');
+    if (storedManifest === undefined ||
+        packed.manifestBytes.byteLength !== manifestBytes.byteLength ||
+        storedManifest.byteLength !== manifestBytes.byteLength ||
+        packed.manifestBytes.some((value, index) => value !== manifestBytes[index]) ||
+        storedManifest.some((value, index) => value !== manifestBytes[index])) {
+        throw new TypeError('MATERIAL_INTEGRITY_MISMATCH: canonical manifest bytes differ');
+    }
+    const integrity = `sha256:${await sha256Hex(manifestBytes)}`;
+    if (packed.integrity !== integrity ||
+        (expectedIntegrity !== undefined && integrity !== expectedIntegrity)) {
+        throw new TypeError('MATERIAL_INTEGRITY_MISMATCH: manifest integrity differs');
+    }
+    const declaredPaths = new Set();
+    let declaredPackageBytes = manifestBytes.byteLength;
+    for (const entry of packed.manifest.files) {
+        if (!validMaterialPackagePath(entry.path) || declaredPaths.has(entry.path)) {
+            throw new TypeError(`MATERIAL_PACKAGE_INVALID: invalid or duplicate path ${entry.path}`);
+        }
+        if (entry.path === 'manifest.json' || entry.path === 'signature.json') {
+            throw new TypeError(`MATERIAL_PACKAGE_INVALID: reserved payload path ${entry.path}`);
+        }
+        if (entry.bytes > limits.maxFileBytes) {
+            materialPackageBudgetExceeded(`declared file ${entry.path}`, entry.bytes, limits.maxFileBytes);
+        }
+        declaredPackageBytes = addMaterialPackageBytes(declaredPackageBytes, entry.bytes, `declared file ${entry.path}`);
+        if (declaredPackageBytes > limits.maxPackageBytes) {
+            materialPackageBudgetExceeded('declared package files', declaredPackageBytes, limits.maxPackageBytes);
+        }
+        declaredPaths.add(entry.path);
+        const data = packed.files.get(entry.path);
+        if (data === undefined ||
+            data.byteLength !== entry.bytes ||
+            (await sha256Hex(data)) !== entry.sha256) {
+            throw new TypeError(`MATERIAL_INTEGRITY_MISMATCH: payload ${entry.path} differs`);
+        }
+    }
+    const actualPayloads = [...packed.files.keys()].filter(path => path !== 'manifest.json');
+    if (actualPayloads.some(path => !declaredPaths.has(path)) ||
+        actualPayloads.length !== declaredPaths.size) {
+        throw new TypeError('MATERIAL_PACKAGE_INVALID: undeclared or missing payload');
+    }
+    const archiveFiles = new Map([['manifest.json', manifestBytes]]);
+    for (const entry of packed.manifest.files) {
+        const data = packed.files.get(entry.path);
+        if (data !== undefined)
+            archiveFiles.set(entry.path, data);
+    }
+    const expectedArchive = createDeterministicMaterialArchive(archiveFiles, limits);
+    if (packed.archiveBytes.byteLength !== expectedArchive.byteLength ||
+        packed.archiveBytes.some((value, index) => value !== expectedArchive[index])) {
+        throw new TypeError('MATERIAL_INTEGRITY_MISMATCH: archive bytes differ from verified files');
+    }
+}
+export function decodeMaterialJson(data) {
+    return JSON.parse(decoder.decode(data));
+}

package/dist/registry.d.ts

@@ -0,0 +1,32 @@
+import type { MaterialTrustStore, SignedMaterialPackage } from './security.js';
+import type { MaterialPackageByteLimitOptions, MaterialPackageReference, MaterialPackageResolver, PackedMaterialPackage, ResolvedMaterial } from './types.js';
+export interface InstallMaterialPackageOptions {
+    readonly expectedIntegrity?: string;
+    /** Required in addition to a trusted-code manifest. Authorization is never inferred. */
+    readonly authorizeTrustedCode?: boolean;
+    readonly trustedPublisherIds?: ReadonlySet<string>;
+    /** Applied before package transport bytes are copied or its ZIP is rebuilt. */
+    readonly limits?: MaterialPackageByteLimitOptions;
+}
+export interface MaterialRegistryOptions {
+    /** Default fail-closed transport budget for install, resolve and registry snapshots. */
+    readonly limits?: MaterialPackageByteLimitOptions;
+}
+export declare class MaterialRegistry implements MaterialPackageResolver {
+    #private;
+    constructor(options?: MaterialRegistryOptions);
+    install(packed: PackedMaterialPackage, options?: InstallMaterialPackageOptions): Promise<void>;
+    installSigned(signed: SignedMaterialPackage, trustStore: MaterialTrustStore, options?: InstallMaterialPackageOptions & {
+        readonly signal?: AbortSignal;
+        readonly nowMs?: number;
+    }): Promise<void>;
+    resolve(reference: Pick<MaterialPackageReference, 'packageId' | 'packageVersion' | 'packageIntegrity'>, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<PackedMaterialPackage>;
+    installFrom(resolver: MaterialPackageResolver, reference: Pick<MaterialPackageReference, 'packageId' | 'packageVersion' | 'packageIntegrity'>, options?: InstallMaterialPackageOptions & {
+        readonly signal?: AbortSignal;
+    }): Promise<void>;
+    resolveMaterial(reference: MaterialPackageReference): Promise<ResolvedMaterial>;
+    uninstall(reference: Pick<MaterialPackageReference, 'packageId' | 'packageVersion' | 'packageIntegrity'>): boolean;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC/E,OAAO,KAAK,EAEV,+BAA+B,EAC/B,wBAAwB,EACxB,uBAAuB,EACvB,qBAAqB,EACrB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,wFAAwF;IACxF,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IACxC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACnD,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,CAAC,EAAE,+BAA+B,CAAC;CACnD;AAED,MAAM,WAAW,uBAAuB;IACtC,wFAAwF;IACxF,QAAQ,CAAC,MAAM,CAAC,EAAE,+BAA+B,CAAC;CACnD;AAkFD,qBAAa,gBAAiB,YAAW,uBAAuB;;gBAIlD,OAAO,GAAE,uBAA4B;IAI3C,OAAO,CACX,MAAM,EAAE,qBAAqB,EAC7B,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,IAAI,CAAC;IA+CV,aAAa,CACjB,MAAM,EAAE,qBAAqB,EAC7B,UAAU,EAAE,kBAAkB,EAC9B,OAAO,GAAE,6BAA6B,GAAG;QACvC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;QAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;KACpB,GACL,OAAO,CAAC,IAAI,CAAC;IAShB,OAAO,CACL,SAAS,EAAE,IAAI,CAAC,wBAAwB,EAAE,WAAW,GAAG,gBAAgB,GAAG,kBAAkB,CAAC,EAC9F,OAAO,GAAE;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAO,GAC9C,OAAO,CAAC,qBAAqB,CAAC;IAa3B,WAAW,CACf,QAAQ,EAAE,uBAAuB,EACjC,SAAS,EAAE,IAAI,CAAC,wBAAwB,EAAE,WAAW,GAAG,gBAAgB,GAAG,kBAAkB,CAAC,EAC9F,OAAO,GAAE,6BAA6B,GAAG;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAO,GAC9E,OAAO,CAAC,IAAI,CAAC;IASV,eAAe,CAAC,SAAS,EAAE,wBAAwB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAgBrF,SAAS,CACP,SAAS,EAAE,IAAI,CAAC,wBAAwB,EAAE,WAAW,GAAG,gBAAgB,GAAG,kBAAkB,CAAC,GAC7F,OAAO;CAKX"}

package/dist/registry.js

@@ -0,0 +1,150 @@
+import { throwIfAborted } from '@aelionsdk/core';
+import { decodeMaterialJson, verifyMaterialPackageSnapshot } from './package.js';
+import { inspectPackedMaterialPackage, resolveMaterialPackageByteLimits, } from './package-limits.js';
+import { assertMaterialDefinitionShape, assertMaterialGraphShape } from './package-shape.js';
+import { snapshotMaterialPackage } from './package-snapshot.js';
+import { validateAuthoredMaterial } from './validation.js';
+function packageKey(packageId, packageVersion, integrity) {
+    return `${packageId}\0${packageVersion}\0${integrity}`;
+}
+function requiresTrustedCode(definition) {
+    return definition.implementations.some(value => value.type === 'shader' || value.type === 'wasm');
+}
+function readDefinition(packed, path) {
+    const data = packed.files.get(path);
+    if (data === undefined)
+        throw new TypeError(`MATERIAL_PACKAGE_INVALID: missing ${path}`);
+    let value;
+    try {
+        value = decodeMaterialJson(data);
+    }
+    catch {
+        throw new TypeError(`MATERIAL_PACKAGE_INVALID: definition ${path} is not valid UTF-8 JSON`);
+    }
+    assertMaterialDefinitionShape(value);
+    return value;
+}
+function readGraph(packed, definition) {
+    const implementation = definition.implementations.find(value => value.type === 'graph');
+    if (implementation?.type !== 'graph')
+        return undefined;
+    const data = packed.files.get(implementation.graph);
+    if (data === undefined) {
+        throw new TypeError(`MATERIAL_PACKAGE_INVALID: missing ${implementation.graph}`);
+    }
+    let value;
+    try {
+        value = decodeMaterialJson(data);
+    }
+    catch {
+        throw new TypeError(`MATERIAL_PACKAGE_INVALID: graph ${implementation.graph} is not valid UTF-8 JSON`);
+    }
+    assertMaterialGraphShape(value);
+    return value;
+}
+function requirePayload(packed, path, owner) {
+    if (packed.files.get(path) === undefined) {
+        throw new TypeError(`MATERIAL_PACKAGE_INVALID: ${owner} references missing ${path}`);
+    }
+}
+function validateReferencedPayloads(packed, definition) {
+    for (const resource of definition.bundledResources) {
+        requirePayload(packed, resource.path, `resource ${resource.id}`);
+    }
+    for (const implementation of definition.implementations) {
+        if (implementation.type === 'graph') {
+            requirePayload(packed, implementation.graph, `graph implementation ${definition.id}`);
+        }
+        else if (implementation.type === 'wasm') {
+            requirePayload(packed, implementation.module, `WASM implementation ${definition.id}`);
+        }
+        else if (implementation.backend === 'webgpu') {
+            requirePayload(packed, implementation.module, `WebGPU implementation ${definition.id}`);
+        }
+        else {
+            requirePayload(packed, implementation.fragmentModule, `WebGL2 implementation ${definition.id}`);
+            if (implementation.vertexModule !== undefined) {
+                requirePayload(packed, implementation.vertexModule, `WebGL2 implementation ${definition.id}`);
+            }
+        }
+    }
+}
+export class MaterialRegistry {
+    #packages = new Map();
+    #limits;
+    constructor(options = {}) {
+        this.#limits = resolveMaterialPackageByteLimits(options.limits);
+    }
+    async install(packed, options = {}) {
+        const limits = resolveMaterialPackageByteLimits(options.limits ?? this.#limits);
+        const inspection = inspectPackedMaterialPackage(packed, limits);
+        const snapshot = snapshotMaterialPackage(packed, limits, inspection);
+        await verifyMaterialPackageSnapshot(snapshot, options.expectedIntegrity, limits);
+        const { manifest } = snapshot;
+        const trusted = manifest.package.trust === 'trusted-code';
+        if (trusted) {
+            if (options.authorizeTrustedCode !== true ||
+                !options.trustedPublisherIds?.has(manifest.package.publisher.id)) {
+                throw new TypeError('MATERIAL_TRUST_REQUIRED: trusted code requires explicit host authorization and publisher allowlist');
+            }
+        }
+        for (const entry of manifest.materials) {
+            const definition = readDefinition(snapshot, entry.definition);
+            if (definition.id !== entry.id || definition.kind !== entry.kind) {
+                throw new TypeError(`MATERIAL_DEFINITION_INVALID: manifest identity differs for ${entry.id}`);
+            }
+            if (requiresTrustedCode(definition) && !trusted) {
+                throw new TypeError(`MATERIAL_TRUST_REQUIRED: ${entry.id} contains code in a declarative package`);
+            }
+            validateReferencedPayloads(snapshot, definition);
+            const graph = readGraph(snapshot, definition);
+            const result = validateAuthoredMaterial({
+                definition,
+                ...(graph === undefined ? {} : { graph }),
+            });
+            if (!result.valid) {
+                throw new TypeError(`MATERIAL_DEFINITION_INVALID: ${result.diagnostics.map(value => value.code).join(', ')}`);
+            }
+        }
+        this.#packages.set(packageKey(manifest.package.id, manifest.package.version, snapshot.integrity), snapshot);
+    }
+    async installSigned(signed, trustStore, options = {}) {
+        await trustStore.verify(signed, {
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+            ...(options.nowMs === undefined ? {} : { nowMs: options.nowMs }),
+        });
+        throwIfAborted(options.signal, 'Signed Material package install');
+        await this.install(signed.package, options);
+    }
+    resolve(reference, options = {}) {
+        throwIfAborted(options.signal, 'Material package resolve');
+        const result = this.#packages.get(packageKey(reference.packageId, reference.packageVersion, reference.packageIntegrity));
+        if (result === undefined) {
+            throw new ReferenceError(`MATERIAL_MISSING: ${reference.packageId}@${reference.packageVersion}#${reference.packageIntegrity}`);
+        }
+        return Promise.resolve(snapshotMaterialPackage(result, this.#limits));
+    }
+    async installFrom(resolver, reference, options = {}) {
+        const packed = await resolver.resolve(reference, options.signal === undefined ? {} : { signal: options.signal });
+        throwIfAborted(options.signal, 'Material package install');
+        await this.install(packed, { ...options, expectedIntegrity: reference.packageIntegrity });
+    }
+    async resolveMaterial(reference) {
+        const packed = await this.resolve(reference);
+        const entry = packed.manifest.materials.find(value => value.id === reference.materialId);
+        if (entry === undefined) {
+            throw new ReferenceError(`MATERIAL_MISSING: material ${reference.materialId}`);
+        }
+        const definition = readDefinition(packed, entry.definition);
+        const graph = readGraph(packed, definition);
+        return {
+            reference,
+            manifest: packed.manifest,
+            definition,
+            ...(graph === undefined ? {} : { graph }),
+        };
+    }
+    uninstall(reference) {
+        return this.#packages.delete(packageKey(reference.packageId, reference.packageVersion, reference.packageIntegrity));
+    }
+}

package/dist/schema-validation.d.ts

@@ -0,0 +1,4 @@
+export declare function assertMaterialManifestSchema(value: unknown): void;
+export declare function assertMaterialDefinitionSchema(value: unknown): void;
+export declare function assertMaterialGraphSchema(value: unknown): void;
+//# sourceMappingURL=schema-validation.d.ts.map

package/dist/schema-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-validation.d.ts","sourceRoot":"","sources":["../src/schema-validation.ts"],"names":[],"mappings":"AAoCA,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAEjE;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAEnE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAE9D"}

package/dist/schema-validation.js

@@ -0,0 +1,36 @@
+import Ajv2020, {} from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { materialDefinitionSchema, materialGraphSchema, materialPackageSchema, } from './bundled-schemas.js';
+const ajv = new Ajv2020({
+    // Shape admission runs before these validators and rejects oversized input.
+    // Stop at the first schema failure so invalid packages cannot amplify CPU or
+    // retained error state by asking Ajv to enumerate every violation.
+    allErrors: false,
+    allowUnionTypes: true,
+    strict: true,
+    validateFormats: true,
+});
+addFormats(ajv);
+const validateManifest = ajv.compile(materialPackageSchema);
+const validateDefinition = ajv.compile(materialDefinitionSchema);
+const validateGraph = ajv.compile(materialGraphSchema);
+function pointer(error) {
+    return error.instancePath === '' ? '/' : error.instancePath;
+}
+function assertSchema(value, name, validator) {
+    if (validator(value))
+        return;
+    const first = validator.errors?.[0];
+    const message = first?.message ?? `does not conform to the ${name} schema`;
+    const path = first === undefined ? '/' : pointer(first);
+    throw new TypeError(`MATERIAL_PACKAGE_INVALID: ${name} ${path} ${message}`);
+}
+export function assertMaterialManifestSchema(value) {
+    assertSchema(value, 'manifest', validateManifest);
+}
+export function assertMaterialDefinitionSchema(value) {
+    assertSchema(value, 'definition', validateDefinition);
+}
+export function assertMaterialGraphSchema(value) {
+    assertSchema(value, 'graph', validateGraph);
+}

package/dist/security.d.ts

@@ -0,0 +1,70 @@
+import type { PackedMaterialPackage } from './types.js';
+export type MaterialSignatureAlgorithm = 'Ed25519' | 'ECDSA-P256-SHA256';
+export interface MaterialPackageSignature {
+    readonly version: 1;
+    readonly publisherId: string;
+    readonly keyId: string;
+    readonly algorithm: MaterialSignatureAlgorithm;
+    readonly signedAtMs: number;
+    readonly manifestIntegrity: string;
+    readonly signatureBase64Url: string;
+}
+export interface SignedMaterialPackage {
+    readonly package: PackedMaterialPackage;
+    readonly signature: MaterialPackageSignature;
+}
+export interface SignMaterialPackageOptions {
+    readonly publisherId: string;
+    readonly keyId: string;
+    readonly algorithm: MaterialSignatureAlgorithm;
+    readonly privateKey: CryptoKey;
+    readonly signedAtMs?: number;
+    readonly signal?: AbortSignal;
+}
+export declare function signMaterialPackage(packed: PackedMaterialPackage, options: SignMaterialPackageOptions): Promise<SignedMaterialPackage>;
+export interface MaterialPublisherKey {
+    readonly publisherId: string;
+    readonly keyId: string;
+    readonly algorithm: MaterialSignatureAlgorithm;
+    readonly publicKey: CryptoKey;
+    readonly validFromMs?: number;
+    readonly validUntilMs?: number;
+}
+export interface MaterialTrustAuditEntry {
+    readonly sequence: number;
+    readonly timeMs: number;
+    readonly action: 'key-added' | 'key-revoked' | 'package-revoked' | 'verified' | 'rejected';
+    readonly publisherId?: string;
+    readonly keyId?: string;
+    readonly integrity?: string;
+    readonly reason?: string;
+}
+export declare class MaterialTrustStore {
+    #private;
+    constructor(maxAuditEntries?: number);
+    addKey(key: MaterialPublisherKey, nowMs?: number): void;
+    revokeKey(publisherId: string, keyId: string, reason: string, nowMs?: number): void;
+    revokePackage(integrity: string, reason: string, nowMs?: number): void;
+    verify(signed: SignedMaterialPackage, options?: {
+        readonly nowMs?: number;
+        readonly signal?: AbortSignal;
+    }): Promise<void>;
+    auditLog(): readonly MaterialTrustAuditEntry[];
+}
+export interface MaterialExecutionPermissions {
+    readonly allowShader: boolean;
+    readonly allowWasm: boolean;
+    readonly allowedNetworkOrigins: readonly string[];
+    readonly maxMemoryBytes: number;
+    readonly maxExecutionMs: number;
+}
+export interface MaterialHostSecurityPolicy {
+    readonly trustedPublisherIds: ReadonlySet<string>;
+    readonly allowShader: boolean;
+    readonly allowWasm: boolean;
+    readonly allowedNetworkOrigins: ReadonlySet<string>;
+    readonly maxMemoryBytes: number;
+    readonly maxExecutionMs: number;
+}
+export declare function enforceMaterialExecutionPolicy(publisherId: string, requested: MaterialExecutionPermissions, host: MaterialHostSecurityPolicy): void;
+//# sourceMappingURL=security.d.ts.map

package/dist/security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../src/security.ts"],"names":[],"mappings":"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"}