@veryfront/ext-image-sharp 0.1.1186 → 0.1.1189

package/esm/deno.d.ts

@@ -0,0 +1,37 @@
+declare namespace _default {
+    let name: string;
+    let version: string;
+    let exports: string;
+    namespace veryfront {
+        let extension: boolean;
+        let activation: string;
+        namespace contracts {
+            let provides: string[];
+        }
+        let capabilities: ({
+            type: string;
+            paths: string[];
+            keys?: undefined;
+        } | {
+            type: string;
+            keys: string[];
+            paths?: undefined;
+        } | {
+            type: string;
+            paths?: undefined;
+            keys?: undefined;
+        })[];
+    }
+    let imports: {
+        sharp: string;
+        "@std/assert": string;
+        "@std/testing/bdd": string;
+        "veryfront/extensions": string;
+        "veryfront/extensions/image": string;
+    };
+    namespace tasks {
+        let test: string;
+    }
+}
+export default _default;
+//# sourceMappingURL=deno.d.ts.map

package/esm/deno.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deno.d.ts","sourceRoot":"","sources":["../src/deno.js"],"names":[],"mappings":""}

package/esm/deno.js

@@ -0,0 +1,33 @@
+export default {
+    "name": "@veryfront/ext-image-sharp",
+    "version": "0.1.0",
+    "exports": "./src/index.ts",
+    "veryfront": {
+        "extension": true,
+        "activation": "explicit",
+        "contracts": {
+            "provides": ["ImageOptimizationEngine"]
+        },
+        "capabilities": [
+            {
+                "type": "fs:read",
+                "paths": ["/proc/self/exe", "/usr/bin/ldd"]
+            },
+            {
+                "type": "env:read",
+                "keys": ["MALLOC_ARENA_MAX", "npm_package_config_libvips"]
+            },
+            { "type": "native:ffi" }
+        ]
+    },
+    "imports": {
+        "sharp": "npm:sharp@0.35.3",
+        "@std/assert": "jsr:@std/assert@1.0.19",
+        "@std/testing/bdd": "jsr:@std/testing@1.0.17/bdd",
+        "veryfront/extensions": "../../src/extensions/types.ts",
+        "veryfront/extensions/image": "../../src/extensions/image/index.ts"
+    },
+    "tasks": {
+        "test": "deno test --allow-read=/proc/self/exe,/usr/bin/ldd --allow-env=MALLOC_ARENA_MAX,npm_package_config_libvips --allow-ffi src/"
+    }
+};

package/esm/src/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Sharp implementation of the dependency-free ImageOptimizationEngine.
+ *
+ * @module extensions/ext-image-sharp
+ */
+import "../_dnt.polyfills.js";
+import type { ExtensionFactory } from "veryfront/extensions";
+import { type ImageOptimizationEngine, type ImageOptimizationRequest, type ImageOptimizationResult } from "veryfront/extensions/image";
+/** Native image decoder, resizer, and encoder supplied by this extension. */
+export declare class SharpImageOptimizationEngine implements ImageOptimizationEngine {
+    #private;
+    readonly cacheIdentity: string;
+    constructor();
+    optimize(request: ImageOptimizationRequest): Promise<ImageOptimizationResult>;
+}
+declare const factory: ExtensionFactory;
+export default factory;
+//# sourceMappingURL=index.d.ts.map

package/esm/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,sBAAsB,CAAC;AAG9B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EACL,KAAK,uBAAuB,EAE5B,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAE7B,MAAM,4BAA4B,CAAC;AAyEpC,6EAA6E;AAC7E,qBAAa,4BAA6B,YAAW,uBAAuB;;IAC1E,QAAQ,CAAC,aAAa,EAAG,MAAM,CAAC;;IAiBhC,QAAQ,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,uBAAuB,CAAC;CAG9E;AA4BD,QAAA,MAAM,OAAO,EAAE,gBA2Bd,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/esm/src/index.js

