@skenora/resources 0.1.2

package/dist/resource-bindings.d.ts

@@ -0,0 +1,94 @@
+import { type AssetReference, type ResourceIntegrity } from "@skenora/contracts";
+import type { ResolvedResource, ResourceAcquireOptions, ResourceDescriptor, ResourceLicenseMetadata, ResourceResolver, ResourceScopeOptions, ResourceTechnicalMetadata } from "./types.js";
+export type LogicalAssetRef = string;
+export interface ResourceBindingRequirement {
+    readonly assetRef: LogicalAssetRef;
+    readonly kind: AssetReference["kind"];
+    readonly mediaType?: string;
+    readonly integrity?: ResourceIntegrity;
+}
+/**
+ * A host-created binding from a plan-level logical reference to an authorized
+ * scene asset. The resources package does not perform authorization; callers
+ * must only provide references that have already passed host policy.
+ */
+export interface ResourceBinding {
+    readonly assetRef: LogicalAssetRef;
+    readonly asset: Readonly<AssetReference>;
+}
+export type ResourceBindingIssueCode = "invalid-asset-ref" | "duplicate-asset-ref" | "duplicate-requirement" | "missing-binding" | "unexpected-binding" | "invalid-asset" | "missing-source" | "invalid-kind" | "invalid-media-type" | "kind-mismatch" | "media-type-mismatch" | "invalid-integrity" | "integrity-mismatch";
+export interface ResourceBindingIssue {
+    readonly code: ResourceBindingIssueCode;
+    readonly path: readonly (string | number)[];
+    readonly message: string;
+    readonly assetRef?: LogicalAssetRef;
+}
+export interface ResourceBindingValidationResult {
+    readonly valid: boolean;
+    readonly issues: readonly ResourceBindingIssue[];
+}
+export interface ResourceBindingValidationOptions {
+    /** Reject bindings not declared by the supplied requirements. */
+    readonly allowAdditionalBindings?: boolean;
+}
+export interface ResourceBindingTable {
+    readonly size: number;
+    readonly bindings: readonly ResourceBinding[];
+    get(assetRef: LogicalAssetRef): ResourceBinding | undefined;
+    require(assetRef: LogicalAssetRef): ResourceBinding;
+}
+export declare class ResourceBindingValidationError extends Error {
+    readonly issues: readonly ResourceBindingIssue[];
+    constructor(issues: readonly ResourceBindingIssue[]);
+}
+/** Validates plan requirements without acquiring resources or performing I/O. */
+export declare function validateResourceBindings(bindings: readonly Readonly<ResourceBinding>[], requirements?: readonly Readonly<ResourceBindingRequirement>[], options?: Readonly<ResourceBindingValidationOptions>): ResourceBindingValidationResult;
+/**
+ * Creates an immutable lookup table for a validated binding set. Asset values
+ * are cloned and frozen so a plan execution cannot observe caller mutation.
+ */
+export declare function createResourceBindingTable(bindings: readonly Readonly<ResourceBinding>[], requirements?: readonly Readonly<ResourceBindingRequirement>[], options?: Readonly<ResourceBindingValidationOptions>): ResourceBindingTable;
+export interface ModelVisibleResourceDescriptor {
+    /** Opaque logical reference selected by the host, never a provider id. */
+    readonly resourceRef: LogicalAssetRef;
+    readonly label: string;
+    readonly kind: AssetReference["kind"];
+    readonly description?: string;
+    readonly tags?: readonly string[];
+    readonly mediaType?: string;
+    readonly integrity?: ResourceIntegrity;
+    readonly technical?: ResourceTechnicalMetadata;
+    readonly license?: ResourceLicenseMetadata;
+}
+/**
+ * Projects a provider descriptor into a model-visible DTO. Source, thumbnail,
+ * provider id, and every locator-bearing field are intentionally omitted.
+ */
+export declare function toModelVisibleResourceDescriptor(descriptor: Readonly<ResourceDescriptor>, resourceRef: LogicalAssetRef): ModelVisibleResourceDescriptor;
+export interface ResourceLease {
+    readonly assetRef: LogicalAssetRef;
+    /** Internal authorized reference; never pass this object to the model. */
+    readonly asset: Readonly<AssetReference>;
+    /** Resolves while the lease remains retained; release invalidates the URL. */
+    readonly resource: Promise<ResolvedResource>;
+    /** Idempotently releases this lease and its underlying ResourceScope. */
+    release(): void;
+}
+export interface ResourceBindingScopeOptions extends ResourceScopeOptions {
+    readonly requirements?: readonly Readonly<ResourceBindingRequirement>[];
+    readonly validation?: Readonly<ResourceBindingValidationOptions>;
+}
+export interface ResourceBindingScope {
+    readonly bindings: ResourceBindingTable;
+    /** Starts acquisition and returns a release handle before provider resolve. */
+    acquire(assetRef: LogicalAssetRef, options?: ResourceAcquireOptions): ResourceLease;
+    acquireAll(assetRefs: readonly LogicalAssetRef[], options?: ResourceAcquireOptions): readonly ResourceLease[];
+    dispose(): void;
+}
+/**
+ * Coordinates one ResourceScope per logical lease. Releasing a lease or
+ * disposing this scope delegates to the existing reference-counted cache and
+ * Blob URL cleanup.
+ */
+export declare function createResourceBindingScope(resolver: ResourceResolver, bindings: ResourceBindingTable | readonly Readonly<ResourceBinding>[], options?: Readonly<ResourceBindingScopeOptions>): ResourceBindingScope;
+//# sourceMappingURL=resource-bindings.d.ts.map

