@veryfront/ext-content-mdx 0.1.1186 → 0.1.1189

package/esm/src/utils/parallel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parallel.d.ts","sourceRoot":"","sources":["../../../src/src/utils/parallel.ts"],"names":[],"mappings":"AAAA;;;;;;;iCAOiC;AAEjC,OAAO,EAAE,SAAS,EAAE,MAAM,oEAAoE,CAAC;AAY/F,KAAK,eAAe,GAAG;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAgBF,wBAAwB;AACxB,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAC9B,KAAK,EAAE,CAAC,EAAE,EACV,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EAC1C,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,CAAC,EAAE,CAAC,CA4Bd;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC,EAAE,EACvE,GAAG,EAAE,CAAC,EACN,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,CAMxD"}
+{"version":3,"file":"parallel.d.ts","sourceRoot":"","sources":["../../../src/src/utils/parallel.ts"],"names":[],"mappings":"AAAA;;;;;;;iCAOiC;AAEjC,OAAO,EAAE,SAAS,EAAE,MAAM,oEAAoE,CAAC;AAY/F,KAAK,eAAe,GAAG;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAyBF,wBAAwB;AACxB,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAC9B,KAAK,EAAE,CAAC,EAAE,EACV,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EAC1C,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,CAAC,EAAE,CAAC,CA4Bd;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,SAAS,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC,EAAE,EACvE,GAAG,EAAE,CAAC,EACN,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,CAMxD"}

package/esm/src/utils/parallel.js

@@ -15,6 +15,16 @@ const ACQUIRE_TIMEOUT_MS = 30_000;
 // so a queue cap would reject items in large batches instead of letting
 // them progress under the concurrency limit with timeout-based backpressure.
 const apiSemaphore = new Semaphore(DEFAULT_CONCURRENCY);
