@skenora/scene-plan 0.1.2

package/dist/validation/validate.js

@@ -0,0 +1,704 @@
+import { createBuiltInFlowNodeRegistry, validateFlowGraph, } from "@skenora/flow";
+import { validateSceneDocument, validateAuthoredMaterial, validateFieldRule, validateProceduralGeometryProgram, MATERIAL_SLOT_TARGET_RULE, } from "@skenora/contracts";
+import { createDiagnostic, finalizeDiagnostics, hasErrors, } from "../diagnostics/diagnostics.js";
+import { isJsonObject, isJsonValue } from "../model/json.js";
+import { normalizeSceneBlueprint } from "../normalization/normalize.js";
+const ENTITY_KINDS = new Set([
+    "group",
+    "model",
+    "primitive",
+    "procedural",
+    "shape",
+    "particle",
+    "annotation",
+    "camera",
+]);
+const RESOURCE_KINDS = new Set([
+    "model",
+    "texture",
+    "environment",
+    "audio",
+    "data",
+]);
+const ID_PATTERN = /^[A-Za-z][A-Za-z0-9._:-]{0,127}$/;
+const EXTENSION_NAMESPACE_PATTERN = /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/;
+const QUATERNION_TOLERANCE = 0.001;
+export function validateSceneBlueprint(input, context = {}) {
+    const normalized = normalizeSceneBlueprint(input);
+    if (!normalized.ok || !normalized.value) {
+        return {
+            valid: false,
+            diagnostics: normalized.diagnostics,
+        };
+    }
+    const diagnostics = [
+        ...normalized.diagnostics,
+        ...validateNormalizedSceneBlueprint(normalized.value, context, {
+            requireResourceBindings: context.resourceBindings !== undefined,
+        }),
+    ];
+    const finalized = finalizeDiagnostics(diagnostics);
+    return {
+        valid: !hasErrors(finalized),
+        normalized: normalized.value,
+        diagnostics: finalized,
+    };
+}
+export function validateNormalizedSceneBlueprint(blueprint, context = {}, options = {}) {
+    const diagnostics = [];
+    validateBlueprintHeader(blueprint, diagnostics);
+    const resources = validateResources(blueprint.resources, context, options, diagnostics);
+    const entityIds = new Set();
+    for (const [index, entity] of blueprint.entities.entries()) {
+        validateEntity(entity, index, entityIds, resources, diagnostics);
+    }
+    validateHierarchy(blueprint.entities, entityIds, diagnostics);
+    const materialIds = validateMaterials(blueprint.materials, diagnostics);
+    const bindingIds = validateBindings(blueprint.materialBindings, materialIds, entityIds, diagnostics);
+    validateTextureAnimations(blueprint.textureAnimations, materialIds, resources, diagnostics);
+    validateCameraPaths(blueprint.cameraPaths, diagnostics);
+    validateSettings(blueprint, resources, diagnostics);
+    validateCapabilities(blueprint.requires, context, diagnostics);
+    validateExtensions(blueprint.extensions, context, diagnostics);
+    validateFlows(blueprint.flows, context, entityIds, materialIds, new Set(blueprint.cameraPaths.map((path) => path.id)), new Set(blueprint.textureAnimations.map((animation) => animation.id)), new Map(blueprint.materials.map((material) => [
+        material.id,
+        new Set(material.creation && Array.isArray(material.animations)
+            ? material.animations.flatMap((animation) => isJsonObject(animation) && typeof animation.id === "string"
+                ? [animation.id]
+                : [])
+            : []),
+    ])), resources, diagnostics);
+    if (Object.keys(blueprint.initialVariables).length > 0 &&
+        context.allowVariables !== true) {
+        diagnostics.push(createDiagnostic({
+            code: "unsupported-capability",
+            stage: "validate",
+            path: ["initialVariables"],
+            message: "Initial Flow variables require an explicit host allowance",
+            recoverable: true,
+        }));
+    }
+    return finalizeDiagnostics(diagnostics);
+}
+export function validateSceneDocumentCandidate(document) {
+    const result = validateSceneDocument(document);
+    return finalizeDiagnostics(result.issues.map((issue) => nativeDiagnostic(issue)));
+}
+export function isStableScenePlanId(value) {
+    return typeof value === "string" && ID_PATTERN.test(value);
+}
+function validateBlueprintHeader(blueprint, diagnostics) {
+    if (blueprint.schema !== "skenora.scene.blueprint") {
+        add(diagnostics, "invalid-schema", ["schema"], "Expected skenora.scene.blueprint");
+    }
+    if (blueprint.version !== 1) {
+        add(diagnostics, "unsupported-version", ["version"], "Only SceneBlueprint version 1 is supported");
+    }
+    if (blueprint.defaultsProfile !== "scene-v1") {
+        add(diagnostics, "unsupported-version", ["defaultsProfile"], "Only the scene-v1 defaults profile is supported");
+    }
+    validateId(blueprint.scene.id, ["scene", "id"], diagnostics);
+    validateName(blueprint.scene.name, ["scene", "name"], diagnostics);
+}
+function validateResources(resources, context, options, diagnostics) {
+    const result = new Map();
+    for (const [index, resource] of resources.entries()) {
+        const path = ["resources", index];
+        if (!isJsonObject(resource)) {
+            add(diagnostics, "invalid-value", path, "Resource must be a JSON object");
+            continue;
+        }
+        validateId(resource.id, [...path, "id"], diagnostics);
+        if (result.has(resource.id)) {
+            add(diagnostics, "duplicate-id", [...path, "id"], `Duplicate resource id: ${resource.id}`);
+        }
+        else {
+            result.set(resource.id, resource);
+        }
+        if (!RESOURCE_KINDS.has(resource.kind)) {
+            add(diagnostics, "invalid-value", [...path, "kind"], `Unsupported resource kind: ${String(resource.kind)}`);
+        }
+        if (resource.mediaType !== undefined &&
+            !isNonEmptyString(resource.mediaType)) {
+            add(diagnostics, "invalid-value", [...path, "mediaType"], "Resource mediaType must be a non-empty string");
+        }
+        if (resource.label !== undefined && typeof resource.label !== "string") {
+            add(diagnostics, "invalid-value", [...path, "label"], "Resource label must be a string");
+        }
+        validateIntegrity(resource.integrity, [...path, "integrity"], diagnostics);
+        if (options.requireResourceBindings ||
+            context.resourceBindings !== undefined) {
+            const binding = context.resourceBindings?.[resource.id];
+            if (!binding) {
+                add(diagnostics, "missing-resource-binding", [...path, "id"], `No authorized resource binding was supplied for ${resource.id}`, { assetId: resource.id, recoverable: true });
+            }
+            else {
+                validateResourceBinding(resource, binding, [...path, "id"], diagnostics);
+            }
+        }
+    }
+    return result;
+}
+function validateResourceBinding(resource, binding, path, diagnostics) {
+    const bindingKind = binding.kind;
+    if (bindingKind !== resource.kind) {
+        add(diagnostics, "resource-kind-mismatch", path, `Resource ${resource.id} expects kind ${resource.kind}, received ${bindingKind}`, { assetId: resource.id, recoverable: true });
+    }
+    const source = binding.source ?? binding.uri;
+    if (!source) {
+        add(diagnostics, "invalid-value", path, `Resource binding ${resource.id} has no source`, { assetId: resource.id });
+    }
+    if (resource.integrity && binding.integrity) {
+        if (resource.integrity.algorithm !== binding.integrity.algorithm ||
+            resource.integrity.value !== binding.integrity.value) {
+            add(diagnostics, "resource-integrity-mismatch", path, `Resource binding integrity does not match ${resource.id}`, { assetId: resource.id, recoverable: true });
+        }
+    }
+    if (!isJsonValue(binding)) {
+        add(diagnostics, "invalid-json", path, `Resource binding ${resource.id} must be serializable JSON`, { assetId: resource.id });
+    }
+}
+function validateEntity(entity, index, entityIds, resources, diagnostics) {
+    const path = ["entities", index];
+    if (!isJsonObject(entity)) {
+        add(diagnostics, "invalid-value", path, "Entity must be a JSON object");
+        return;
+    }
+    validateId(entity.id, [...path, "id"], diagnostics);
+    if (entityIds.has(entity.id)) {
+        add(diagnostics, "duplicate-id", [...path, "id"], `Duplicate entity id: ${entity.id}`, { entityId: entity.id });
+    }
+    else {
+        entityIds.add(entity.id);
+    }
+    validateName(entity.name, [...path, "name"], diagnostics);
+    if (!ENTITY_KINDS.has(entity.kind)) {
+        add(diagnostics, "unsupported-entity-kind", [...path, "kind"], `Unsupported Blueprint entity kind: ${String(entity.kind)}`, { entityId: entity.id });
+    }
+    if (entity.parentId !== null && entity.parentId !== undefined) {
+        validateId(entity.parentId, [...path, "parentId"], diagnostics);
+    }
+    if (typeof entity.enabled !== "boolean") {
+        add(diagnostics, "invalid-value", [...path, "enabled"], "Entity enabled must be boolean", { entityId: entity.id });
+    }
+    if (typeof entity.visible !== "boolean") {
+        add(diagnostics, "invalid-value", [...path, "visible"], "Entity visible must be boolean", { entityId: entity.id });
+    }
+    validateTransform(entity.transform, [...path, "transform"], diagnostics, entity.id);
+    if (entity.properties !== undefined && !isJsonObject(entity.properties)) {
+        add(diagnostics, "invalid-value", [...path, "properties"], "Entity properties must be a JSON object", { entityId: entity.id });
+    }
+    if (entity.kind === "model") {
+        validateAssetReference(entity.assetRef, "model", resources, [...path, "assetRef"], diagnostics, entity.id);
+        if (entity.sourceNode !== undefined &&
+            !isNonEmptyString(entity.sourceNode)) {
+            add(diagnostics, "invalid-value", [...path, "sourceNode"], "Model sourceNode must be a non-empty string", { entityId: entity.id });
+        }
+    }
+    else if (entity.kind === "primitive") {
+        if (!["box", "sphere", "plane", "cylinder", "torus"].includes(entity.primitive)) {
+            add(diagnostics, "invalid-value", [...path, "primitive"], "Primitive kind is invalid", { entityId: entity.id });
+        }
+        for (const key of [
+            "size",
+            "width",
+            "height",
+            "depth",
+            "diameter",
+        ]) {
+            validatePositiveNumber(entity[key], [...path, key], diagnostics, entity.id);
+        }
+        if (entity.color !== undefined)
+            validateColor(entity.color, [...path, "color"], diagnostics, entity.id);
+    }
+    else if (entity.kind === "procedural") {
+        for (const issue of validateProceduralGeometryProgram(entity.program)
+            .issues)
+            add(diagnostics, issue.code === "budget-exceeded" ? "budget-exceeded" : "invalid-value", [...path, "program", ...issue.path], issue.message, { entityId: entity.id });
+        if (entity.color !== undefined)
+            validateColor(entity.color, [...path, "color"], diagnostics, entity.id);
+    }
+    else if (entity.kind === "shape") {
+        if (![
+            "rectangle",
+            "circle",
+            "polygon",
+            "polyline",
+            "tube",
+            "wall",
+            "box",
+        ].includes(entity.shape)) {
+            add(diagnostics, "invalid-value", [...path, "shape"], "Shape kind is invalid", { entityId: entity.id });
+        }
+        if (entity.points !== undefined) {
+            if (!Array.isArray(entity.points)) {
+                add(diagnostics, "invalid-value", [...path, "points"], "Shape points must be an array", { entityId: entity.id });
+            }
+            else {
+                for (const [pointIndex, point] of entity.points.entries()) {
+                    validateVector3(point, [...path, "points", pointIndex], diagnostics, entity.id);
+                }
+            }
+        }
+        for (const key of [
+            "width",
+            "height",
+            "radius",
+            "depth",
+            "tubeRadius",
+            "wallHeight",
+        ]) {
+            validatePositiveNumber(entity[key], [...path, key], diagnostics, entity.id);
+        }
+        if (entity.segments !== undefined &&
+            (!Number.isInteger(entity.segments) || entity.segments < 3)) {
+            add(diagnostics, "invalid-value", [...path, "segments"], "Shape segments must be an integer >= 3", { entityId: entity.id });
+        }
+        if (entity.closed !== undefined && typeof entity.closed !== "boolean") {
+            add(diagnostics, "invalid-value", [...path, "closed"], "Shape closed must be boolean", { entityId: entity.id });
+        }
+        if (entity.fillColor !== undefined)
+            validateColor(entity.fillColor, [...path, "fillColor"], diagnostics, entity.id);
+        if (entity.strokeColor !== undefined)
+            validateColor(entity.strokeColor, [...path, "strokeColor"], diagnostics, entity.id);
+        if (entity.fillAlpha !== undefined &&
+            (!Number.isFinite(entity.fillAlpha) ||
+                entity.fillAlpha < 0 ||
+                entity.fillAlpha > 1)) {
+            add(diagnostics, "invalid-value", [...path, "fillAlpha"], "Shape fillAlpha must be in the 0..1 range", { entityId: entity.id });
+        }
+    }
+    else if (entity.kind === "particle" &&
+        entity.textureAssetRef !== undefined) {
+        validateAssetReference(entity.textureAssetRef, "texture", resources, [...path, "textureAssetRef"], diagnostics, entity.id);
+    }
+}
+function validateHierarchy(entities, entityIds, diagnostics) {
+    for (const [index, entity] of entities.entries()) {
+        if (entity.parentId === null || entity.parentId === undefined)
+            continue;
+        if (!entityIds.has(entity.parentId)) {
+            add(diagnostics, "missing-reference", ["entities", index, "parentId"], `Parent entity not found: ${entity.parentId}`, { entityId: entity.id });
+        }
+    }
+    const state = new Map();
+    const entitiesById = new Map(entities.map((entity) => [entity.id, entity]));
+    const visit = (id, path) => {
+        const current = state.get(id);
+        if (current === "visiting") {
+            add(diagnostics, "hierarchy-cycle", path, `Entity hierarchy contains a cycle at ${id}`, { entityId: id });
+            return;
+        }
+        if (current === "visited")
+            return;
+        state.set(id, "visiting");
+        const entity = entitiesById.get(id);
+        if (entity?.parentId && entitiesById.has(entity.parentId)) {
+            visit(entity.parentId, [...path, "parentId"]);
+        }
+        state.set(id, "visited");
+    };
+    for (const entity of entities)
+        visit(entity.id, ["entities", entity.id]);
+}
+function validateMaterials(materials, diagnostics) {
+    const ids = new Set();
+    for (const [index, material] of materials.entries()) {
+        const path = ["materials", index];
+        if (!isJsonObject(material)) {
+            add(diagnostics, "invalid-value", path, "Material must be a JSON object");
+            continue;
+        }
+        validateId(material.id, [...path, "id"], diagnostics);
+        if (ids.has(material.id))
+            add(diagnostics, "duplicate-id", [...path, "id"], `Duplicate material id: ${material.id}`, { materialId: material.id });
+        ids.add(material.id);
+        if (material.creation !== undefined) {
+            for (const issue of validateAuthoredMaterial(material, path)) {
+                add(diagnostics, issue.code, issue.path, issue.message, {
+                    materialId: material.id,
+                });
+            }
+        }
+        const textures = material.textures;
+        if (textures !== undefined) {
+            if (!isJsonObject(textures)) {
+                add(diagnostics, "invalid-value", [...path, "textures"], "Material textures must be an object", { materialId: material.id });
+            }
+            else {
+                for (const [slot, texture] of Object.entries(textures)) {
+                    if (!isJsonObject(texture) || typeof texture.assetId !== "string") {
+                        add(diagnostics, "invalid-value", [...path, "textures", slot], "Material texture requires an assetId", { materialId: material.id });
+                    }
+                }
+            }
+        }
+    }
+    return ids;
+}
+function validateBindings(bindings, materialIds, entityIds, diagnostics) {
+    const ids = new Set();
+    for (const [index, binding] of bindings.entries()) {
+        const path = ["materialBindings", index];
+        if (binding.target !== undefined) {
+            for (const issue of validateFieldRule(binding.target, MATERIAL_SLOT_TARGET_RULE, [...path, "target"])) {
+                add(diagnostics, issue.code, issue.path, issue.message);
+            }
+        }
+        validateId(binding.id, [...path, "id"], diagnostics);
+        if (ids.has(binding.id))
+            add(diagnostics, "duplicate-id", [...path, "id"], `Duplicate material binding id: ${binding.id}`);
+        ids.add(binding.id);
+        if (!materialIds.has(binding.materialId))
+            add(diagnostics, "missing-reference", [...path, "materialId"], `Material not found: ${binding.materialId}`, { materialId: binding.materialId });
+        if (!entityIds.has(binding.entityId))
+            add(diagnostics, "missing-reference", [...path, "entityId"], `Entity not found: ${binding.entityId}`, { entityId: binding.entityId });
+        if (binding.targetName !== undefined &&
+            typeof binding.targetName !== "string")
+            add(diagnostics, "invalid-value", [...path, "targetName"], "Material binding targetName must be a string");
+    }
+    return ids;
+}
+function validateTextureAnimations(animations, materialIds, resources, diagnostics) {
+    const ids = new Set();
+    for (const [index, animation] of animations.entries()) {
+        const path = ["textureAnimations", index];
+        validateId(animation.id, [...path, "id"], diagnostics);
+        if (ids.has(animation.id))
+            add(diagnostics, "duplicate-id", [...path, "id"], `Duplicate texture animation id: ${animation.id}`);
+        ids.add(animation.id);
+        if (!materialIds.has(animation.materialId))
+            add(diagnostics, "missing-reference", [...path, "materialId"], `Material not found: ${animation.materialId}`);
+        const texture = animation
+            .textureAssetId;
+        if (texture !== undefined)
+            validateAssetReference(texture, "texture", resources, [...path, "textureAssetId"], diagnostics);
+    }
+}
+function validateCameraPaths(paths, diagnostics) {
+    const ids = new Set();
+    for (const [index, pathValue] of paths.entries()) {
+        const path = ["cameraPaths", index];
+        validateId(pathValue.id, [...path, "id"], diagnostics);
+        if (ids.has(pathValue.id))
+            add(diagnostics, "duplicate-id", [...path, "id"], `Duplicate camera path id: ${pathValue.id}`);
+        ids.add(pathValue.id);
+        validateName(pathValue.name, [...path, "name"], diagnostics);
+        if (!Array.isArray(pathValue.keyframes) || pathValue.keyframes.length < 2)
+            add(diagnostics, "invalid-value", [...path, "keyframes"], "Camera path requires at least two keyframes");
+        const keyframeIds = new Set();
+        for (const [keyframeIndex, keyframe] of (pathValue.keyframes ?? []).entries()) {
+            if (!isJsonObject(keyframe)) {
+                add(diagnostics, "invalid-value", [...path, "keyframes", keyframeIndex], "Camera keyframe must be a JSON object");
+                continue;
+            }
+            if (typeof keyframe.id !== "string" || !isStableScenePlanId(keyframe.id))
+                add(diagnostics, "invalid-id", [...path, "keyframes", keyframeIndex, "id"], "Camera keyframe id is invalid");
+            if (typeof keyframe.id === "string" && keyframeIds.has(keyframe.id))
+                add(diagnostics, "duplicate-id", [...path, "keyframes", keyframeIndex, "id"], `Duplicate camera keyframe id: ${keyframe.id}`);
+            if (typeof keyframe.id === "string")
+                keyframeIds.add(keyframe.id);
+            if (typeof keyframe.timeMs !== "number" ||
+                !Number.isFinite(keyframe.timeMs) ||
+                keyframe.timeMs < 0)
+                add(diagnostics, "invalid-value", [...path, "keyframes", keyframeIndex, "timeMs"], "Camera keyframe timeMs must be finite and non-negative");
+        }
+    }
+}
+function validateSettings(blueprint, resources, diagnostics) {
+    const environment = blueprint.environment;
+    if (environment?.assetId !== undefined)
+        validateAssetReference(environment.assetId, "environment", resources, ["environment", "assetId"], diagnostics);
+    const background = isJsonObject(environment?.background)
+        ? environment.background
+        : undefined;
+    if (background?.assetId !== undefined) {
+        const resource = resources.get(String(background.assetId));
+        if (!resource ||
+            (resource.kind !== "texture" && resource.kind !== "environment"))
+            add(diagnostics, "missing-reference", ["environment", "background", "assetId"], `Background asset is not a texture or environment: ${String(background.assetId)}`);
+    }
+    const skybox = isJsonObject(background?.skybox)
+        ? background.skybox
+        : undefined;
+    const skyboxSource = isJsonObject(skybox?.source) ? skybox.source : undefined;
+    if (skyboxSource?.kind === "environment") {
+        validateAssetReference(skyboxSource.assetId, "environment", resources, ["environment", "background", "skybox", "source", "assetId"], diagnostics);
+    }
+    else if (skyboxSource?.kind === "panorama") {
+        validateAssetReference(skyboxSource.assetId, "texture", resources, ["environment", "background", "skybox", "source", "assetId"], diagnostics);
+    }
+    else if (skyboxSource?.kind === "cubemap" &&
+        isJsonObject(skyboxSource.faces)) {
+        for (const face of [
+            "positiveX",
+            "positiveY",
+            "positiveZ",
+            "negativeX",
+            "negativeY",
+            "negativeZ",
+        ]) {
+            validateAssetReference(skyboxSource.faces[face], "texture", resources, ["environment", "background", "skybox", "source", "faces", face], diagnostics);
+        }
+    }
+    const weather = blueprint.weather;
+    if (weather?.textureAssetId !== undefined)
+        validateAssetReference(weather.textureAssetId, "texture", resources, ["weather", "textureAssetId"], diagnostics);
+    if (blueprint.lights !== undefined) {
+        const ids = new Set();
+        for (const [index, light] of blueprint.lights.entries()) {
+            validateId(light.id, ["lights", index, "id"], diagnostics);
+            if (ids.has(light.id))
+                add(diagnostics, "duplicate-id", ["lights", index, "id"], `Duplicate light id: ${light.id}`);
+            ids.add(light.id);
+        }
+    }
+}
+function validateCapabilities(requirements, context, diagnostics) {
+    const seen = new Set();
+    for (const [index, requirement] of requirements.entries()) {
+        const path = ["requires", index];
+        validateId(requirement.id, [...path, "id"], diagnostics);
+        if (typeof requirement.version !== "string" || !requirement.version.trim())
+            add(diagnostics, "invalid-capability", [...path, "version"], "Capability version must be a non-empty string");
+        if (typeof requirement.required !== "boolean")
+            add(diagnostics, "invalid-capability", [...path, "required"], "Capability required must be boolean");
+        if (seen.has(requirement.id))
+            add(diagnostics, "duplicate-id", [...path, "id"], `Duplicate capability requirement: ${requirement.id}`);
+        seen.add(requirement.id);
+        const observed = context.capabilityAvailability?.find((candidate) => candidate.id === requirement.id);
+        const descriptor = context.capabilityAvailability
+            ? observed?.installed &&
+                observed.enabled &&
+                observed.compatibility === "supported"
+                ? observed
+                : undefined
+            : context.capabilities?.find((candidate) => candidate.id === requirement.id);
+        if (!descriptor) {
+            add(diagnostics, requirement.required ? "missing-capability" : "unsupported-capability", path, `Capability is not available: ${requirement.id}`, { recoverable: !requirement.required });
+        }
+        else if (descriptor.version !== requirement.version) {
+            add(diagnostics, requirement.required ? "missing-capability" : "unsupported-capability", [...path, "version"], `Capability ${requirement.id} requires ${requirement.version}, received ${descriptor.version}`, { recoverable: !requirement.required });
+        }
+    }
+}
+function validateExtensions(extensions, context, diagnostics) {
+    const seen = new Set();
+    for (const [index, extension] of extensions.entries()) {
+        const path = ["extensions", index];
+        if (!EXTENSION_NAMESPACE_PATTERN.test(extension.namespace))
+            add(diagnostics, "invalid-extension", [...path, "namespace"], "Extension namespace is invalid");
+        if (!Number.isSafeInteger(extension.version) || extension.version < 1)
+            add(diagnostics, "invalid-extension", [...path, "version"], "Extension version must be a positive integer");
+        if (!isNonEmptyString(extension.capability))
+            add(diagnostics, "invalid-extension", [...path, "capability"], "Extension capability must be a non-empty string");
+        if (typeof extension.required !== "boolean")
+            add(diagnostics, "invalid-extension", [...path, "required"], "Extension required must be boolean");
+        if (!isJsonValue(extension.data))
+            add(diagnostics, "invalid-json", [...path, "data"], "Extension data must contain only JSON values");
+        const key = `${extension.namespace}@${extension.version}`;
+        if (seen.has(key))
+            add(diagnostics, "duplicate-id", [...path, "namespace"], `Duplicate extension namespace/version: ${key}`);
+        seen.add(key);
+        const capability = context.extensionCapabilities?.find((candidate) => candidate.namespace === extension.namespace &&
+            candidate.version === extension.version &&
+            candidate.capability === extension.capability);
+        if (!capability)
+            add(diagnostics, extension.required ? "unsupported-extension" : "unsupported-extension", path, `Extension capability is not registered: ${extension.namespace}`, { recoverable: !extension.required });
+    }
+}
+function validateFlows(flows, context, entityIds, materialIds, cameraPathIds, textureAnimationIds, materialAnimationIds, resources, diagnostics) {
+    const ids = new Set();
+    for (const [index, flow] of flows.entries()) {
+        const path = ["flows", index];
+        if (!isJsonObject(flow)) {
+            add(diagnostics, "invalid-value", path, "Flow must be a JSON object");
+            continue;
+        }
+        validateId(flow.id, [...path, "id"], diagnostics);
+        if (ids.has(flow.id))
+            add(diagnostics, "duplicate-id", [...path, "id"], `Duplicate flow id: ${flow.id}`);
+        ids.add(flow.id);
+        validateName(flow.name, [...path, "name"], diagnostics);
+        if (flow.schema !== "skenora.flow" || flow.version !== 1)
+            add(diagnostics, "invalid-schema", path, `Flow ${flow.id} must use skenora.flow version 1`);
+        if (typeof flow.enabled !== "boolean")
+            add(diagnostics, "invalid-value", [...path, "enabled"], "Flow enabled must be boolean");
+        const flowValidator = context.flowValidator;
+        const result = flowValidator
+            ? { issues: flowValidator.validate(flow) }
+            : validateFlowGraph(flow, context.flowRegistry ?? createBuiltInFlowNodeRegistry());
+        for (const issue of result.issues) {
+            const nodeIndex = issue.nodeId === undefined
+                ? -1
+                : flow.nodes.findIndex((node) => node.id === issue.nodeId);
+            const edgeIndex = issue.edgeId === undefined
+                ? -1
+                : flow.edges.findIndex((edge) => edge.id === issue.edgeId);
+            const issuePath = nodeIndex >= 0
+                ? [...path, "nodes", nodeIndex]
+                : edgeIndex >= 0
+                    ? [...path, "edges", edgeIndex]
+                    : path;
+            add(diagnostics, "flow-invalid", issuePath, issue.message, {
+                recoverable: false,
+                details: {
+                    code: issue.code,
+                    ...(issue.nodeId === undefined ? {} : { nodeId: issue.nodeId }),
+                    ...(issue.edgeId === undefined ? {} : { edgeId: issue.edgeId }),
+                },
+            });
+        }
+        for (const [nodeIndex, node] of flow.nodes.entries()) {
+            validateFlowTargets(node.config, [...path, "nodes", nodeIndex, "config"], entityIds, materialIds, cameraPathIds, node.type.startsWith("action.materialAnimation.")
+                ? (materialAnimationIds.get(String(node.config.materialId)) ??
+                    new Set())
+                : textureAnimationIds, resources, diagnostics);
+        }
+    }
+}
+function validateFlowTargets(value, path, entityIds, materialIds, cameraPathIds, textureAnimationIds, resources, diagnostics) {
+    if (Array.isArray(value)) {
+        for (const [index, child] of value.entries())
+            validateFlowTargets(child, [...path, index], entityIds, materialIds, cameraPathIds, textureAnimationIds, resources, diagnostics);
+        return;
+    }
+    if (!isJsonObject(value))
+        return;
+    for (const [key, child] of Object.entries(value)) {
+        if (typeof child === "string") {
+            const reference = key === "entityId"
+                ? entityIds
+                : key === "materialId"
+                    ? materialIds
+                    : key === "pathId"
+                        ? cameraPathIds
+                        : key === "animationId"
+                            ? textureAnimationIds
+                            : undefined;
+            if (reference && !reference.has(child))
+                add(diagnostics, "flow-target-missing", [...path, key], `Flow target not found: ${child}`);
+            if (key === "textureAssetId") {
+                const resource = resources.get(child);
+                if (!resource || resource.kind !== "texture")
+                    add(diagnostics, "flow-target-missing", [...path, key], `Flow texture asset not found or not a texture: ${child}`, { assetId: child });
+            }
+        }
+        validateFlowTargets(child, [...path, key], entityIds, materialIds, cameraPathIds, textureAnimationIds, resources, diagnostics);
+    }
+}
+function validateAssetReference(reference, kind, resources, path, diagnostics, entityId) {
+    if (typeof reference !== "string" || !isStableScenePlanId(reference)) {
+        add(diagnostics, "invalid-id", path, "Asset reference must be a stable id", { entityId });
+        return;
+    }
+    const resource = resources.get(reference);
+    if (!resource) {
+        add(diagnostics, "missing-reference", path, `Resource not found: ${reference}`, { entityId, assetId: reference });
+    }
+    else if (resource.kind !== kind) {
+        add(diagnostics, "resource-kind-mismatch", path, `Resource ${reference} must be a ${kind} resource`, { entityId, assetId: reference });
+    }
+}
+function validateTransform(transform, path, diagnostics, entityId) {
+    if (!isJsonObject(transform)) {
+        add(diagnostics, "invalid-transform", path, "Entity transform must be a JSON object", { entityId });
+        return;
+    }
+    if (transform.coordinateSpace !== "local")
+        add(diagnostics, "invalid-transform", [...path, "coordinateSpace"], "Only local entity transforms are supported", { entityId });
+    if (transform.units !== "meters")
+        add(diagnostics, "invalid-transform", [...path, "units"], "Entity transforms must use meters", { entityId });
+    validateVector3(transform.position, [...path, "position"], diagnostics, entityId);
+    validateVector3(transform.scaling, [...path, "scaling"], diagnostics, entityId);
+    const hasEuler = transform.rotationRadians !== undefined;
+    const hasQuaternion = transform.rotationQuaternion !== undefined;
+    if (hasEuler === hasQuaternion)
+        add(diagnostics, "invalid-transform", path, "Provide exactly one rotationRadians or rotationQuaternion representation", { entityId });
+    if (hasEuler)
+        validateVector3(transform.rotationRadians, [...path, "rotationRadians"], diagnostics, entityId);
+    if (hasQuaternion)
+        validateQuaternion(transform.rotationQuaternion, [...path, "rotationQuaternion"], diagnostics, entityId);
+}
+function validateQuaternion(value, path, diagnostics, entityId) {
+    if (!isFiniteObjectNumbers(value, ["x", "y", "z", "w"])) {
+        add(diagnostics, "invalid-quaternion", path, "Quaternion must contain finite x, y, z, and w values", { entityId });
+        return;
+    }
+    const quaternion = value;
+    const length = Math.hypot(quaternion.x, quaternion.y, quaternion.z, quaternion.w);
+    if (Math.abs(length - 1) > QUATERNION_TOLERANCE)
+        add(diagnostics, "invalid-quaternion", path, "Quaternion must be normalized", { entityId });
+}
+function validateVector3(value, path, diagnostics, entityId) {
+    if (!isFiniteObjectNumbers(value, ["x", "y", "z"]))
+        add(diagnostics, "invalid-value", path, "Vector3 must contain finite x, y, and z values", { entityId });
+}
+function validateColor(value, path, diagnostics, entityId) {
+    if (!isFiniteObjectNumbers(value, ["r", "g", "b"]))
+        add(diagnostics, "invalid-value", path, "Color must contain finite r, g, and b values", { entityId });
+}
+function isFiniteObjectNumbers(value, keys) {
+    if (!isJsonObject(value))
+        return false;
+    return keys.every((key) => typeof value[key] === "number" && Number.isFinite(value[key]));
+}
+function validatePositiveNumber(value, path, diagnostics, entityId) {
+    if (value !== undefined &&
+        (typeof value !== "number" || !Number.isFinite(value) || value <= 0))
+        add(diagnostics, "invalid-value", path, "Value must be a positive finite number", { entityId });
+}
+function validateIntegrity(value, path, diagnostics) {
+    if (value === undefined)
+        return;
+    if (!isJsonObject(value) ||
+        value.algorithm !== "sha256" ||
+        typeof value.value !== "string" ||
+        !/^[a-f0-9]{64}$/.test(value.value))
+        add(diagnostics, "invalid-value", path, "Integrity must be a lowercase SHA-256 digest");
+}
+function validateId(value, path, diagnostics) {
+    if (!isStableScenePlanId(value))
+        add(diagnostics, "invalid-id", path, "ID must start with a letter, contain only stable ID characters, and be at most 128 characters");
+}
+function validateName(value, path, diagnostics) {
+    if (!isNonEmptyString(value))
+        add(diagnostics, "invalid-value", path, "Name must be a non-empty string");
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function add(diagnostics, code, path, message, options = {}) {
+    diagnostics.push(createDiagnostic({
+        code,
+        stage: "validate",
+        path,
+        message,
+        ...(options.recoverable === undefined
+            ? {}
+            : { recoverable: options.recoverable }),
+        ...(options.entityId === undefined ? {} : { entityId: options.entityId }),
+        ...(options.assetId === undefined ? {} : { assetId: options.assetId }),
+        ...(options.materialId === undefined
+            ? {}
+            : { materialId: options.materialId }),
+        ...(options.details === undefined ? {} : { details: options.details }),
+    }));
+}
+function nativeDiagnostic(issue) {
+    return createDiagnostic({
+        code: issue.code === "material-effect-pass-unsupported"
+            ? issue.code
+            : "native-document-invalid",
+        stage: "compile",
+        path: issue.path,
+        message: issue.message,
+        recoverable: false,
+        details: { nativeCode: issue.code },
+    });
+}
+export function validateNativeDocumentShape(document) {
+    const diagnostics = validateSceneDocumentCandidate(document);
+    return { valid: !hasErrors(diagnostics), diagnostics };
+}
+//# sourceMappingURL=validate.js.map