package/dist/resource-bindings.d.ts.map

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

package/dist/resource-bindings.js

@@ -0,0 +1,546 @@
+import { getAssetResourceLocator, } from "@skenora/contracts";
+export class ResourceBindingValidationError extends Error {
+    issues;
+    constructor(issues) {
+        const ownedIssues = issues.map((issue) => Object.freeze({
+            ...issue,
+            path: Object.freeze([...issue.path]),
+        }));
+        super(ownedIssues.map(formatIssue).join("; "));
+        this.name = "ResourceBindingValidationError";
+        this.issues = Object.freeze(ownedIssues);
+    }
+}
+/** Validates plan requirements without acquiring resources or performing I/O. */
+export function validateResourceBindings(bindings, requirements = [], options = {}) {
+    const issues = [];
+    const bindingByRef = new Map();
+    const requirementByRef = new Map();
+    requirements.forEach((requirement, index) => {
+        const assetRef = requirement.assetRef;
+        if (!isNormalizedAssetRef(assetRef)) {
+            issues.push({
+                code: "invalid-asset-ref",
+                path: ["requirements", index, "assetRef"],
+                message: "Resource requirement assetRef must be normalized",
+                ...(typeof assetRef === "string" ? { assetRef } : {}),
+            });
+        }
+        else if (requirementByRef.has(assetRef)) {
+            issues.push({
+                code: "duplicate-requirement",
+                path: ["requirements", index, "assetRef"],
+                message: "Resource requirement assetRef must be unique",
+                assetRef,
+            });
+        }
+        else {
+            requirementByRef.set(assetRef, index);
+        }
+        validateRequirement(requirement, index, issues);
+    });
+    bindings.forEach((binding, index) => {
+        const assetRef = binding.assetRef;
+        if (!isNormalizedAssetRef(assetRef)) {
+            issues.push({
+                code: "invalid-asset-ref",
+                path: ["bindings", index, "assetRef"],
+                message: "Resource binding assetRef must be normalized",
+                ...(typeof assetRef === "string" ? { assetRef } : {}),
+            });
+        }
+        else if (bindingByRef.has(assetRef)) {
+            issues.push({
+                code: "duplicate-asset-ref",
+                path: ["bindings", index, "assetRef"],
+                message: "Resource binding assetRef must be unique",
+                assetRef,
+            });
+        }
+        else {
+            bindingByRef.set(assetRef, index);
+        }
+        validateBinding(binding, index, issues);
+        const requirementIndex = typeof assetRef === "string" ? requirementByRef.get(assetRef) : undefined;
+        if (requirementIndex !== undefined) {
+            validateBindingAgainstRequirement(binding, requirements[requirementIndex], index, issues);
+        }
+        else if (requirements.length > 0 &&
+            !options.allowAdditionalBindings &&
+            isNormalizedAssetRef(assetRef)) {
+            issues.push({
+                code: "unexpected-binding",
+                path: ["bindings", index, "assetRef"],
+                message: "Resource binding was not declared by the plan",
+                assetRef,
+            });
+        }
+    });
+    requirements.forEach((requirement, index) => {
+        if (isNormalizedAssetRef(requirement.assetRef) &&
+            !bindingByRef.has(requirement.assetRef)) {
+            issues.push({
+                code: "missing-binding",
+                path: ["requirements", index, "assetRef"],
+                message: "Resource requirement has no authorized binding",
+                assetRef: requirement.assetRef,
+            });
+        }
+    });
+    return {
+        valid: issues.length === 0,
+        issues: Object.freeze(issues.map(ownIssue)),
+    };
+}
+/**
+ * Creates an immutable lookup table for a validated binding set. Asset values
+ * are cloned and frozen so a plan execution cannot observe caller mutation.
+ */
+export function createResourceBindingTable(bindings, requirements = [], options = {}) {
+    const validation = validateResourceBindings(bindings, requirements, options);
+    if (!validation.valid) {
+        throw new ResourceBindingValidationError(validation.issues);
+    }
+    const ownedBindings = Object.freeze(bindings.map((binding) => Object.freeze({
+        assetRef: binding.assetRef,
+        asset: freezeValue(structuredClone(binding.asset)),
+    })));
+    const bindingByRef = new Map(ownedBindings.map((binding) => [binding.assetRef, binding]));
+    return Object.freeze({
+        size: ownedBindings.length,
+        bindings: ownedBindings,
+        get(assetRef) {
+            return bindingByRef.get(assetRef);
+        },
+        require(assetRef) {
+            if (!isNormalizedAssetRef(assetRef)) {
+                throw new ResourceBindingValidationError([
+                    {
+                        code: "invalid-asset-ref",
+                        path: ["assetRef"],
+                        message: "Resource binding assetRef must be normalized",
+                        ...(typeof assetRef === "string" ? { assetRef } : {}),
+                    },
+                ]);
+            }
+            const binding = bindingByRef.get(assetRef);
+            if (!binding) {
+                throw new ResourceBindingValidationError([
+                    {
+                        code: "missing-binding",
+                        path: ["assetRef"],
+                        message: "Resource binding was not provided",
+                        assetRef,
+                    },
+                ]);
+            }
+            return binding;
+        },
+    });
+}
+/**
+ * Projects a provider descriptor into a model-visible DTO. Source, thumbnail,
+ * provider id, and every locator-bearing field are intentionally omitted.
+ */
+export function toModelVisibleResourceDescriptor(descriptor, resourceRef) {
+    assertOpaqueResourceRef(resourceRef);
+    assertAssetKind(descriptor.kind);
+    if (!descriptor.label.trim()) {
+        throw new Error("Resource descriptor label must be non-empty");
+    }
+    if (descriptor.mediaType !== undefined) {
+        assertMediaType(descriptor.mediaType);
+    }
+    if (descriptor.integrity !== undefined) {
+        assertIntegrity(descriptor.integrity);
+    }
+    const safeDescriptor = {
+        resourceRef,
+        label: descriptor.label,
+        kind: descriptor.kind,
+        ...(descriptor.description !== undefined
+            ? { description: descriptor.description }
+            : {}),
+        ...(descriptor.tags !== undefined ? { tags: descriptor.tags } : {}),
+        ...(descriptor.mediaType !== undefined
+            ? { mediaType: descriptor.mediaType }
+            : {}),
+        ...(descriptor.integrity !== undefined
+            ? { integrity: descriptor.integrity }
+            : {}),
+        ...(descriptor.technical !== undefined
+            ? { technical: descriptor.technical }
+            : {}),
+        ...(descriptor.license !== undefined
+            ? { license: descriptor.license }
+            : {}),
+    };
+    return freezeValue(structuredClone(safeDescriptor));
+}
+/**
+ * Coordinates one ResourceScope per logical lease. Releasing a lease or
+ * disposing this scope delegates to the existing reference-counted cache and
+ * Blob URL cleanup.
+ */
+export function createResourceBindingScope(resolver, bindings, options = {}) {
+    const table = "bindings" in bindings
+        ? validateTable(bindings, options)
+        : createResourceBindingTable(bindings, options.requirements ?? [], options.validation ?? {});
+    return new ManagedResourceBindingScope(resolver, table, options.signal);
+}
+class ManagedResourceBindingScope {
+    bindings;
+    #resolver;
+    #signal;
+    #releases = new Set();
+    #abortListener;
+    #disposed = false;
+    constructor(resolver, bindings, signal) {
+        this.#resolver = resolver;
+        this.bindings = bindings;
+        this.#signal = signal;
+        if (!signal) {
+            this.#abortListener = null;
+        }
+        else {
+            const listener = () => this.dispose();
+            this.#abortListener = listener;
+            if (signal.aborted)
+                this.#disposed = true;
+            else
+                signal.addEventListener("abort", listener, { once: true });
+        }
+    }
+    acquire(assetRef, options = {}) {
+        this.#assertActive();
+        const binding = this.bindings.require(assetRef);
+        const acquireOptions = bindingAcquireOptions(binding, options);
+        const resourceScope = this.#resolver.createScope(this.#signal ? { signal: this.#signal } : {});
+        let released = false;
+        const release = () => {
+            if (released)
+                return;
+            released = true;
+            this.#releases.delete(release);
+            resourceScope.dispose();
+        };
+        this.#releases.add(release);
+        let resource;
+        try {
+            resource = resourceScope
+                .acquire(binding.asset, acquireOptions)
+                .then((resolved) => {
+                assertResolvedResourceMediaType(binding.assetRef, binding.asset, resolved);
+                return resolved;
+            })
+                .catch((error) => {
+                release();
+                throw error;
+            });
+        }
+        catch (error) {
+            release();
+            throw error;
+        }
+        return Object.freeze({
+            assetRef: binding.assetRef,
+            asset: binding.asset,
+            resource,
+            release,
+        });
+    }
+    acquireAll(assetRefs, options = {}) {
+        this.#assertActive();
+        const leases = [];
+        try {
+            for (const assetRef of assetRefs)
+                leases.push(this.acquire(assetRef, options));
+        }
+        catch (error) {
+            for (const lease of leases)
+                lease.release();
+            throw error;
+        }
+        return Object.freeze(leases);
+    }
+    dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        if (this.#signal && this.#abortListener) {
+            this.#signal.removeEventListener("abort", this.#abortListener);
+        }
+        for (const release of this.#releases)
+            release();
+        this.#releases.clear();
+    }
+    #assertActive() {
+        if (this.#disposed) {
+            throw new DOMException("Resource binding scope has been disposed", "AbortError");
+        }
+    }
+}
+function validateTable(table, options) {
+    const validation = validateResourceBindings(table.bindings, options.requirements ?? [], options.validation ?? {});
+    if (!validation.valid) {
+        throw new ResourceBindingValidationError(validation.issues);
+    }
+    return table;
+}
+function validateRequirement(requirement, index, issues) {
+    if (!isValidAssetKind(requirement.kind)) {
+        issues.push({
+            code: "invalid-kind",
+            path: ["requirements", index, "kind"],
+            message: "Resource requirement kind is invalid",
+            ...(isNormalizedAssetRef(requirement.assetRef)
+                ? { assetRef: requirement.assetRef }
+                : {}),
+        });
+    }
+    if (requirement.mediaType !== undefined) {
+        pushInvalidMediaType(requirement.mediaType, ["requirements", index, "mediaType"], requirement.assetRef, issues);
+    }
+    if (requirement.integrity !== undefined) {
+        pushInvalidIntegrity(requirement.integrity, ["requirements", index, "integrity"], requirement.assetRef, issues);
+    }
+}
+function validateBinding(binding, index, issues) {
+    const assetRef = isNormalizedAssetRef(binding.assetRef)
+        ? binding.assetRef
+        : undefined;
+    const asset = binding.asset;
+    if (!asset || typeof asset !== "object") {
+        issues.push({
+            code: "invalid-asset",
+            path: ["bindings", index, "asset"],
+            message: "Resource binding asset must be an object",
+            ...(assetRef ? { assetRef } : {}),
+        });
+        return;
+    }
+    if (!isNormalizedAssetRef(asset.id)) {
+        issues.push({
+            code: "invalid-asset",
+            path: ["bindings", index, "asset", "id"],
+            message: "Bound asset id must be normalized",
+            ...(assetRef ? { assetRef } : {}),
+        });
+    }
+    if (!isValidAssetKind(asset.kind)) {
+        issues.push({
+            code: "invalid-kind",
+            path: ["bindings", index, "asset", "kind"],
+            message: "Bound asset kind is invalid",
+            ...(assetRef ? { assetRef } : {}),
+        });
+    }
+    try {
+        getAssetResourceLocator(asset);
+    }
+    catch {
+        issues.push({
+            code: "missing-source",
+            path: ["bindings", index, "asset", "source"],
+            message: "Bound asset must provide a resource source",
+            ...(assetRef ? { assetRef } : {}),
+        });
+    }
+    if (asset.mediaType !== undefined) {
+        pushInvalidMediaType(asset.mediaType, ["bindings", index, "asset", "mediaType"], assetRef, issues);
+    }
+    if (asset.integrity !== undefined) {
+        pushInvalidIntegrity(asset.integrity, ["bindings", index, "asset", "integrity"], assetRef, issues);
+    }
+}
+function validateBindingAgainstRequirement(binding, requirement, index, issues) {
+    const assetRef = binding.assetRef;
+    if (binding.asset.kind !== requirement.kind) {
+        issues.push({
+            code: "kind-mismatch",
+            path: ["bindings", index, "asset", "kind"],
+            message: "Bound asset kind does not match the plan requirement",
+            assetRef,
+        });
+    }
+    if (requirement.mediaType !== undefined &&
+        !mediaTypesEqual(binding.asset.mediaType, requirement.mediaType)) {
+        issues.push({
+            code: "media-type-mismatch",
+            path: ["bindings", index, "asset", "mediaType"],
+            message: "Bound asset mediaType does not match the plan requirement",
+            assetRef,
+        });
+    }
+    if (requirement.integrity !== undefined &&
+        !integritiesEqual(binding.asset.integrity, requirement.integrity)) {
+        issues.push({
+            code: "integrity-mismatch",
+            path: ["bindings", index, "asset", "integrity"],
+            message: "Bound asset integrity does not match the plan requirement",
+            assetRef,
+        });
+    }
+}
+function bindingAcquireOptions(binding, options) {
+    if (options.expectedMediaType !== undefined) {
+        assertMediaType(options.expectedMediaType);
+    }
+    if (options.expectedKind !== undefined &&
+        options.expectedKind !== binding.asset.kind) {
+        throw new ResourceBindingValidationError([
+            {
+                code: "kind-mismatch",
+                path: ["assetRef"],
+                message: "Requested resource kind does not match the binding",
+                assetRef: binding.assetRef,
+            },
+        ]);
+    }
+    if (options.expectedMediaType !== undefined &&
+        binding.asset.mediaType !== undefined &&
+        !mediaTypesEqual(options.expectedMediaType, binding.asset.mediaType)) {
+        throw new ResourceBindingValidationError([
+            {
+                code: "media-type-mismatch",
+                path: ["assetRef"],
+                message: "Requested mediaType does not match the binding",
+                assetRef: binding.assetRef,
+            },
+        ]);
+    }
+    return {
+        ...options,
+        expectedKind: binding.asset.kind,
+        ...(binding.asset.mediaType !== undefined
+            ? { expectedMediaType: binding.asset.mediaType }
+            : {}),
+    };
+}
+function assertResolvedResourceMediaType(assetRef, asset, resource) {
+    if (asset.mediaType !== undefined &&
+        !mediaTypesEqual(resource.mediaType, asset.mediaType)) {
+        throw new ResourceBindingValidationError([
+            {
+                code: "media-type-mismatch",
+                path: ["resource", "mediaType"],
+                message: "Resolved resource mediaType does not match the asset",
+                assetRef,
+            },
+        ]);
+    }
+}
+function assertNormalizedAssetRef(value) {
+    if (!isNormalizedAssetRef(value)) {
+        throw new Error("Resource reference must be a normalized non-empty string");
+    }
+}
+function assertOpaqueResourceRef(value) {
+    assertNormalizedAssetRef(value);
+    if (value.includes("/") ||
+        value.includes("\\") ||
+        value.includes("?") ||
+        value.includes("#") ||
+        /^[a-z][a-z\d+.-]*:\/\//iu.test(value)) {
+        throw new Error("Model-visible resourceRef must be opaque");
+    }
+}
+function isNormalizedAssetRef(value) {
+    return (typeof value === "string" && value.length > 0 && value === value.trim());
+}
+function assertAssetKind(value) {
+    if (!isValidAssetKind(value))
+        throw new Error("Resource kind is invalid");
+}
+function isValidAssetKind(value) {
+    return (value === "model" ||
+        value === "texture" ||
+        value === "environment" ||
+        value === "audio" ||
+        value === "data");
+}
+function assertMediaType(value) {
+    if (!isValidMediaType(value)) {
+        throw new Error("Resource mediaType must be a valid MIME type");
+    }
+}
+function isValidMediaType(value) {
+    if (typeof value !== "string" ||
+        !value.trim() ||
+        /[\u0000-\u001f\u007f]/u.test(value)) {
+        return false;
+    }
+    return /^[^\s/;]+\/[^\s/;]+(?:\s*;\s*[^;\r\n]+)*$/u.test(value.trim());
+}
+function pushInvalidMediaType(value, path, assetRef, issues) {
+    if (!isValidMediaType(value)) {
+        issues.push({
+            code: "invalid-media-type",
+            path: [...path],
+            message: "Resource mediaType must be a valid MIME type",
+            ...(isNormalizedAssetRef(assetRef) ? { assetRef } : {}),
+        });
+    }
+}
+function assertIntegrity(value) {
+    if (!isValidIntegrity(value)) {
+        throw new Error("Resource integrity must be a lowercase hexadecimal SHA-256 digest");
+    }
+}
+function isValidIntegrity(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        value.algorithm === "sha256" &&
+        typeof value.value === "string" &&
+        /^[a-f\d]{64}$/u.test(value.value));
+}
+function pushInvalidIntegrity(value, path, assetRef, issues) {
+    if (!isValidIntegrity(value)) {
+        issues.push({
+            code: "invalid-integrity",
+            path: [...path],
+            message: "Resource integrity must be a lowercase hexadecimal SHA-256 digest",
+            ...(isNormalizedAssetRef(assetRef) ? { assetRef } : {}),
+        });
+    }
+}
+function mediaTypeForComparison(value) {
+    if (value === undefined || value === null)
+        return null;
+    return isValidMediaType(value)
+        ? (value.trim().split(";", 1)[0] ?? "").toLowerCase()
+        : null;
+}
+function mediaTypesEqual(first, second) {
+    const left = mediaTypeForComparison(first);
+    const right = mediaTypeForComparison(second);
+    return left !== null && right !== null && left === right;
+}
+function integritiesEqual(first, second) {
+    return Boolean(first &&
+        second &&
+        first.algorithm === second.algorithm &&
+        first.value === second.value);
+}
+function ownIssue(issue) {
+    return Object.freeze({
+        ...issue,
+        path: Object.freeze([...issue.path]),
+    });
+}
+function formatIssue(issue) {
+    const path = issue.path.reduce((result, segment) => typeof segment === "number"
+        ? `${result}[${segment}]`
+        : `${result}.${segment}`, "$");
+    return `${path}: ${issue.message}`;
+}
+function freezeValue(value) {
+    if (!value || typeof value !== "object" || Object.isFrozen(value)) {
+        return value;
+    }
+    for (const child of Object.values(value)) {
+        freezeValue(child);
+    }
+    return Object.freeze(value);
+}
+//# sourceMappingURL=resource-bindings.js.map