+function resolveParallelSemaphore(options) {
+    if (options.semaphore !== undefined)
+        return options.semaphore;
+    if (options.concurrency === undefined)
+        return apiSemaphore;
+    if (!Number.isSafeInteger(options.concurrency) || options.concurrency < 1) {
+        throw new RangeError("parallel concurrency must be a positive safe integer");
+    }
+    return new Semaphore(options.concurrency);
+}
 async function acquireOrThrow(semaphore, timeoutMs, label) {
     const acquired = await semaphore.tryAcquire(timeoutMs);
     if (acquired)
@@ -28,7 +38,7 @@ export function parallelMap(items, fn, options = {}) {
     return withSpan("utils.parallelMap", async () => {
         if (items.length === 0)
             return [];
-        const semaphore = options.semaphore ?? apiSemaphore;
+        const semaphore = resolveParallelSemaphore(options);
         const timeoutMs = options.timeoutMs ?? ACQUIRE_TIMEOUT_MS;
         const results = new Array(items.length);
         await Promise.all(items.map(async (item, index) => {

package/esm/src/utils/project-identity.d.ts

@@ -0,0 +1,11 @@
+import { MAX_OPAQUE_ID_CODE_UNITS, MAX_PROJECT_SLUG_CODE_UNITS } from "./constants/project-identity.js";
+/** Whether a string contains a Unicode Cc control code point. */
+export declare function hasProjectIdentityControlCharacters(value: string): boolean;
+/** Normalize optional whitespace surrounding an upstream project slug. */
+export declare function normalizeProjectSlug(value: string): string;
+/** Whether a value is a bounded, exact opaque identifier. */
+export declare function isCanonicalOpaqueProjectIdentifier(value: unknown): value is string;
+/** Whether a normalized value is a canonical hosted project slug. */
+export declare function isCanonicalProjectSlug(value: string): boolean;
+export { MAX_OPAQUE_ID_CODE_UNITS, MAX_PROJECT_SLUG_CODE_UNITS };
+//# sourceMappingURL=project-identity.d.ts.map

package/esm/src/utils/project-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-identity.d.ts","sourceRoot":"","sources":["../../../src/src/utils/project-identity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,2BAA2B,EAC5B,MAAM,iCAAiC,CAAC;AAiCzC,iEAAiE;AACjE,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAQ1E;AAED,0EAA0E;AAC1E,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,6DAA6D;AAC7D,wBAAgB,kCAAkC,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CASlF;AAED,qEAAqE;AACrE,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAiB7D;AAED,OAAO,EAAE,wBAAwB,EAAE,2BAA2B,EAAE,CAAC"}

package/esm/src/utils/project-identity.js

@@ -0,0 +1,69 @@
+import { MAX_OPAQUE_ID_CODE_UNITS, MAX_PROJECT_SLUG_CODE_UNITS, } from "./constants/project-identity.js";
+const ReflectApply = Reflect.apply;
+const StringPrototypeCharCodeAt = String.prototype.charCodeAt;
+const StringPrototypeTrim = String.prototype.trim;
+function charCodeAt(value, index) {
+    return ReflectApply(StringPrototypeCharCodeAt, value, [index]);
+}
+function isAsciiLetterOrDigit(code) {
+    return ((code >= 0x30 && code <= 0x39) ||
+        (code >= 0x41 && code <= 0x5a) ||
+        (code >= 0x61 && code <= 0x7a));
+}
+function isWellFormedUtf16(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = charCodeAt(value, index);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            if (index + 1 >= value.length)
+                return false;
+            const low = charCodeAt(value, index + 1);
+            if (low < 0xdc00 || low > 0xdfff)
+                return false;
+            index += 1;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Whether a string contains a Unicode Cc control code point. */
+export function hasProjectIdentityControlCharacters(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = charCodeAt(value, index);
+        if (code <= 0x1f || (code >= 0x7f && code <= 0x9f)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Normalize optional whitespace surrounding an upstream project slug. */
+export function normalizeProjectSlug(value) {
+    return ReflectApply(StringPrototypeTrim, value, []);
+}
+/** Whether a value is a bounded, exact opaque identifier. */
+export function isCanonicalOpaqueProjectIdentifier(value) {
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        value.length <= MAX_OPAQUE_ID_CODE_UNITS &&
+        isWellFormedUtf16(value) &&
+        value === normalizeProjectSlug(value) &&
+        !hasProjectIdentityControlCharacters(value));
+}
+/** Whether a normalized value is a canonical hosted project slug. */
+export function isCanonicalProjectSlug(value) {
+    if (value.length === 0 ||
+        value.length > MAX_PROJECT_SLUG_CODE_UNITS ||
+        !isAsciiLetterOrDigit(charCodeAt(value, 0)) ||
+        !isAsciiLetterOrDigit(charCodeAt(value, value.length - 1))) {
+        return false;
+    }
+    for (let index = 1; index < value.length - 1; index += 1) {
+        const code = charCodeAt(value, index);
+        if (!isAsciiLetterOrDigit(code) && code !== 0x2d) {
+            return false;
+        }
+    }
+    return true;
+}
+export { MAX_OPAQUE_ID_CODE_UNITS, MAX_PROJECT_SLUG_CODE_UNITS };

package/esm/src/utils/version-constant.d.ts

@@ -1,3 +1,3 @@
 /** Shared version value. */
-export declare const VERSION = "0.1.1186";
+export declare const VERSION = "0.1.1189";
 //# sourceMappingURL=version-constant.d.ts.map

package/esm/src/utils/version-constant.js

@@ -1,4 +1,4 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
 /** Shared version value. */
-export const VERSION = "0.1.1186";
+export const VERSION = "0.1.1189";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veryfront/ext-content-mdx",
-  "version": "0.1.1186",
+  "version": "0.1.1189",
   "description": "Veryfront first-party extension package for ext-content-mdx",
   "keywords": [
     "veryfront",
@@ -27,7 +27,7 @@
   },
   "scripts": {},
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.3.0"
   },
   "publishConfig": {
     "access": "public"
@@ -67,7 +67,7 @@
     "vfile": "6.0.3"
   },
   "peerDependencies": {
-    "veryfront": "^0.1.1186"
+    "veryfront": "^0.1.1189"
   },
   "type": "module",
   "types": "./esm/extensions/ext-content-mdx/src/index.d.ts",

package/esm/src/platform/adapters/runtime/shared/native-file-capabilities.d.ts

@@ -1,33 +0,0 @@
-interface SnapshotStat {
-    readonly dev: bigint;
-    readonly ino: bigint;
-    readonly size: bigint;
-    readonly mtimeNs: bigint;
-    readonly ctimeNs: bigint;
-    isFile(): boolean;
-    isSymbolicLink(): boolean;
-}
-interface SnapshotHandle {
-    stat(): Promise<SnapshotStat>;
-    read(buffer: Uint8Array, offset: number, length: number, position: number): Promise<{
-        bytesRead: number;
-    }>;
-    writeFile(content: Uint8Array): Promise<void>;
-    close(): Promise<void>;
-}
-export interface NativeSnapshotOperations {
-    realpath(path: string): Promise<string>;
-    lstat(path: string): Promise<SnapshotStat>;
-    open(path: string, flags: number | string): Promise<SnapshotHandle>;
-}
-/** Whether the runtime can enforce a no-follow native snapshot open. */
-export declare function supportsNativeFileSnapshots(platform?: "posix" | "windows"): boolean;
-/**
- * Read one verified regular-file generation without following a terminal link.
- * Identity and generation are checked before and after the bounded positional read.
- */
-export declare function readNodeFileSnapshotWithinLimit(path: string, containmentRoot: string, byteLimit: number, operations?: NativeSnapshotOperations): Promise<Uint8Array>;
-/** Create a new file without replacement and join handle cleanup. */
-export declare function createNodeFileBytesExclusive(path: string, content: Uint8Array, operations?: NativeSnapshotOperations): Promise<void>;
-export {};
-//# sourceMappingURL=native-file-capabilities.d.ts.map

package/esm/src/platform/adapters/runtime/shared/native-file-capabilities.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"native-file-capabilities.d.ts","sourceRoot":"","sources":["../../../../../../src/src/platform/adapters/runtime/shared/native-file-capabilities.ts"],"names":[],"mappings":"AAIA,UAAU,YAAY;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,MAAM,IAAI,OAAO,CAAC;IAClB,cAAc,IAAI,OAAO,CAAC;CAC3B;AAED,UAAU,cAAc;IACtB,IAAI,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;IAC9B,IAAI,CACF,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClC,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACxC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAC3C,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CACrE;AAED,wEAAwE;AACxE,wBAAgB,2BAA2B,CACzC,QAAQ,GAAE,OAAO,GAAG,SAA2D,GAC9E,OAAO,CAET;AAkFD;;;GAGG;AACH,wBAAsB,+BAA+B,CACnD,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,MAAM,EACvB,SAAS,EAAE,MAAM,EACjB,UAAU,CAAC,EAAE,wBAAwB,GACpC,OAAO,CAAC,UAAU,CAAC,CAsHrB;AAED,qEAAqE;AACrE,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,UAAU,EACnB,UAAU,CAAC,EAAE,wBAAwB,GACpC,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/esm/src/platform/adapters/runtime/shared/native-file-capabilities.js

@@ -1,205 +0,0 @@
-import { isAbsolute, relative, resolve, sep } from "../../../compat/path/index.js";
-import { runtimeUsesWindowsPaths } from "../../../compat/path/portable.js";
-import { FileSnapshotChangedError } from "../../file-snapshot-error.js";
-/** Whether the runtime can enforce a no-follow native snapshot open. */
-export function supportsNativeFileSnapshots(platform = runtimeUsesWindowsPaths() ? "windows" : "posix") {
-    return platform === "posix";
-}
-function toSnapshotStat(stats) {
-    return {
-        dev: stats.dev,
-        ino: stats.ino,
-        size: stats.size,
-        mtimeNs: stats.mtimeNs,
-        ctimeNs: stats.ctimeNs,
-        isFile: () => stats.isFile(),
-        isSymbolicLink: () => stats.isSymbolicLink(),
-    };
-}
-async function defaultOperations() {
-    const fs = await import("node:fs/promises");
-    return {
-        realpath: (path) => fs.realpath(path),
-        async lstat(path) {
-            return toSnapshotStat(await fs.lstat(path, { bigint: true }));
-        },
-        async open(path, flags) {
-            const handle = await fs.open(path, flags);
-            return {
-                async stat() {
-                    return toSnapshotStat(await handle.stat({ bigint: true }));
-                },
-                read: (buffer, offset, length, position) => handle.read(buffer, offset, length, position),
-                writeFile: (content) => handle.writeFile(content),
-                close: () => handle.close(),
-            };
-        },
-    };
-}
-function requireByteLimit(value) {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-        throw new RangeError("Snapshot byte limit must be a positive safe integer");
-    }
-    return value;
-}
-function isContainedPath(path, root) {
-    const relation = relative(root, path);
-    return relation === "" ||
-        (relation !== ".." && !relation.startsWith(`..${sep}`) && !isAbsolute(relation));
-}
-function sameIdentity(left, right) {
-    return left.dev === right.dev && left.ino === right.ino;
-}
-function sameGeneration(left, right) {
-    return sameIdentity(left, right) && left.size === right.size &&
-        left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
-}
-function changed(message, cause) {
-    const error = new FileSnapshotChangedError(message);
-    if (cause !== undefined)
-        Object.defineProperty(error, "cause", { value: cause });
-    return error;
-}
-async function closeSnapshotHandle(handle, primaryFailure, failed) {
-    try {
-        await handle.close();
-    }
-    catch (cleanupFailure) {
-        if (failed) {
-            throw new AggregateError([primaryFailure, cleanupFailure], "Filesystem snapshot read and handle cleanup both failed");
-        }
-        throw cleanupFailure;
-    }
-    if (failed)
-        throw primaryFailure;
-}
-/**
- * Read one verified regular-file generation without following a terminal link.
- * Identity and generation are checked before and after the bounded positional read.
- */
-export async function readNodeFileSnapshotWithinLimit(path, containmentRoot, byteLimit, operations) {
-    const admittedLimit = requireByteLimit(byteLimit);
-    const lexicalRoot = resolve(containmentRoot);
-    const candidate = resolve(path);
-    const fsOperations = operations ?? await defaultOperations();
-    const { constants } = await import("node:fs");
-    if (!Number.isSafeInteger(constants.O_NOFOLLOW) || constants.O_NOFOLLOW === 0) {
-        throw new TypeError("This runtime cannot guarantee no-follow snapshot opens");
-    }
-    const canonicalRoot = await fsOperations.realpath(lexicalRoot);
-    if (!isContainedPath(candidate, lexicalRoot) &&
-        !isContainedPath(candidate, canonicalRoot)) {
-        throw new TypeError("Snapshot path must be contained by the requested root");
-    }
-    const pathnameBefore = await fsOperations.lstat(candidate);
-    if (pathnameBefore.isSymbolicLink()) {
-        throw new TypeError("Snapshot path must not be a symbolic link");
-    }
-    if (!pathnameBefore.isFile()) {
-        throw new TypeError("Snapshot path must identify a regular file");
-    }
-    let handle;
-    try {
-        handle = await fsOperations.open(candidate, constants.O_RDONLY | constants.O_NOFOLLOW);
-    }
-    catch (cause) {
-        throw changed("File identity became uncertain while opening the snapshot", cause);
-    }
-    let failed = false;
-    let primaryFailure;
-    let result;
-    try {
-        let handleBefore;
-        try {
-            handleBefore = await handle.stat();
-        }
-        catch (cause) {
-            throw changed("Opened file identity could not be verified", cause);
-        }
-        if (!handleBefore.isFile() || !sameGeneration(pathnameBefore, handleBefore)) {
-            throw changed("File identity changed while opening the snapshot");
-        }
-        let canonicalTarget;
-        let pathnameOpened;
-        try {
-            [canonicalTarget, pathnameOpened] = await Promise.all([
-                fsOperations.realpath(candidate),
-                fsOperations.lstat(candidate),
-            ]);
-        }
-        catch (cause) {
-            throw changed("File target became uncertain while opening the snapshot", cause);
-        }
-        if (pathnameOpened.isSymbolicLink() || !pathnameOpened.isFile() ||
-            !sameGeneration(handleBefore, pathnameOpened)) {
-            throw changed("File identity changed while opening the snapshot");
-        }
-        if (!isContainedPath(canonicalTarget, canonicalRoot)) {
-            throw new TypeError("Snapshot target must be contained by the canonical root");
-        }
-        if (handleBefore.size < 0n) {
-            throw changed("File size became uncertain while opening the snapshot");
-        }
-        if (handleBefore.size > BigInt(admittedLimit)) {
-            throw new RangeError(`File exceeds byte limit of ${admittedLimit} bytes`);
-        }
-        const size = Number(handleBefore.size);
-        let bytes;
-        try {
-            bytes = new Uint8Array(size);
-        }
-        catch (cause) {
-            throw new Error("Unable to allocate the admitted snapshot buffer", { cause });
-        }
-        let offset = 0;
-        while (offset < size) {
-            const { bytesRead } = await handle.read(bytes, offset, size - offset, offset);
-            if (!Number.isSafeInteger(bytesRead) || bytesRead <= 0 || bytesRead > size - offset) {
-                throw changed("File size changed while reading the snapshot");
-            }
-            offset += bytesRead;
-        }
-        let handleAfter;
-        let pathnameAfter;
-        let canonicalTargetAfter;
-        try {
-            [handleAfter, pathnameAfter, canonicalTargetAfter] = await Promise.all([
-                handle.stat(),
-                fsOperations.lstat(candidate),
-                fsOperations.realpath(candidate),
-            ]);
-        }
-        catch (cause) {
-            throw changed("File identity became uncertain after reading the snapshot", cause);
-        }
-        if (pathnameAfter.isSymbolicLink() || !pathnameAfter.isFile() ||
-            !sameGeneration(handleBefore, handleAfter) ||
-            !sameGeneration(handleBefore, pathnameAfter) ||
-            canonicalTargetAfter !== canonicalTarget ||
-            !isContainedPath(canonicalTargetAfter, canonicalRoot)) {
-            throw changed("File snapshot changed during the read");
-        }
-        result = bytes;
-    }
-    catch (error) {
-        failed = true;
-        primaryFailure = error;
-    }
-    await closeSnapshotHandle(handle, primaryFailure, failed);
-    return result;
-}
-/** Create a new file without replacement and join handle cleanup. */
-export async function createNodeFileBytesExclusive(path, content, operations) {
-    const fsOperations = operations ?? await defaultOperations();
-    const handle = await fsOperations.open(path, "wx");
-    let failed = false;
-    let primaryFailure;
-    try {
-        await handle.writeFile(content);
-    }
-    catch (error) {
-        failed = true;
-        primaryFailure = error;
-    }
-    await closeSnapshotHandle(handle, primaryFailure, failed);
-}