@@ -0,0 +1,140 @@
+/**
+ * Sharp implementation of the dependency-free ImageOptimizationEngine.
+ *
+ * @module extensions/ext-image-sharp
+ */
+import "../_dnt.polyfills.js";
+import { ImageOptimizationEngineName, MAX_IMAGE_OPTIMIZATION_ENGINE_IDENTITY_CHARACTERS, } from "veryfront/extensions/image";
+import { arch, platform } from "node:process";
+import sharp from "sharp";
+import extensionPackage from "../deno.js";
+import { BoundSharpImageOptimizationEngine, captureSharpRuntime, SHARP_IMAGE_LIMITS, } from "./sharp-runtime.js";
+const ENGINE_SEMANTICS_VERSION = "veryfront.image-sharp.v2";
+const SHARP_VERSION_PATTERN = /^npm:sharp@((?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*))$/;
+const VERSION_COMPONENTS = [
+    "vips",
+    "aom",
+    "ffi",
+    "heif",
+    "mozjpeg",
+    "png",
+    "webp",
+    "zlib-ng",
+];
+const executeRegularExpression = RegExp.prototype.exec;
+const apply = Reflect.apply;
+const arrayIsArray = Array.isArray;
+const arrayJoin = Array.prototype.join;
+const arrayPush = Array.prototype.push;
+const defineProperty = Object.defineProperty;
+const freeze = Object.freeze;
+const getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
+const getPrototypeOf = Object.getPrototypeOf;
+const ownKeys = Reflect.ownKeys;
+const standardObjectPrototype = Object.prototype;
+const sharpRuntime = captureSharpRuntime(sharp);
+function exactSharpVersion(specifier) {
+    const match = apply(executeRegularExpression, SHARP_VERSION_PATTERN, [specifier]);
+    if (!match?.[1]) {
+        throw new TypeError("ext-image-sharp requires an exact Sharp dependency version");
+    }
+    return match[1];
+}
+function createCacheIdentity() {
+    const components = [
+        `ext-image-sharp@${extensionPackage.version}`,
+        `sharp@${exactSharpVersion(extensionPackage.imports.sharp)}`,
+        ENGINE_SEMANTICS_VERSION,
+        `runtime@${platform}-${arch}`,
+    ];
+    for (let index = 0; index < VERSION_COMPONENTS.length; index++) {
+        const name = VERSION_COMPONENTS[index];
+        const version = sharpRuntime.versions[name];
+        if (typeof version !== "string" || version.length === 0) {
+            throw new TypeError(`Sharp did not report its ${name} backend version`);
+        }
+        apply(arrayPush, components, [`${name}@${version}`]);
+    }
+    apply(arrayPush, components, [
+        `limits@${SHARP_IMAGE_LIMITS.maxDecodedPixels}:` +
+            `${SHARP_IMAGE_LIMITS.maxOutputBytesPerVariant}:` +
+            `${SHARP_IMAGE_LIMITS.maxTotalOutputBytes}`,
+    ]);
+    const identity = apply(arrayJoin, components, ["|"]);
+    if (identity.length > MAX_IMAGE_OPTIMIZATION_ENGINE_IDENTITY_CHARACTERS) {
+        throw new TypeError("ext-image-sharp cache identity exceeds the core limit");
+    }
+    return identity;
+}
+const CACHE_IDENTITY = createCacheIdentity();
+/** Native image decoder, resizer, and encoder supplied by this extension. */
+export class SharpImageOptimizationEngine {
+    cacheIdentity;
+    #engine;
+    constructor() {
+        this.#engine = new BoundSharpImageOptimizationEngine(sharpRuntime, CACHE_IDENTITY);
+        defineProperty(this, "cacheIdentity", {
+            value: CACHE_IDENTITY,
+            enumerable: true,
+            configurable: false,
+            writable: false,
+        });
+        freeze(this);
+    }
+    optimize(request) {
+        return this.#engine.optimize(request);
+    }
+}
+freeze(SharpImageOptimizationEngine.prototype);
+freeze(SharpImageOptimizationEngine);
+function readConfig(value) {
+    if (value === undefined)
+        return;
+    if (typeof value !== "object" || value === null || arrayIsArray(value)) {
+        throw new TypeError("ext-image-sharp config must be an object");
+    }
+    let prototype;
+    let keys;
+    try {
+        prototype = getPrototypeOf(value);
+        keys = ownKeys(getOwnPropertyDescriptors(value));
+    }
+    catch (cause) {
+        throw new TypeError("ext-image-sharp config could not be inspected", {
+            cause,
+        });
+    }
+    if (prototype !== standardObjectPrototype && prototype !== null) {
+        throw new TypeError("ext-image-sharp config must not inherit configuration");
+    }
+    if (keys.length !== 0) {
+        throw new TypeError("ext-image-sharp does not accept configuration properties");
+    }
+}
+const factory = (config) => {
+    readConfig(config);
+    const engine = new SharpImageOptimizationEngine();
+    return {
+        name: "ext-image-sharp",
+        version: extensionPackage.version,
+        capabilities: [
+            {
+                type: "fs:read",
+                paths: ["/proc/self/exe", "/usr/bin/ldd"],
+            },
+            {
+                type: "env:read",
+                keys: ["MALLOC_ARENA_MAX", "npm_package_config_libvips"],
+            },
+            { type: "native:ffi" },
+        ],
+        contracts: {
+            provides: ["ImageOptimizationEngine"],
+        },
+        setup(ctx) {
+            ctx.provide(ImageOptimizationEngineName, engine);
+            ctx.logger.debug(`[ext-image-sharp] ${ImageOptimizationEngineName} registered`);
+        },
+    };
+};
+export default factory;

