@aelionsdk/project-schema 0.1.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FoyonaCZY and AelionSDK contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @aelionsdk/project-schema
+
+Project v1 types, validation and canonical serialization for AelionSDK
+
+Install with `npm install @aelionsdk/project-schema@next`.
+
+Version 0.1.0-beta.1 is a prerelease and its API may change before the first stable release. This package is part of [AelionSDK](https://github.com/FoyonaCZY/AelionSDK); see the repository README for supported browsers, examples and deployment requirements.

package/dist/admission.d.ts

@@ -0,0 +1,24 @@
+import type { JsonValue } from '@aelionsdk/core';
+export declare const PROJECT_INPUT_MAX_DEPTH = 64;
+export declare const PROJECT_INPUT_MAX_NODES = 262144;
+export declare const PROJECT_INPUT_MAX_ARRAY_LENGTH = 16384;
+export declare const PROJECT_INPUT_MAX_OBJECT_KEYS = 4096;
+export declare const PROJECT_INPUT_MAX_PROPERTY_KEY_BYTES: number;
+export declare const PROJECT_INPUT_MAX_STRING_BYTES: number;
+export declare const PROJECT_INPUT_MAX_TOTAL_STRING_BYTES: number;
+type ProjectAdmissionCode = 'PROJECT_INPUT_INVALID' | 'PROJECT_INPUT_LIMIT_EXCEEDED';
+export declare class ProjectInputAdmissionError extends TypeError {
+    readonly code: ProjectAdmissionCode;
+    readonly path: readonly (string | number)[];
+    constructor(code: ProjectAdmissionCode, message: string, path: readonly (string | number)[]);
+}
+/**
+ * Captures a bounded, ownership-isolated JSON snapshot before Ajv or semantic
+ * validation sees caller-controlled objects. Reflection on a Proxy can still
+ * invoke its traps; failures are caught, and no accessor getter or iterator is
+ * intentionally called. After this function returns, the original value is no
+ * longer observed.
+ */
+export declare function snapshotProjectInput(value: unknown): JsonValue;
+export {};
+//# sourceMappingURL=admission.d.ts.map

package/dist/admission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admission.d.ts","sourceRoot":"","sources":["../src/admission.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAC1C,eAAO,MAAM,uBAAuB,SAAU,CAAC;AAC/C,eAAO,MAAM,8BAA8B,QAAS,CAAC;AACrD,eAAO,MAAM,6BAA6B,OAAQ,CAAC;AACnD,eAAO,MAAM,oCAAoC,QAAa,CAAC;AAC/D,eAAO,MAAM,8BAA8B,QAAoB,CAAC;AAChE,eAAO,MAAM,oCAAoC,QAAqB,CAAC;AAEvE,KAAK,oBAAoB,GAAG,uBAAuB,GAAG,8BAA8B,CAAC;AA2BrF,qBAAa,0BAA2B,SAAQ,SAAS;IACvD,SAAgB,IAAI,EAAE,oBAAoB,CAAC;IAC3C,SAAgB,IAAI,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;gBAGjD,IAAI,EAAE,oBAAoB,EAC1B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE;CAOrC;AAmKD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAuI9D"}

package/dist/admission.js

@@ -0,0 +1,287 @@
+export const PROJECT_INPUT_MAX_DEPTH = 64;
+export const PROJECT_INPUT_MAX_NODES = 262_144;
+export const PROJECT_INPUT_MAX_ARRAY_LENGTH = 16_384;
+export const PROJECT_INPUT_MAX_OBJECT_KEYS = 4_096;
+export const PROJECT_INPUT_MAX_PROPERTY_KEY_BYTES = 16 * 1_024;
+export const PROJECT_INPUT_MAX_STRING_BYTES = 4 * 1_024 * 1_024;
+export const PROJECT_INPUT_MAX_TOTAL_STRING_BYTES = 16 * 1_024 * 1_024;
+const arrayIsArray = Array.isArray;
+const defineProperty = Object.defineProperty;
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const getPrototypeOf = Object.getPrototypeOf;
+const ownKeys = Reflect.ownKeys;
+const reflectApply = Reflect.apply;
+const functionToString = (value) => 
+// Calling through Reflect.apply deliberately avoids observing value.toString.
+// eslint-disable-next-line @typescript-eslint/unbound-method
+reflectApply(Function.prototype.toString, value, []);
+const textEncoder = new TextEncoder();
+export class ProjectInputAdmissionError extends TypeError {
+    code;
+    path;
+    constructor(code, message, path) {
+        super(message);
+        this.name = 'ProjectInputAdmissionError';
+        this.code = code;
+        this.path = path;
+    }
+}
+function pathSegments(path) {
+    const segments = [];
+    for (let current = path; current !== null; current = current.parent) {
+        segments.push(current.segment);
+    }
+    return segments.reverse();
+}
+function invalid(path, message) {
+    throw new ProjectInputAdmissionError('PROJECT_INPUT_INVALID', message, pathSegments(path));
+}
+function limit(path, message) {
+    throw new ProjectInputAdmissionError('PROJECT_INPUT_LIMIT_EXCEEDED', message, pathSegments(path));
+}
+function descriptor(value, key, path) {
+    let result;
+    try {
+        result = getOwnPropertyDescriptor(value, key);
+    }
+    catch {
+        invalid(path, 'Project input contains an inaccessible property');
+    }
+    if (result === undefined || !('value' in result) || result.enumerable !== true) {
+        invalid(path, 'Project input properties must be enumerable own data properties');
+    }
+    return result;
+}
+function arrayLength(value, path) {
+    let result;
+    try {
+        result = getOwnPropertyDescriptor(value, 'length');
+    }
+    catch {
+        invalid(path, 'Project input contains an inaccessible array length');
+    }
+    if (result === undefined || !('value' in result) || !Number.isSafeInteger(result.value)) {
+        invalid(path, 'Project input array length must be a safe own data property');
+    }
+    const length = Number(result.value);
+    if (length < 0)
+        invalid(path, 'Project input array length must be non-negative');
+    if (length > PROJECT_INPUT_MAX_ARRAY_LENGTH) {
+        limit(path, `Project input array exceeds ${PROJECT_INPUT_MAX_ARRAY_LENGTH.toString()} values`);
+    }
+    return length;
+}
+function inspectedPrototype(value, path) {
+    let prototype;
+    try {
+        prototype = getPrototypeOf(value);
+    }
+    catch {
+        invalid(path, 'Project input contains an inaccessible prototype');
+    }
+    return prototype;
+}
+function inspectedDescriptor(value, key, path) {
+    try {
+        return getOwnPropertyDescriptor(value, key);
+    }
+    catch {
+        invalid(path, 'Project input contains an inaccessible prototype property');
+    }
+}
+function isNativeConstructorFor(prototype, expectedName, path) {
+    const constructorDescriptor = inspectedDescriptor(prototype, 'constructor', path);
+    if (constructorDescriptor === undefined ||
+        !('value' in constructorDescriptor) ||
+        constructorDescriptor.enumerable !== false ||
+        typeof constructorDescriptor.value !== 'function') {
+        return false;
+    }
+    const constructor = constructorDescriptor.value;
+    const prototypeDescriptor = inspectedDescriptor(constructor, 'prototype', path);
+    if (prototypeDescriptor === undefined ||
+        !('value' in prototypeDescriptor) ||
+        prototypeDescriptor.value !== prototype) {
+        return false;
+    }
+    let source;
+    try {
+        source = functionToString(constructor);
+    }
+    catch {
+        return false;
+    }
+    return source.replaceAll(/\s+/gu, ' ') === `function ${expectedName}() { [native code] }`;
+}
+function isPlainObjectPrototype(prototype, path) {
+    return (inspectedPrototype(prototype, path) === null &&
+        isNativeConstructorFor(prototype, 'Object', path));
+}
+function recordPrototype(value, kind, path) {
+    const prototype = inspectedPrototype(value, path);
+    if (prototype === null)
+        return;
+    const accepted = kind === 'object'
+        ? prototype === Object.prototype || isPlainObjectPrototype(prototype, path)
+        : prototype === Array.prototype ||
+            (arrayIsArray(prototype) &&
+                isNativeConstructorFor(prototype, 'Array', path) &&
+                (() => {
+                    const parent = inspectedPrototype(prototype, path);
+                    return parent !== null && isPlainObjectPrototype(parent, path);
+                })());
+    if (!accepted) {
+        invalid(path, 'Project input must contain only plain JSON objects and arrays');
+    }
+}
+function inspectedKeys(value, path) {
+    let keys;
+    try {
+        keys = ownKeys(value);
+    }
+    catch {
+        invalid(path, 'Project input contains inaccessible properties');
+    }
+    return keys;
+}
+function byteLength(value, maximum, path, scope) {
+    // A UTF-16 code unit contributes at least one UTF-8 byte, so this cheap
+    // preflight avoids allocating a multi-megabyte encoded copy for obviously
+    // oversized attacker-controlled strings. JSON escaping can expand the
+    // canonical document further, but this admission budget is explicitly the
+    // decoded UTF-8 payload budget rather than a serialized-file-size limit.
+    if (value.length > maximum)
+        limit(path, `${scope} exceeds ${maximum.toString()} UTF-8 bytes`);
+    const bytes = textEncoder.encode(value).byteLength;
+    if (bytes > maximum)
+        limit(path, `${scope} exceeds ${maximum.toString()} UTF-8 bytes`);
+    return bytes;
+}
+function assign(target, key, value) {
+    defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value,
+    });
+}
+/**
+ * Captures a bounded, ownership-isolated JSON snapshot before Ajv or semantic
+ * validation sees caller-controlled objects. Reflection on a Proxy can still
+ * invoke its traps; failures are caught, and no accessor getter or iterator is
+ * intentionally called. After this function returns, the original value is no
+ * longer observed.
+ */
+export function snapshotProjectInput(value) {
+    const holder = {};
+    const tasks = [{ value, target: holder, key: 'value', path: null, depth: 0 }];
+    const seen = new WeakSet();
+    let nodes = 0;
+    let totalStringBytes = 0;
+    while (tasks.length > 0) {
+        const task = tasks.pop();
+        if (task === undefined)
+            break;
+        nodes += 1;
+        if (nodes > PROJECT_INPUT_MAX_NODES) {
+            limit(task.path, `Project input exceeds ${PROJECT_INPUT_MAX_NODES.toString()} JSON values`);
+        }
+        if (task.depth > PROJECT_INPUT_MAX_DEPTH) {
+            limit(task.path, `Project input exceeds depth ${PROJECT_INPUT_MAX_DEPTH.toString()}`);
+        }
+        const current = task.value;
+        if (current === null || typeof current === 'boolean') {
+            assign(task.target, task.key, current);
+            continue;
+        }
+        if (typeof current === 'number') {
+            if (!Number.isFinite(current) ||
+                Object.is(current, -0) ||
+                (Number.isInteger(current) && !Number.isSafeInteger(current))) {
+                invalid(task.path, 'Project input contains a non-canonical number');
+            }
+            assign(task.target, task.key, current);
+            continue;
+        }
+        if (typeof current === 'string') {
+            totalStringBytes += byteLength(current, PROJECT_INPUT_MAX_STRING_BYTES, task.path, 'Project input string');
+            if (totalStringBytes > PROJECT_INPUT_MAX_TOTAL_STRING_BYTES) {
+                limit(task.path, `Project input strings exceed ${PROJECT_INPUT_MAX_TOTAL_STRING_BYTES.toString()} total UTF-8 bytes`);
+            }
+            assign(task.target, task.key, current);
+            continue;
+        }
+        if (typeof current !== 'object') {
+            invalid(task.path, 'Project input contains a non-JSON value');
+        }
+        if (seen.has(current))
+            invalid(task.path, 'Project input contains a cycle or shared object');
+        seen.add(current);
+        if (arrayIsArray(current)) {
+            recordPrototype(current, 'array', task.path);
+            const length = arrayLength(current, task.path);
+            const keys = inspectedKeys(current, task.path);
+            if (keys.length !== length + 1) {
+                invalid(task.path, 'Project input arrays must be dense and contain no extra properties');
+            }
+            const remaining = new Set();
+            for (const key of keys) {
+                if (typeof key !== 'string') {
+                    invalid(task.path, 'Project input arrays must contain only numeric index properties');
+                }
+                remaining.add(key);
+            }
+            if (!remaining.delete('length')) {
+                invalid(task.path, 'Project input arrays must be dense and contain no extra properties');
+            }
+            for (let index = 0; index < length; index += 1) {
+                if (!remaining.delete(index.toString())) {
+                    invalid(task.path, 'Project input arrays must be dense and contain no extra properties');
+                }
+            }
+            if (remaining.size !== 0) {
+                invalid(task.path, 'Project input arrays must be dense and contain no extra properties');
+            }
+            const output = [];
+            defineProperty(output, 'length', { value: length, writable: true });
+            assign(task.target, task.key, output);
+            for (let index = length - 1; index >= 0; index -= 1) {
+                const key = index.toString();
+                const path = { parent: task.path, segment: index };
+                tasks.push({
+                    value: descriptor(current, key, path).value,
+                    target: output,
+                    key: index,
+                    path,
+                    depth: task.depth + 1,
+                });
+            }
+            continue;
+        }
+        recordPrototype(current, 'object', task.path);
+        const keys = inspectedKeys(current, task.path);
+        if (keys.length > PROJECT_INPUT_MAX_OBJECT_KEYS) {
+            limit(task.path, `Project input object exceeds ${PROJECT_INPUT_MAX_OBJECT_KEYS.toString()} properties`);
+        }
+        const output = {};
+        assign(task.target, task.key, output);
+        for (let index = keys.length - 1; index >= 0; index -= 1) {
+            const key = keys[index];
+            if (typeof key !== 'string')
+                invalid(task.path, 'Project input contains a symbol property');
+            const path = { parent: task.path, segment: key };
+            totalStringBytes += byteLength(key, PROJECT_INPUT_MAX_PROPERTY_KEY_BYTES, path, 'Project input property key');
+            if (totalStringBytes > PROJECT_INPUT_MAX_TOTAL_STRING_BYTES) {
+                limit(path, `Project input strings exceed ${PROJECT_INPUT_MAX_TOTAL_STRING_BYTES.toString()} total UTF-8 bytes`);
+            }
+            tasks.push({
+                value: descriptor(current, key, path).value,
+                target: output,
+                key,
+                path,
+                depth: task.depth + 1,
+            });
+        }
+    }
+    return holder.value;
+}