package/esm/src/sharp-runtime.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Descriptor-safe Sharp runtime capture and bounded image optimization.
+ *
+ * This module is intentionally not a package entry point. The public extension
+ * binds it to the exact Sharp dependency declared by the extension manifest.
+ */
+import type { ImageOptimizationEngine, ImageOptimizationRequest, ImageOptimizationResult } from "veryfront/extensions/image";
+/** Provider-level resource limits, independent of core's stricter boundary. */
+export declare const SHARP_IMAGE_LIMITS: Readonly<{
+    maxInputBytes: number;
+    maxDecodedPixels: 100000000;
+    maxDimension: 32768;
+    maxTargetWidths: 64;
+    maxFormats: 4;
+    maxVariants: 260;
+    maxOutputBytesPerVariant: number;
+    maxTotalOutputBytes: number;
+}>;
+export interface SharpImageLimits {
+    readonly maxInputBytes: number;
+    readonly maxDecodedPixels: number;
+    readonly maxDimension: number;
+    readonly maxTargetWidths: number;
+    readonly maxFormats: number;
+    readonly maxVariants: number;
+    readonly maxOutputBytesPerVariant: number;
+    readonly maxTotalOutputBytes: number;
+}
+/** Captured calls into one exact Sharp module implementation. */
+export interface CapturedSharpRuntime {
+    readonly versions: Readonly<Record<string, string>>;
+    create(input: Uint8Array, options: Readonly<Record<string, unknown>>): object;
+    autoOrient(pipeline: object): object;
+    metadata(pipeline: object): unknown;
+    clone(pipeline: object): object;
+    resize(pipeline: object, options: Readonly<Record<string, unknown>>): object;
+    webp(pipeline: object, options: Readonly<Record<string, unknown>>): object;
+    avif(pipeline: object, options: Readonly<Record<string, unknown>>): object;
+    jpeg(pipeline: object, options: Readonly<Record<string, unknown>>): object;
+    png(pipeline: object, options: Readonly<Record<string, unknown>>): object;
+    toBuffer(pipeline: object, options: Readonly<Record<string, unknown>>): unknown;
+}
+/** Capture Sharp's callable, versions, and prototype methods exactly once. */
+export declare function captureSharpRuntime(value: unknown): CapturedSharpRuntime;
+/**
+ * Internal engine used by the public extension and focused fake-runtime tests.
+ * Every call snapshots one request and creates an independent Sharp pipeline.
+ */
+export declare class BoundSharpImageOptimizationEngine implements ImageOptimizationEngine {
+    #private;
+    readonly cacheIdentity: string;
+    constructor(runtime: CapturedSharpRuntime, cacheIdentity: string, limits?: SharpImageLimits);
+    optimize(request: ImageOptimizationRequest): Promise<ImageOptimizationResult>;
+}
+//# sourceMappingURL=sharp-runtime.d.ts.map

package/esm/src/sharp-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sharp-runtime.d.ts","sourceRoot":"","sources":["../../src/src/sharp-runtime.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,uBAAuB,EAEvB,wBAAwB,EACxB,uBAAuB,EAExB,MAAM,4BAA4B,CAAC;AAgEpC,+EAA+E;AAC/E,eAAO,MAAM,kBAAkB;;;;;;;;;EAS7B,CAAC;AAEH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC;IAC1C,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;CACtC;AAID,iEAAiE;AACjE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,MAAM,CAAC;IAC9E,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IACpC,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,MAAM,CAAC;IAC7E,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,MAAM,CAAC;IAC3E,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,MAAM,CAAC;IAC3E,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,MAAM,CAAC;IAC3E,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,MAAM,CAAC;IAC1E,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,OAAO,CAAC;CACjF;AAgXD,8EAA8E;AAC9E,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,CA6FxE;AAkMD;;;GAGG;AACH,qBAAa,iCAAkC,YAAW,uBAAuB;;IAC/E,QAAQ,CAAC,aAAa,EAAG,MAAM,CAAC;gBAK9B,OAAO,EAAE,oBAAoB,EAC7B,aAAa,EAAE,MAAM,EACrB,MAAM,GAAE,gBAAqC;IAazC,QAAQ,CACZ,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,uBAAuB,CAAC;CAkEpC"}

package/esm/src/sharp-runtime.js