package/dist/canonical.d.ts

@@ -0,0 +1,9 @@
+import type { JsonValue } from '@aelionsdk/core';
+export declare class CanonicalizationError extends TypeError {
+    readonly code: 'CANONICAL_UNSUPPORTED_VALUE' | 'CANONICAL_NON_FINITE_NUMBER' | 'CANONICAL_NEGATIVE_ZERO' | 'CANONICAL_UNSAFE_INTEGER';
+    constructor(code: CanonicalizationError['code'], message: string);
+}
+export declare function canonicalStringify(value: JsonValue): string;
+export declare function canonicalHash(value: JsonValue): Promise<string>;
+export declare function canonicalClone<T extends JsonValue>(value: T): T;
+//# sourceMappingURL=canonical.d.ts.map

package/dist/canonical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.d.ts","sourceRoot":"","sources":["../src/canonical.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,qBAAa,qBAAsB,SAAQ,SAAS;IAClD,SAAgB,IAAI,EAChB,6BAA6B,GAC7B,6BAA6B,GAC7B,yBAAyB,GACzB,0BAA0B,CAAC;gBAEZ,IAAI,EAAE,qBAAqB,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM;CAKxE;AA8CD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAE3D;AAED,wBAAsB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAOrE;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,SAAS,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAE/D"}

package/dist/canonical.js

@@ -0,0 +1,61 @@
+export class CanonicalizationError extends TypeError {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'CanonicalizationError';
+        this.code = code;
+    }
+}
+function compareCodePoints(left, right) {
+    const leftPoints = Array.from(left, character => character.codePointAt(0) ?? 0);
+    const rightPoints = Array.from(right, character => character.codePointAt(0) ?? 0);
+    const length = Math.min(leftPoints.length, rightPoints.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = (leftPoints[index] ?? 0) - (rightPoints[index] ?? 0);
+        if (difference !== 0)
+            return difference;
+    }
+    return leftPoints.length - rightPoints.length;
+}
+function assertCanonicalNumber(value, path) {
+    if (!Number.isFinite(value)) {
+        throw new CanonicalizationError('CANONICAL_NON_FINITE_NUMBER', `Non-finite number at ${path}`);
+    }
+    if (Object.is(value, -0)) {
+        throw new CanonicalizationError('CANONICAL_NEGATIVE_ZERO', `Negative zero at ${path}`);
+    }
+    if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+        throw new CanonicalizationError('CANONICAL_UNSAFE_INTEGER', `Unsafe integer at ${path}`);
+    }
+}
+function encode(value, path) {
+    if (value === null || typeof value === 'boolean' || typeof value === 'string') {
+        return JSON.stringify(value);
+    }
+    if (typeof value === 'number') {
+        assertCanonicalNumber(value, path);
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((entry, index) => encode(entry, `${path}/${index}`)).join(',')}]`;
+    }
+    if (typeof value === 'object') {
+        const keys = Object.keys(value).sort(compareCodePoints);
+        return `{${keys
+            .map(key => `${JSON.stringify(key)}:${encode(value[key], `${path}/${key}`)}`)
+            .join(',')}}`;
+    }
+    throw new CanonicalizationError('CANONICAL_UNSUPPORTED_VALUE', `Unsupported value at ${path}`);
+}
+export function canonicalStringify(value) {
+    return encode(value, '$');
+}
+export async function canonicalHash(value) {
+    const bytes = new TextEncoder().encode(canonicalStringify(value));
+    const digest = await globalThis.crypto.subtle.digest('SHA-256', bytes);
+    const hex = Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, '0')).join('');
+    return `sha256:${hex}`;
+}
+export function canonicalClone(value) {
+    return JSON.parse(canonicalStringify(value));
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './admission.js';
+export * from './canonical.js';
+export * from './types.js';
+export * from './validate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './admission.js';
+export * from './canonical.js';
+export * from './types.js';
+export * from './validate.js';

package/dist/types.d.ts

@@ -0,0 +1,114 @@
+import type { JsonObject, JsonValue, Rational } from '@aelionsdk/core';
+export type EntityId = string;
+export type CollectionName = 'assets' | 'sequences' | 'tracks' | 'items' | 'materialInstances' | 'transitions' | 'markers' | 'linkGroups';
+export interface TimeRange {
+    readonly startUs: number;
+    readonly durationUs: number;
+}
+export interface ProjectSettings extends JsonObject {
+    defaultSequenceId: EntityId;
+    defaultStillDurationUs: number;
+    missingAssetPolicy: 'placeholder' | 'error';
+    missingMaterialPolicy: 'placeholder' | 'error';
+    missingPluginPolicy: 'placeholder' | 'error';
+    locale?: string;
+    timezone?: string;
+}
+export interface ProjectEntity extends JsonObject {
+    id: EntityId;
+}
+export interface SequenceEntity extends ProjectEntity {
+    trackIds: EntityId[];
+    transitionIds: EntityId[];
+    materialInstanceIds: EntityId[];
+    markerIds: EntityId[];
+}
+export interface TrackAudioProperties extends JsonObject {
+    gainDb: JsonValue;
+    pan: JsonValue;
+    muted: boolean;
+    /** Missing in older Project v1 documents means false. */
+    solo?: boolean;
+}
+export interface TrackEntity extends ProjectEntity {
+    sequenceId: EntityId;
+    kind: 'visual' | 'audio' | 'caption';
+    enabled: boolean;
+    locked: boolean;
+    itemIds: EntityId[];
+    materialInstanceIds: EntityId[];
+    audio?: TrackAudioProperties;
+}
+export interface ItemEntity extends ProjectEntity {
+    trackId: EntityId;
+    type: string;
+    enabled: boolean;
+    range: TimeRange & JsonObject;
+    materialInstanceIds: EntityId[];
+    markerIds?: EntityId[];
+    linkGroupId?: EntityId;
+}
+/** Project v1 audio Items can use varispeed or deterministic pitch-preserving stretch. */
+export interface ItemAudioProperties extends JsonObject {
+    gainDb: JsonValue;
+    pan: JsonValue;
+    fadeInUs?: number;
+    fadeOutUs?: number;
+    pitchPolicy?: 'varispeed' | 'preserve';
+    channelMap?: JsonValue[];
+}
+export interface TransitionEntity extends ProjectEntity {
+    sequenceId: EntityId;
+    trackId: EntityId;
+    fromItemId: EntityId;
+    toItemId: EntityId;
+    range: TimeRange & JsonObject;
+    materialInstanceId: EntityId;
+}
+export interface MaterialInstanceEntity extends ProjectEntity {
+    definition: JsonObject;
+    enabled: boolean;
+    parameters: JsonObject;
+}
+export interface LinkGroupEntity extends ProjectEntity {
+    kind: 'av-sync' | 'edit-group';
+    itemIds: EntityId[];
+    syncOffsetsUs?: Record<EntityId, number>;
+}
+export interface MarkerEntity extends ProjectEntity {
+    owner: {
+        type: 'sequence' | 'item';
+        id: EntityId;
+    } & JsonObject;
+    timeUs: number;
+    durationUs: number;
+    label?: string;
+    color?: string;
+    payload?: JsonValue;
+}
+export interface AelionProject extends JsonObject {
+    $schema: string;
+    schemaVersion: string;
+    projectId: EntityId;
+    metadata: JsonObject;
+    settings: ProjectSettings;
+    assets: Record<EntityId, ProjectEntity>;
+    sequences: Record<EntityId, SequenceEntity>;
+    tracks: Record<EntityId, TrackEntity>;
+    items: Record<EntityId, ItemEntity>;
+    materialInstances: Record<EntityId, MaterialInstanceEntity>;
+    transitions: Record<EntityId, TransitionEntity>;
+    markers: Record<EntityId, MarkerEntity>;
+    linkGroups: Record<EntityId, LinkGroupEntity>;
+    extensions: Record<string, JsonValue>;
+}
+export interface FrameFormat {
+    readonly width: number;
+    readonly height: number;
+    readonly pixelAspectRatio: Rational;
+    readonly frameRate: Rational;
+    readonly sampleRate: 44_100 | 48_000 | 96_000;
+    readonly channelLayout: 'mono' | 'stereo' | '5.1';
+}
+export declare const COLLECTION_NAMES: readonly CollectionName[];
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEvE,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAC9B,MAAM,MAAM,cAAc,GACtB,QAAQ,GACR,WAAW,GACX,QAAQ,GACR,OAAO,GACP,mBAAmB,GACnB,aAAa,GACb,SAAS,GACT,YAAY,CAAC;AAEjB,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,eAAgB,SAAQ,UAAU;IACjD,iBAAiB,EAAE,QAAQ,CAAC;IAC5B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,kBAAkB,EAAE,aAAa,GAAG,OAAO,CAAC;IAC5C,qBAAqB,EAAE,aAAa,GAAG,OAAO,CAAC;IAC/C,mBAAmB,EAAE,aAAa,GAAG,OAAO,CAAC;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C,EAAE,EAAE,QAAQ,CAAC;CACd;AAED,MAAM,WAAW,cAAe,SAAQ,aAAa;IACnD,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACrB,aAAa,EAAE,QAAQ,EAAE,CAAC;IAC1B,mBAAmB,EAAE,QAAQ,EAAE,CAAC;IAChC,SAAS,EAAE,QAAQ,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,oBAAqB,SAAQ,UAAU;IACtD,MAAM,EAAE,SAAS,CAAC;IAClB,GAAG,EAAE,SAAS,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,yDAAyD;IACzD,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,WAAY,SAAQ,aAAa;IAChD,UAAU,EAAE,QAAQ,CAAC;IACrB,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB,mBAAmB,EAAE,QAAQ,EAAE,CAAC;IAChC,KAAK,CAAC,EAAE,oBAAoB,CAAC;CAC9B;AAED,MAAM,WAAW,UAAW,SAAQ,aAAa;IAC/C,OAAO,EAAE,QAAQ,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,SAAS,GAAG,UAAU,CAAC;IAC9B,mBAAmB,EAAE,QAAQ,EAAE,CAAC;IAChC,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IACvB,WAAW,CAAC,EAAE,QAAQ,CAAC;CACxB;AAED,0FAA0F;AAC1F,MAAM,WAAW,mBAAoB,SAAQ,UAAU;IACrD,MAAM,EAAE,SAAS,CAAC;IAClB,GAAG,EAAE,SAAS,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,WAAW,GAAG,UAAU,CAAC;IACvC,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACrD,UAAU,EAAE,QAAQ,CAAC;IACrB,OAAO,EAAE,QAAQ,CAAC;IAClB,UAAU,EAAE,QAAQ,CAAC;IACrB,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,EAAE,SAAS,GAAG,UAAU,CAAC;IAC9B,kBAAkB,EAAE,QAAQ,CAAC;CAC9B;AAED,MAAM,WAAW,sBAAuB,SAAQ,aAAa;IAC3D,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,eAAgB,SAAQ,aAAa;IACpD,IAAI,EAAE,SAAS,GAAG,YAAY,CAAC;IAC/B,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;CAC1C;AAED,MAAM,WAAW,YAAa,SAAQ,aAAa;IACjD,KAAK,EAAE;QAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC;QAAC,EAAE,EAAE,QAAQ,CAAA;KAAE,GAAG,UAAU,CAAC;IAChE,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,SAAS,CAAC;CACrB;AAED,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,QAAQ,CAAC;IACpB,QAAQ,EAAE,UAAU,CAAC;IACrB,QAAQ,EAAE,eAAe,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;IACxC,SAAS,EAAE,MAAM,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;IAC5C,MAAM,EAAE,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;IACtC,KAAK,EAAE,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;IACpC,iBAAiB,EAAE,MAAM,CAAC,QAAQ,EAAE,sBAAsB,CAAC,CAAC;IAC5D,WAAW,EAAE,MAAM,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;IAChD,OAAO,EAAE,MAAM,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;IACxC,UAAU,EAAE,MAAM,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;IAC9C,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,gBAAgB,EAAE,QAAQ,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IAC9C,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;CACnD;AAED,eAAO,MAAM,gBAAgB,EAAE,SAAS,cAAc,EAS5C,CAAC"}

package/dist/types.js

@@ -0,0 +1,10 @@
+export const COLLECTION_NAMES = [
+    'assets',
+    'sequences',
+    'tracks',
+    'items',
+    'materialInstances',
+    'transitions',
+    'markers',
+    'linkGroups',
+];

package/dist/validate.d.ts

@@ -0,0 +1,15 @@
+import type { JsonObject, Result } from '@aelionsdk/core';
+import { type AelionProject } from './types.js';
+export interface ProjectValidatorOptions {
+    readonly projectSchema: JsonObject;
+    readonly materialInstanceSchema: JsonObject;
+}
+export interface ProjectValidationSuccess {
+    readonly project: AelionProject;
+}
+export declare class ProjectValidator {
+    #private;
+    constructor(options: ProjectValidatorOptions);
+    validate(value: unknown): Result<ProjectValidationSuccess>;
+}
+//# sourceMappingURL=validate.d.ts.map

package/dist/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAc,UAAU,EAAa,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAGjF,OAAO,EAAoB,KAAK,aAAa,EAAuB,MAAM,YAAY,CAAC;AAmCvF,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,aAAa,EAAE,UAAU,CAAC;IACnC,QAAQ,CAAC,sBAAsB,EAAE,UAAU,CAAC;CAC7C;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;CACjC;AAsrBD,qBAAa,gBAAgB;;gBAGR,OAAO,EAAE,uBAAuB;IAY5C,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,wBAAwB,CAAC;CA+ClE"}

package/dist/validate.js

@@ -0,0 +1,415 @@
+import Ajv2020, {} from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { err, ok } from '@aelionsdk/core';
+import { COLLECTION_NAMES } from './types.js';
+import { ProjectInputAdmissionError, snapshotProjectInput } from './admission.js';
+const MAX_PROJECT_DIAGNOSTICS = 64;
+class BoundedDiagnosticCollector {
+    #diagnostics = [];
+    #truncated = false;
+    get diagnostics() {
+        return this.#diagnostics;
+    }
+    push(...diagnostics) {
+        for (const diagnostic of diagnostics) {
+            if (this.#diagnostics.length < MAX_PROJECT_DIAGNOSTICS - 1) {
+                this.#diagnostics.push(diagnostic);
+            }
+            else if (!this.#truncated) {
+                this.#diagnostics.push({
+                    code: 'PROJECT_DIAGNOSTICS_TRUNCATED',
+                    severity: 'error',
+                    message: `Project validation produced more than ${MAX_PROJECT_DIAGNOSTICS.toString()} diagnostics`,
+                    recoverable: false,
+                });
+                this.#truncated = true;
+            }
+        }
+        return this.#diagnostics.length;
+    }
+}
+function schemaDiagnostic(error) {
+    const path = error.instancePath
+        .split('/')
+        .slice(1)
+        .map(segment => segment.replaceAll('~1', '/').replaceAll('~0', '~'));
+    return {
+        code: 'PROJECT_SCHEMA_INVALID',
+        severity: 'error',
+        message: error.message ?? 'Project does not conform to its JSON Schema',
+        path,
+        recoverable: false,
+        details: {
+            keyword: error.keyword,
+            schemaPath: error.schemaPath,
+            params: error.params,
+        },
+    };
+}
+function semanticDiagnostic(code, message, path, entityId) {
+    return {
+        code,
+        severity: 'error',
+        message,
+        path,
+        ...(entityId === undefined ? {} : { entityId }),
+        recoverable: false,
+    };
+}
+function validateEntityMap(project, collection, diagnostics) {
+    const entities = project[collection];
+    for (const [key, entity] of Object.entries(entities)) {
+        if (key !== entity.id) {
+            diagnostics.push(semanticDiagnostic('PROJECT_ENTITY_KEY_MISMATCH', `${collection} key ${key} does not match entity id ${entity.id}`, [collection, key, 'id'], entity.id));
+        }
+    }
+}
+function requireReference(values, id, expectedCollection, path, diagnostics) {
+    if (Object.hasOwn(values, id))
+        return true;
+    diagnostics.push(semanticDiagnostic('PROJECT_REFERENCE_MISSING', `Reference ${id} does not exist in ${expectedCollection}`, path, id));
+    return false;
+}
+function validateUniqueList(values, path, diagnostics) {
+    const seen = new Set();
+    values.forEach((value, index) => {
+        if (seen.has(value)) {
+            diagnostics.push(semanticDiagnostic('PROJECT_DUPLICATE_REFERENCE', `Duplicate reference ${value}`, [...path, index], value));
+        }
+        seen.add(value);
+    });
+}
+function validateReferences(project, diagnostics) {
+    requireReference(project.sequences, project.settings.defaultSequenceId, 'sequences', ['settings', 'defaultSequenceId'], diagnostics);
+    for (const sequence of Object.values(project.sequences)) {
+        validateUniqueList(sequence.trackIds, ['sequences', sequence.id, 'trackIds'], diagnostics);
+        validateUniqueList(sequence.transitionIds, ['sequences', sequence.id, 'transitionIds'], diagnostics);
+        validateUniqueList(sequence.materialInstanceIds, ['sequences', sequence.id, 'materialInstanceIds'], diagnostics);
+        validateUniqueList(sequence.markerIds, ['sequences', sequence.id, 'markerIds'], diagnostics);
+        sequence.trackIds.forEach((id, index) => {
+            if (requireReference(project.tracks, id, 'tracks', ['sequences', sequence.id, 'trackIds', index], diagnostics) &&
+                project.tracks[id]?.sequenceId !== sequence.id) {
+                diagnostics.push(semanticDiagnostic('PROJECT_HOST_MISMATCH', `Track ${id} belongs to another sequence`, ['sequences', sequence.id, 'trackIds', index], id));
+            }
+        });
+        sequence.transitionIds.forEach((id, index) => requireReference(project.transitions, id, 'transitions', ['sequences', sequence.id, 'transitionIds', index], diagnostics));
+        sequence.materialInstanceIds.forEach((id, index) => requireReference(project.materialInstances, id, 'materialInstances', ['sequences', sequence.id, 'materialInstanceIds', index], diagnostics));
+        sequence.markerIds.forEach((id, index) => requireReference(project.markers, id, 'markers', ['sequences', sequence.id, 'markerIds', index], diagnostics));
+    }
+    for (const track of Object.values(project.tracks)) {
+        requireReference(project.sequences, track.sequenceId, 'sequences', ['tracks', track.id, 'sequenceId'], diagnostics);
+        validateUniqueList(track.itemIds, ['tracks', track.id, 'itemIds'], diagnostics);
+        validateUniqueList(track.materialInstanceIds, ['tracks', track.id, 'materialInstanceIds'], diagnostics);
+        track.itemIds.forEach((id, index) => {
+            if (requireReference(project.items, id, 'items', ['tracks', track.id, 'itemIds', index], diagnostics) &&
+                project.items[id]?.trackId !== track.id) {
+                diagnostics.push(semanticDiagnostic('PROJECT_HOST_MISMATCH', `Item ${id} belongs to another track`, ['tracks', track.id, 'itemIds', index], id));
+            }
+        });
+        track.materialInstanceIds.forEach((id, index) => requireReference(project.materialInstances, id, 'materialInstances', ['tracks', track.id, 'materialInstanceIds', index], diagnostics));
+    }
+    for (const item of Object.values(project.items)) {
+        requireReference(project.tracks, item.trackId, 'tracks', ['items', item.id, 'trackId'], diagnostics);
+        validateUniqueList(item.materialInstanceIds, ['items', item.id, 'materialInstanceIds'], diagnostics);
+        item.materialInstanceIds.forEach((id, index) => requireReference(project.materialInstances, id, 'materialInstances', ['items', item.id, 'materialInstanceIds', index], diagnostics));
+        if (item.type === 'adjustment' && item.materialInstanceIds.length === 0) {
+            diagnostics.push(semanticDiagnostic('PROJECT_ADJUSTMENT_EMPTY', `Adjustment Item ${item.id} must own at least one Material`, ['items', item.id, 'materialInstanceIds'], item.id));
+        }
+        if (item.type === 'nested-sequence') {
+            const source = item.source;
+            if (typeof source?.sequenceId === 'string') {
+                requireReference(project.sequences, source.sequenceId, 'sequences', ['items', item.id, 'source', 'sequenceId'], diagnostics);
+            }
+        }
+        if (item.type === 'image') {
+            const source = item.source;
+            if (source?.stream?.type !== 'video') {
+                diagnostics.push(semanticDiagnostic('PROJECT_IMAGE_STREAM_INVALID', `Image Item ${item.id} must use the visual stream adapter`, ['items', item.id, 'source', 'stream', 'type'], item.id));
+            }
+        }
+        const visual = item.visual;
+        if (visual !== null && typeof visual === 'object' && !Array.isArray(visual)) {
+            const mask = Reflect.get(visual, 'mask');
+            if (mask !== null && typeof mask === 'object' && !Array.isArray(mask)) {
+                const sourceItemId = Reflect.get(mask, 'sourceItemId');
+                if (typeof sourceItemId === 'string') {
+                    const exists = requireReference(project.items, sourceItemId, 'items', ['items', item.id, 'visual', 'mask', 'sourceItemId'], diagnostics);
+                    const sourceTrackId = project.items[sourceItemId]?.trackId;
+                    const ownerSequenceId = project.tracks[item.trackId]?.sequenceId;
+                    const sourceSequenceId = sourceTrackId === undefined ? undefined : project.tracks[sourceTrackId]?.sequenceId;
+                    if (exists && (sourceItemId === item.id || sourceSequenceId !== ownerSequenceId)) {
+                        diagnostics.push(semanticDiagnostic('PROJECT_MASK_SOURCE_INVALID', `Mask source ${sourceItemId} must be another Item in the same Sequence`, ['items', item.id, 'visual', 'mask', 'sourceItemId'], item.id));
+                    }
+                }
+            }
+        }
+        if (item.linkGroupId !== undefined) {
+            if (requireReference(project.linkGroups, item.linkGroupId, 'linkGroups', ['items', item.id, 'linkGroupId'], diagnostics) &&
+                !project.linkGroups[item.linkGroupId]?.itemIds.includes(item.id)) {
+                diagnostics.push(semanticDiagnostic('PROJECT_LINK_GROUP_BACKREF_MISSING', `LinkGroup ${item.linkGroupId} does not contain Item ${item.id}`, ['items', item.id, 'linkGroupId'], item.id));
+            }
+        }
+    }
+    for (const group of Object.values(project.linkGroups)) {
+        validateUniqueList(group.itemIds, ['linkGroups', group.id, 'itemIds'], diagnostics);
+        if (group.itemIds.length < 2) {
+            diagnostics.push(semanticDiagnostic('PROJECT_LINK_GROUP_TOO_SMALL', `LinkGroup ${group.id} must contain at least two Items`, ['linkGroups', group.id, 'itemIds'], group.id));
+        }
+        let sequenceId;
+        group.itemIds.forEach((id, index) => {
+            if (!requireReference(project.items, id, 'items', ['linkGroups', group.id, 'itemIds', index], diagnostics)) {
+                return;
+            }
+            const item = project.items[id];
+            if (item?.linkGroupId !== group.id) {
+                diagnostics.push(semanticDiagnostic('PROJECT_LINK_GROUP_BACKREF_MISSING', `Item ${id} does not reference LinkGroup ${group.id}`, ['linkGroups', group.id, 'itemIds', index], id));
+            }
+            const itemSequenceId = item === undefined ? undefined : project.tracks[item.trackId]?.sequenceId;
+            if (sequenceId === undefined)
+                sequenceId = itemSequenceId;
+            else if (itemSequenceId !== undefined && itemSequenceId !== sequenceId) {
+                diagnostics.push(semanticDiagnostic('PROJECT_LINK_GROUP_SEQUENCE_MISMATCH', `LinkGroup ${group.id} cannot span Sequences`, ['linkGroups', group.id, 'itemIds', index], group.id));
+            }
+        });
+        for (const id of Object.keys(group.syncOffsetsUs ?? {})) {
+            if (!group.itemIds.includes(id)) {
+                diagnostics.push(semanticDiagnostic('PROJECT_LINK_GROUP_OFFSET_ORPHAN', `LinkGroup ${group.id} has an offset for non-member ${id}`, ['linkGroups', group.id, 'syncOffsetsUs', id], group.id));
+            }
+        }
+    }
+    for (const transition of Object.values(project.transitions)) {
+        requireReference(project.sequences, transition.sequenceId, 'sequences', ['transitions', transition.id, 'sequenceId'], diagnostics);
+        requireReference(project.tracks, transition.trackId, 'tracks', ['transitions', transition.id, 'trackId'], diagnostics);
+        requireReference(project.items, transition.fromItemId, 'items', ['transitions', transition.id, 'fromItemId'], diagnostics);
+        requireReference(project.items, transition.toItemId, 'items', ['transitions', transition.id, 'toItemId'], diagnostics);
+        requireReference(project.materialInstances, transition.materialInstanceId, 'materialInstances', ['transitions', transition.id, 'materialInstanceId'], diagnostics);
+    }
+}
+function validateNestedSequenceCycles(project, diagnostics) {
+    const edges = new Map();
+    for (const item of Object.values(project.items)) {
+        if (item.type !== 'nested-sequence')
+            continue;
+        const owner = project.tracks[item.trackId]?.sequenceId;
+        const source = item.source;
+        if (owner === undefined || typeof source?.sequenceId !== 'string')
+            continue;
+        const values = edges.get(owner);
+        const edge = { itemId: item.id, target: source.sequenceId };
+        if (values === undefined)
+            edges.set(owner, [edge]);
+        else
+            values.push(edge);
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    const stack = [];
+    const visit = (sequenceId) => {
+        if (visited.has(sequenceId))
+            return;
+        visiting.add(sequenceId);
+        stack.push(sequenceId);
+        for (const edge of edges.get(sequenceId) ?? []) {
+            if (visiting.has(edge.target)) {
+                const cycleStart = stack.indexOf(edge.target);
+                diagnostics.push(semanticDiagnostic('PROJECT_NESTED_SEQUENCE_CYCLE', `Nested Sequence cycle: ${[...stack.slice(cycleStart), edge.target].join(' -> ')}`, ['items', edge.itemId, 'source', 'sequenceId'], edge.itemId));
+            }
+            else {
+                visit(edge.target);
+            }
+        }
+        stack.pop();
+        visiting.delete(sequenceId);
+        visited.add(sequenceId);
+    };
+    for (const sequenceId of Object.keys(project.sequences))
+        visit(sequenceId);
+}
+function validateMaterialOwnership(project, diagnostics) {
+    const owners = new Map();
+    const claim = (instanceId, owner, path) => {
+        if (!Object.hasOwn(project.materialInstances, instanceId))
+            return;
+        const existing = owners.get(instanceId);
+        if (existing !== undefined) {
+            diagnostics.push(semanticDiagnostic('PROJECT_MATERIAL_MULTIPLE_OWNERS', `Material instance ${instanceId} is owned by both ${existing} and ${owner}`, path, instanceId));
+            return;
+        }
+        owners.set(instanceId, owner);
+    };
+    for (const sequence of Object.values(project.sequences)) {
+        sequence.materialInstanceIds.forEach((id, index) => claim(id, `sequence:${sequence.id}`, [
+            'sequences',
+            sequence.id,
+            'materialInstanceIds',
+            index,
+        ]));
+    }
+    for (const track of Object.values(project.tracks)) {
+        track.materialInstanceIds.forEach((id, index) => claim(id, `track:${track.id}`, ['tracks', track.id, 'materialInstanceIds', index]));
+    }
+    for (const item of Object.values(project.items)) {
+        item.materialInstanceIds.forEach((id, index) => claim(id, `item:${item.id}`, ['items', item.id, 'materialInstanceIds', index]));
+    }
+    for (const transition of Object.values(project.transitions)) {
+        claim(transition.materialInstanceId, `transition:${transition.id}`, [
+            'transitions',
+            transition.id,
+            'materialInstanceId',
+        ]);
+    }
+    for (const id of Object.keys(project.materialInstances)) {
+        if (!owners.has(id)) {
+            diagnostics.push(semanticDiagnostic('PROJECT_MATERIAL_ORPHAN', `Material instance ${id} has no owner`, ['materialInstances', id], id));
+        }
+    }
+}
+function validateVisualTransitionOverlap(project, diagnostics) {
+    const bySequence = new Map();
+    for (const transition of Object.values(project.transitions)) {
+        if (transition.kind !== 'visual')
+            continue;
+        const startUs = BigInt(transition.range.startUs);
+        const interval = {
+            id: transition.id,
+            startUs,
+            endUs: startUs + BigInt(transition.range.durationUs),
+        };
+        const transitions = bySequence.get(transition.sequenceId);
+        if (transitions === undefined) {
+            bySequence.set(transition.sequenceId, [interval]);
+        }
+        else {
+            transitions.push(interval);
+        }
+    }
+    for (const transitions of bySequence.values()) {
+        transitions.sort((left, right) => {
+            if (left.startUs !== right.startUs)
+                return left.startUs < right.startUs ? -1 : 1;
+            if (left.endUs !== right.endUs)
+                return left.endUs < right.endUs ? -1 : 1;
+            return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+        });
+        let active = transitions[0];
+        for (const transition of transitions.slice(1)) {
+            if (active !== undefined && transition.startUs < active.endUs) {
+                diagnostics.push(semanticDiagnostic('PROJECT_VISUAL_TRANSITION_OVERLAP', `Visual transition ${transition.id} overlaps ${active.id} in the same sequence`, ['transitions', transition.id, 'range'], transition.id));
+            }
+            if (active === undefined || transition.startUs >= active.endUs) {
+                active = transition;
+            }
+            else if (transition.endUs > active.endUs) {
+                active = transition;
+            }
+        }
+    }
+}
+function validateTimeMappingSemantics(project, diagnostics) {
+    for (const item of Object.values(project.items)) {
+        if (item.type !== 'video' && item.type !== 'audio' && item.type !== 'nested-sequence')
+            continue;
+        const source = item.source;
+        const mapping = source.timeMapping;
+        if (mapping?.type !== 'curve' || !Array.isArray(mapping.points))
+            continue;
+        const points = mapping.points;
+        const pointTime = (value) => value !== null && typeof value === 'object' && !Array.isArray(value)
+            ? Reflect.get(value, 'itemTimeUs')
+            : undefined;
+        const firstTime = pointTime(points[0]);
+        const lastTime = pointTime(points.at(-1));
+        if (firstTime !== 0 || lastTime !== item.range.durationUs) {
+            diagnostics.push(semanticDiagnostic('PROJECT_TIME_MAPPING_ENDPOINT_INVALID', `Curve TimeMap for ${item.id} must start at 0 and end at the Item duration`, ['items', item.id, 'source', 'timeMapping', 'points'], item.id));
+        }
+        for (let index = 1; index < points.length; index += 1) {
+            const previous = pointTime(points[index - 1]);
+            const current = pointTime(points[index]);
+            if (typeof previous === 'number' && typeof current === 'number' && current <= previous) {
+                diagnostics.push(semanticDiagnostic('PROJECT_TIME_MAPPING_ORDER_INVALID', `Curve TimeMap Item times must strictly increase for ${item.id}`, ['items', item.id, 'source', 'timeMapping', 'points', index, 'itemTimeUs'], item.id));
+                break;
+            }
+        }
+    }
+}
+function validateAudioSemantics(project, diagnostics) {
+    for (const item of Object.values(project.items)) {
+        if (item.type !== 'audio')
+            continue;
+        const typedItem = item;
+        const audio = typedItem.audio;
+        for (const property of ['fadeInUs', 'fadeOutUs']) {
+            const durationUs = audio?.[property];
+            if (typeof durationUs !== 'number' || durationUs <= item.range.durationUs)
+                continue;
+            diagnostics.push(semanticDiagnostic('PROJECT_AUDIO_FADE_OUT_OF_RANGE', `${property} for audio item ${item.id} cannot exceed the Item duration`, ['items', item.id, 'audio', property], item.id));
+        }
+        if (audio?.pitchPolicy === 'preserve' && typedItem.source?.timeMapping?.type !== 'linear') {
+            diagnostics.push(semanticDiagnostic('PROJECT_AUDIO_PITCH_POLICY_UNSUPPORTED', `Pitch-preserving stretch for audio item ${item.id} requires a linear TimeMap`, ['items', item.id, 'audio', 'pitchPolicy'], item.id));
+        }
+    }
+}
+function validateColorSemantics(project, diagnostics) {
+    for (const sequence of Object.values(project.sequences)) {
+        const format = sequence.format;
+        if (format.transferFunction !== 'pq' && format.transferFunction !== 'hlg')
+            continue;
+        if (format.workingColorSpace !== 'rec2020-linear' || format.bitDepth !== 10) {
+            diagnostics.push(semanticDiagnostic('PROJECT_HDR_FORMAT_INVALID', `HDR Sequence ${sequence.id} requires rec2020-linear working space and 10-bit output`, ['sequences', sequence.id, 'format'], sequence.id));
+        }
+    }
+}
+export class ProjectValidator {
+    #schemaValidator;
+    constructor(options) {
+        const ajv = new Ajv2020({
+            allErrors: false,
+            allowUnionTypes: true,
+            strict: true,
+            validateFormats: true,
+        });
+        addFormats(ajv);
+        ajv.addSchema(options.materialInstanceSchema);
+        this.#schemaValidator = ajv.compile(options.projectSchema);
+    }
+    validate(value) {
+        let admitted;
+        try {
+            admitted = snapshotProjectInput(value);
+        }
+        catch (error) {
+            const admission = error instanceof ProjectInputAdmissionError
+                ? error
+                : new ProjectInputAdmissionError('PROJECT_INPUT_INVALID', 'Project input could not be safely inspected', []);
+            return err({
+                code: admission.code,
+                severity: 'error',
+                message: admission.message,
+                path: admission.path,
+                recoverable: false,
+            });
+        }
+        if (!this.#schemaValidator(admitted)) {
+            const first = this.#schemaValidator.errors?.[0];
+            return err(first === undefined
+                ? {
+                    code: 'PROJECT_SCHEMA_INVALID',
+                    severity: 'error',
+                    message: 'Project does not conform to its JSON Schema',
+                    recoverable: false,
+                }
+                : schemaDiagnostic(first));
+        }
+        const project = admitted;
+        const diagnostics = new BoundedDiagnosticCollector();
+        COLLECTION_NAMES.forEach(collection => validateEntityMap(project, collection, diagnostics));
+        validateReferences(project, diagnostics);
+        validateMaterialOwnership(project, diagnostics);
+        validateNestedSequenceCycles(project, diagnostics);
+        validateVisualTransitionOverlap(project, diagnostics);
+        validateTimeMappingSemantics(project, diagnostics);
+        validateAudioSemantics(project, diagnostics);
+        validateColorSemantics(project, diagnostics);
+        return diagnostics.diagnostics.length === 0 ? ok({ project }) : err(...diagnostics.diagnostics);
+    }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@aelionsdk/project-schema",
+  "version": "0.1.0-beta.1",
+  "description": "Project v1 types, validation and canonical serialization for AelionSDK",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/FoyonaCZY/AelionSDK.git",
+    "directory": "packages/project-schema"
+  },
+  "keywords": [
+    "aelion",
+    "timeline",
+    "video",
+    "schema"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/.tsbuildinfo"
+  ],
+  "engines": {
+    "node": ">=20.19"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@aelionsdk/core": "0.1.0-beta.1",
+    "ajv": "8.17.1",
+    "ajv-formats": "3.0.1"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "typecheck": "tsc -b --pretty false"
+  }
+}