@@ -0,0 +1,573 @@
+/**
+ * Descriptor-safe Sharp runtime capture and bounded image optimization.
+ *
+ * This module is intentionally not a package entry point. The public extension
+ * binds it to the exact Sharp dependency declared by the extension manifest.
+ */
+const apply = Reflect.apply;
+const arrayIncludes = Array.prototype.includes;
+const arrayIsArray = Array.isArray;
+const arrayPush = Array.prototype.push;
+const arraySort = Array.prototype.sort;
+const createObject = Object.create;
+const defineProperty = Object.defineProperty;
+const freeze = Object.freeze;
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
+const getPrototypeOf = Object.getPrototypeOf;
+const hasOwn = Object.hasOwn;
+const numberIsInteger = Number.isInteger;
+const numberIsSafeInteger = Number.isSafeInteger;
+const ownKeys = Reflect.ownKeys;
+const promiseResolve = Promise.resolve;
+const PromiseConstructor = Promise;
+const setAdd = Set.prototype.add;
+const setHas = Set.prototype.has;
+const SetConstructor = Set;
+const setBytes = Uint8Array.prototype.set;
+const sortNumbers = (left, right) => left - right;
+const standardArrayPrototype = Array.prototype;
+const standardObjectPrototype = Object.prototype;
+const Uint8ArrayConstructor = Uint8Array;
+const typedArrayPrototype = getPrototypeOf(Uint8Array.prototype);
+const byteLengthGetter = getOwnPropertyDescriptor(typedArrayPrototype, "byteLength")?.get;
+const typedArrayNameGetter = getOwnPropertyDescriptor(typedArrayPrototype, Symbol.toStringTag)?.get;
+const abortedGetter = getOwnPropertyDescriptor(AbortSignal.prototype, "aborted")?.get;
+if (!byteLengthGetter || !typedArrayNameGetter || !abortedGetter) {
+    throw new TypeError("Required image optimization intrinsics are unavailable");
+}
+const REQUEST_PROPERTIES = freeze([
+    "input",
+    "targetWidths",
+    "formats",
+    "quality",
+    "signal",
+]);
+const SUPPORTED_FORMATS = freeze([
+    "webp",
+    "avif",
+    "jpeg",
+    "png",
+]);
+const MAX_SHARP_PROTOTYPE_DEPTH = 16;
+/** Provider-level resource limits, independent of core's stricter boundary. */
+export const SHARP_IMAGE_LIMITS = freeze({
+    maxInputBytes: 64 * 1024 * 1024,
+    maxDecodedPixels: 100_000_000,
+    maxDimension: 32_768,
+    maxTargetWidths: 64,
+    maxFormats: SUPPORTED_FORMATS.length,
+    maxVariants: 260,
+    maxOutputBytesPerVariant: 64 * 1024 * 1024,
+    maxTotalOutputBytes: 256 * 1024 * 1024,
+});
+function invoke(method, receiver, args) {
+    return apply(method, receiver, args);
+}
+function ownDescriptors(value, label) {
+    try {
+        return getOwnPropertyDescriptors(value);
+    }
+    catch (cause) {
+        throw new TypeError(`${label} properties could not be inspected`, { cause });
+    }
+}
+function readDataProperty(descriptors, property, label) {
+    const descriptor = descriptors[property];
+    if (descriptor === undefined || !hasOwn(descriptor, "value")) {
+        throw new TypeError(`${label} ${property} must be a data property`);
+    }
+    return descriptor.value;
+}
+function readOptionalDataProperty(descriptors, property, label) {
+    const descriptor = descriptors[property];
+    if (descriptor === undefined)
+        return undefined;
+    if (!hasOwn(descriptor, "value")) {
+        throw new TypeError(`${label} ${property} must be a data property`);
+    }
+    return descriptor.value;
+}
+function assertPlainRecord(value, label) {
+    let prototype;
+    try {
+        prototype = getPrototypeOf(value);
+    }
+    catch (cause) {
+        throw new TypeError(`${label} prototype could not be inspected`, { cause });
+    }
+    if (prototype !== standardObjectPrototype && prototype !== null) {
+        throw new TypeError(`${label} must not inherit custom behavior`);
+    }
+}
+function assertExactProperties(descriptors, expected, label) {
+    const keys = ownKeys(descriptors);
+    if (keys.length !== expected.length) {
+        throw new TypeError(`${label} contains unsupported properties`);
+    }
+    for (let index = 0; index < expected.length; index++) {
+        if (!hasOwn(descriptors, expected[index])) {
+            throw new TypeError(`${label} contains unsupported properties`);
+        }
+    }
+}
+function denseDataArray(value, maximumLength, label) {
+    if (!arrayIsArray(value)) {
+        throw new TypeError(`${label} must be an array`);
+    }
+    let prototype;
+    try {
+        prototype = getPrototypeOf(value);
+    }
+    catch (cause) {
+        throw new TypeError(`${label} prototype could not be inspected`, { cause });
+    }
+    if (prototype !== standardArrayPrototype) {
+        throw new TypeError(`${label} must use the standard array prototype`);
+    }
+    const descriptors = ownDescriptors(value, label);
+    const length = readDataProperty(descriptors, "length", label);
+    if (!numberIsSafeInteger(length) ||
+        length < 0 ||
+        length > maximumLength) {
+        throw new TypeError(`${label} exceeds its supported length`);
+    }
+    const entries = [];
+    for (let index = 0; index < length; index++) {
+        const descriptor = descriptors[String(index)];
+        if (descriptor === undefined ||
+            !hasOwn(descriptor, "value") ||
+            descriptor.enumerable !== true) {
+            throw new TypeError(`${label} must be a dense data-property array`);
+        }
+        invoke(arrayPush, entries, [descriptor.value]);
+    }
+    if (ownKeys(descriptors).length !== entries.length + 1) {
+        throw new TypeError(`${label} must not define custom properties`);
+    }
+    return entries;
+}
+function byteLength(value, label) {
+    try {
+        return invoke(byteLengthGetter, value, []);
+    }
+    catch (cause) {
+        throw new TypeError(`${label} must be a Uint8Array`, { cause });
+    }
+}
+function copyBytes(value, maximumLength, label) {
+    let typedArrayName;
+    try {
+        typedArrayName = invoke(typedArrayNameGetter, value, []);
+    }
+    catch (cause) {
+        throw new TypeError(`${label} must be a Uint8Array`, { cause });
+    }
+    if (typedArrayName !== "Uint8Array") {
+        throw new TypeError(`${label} must be a Uint8Array`);
+    }
+    const length = byteLength(value, label);
+    if (length === 0) {
+        throw new TypeError(`${label} must not be empty`);
+    }
+    if (length > maximumLength) {
+        throw new TypeError(`${label} exceeds ${maximumLength} bytes`);
+    }
+    try {
+        const copy = new Uint8ArrayConstructor(length);
+        invoke(setBytes, copy, [value]);
+        return copy;
+    }
+    catch (cause) {
+        throw new TypeError(`${label} could not be copied`, { cause });
+    }
+}
+function isAborted(signal) {
+    return invoke(abortedGetter, signal, []);
+}
+function snapshotAbortSignal(value) {
+    try {
+        invoke(abortedGetter, value, []);
+    }
+    catch (cause) {
+        throw new TypeError("Image optimization signal must be an AbortSignal", {
+            cause,
+        });
+    }
+    return value;
+}
+function cancellationError(cause) {
+    const message = "Image optimization was cancelled or exceeded its deadline";
+    return cause === undefined ? new Error(message) : new Error(message, { cause });
+}
+function throwIfAborted(signal) {
+    if (isAborted(signal))
+        throw cancellationError();
+}
+async function awaitNativeOperation(value, signal) {
+    const operation = invoke(promiseResolve, PromiseConstructor, [value]);
+    let result;
+    try {
+        result = await operation;
+    }
+    catch (cause) {
+        if (isAborted(signal))
+            throw cancellationError(cause);
+        throw cause;
+    }
+    throwIfAborted(signal);
+    return result;
+}
+function snapshotRequest(value, limits) {
+    if (typeof value !== "object" || value === null || arrayIsArray(value)) {
+        throw new TypeError("Image optimization request must be an object");
+    }
+    assertPlainRecord(value, "Image optimization request");
+    const descriptors = ownDescriptors(value, "Image optimization request");
+    assertExactProperties(descriptors, REQUEST_PROPERTIES, "Image optimization request");
+    const signal = snapshotAbortSignal(readDataProperty(descriptors, "signal", "Image optimization request"));
+    throwIfAborted(signal);
+    const input = copyBytes(readDataProperty(descriptors, "input", "Image optimization request"), limits.maxInputBytes, "Image optimization input");
+    const targetWidthEntries = denseDataArray(readDataProperty(descriptors, "targetWidths", "Image optimization request"), limits.maxTargetWidths, "Image optimization target widths");
+    const targetWidths = [];
+    for (let index = 0; index < targetWidthEntries.length; index++) {
+        const width = targetWidthEntries[index];
+        if (!numberIsInteger(width) ||
+            width <= 0 ||
+            width > limits.maxDimension) {
+            throw new TypeError(`Image optimization target widths must be integers from 1 through ${limits.maxDimension}`);
+        }
+        if (!invoke(arrayIncludes, targetWidths, [width])) {
+            invoke(arrayPush, targetWidths, [width]);
+        }
+    }
+    const formatEntries = denseDataArray(readDataProperty(descriptors, "formats", "Image optimization request"), limits.maxFormats, "Image optimization formats");
+    if (formatEntries.length === 0) {
+        throw new TypeError("Image optimization formats must not be empty");
+    }
+    const requestedFormats = new SetConstructor();
+    for (let index = 0; index < formatEntries.length; index++) {
+        const format = formatEntries[index];
+        if (format !== "webp" && format !== "avif" && format !== "jpeg" &&
+            format !== "png") {
+            throw new TypeError("Image optimization format is unsupported");
+        }
+        if (invoke(setHas, requestedFormats, [format])) {
+            throw new TypeError("Image optimization formats must be unique");
+        }
+        invoke(setAdd, requestedFormats, [format]);
+    }
+    const formats = [];
+    for (let index = 0; index < SUPPORTED_FORMATS.length; index++) {
+        const format = SUPPORTED_FORMATS[index];
+        if (invoke(setHas, requestedFormats, [format])) {
+            invoke(arrayPush, formats, [format]);
+        }
+    }
+    const quality = readDataProperty(descriptors, "quality", "Image optimization request");
+    if (!numberIsInteger(quality) || quality < 1 || quality > 100) {
+        throw new TypeError("Image optimization quality must be an integer from 1 through 100");
+    }
+    return freeze({
+        input,
+        targetWidths: freeze(targetWidths),
+        formats: freeze(formats),
+        quality: quality,
+        signal,
+    });
+}
+function findMethod(prototype, property) {
+    const visited = new SetConstructor();
+    let owner = prototype;
+    let depth = 0;
+    while (owner !== null) {
+        if (depth >= MAX_SHARP_PROTOTYPE_DEPTH ||
+            invoke(setHas, visited, [owner])) {
+            throw new TypeError("Sharp has an invalid prototype chain");
+        }
+        invoke(setAdd, visited, [owner]);
+        const descriptor = getOwnPropertyDescriptor(owner, property);
+        if (descriptor !== undefined) {
+            if (!hasOwn(descriptor, "value") || typeof descriptor.value !== "function") {
+                throw new TypeError(`Sharp ${property} must be a data-property method`);
+            }
+            return descriptor.value;
+        }
+        owner = getPrototypeOf(owner);
+        depth++;
+    }
+    throw new TypeError(`Sharp does not implement ${property}()`);
+}
+function snapshotVersions(value) {
+    if (typeof value !== "object" || value === null || arrayIsArray(value)) {
+        throw new TypeError("Sharp versions must be an object");
+    }
+    const descriptors = ownDescriptors(value, "Sharp versions");
+    const versions = createObject(null);
+    for (const property of ownKeys(descriptors)) {
+        if (typeof property !== "string") {
+            throw new TypeError("Sharp versions must not contain symbol properties");
+        }
+        const version = readDataProperty(descriptors, property, "Sharp versions");
+        if (typeof version !== "string" || version.length === 0 ||
+            version.length > 64) {
+            throw new TypeError(`Sharp reported an invalid ${property} version`);
+        }
+        defineProperty(versions, property, {
+            value: version,
+            enumerable: true,
+            configurable: false,
+            writable: false,
+        });
+    }
+    return freeze(versions);
+}
+function requirePipeline(value, operation) {
+    if ((typeof value !== "object" && typeof value !== "function") || value === null) {
+        throw new TypeError(`Sharp ${operation} did not return an image pipeline`);
+    }
+    return value;
+}
+/** Capture Sharp's callable, versions, and prototype methods exactly once. */
+export function captureSharpRuntime(value) {
+    if (typeof value !== "function") {
+        throw new TypeError("Sharp must export an image constructor function");
+    }
+    let prototypeDescriptor;
+    let versionsDescriptor;
+    try {
+        prototypeDescriptor = getOwnPropertyDescriptor(value, "prototype");
+        versionsDescriptor = getOwnPropertyDescriptor(value, "versions");
+    }
+    catch (cause) {
+        throw new TypeError("Sharp export could not be inspected", { cause });
+    }
+    if (prototypeDescriptor === undefined ||
+        !hasOwn(prototypeDescriptor, "value") ||
+        typeof prototypeDescriptor.value !== "object" ||
+        prototypeDescriptor.value === null) {
+        throw new TypeError("Sharp prototype must be an own data property");
+    }
+    if (versionsDescriptor === undefined || !hasOwn(versionsDescriptor, "value")) {
+        throw new TypeError("Sharp versions must be an own data property");
+    }
+    const callable = value;
+    const prototype = prototypeDescriptor.value;
+    const methods = freeze({
+        autoOrient: findMethod(prototype, "autoOrient"),
+        metadata: findMethod(prototype, "metadata"),
+        clone: findMethod(prototype, "clone"),
+        resize: findMethod(prototype, "resize"),
+        webp: findMethod(prototype, "webp"),
+        avif: findMethod(prototype, "avif"),
+        jpeg: findMethod(prototype, "jpeg"),
+        png: findMethod(prototype, "png"),
+        toBuffer: findMethod(prototype, "toBuffer"),
+    });
+    const versions = snapshotVersions(versionsDescriptor.value);
+    return freeze({
+        versions,
+        create(input, options) {
+            return requirePipeline(invoke(callable, undefined, [input, options]), "constructor");
+        },
+        autoOrient(pipeline) {
+            return requirePipeline(invoke(methods.autoOrient, pipeline, []), "autoOrient");
+        },
+        metadata(pipeline) {
+            return invoke(methods.metadata, pipeline, []);
+        },
+        clone(pipeline) {
+            return requirePipeline(invoke(methods.clone, pipeline, []), "clone");
+        },
+        resize(pipeline, options) {
+            return requirePipeline(invoke(methods.resize, pipeline, [options]), "resize");
+        },
+        webp(pipeline, options) {
+            return requirePipeline(invoke(methods.webp, pipeline, [options]), "webp");
+        },
+        avif(pipeline, options) {
+            return requirePipeline(invoke(methods.avif, pipeline, [options]), "avif");
+        },
+        jpeg(pipeline, options) {
+            return requirePipeline(invoke(methods.jpeg, pipeline, [options]), "jpeg");
+        },
+        png(pipeline, options) {
+            return requirePipeline(invoke(methods.png, pipeline, [options]), "png");
+        },
+        toBuffer(pipeline, options) {
+            return invoke(methods.toBuffer, pipeline, [options]);
+        },
+    });
+}
+function assertDimension(value, label, limits) {
+    if (!numberIsInteger(value) ||
+        value <= 0 ||
+        value > limits.maxDimension) {
+        throw new TypeError(`${label} must be an integer from 1 through ${limits.maxDimension}`);
+    }
+}
+function readDimensions(value, label, limits) {
+    if (typeof value !== "object" || value === null || arrayIsArray(value)) {
+        throw new TypeError(`${label} must be an object`);
+    }
+    const descriptors = ownDescriptors(value, label);
+    const width = readDataProperty(descriptors, "width", label);
+    const height = readDataProperty(descriptors, "height", label);
+    assertDimension(width, `${label} width`, limits);
+    assertDimension(height, `${label} height`, limits);
+    if (width * height > limits.maxDecodedPixels) {
+        throw new TypeError(`${label} exceeds ${limits.maxDecodedPixels} pixels`);
+    }
+    return freeze({ width, height });
+}
+function sourceDimensions(value, limits) {
+    if (typeof value !== "object" || value === null || arrayIsArray(value)) {
+        throw new TypeError("Sharp metadata must be an object");
+    }
+    const descriptors = ownDescriptors(value, "Sharp metadata");
+    const oriented = readOptionalDataProperty(descriptors, "autoOrient", "Sharp metadata");
+    if (oriented !== undefined) {
+        return readDimensions(oriented, "Auto-oriented image", limits);
+    }
+    return readDimensions(value, "Source image", limits);
+}
+function outputWidths(configured, sourceWidth, limits) {
+    const widths = [];
+    for (let index = 0; index < configured.length; index++) {
+        const width = configured[index];
+        if (width <= sourceWidth)
+            invoke(arrayPush, widths, [width]);
+    }
+    if (!invoke(arrayIncludes, widths, [sourceWidth])) {
+        invoke(arrayPush, widths, [sourceWidth]);
+    }
+    invoke(arraySort, widths, [sortNumbers]);
+    if (widths.length > limits.maxTargetWidths + 1) {
+        throw new TypeError(`Image optimization produces more than ${limits.maxTargetWidths + 1} output widths`);
+    }
+    return freeze(widths);
+}
+function encode(runtime, pipeline, format, quality) {
+    if (format === "webp")
+        return runtime.webp(pipeline, freeze({ quality }));
+    if (format === "avif")
+        return runtime.avif(pipeline, freeze({ quality }));
+    if (format === "jpeg") {
+        return runtime.jpeg(pipeline, freeze({ quality, progressive: true }));
+    }
+    return runtime.png(pipeline, freeze({ quality, compressionLevel: 9, adaptiveFiltering: true }));
+}
+function readOutput(value, format, width, sourceWidth, sourceHeight, aggregate, limits) {
+    if (typeof value !== "object" || value === null || arrayIsArray(value)) {
+        throw new TypeError("Sharp output must be an object");
+    }
+    const descriptors = ownDescriptors(value, "Sharp output");
+    const dataValue = readDataProperty(descriptors, "data", "Sharp output");
+    const infoValue = readDataProperty(descriptors, "info", "Sharp output");
+    const dataLength = byteLength(dataValue, "Sharp output data");
+    if (dataLength === 0)
+        throw new TypeError("Sharp returned an empty image");
+    if (dataLength > limits.maxOutputBytesPerVariant) {
+        throw new TypeError(`Sharp output exceeds ${limits.maxOutputBytesPerVariant} bytes`);
+    }
+    if (typeof infoValue !== "object" || infoValue === null || arrayIsArray(infoValue)) {
+        throw new TypeError("Sharp output info must be an object");
+    }
+    const infoDescriptors = ownDescriptors(infoValue, "Sharp output info");
+    const outputWidth = readDataProperty(infoDescriptors, "width", "Sharp output info");
+    const outputHeight = readDataProperty(infoDescriptors, "height", "Sharp output info");
+    const outputSize = readDataProperty(infoDescriptors, "size", "Sharp output info");
+    const outputFormat = readDataProperty(infoDescriptors, "format", "Sharp output info");
+    assertDimension(outputWidth, "Sharp output width", limits);
+    assertDimension(outputHeight, "Sharp output height", limits);
+    if (outputWidth !== width) {
+        throw new TypeError(`Sharp encoded ${outputWidth}px for requested ${width}px output`);
+    }
+    const expectedHeight = Math.max(1, Math.round(sourceHeight * width / sourceWidth));
+    if (outputHeight !== expectedHeight) {
+        throw new TypeError("Sharp did not preserve the source aspect ratio");
+    }
+    if (!numberIsSafeInteger(outputSize) || outputSize !== dataLength) {
+        throw new TypeError("Sharp output size metadata does not match its bytes");
+    }
+    if (outputFormat !== format &&
+        !(format === "avif" && outputFormat === "heif")) {
+        throw new TypeError(`Sharp returned ${String(outputFormat)} for ${format} output`);
+    }
+    aggregate.value += dataLength;
+    if (!numberIsSafeInteger(aggregate.value) ||
+        aggregate.value > limits.maxTotalOutputBytes) {
+        throw new TypeError(`Sharp outputs exceed ${limits.maxTotalOutputBytes} bytes in total`);
+    }
+    return freeze({
+        format,
+        width,
+        height: outputHeight,
+        data: copyBytes(dataValue, limits.maxOutputBytesPerVariant, "Sharp output data"),
+    });
+}
+const SHARP_INPUT_OPTIONS = freeze({
+    failOn: "warning",
+    limitInputPixels: SHARP_IMAGE_LIMITS.maxDecodedPixels,
+    pages: 1,
+    sequentialRead: true,
+});
+const SHARP_OUTPUT_OPTIONS = freeze({ resolveWithObject: true });
+/**
+ * Internal engine used by the public extension and focused fake-runtime tests.
+ * Every call snapshots one request and creates an independent Sharp pipeline.
+ */
+export class BoundSharpImageOptimizationEngine {
+    cacheIdentity;
+    #runtime;
+    #limits;
+    constructor(runtime, cacheIdentity, limits = SHARP_IMAGE_LIMITS) {
+        this.#runtime = runtime;
+        this.#limits = limits;
+        defineProperty(this, "cacheIdentity", {
+            value: cacheIdentity,
+            enumerable: true,
+            configurable: false,
+            writable: false,
+        });
+        freeze(this);
+    }
+    async optimize(request) {
+        const snapshot = snapshotRequest(request, this.#limits);
+        throwIfAborted(snapshot.signal);
+        let source = this.#runtime.create(snapshot.input, SHARP_INPUT_OPTIONS);
+        throwIfAborted(snapshot.signal);
+        source = this.#runtime.autoOrient(source);
+        throwIfAborted(snapshot.signal);
+        const metadata = await awaitNativeOperation(this.#runtime.metadata(source), snapshot.signal);
+        const sourceSize = sourceDimensions(metadata, this.#limits);
+        const widths = outputWidths(snapshot.targetWidths, sourceSize.width, this.#limits);
+        if (widths.length * snapshot.formats.length > this.#limits.maxVariants) {
+            throw new TypeError(`Image optimization produces more than ${this.#limits.maxVariants} variants`);
+        }
+        const variants = [];
+        const aggregate = { value: 0 };
+        for (let widthIndex = 0; widthIndex < widths.length; widthIndex++) {
+            const width = widths[widthIndex];
+            for (let formatIndex = 0; formatIndex < snapshot.formats.length; formatIndex++) {
+                const format = snapshot.formats[formatIndex];
+                throwIfAborted(snapshot.signal);
+                let pipeline = this.#runtime.clone(source);
+                pipeline = this.#runtime.resize(pipeline, freeze({ width, fit: "inside", withoutEnlargement: true }));
+                pipeline = encode(this.#runtime, pipeline, format, snapshot.quality);
+                const output = await awaitNativeOperation(this.#runtime.toBuffer(pipeline, SHARP_OUTPUT_OPTIONS), snapshot.signal);
+                throwIfAborted(snapshot.signal);
+                invoke(arrayPush, variants, [
+                    readOutput(output, format, width, sourceSize.width, sourceSize.height, aggregate, this.#limits),
+                ]);
+            }
+        }
+        return freeze({
+            sourceWidth: sourceSize.width,
+            sourceHeight: sourceSize.height,
+            variants: freeze(variants),
+        });
+    }
+}
+freeze(BoundSharpImageOptimizationEngine.prototype);
+freeze(BoundSharpImageOptimizationEngine);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veryfront/ext-image-sharp",
-  "version": "0.1.1186",
+  "version": "0.1.1189",
   "description": "Veryfront first-party extension package for ext-image-sharp",
   "keywords": [
     "veryfront",
@@ -27,7 +27,7 @@
   },
   "scripts": {},
   "engines": {
-    "node": ">=20.9.0"
+    "node": ">=22.3.0"
   },
   "publishConfig": {
     "access": "public"
@@ -35,9 +35,6 @@
   "veryfront": {
     "extension": true,
     "activation": "explicit",
-    "npm": {
-      "nodeEngine": ">=20.9.0"
-    },
     "contracts": {
       "provides": [
         "ImageOptimizationEngine"
@@ -67,7 +64,7 @@
     "sharp": "0.35.3"
   },
   "peerDependencies": {
-    "veryfront": "^0.1.1186"
+    "veryfront": "^0.1.1189"
   },
   "type": "module",
   "types": "./esm/src/index.d.ts",