rea-agents 3.1.0 → 3.2.0

package/dist/application/UnknownEvidence.js

@@ -7,7 +7,7 @@ export const UNKNOWN_REGISTRY_PROVIDER = {
 };
 /** Create immutable evidence for one approved residual-unknown mutation. */
 export const unknownMutationEvidence = (target, input) => createEvidence(target, UNKNOWN_REGISTRY_PROVIDER, {
-    predicateType: "rea.residual-unknown-mutation/v1",
+    predicateType: "rea.residual-unknown-mutation",
     operation: "record_unknown",
     parameters: { domain: input.domain, severity: input.severity },
     result: {

package/dist/artifacts/ArtifactPaths.js

@@ -1,9 +1,8 @@
-import { Buffer } from "node:buffer";
 import { posix } from "node:path";
-import { ArtifactReaderFailure, } from "./ArtifactReader.js";
+import { ArtifactReaderFailure } from "./ArtifactReader.js";
 const DRIVE_OR_UNC = /^(?:[A-Za-z]:|\\|\/\/)/u;
 /** Normalize an untrusted logical archive path without touching filesystem. */
-export const normalizeArtifactPath = (input, limits) => {
+export const normalizeArtifactPath = (input) => {
     if (input.includes("\0") ||
         input.includes("\\") ||
         input.startsWith("/") ||
@@ -13,8 +12,6 @@ export const normalizeArtifactPath = (input, limits) => {
     const parts = normalized.split("/");
     if (normalized.length === 0 ||
         parts.some((part) => part === "" || part === "." || part === "..") ||
-        parts.length > limits.maxDepth ||
-        Buffer.byteLength(normalized, "utf8") > limits.maxPathBytes ||
         posix.normalize(normalized) !== normalized)
         throw new ArtifactReaderFailure("path", "Artifact path is not normalized");
     return normalized;

package/dist/artifacts/ArtifactProvider.js

@@ -1,10 +1,12 @@
 import { createAnalysisExecution, } from "../application/AnalysisProvider.js";
 import { inventoryArtifact } from "../application/ArtifactInventory.js";
 import { extractArtifact } from "../application/ArtifactExtraction.js";
-import { ARTIFACT_TOOL_CONTRACTS, artifactInspectionInputSchema, artifactInventoryInputSchema, artifactExtractionInputSchema, } from "../contracts/artifactToolContracts.js";
+import { analyzeInterfaceBuilderBundle } from "../application/InterfaceBuilderAnalysis.js";
+import { ARTIFACT_ANALYSIS_OPERATIONS, artifactInventoryInputSchema, artifactExtractionExecutionSchema, } from "../contracts/artifactToolContracts.js";
 import { AnalysisCapabilityUnavailableError, ArtifactOperationError, } from "../domain/errors.js";
+import { interfaceBuilderLimitsSchema } from "../domain/interfaceBuilderGraph.js";
 import { err, ok } from "../domain/result.js";
-import { ArtifactReaderFailure, } from "./ArtifactReader.js";
+import { ArtifactReaderFailure } from "./ArtifactReader.js";
 import { ARTIFACT_GRAPH_PROVIDER } from "../application/InvestigationProviders.js";
 import { createEvidence } from "../domain/evidence.js";
 import { createArtifactInspection } from "../domain/artifactInspection.js";
@@ -18,31 +20,20 @@ export class ArtifactProvider {
         this.nativeMountEnabled = nativeMountEnabled;
         this.integrityContinueEnabled = integrityContinueEnabled;
     }
-    #capabilities = Object.freeze(ARTIFACT_TOOL_CONTRACTS.map((contract) => Object.freeze({
+    #capabilities = Object.freeze(ARTIFACT_ANALYSIS_OPERATIONS.map((operation) => Object.freeze({
         provider: IDENTITY,
-        operation: contract.name,
-        inputContractVersion: 1,
-        outputContractVersion: 1,
+        operation,
         available: true,
         reason: null,
-        pagination: contract.name === "inspect_artifact"
-            ? "none"
-            : "offset",
-        exhaustive: false,
         effects: Object.freeze({
             mutatesArtifact: false,
-            launchesProcess: true,
+            launchesProcess: operation !== "decode_interface_builder",
             mayShowUi: false,
             mayAccessNetwork: false,
-            mayWriteFilesystem: contract.name === "extract_artifact",
+            mayWriteFilesystem: operation === "extract_artifact",
             changesPermissions: false,
             requiresRoot: false,
         }),
-        limits: Object.freeze({
-            maxResults: 500,
-            maxPayloadBytes: 4 * 1024 * 1024,
-            timeoutMs: 120_000,
-        }),
         limitations: Object.freeze([
             "DMG child inventory is macOS-only and requires per-call approval plus operator policy; PKG remains root-hash-only.",
             "ASAR files discovered in filesystem-backed inventories are expanded without bulk extraction; other nested containers remain recorded only.",
@@ -77,22 +68,38 @@ class ArtifactClient {
                 const inspected = await this.inspectArtifact(parameters, options);
                 return inspected;
             }
+            if (operation === "decode_interface_builder") {
+                if (this.target.kind !== "executable" ||
+                    this.target.sourcePath === undefined ||
+                    !this.target.sourcePath.toLowerCase().endsWith(".app"))
+                    throw new ArtifactReaderFailure("unavailable", "decode_interface_builder requires an active .app bundle target");
+                const limits = interfaceBuilderLimitsSchema.parse(parameters);
+                const result = await analyzeInterfaceBuilderBundle({
+                    bundlePath: this.target.sourcePath,
+                    targetSha256: this.target.sha256,
+                    limits,
+                    ...(options?.signal === undefined ? {} : { signal: options.signal }),
+                });
+                return ok(createAnalysisExecution(result, IDENTITY, {
+                    limitations: result.limitations,
+                    locations: result.documents.map(({ relative_path: path }) => ({
+                        kind: "artifact-path",
+                        path,
+                    })),
+                }));
+            }
             if (operation === "extract_artifact") {
-                const parsed = artifactExtractionInputSchema.parse(parameters);
+                const parsed = artifactExtractionExecutionSchema.parse(parameters);
                 const result = await extractArtifact({
                     inputPath: this.target.sourcePath ?? this.target.path,
                     inputFormat: this.target.format,
                     outputRoot: parsed.output_root,
-                    occurrenceIds: parsed.occurrence_ids,
-                    offset: parsed.offset,
-                    limit: parsed.limit,
-                    limits: limitsFrom(parsed),
                 }, options?.signal);
                 return ok(createAnalysisExecution(result, IDENTITY, {
                     rawResult: null,
                     limitations: result.limitations,
                     subject: subjectFor(this.target.sourcePath ?? this.target.path, result.manifest),
-                    locations: result.artifacts.items.map(({ relative_path: path }) => ({
+                    locations: result.artifacts.map(({ relative_path: path }) => ({
                         kind: "artifact-path",
                         path,
                     })),
@@ -104,7 +111,7 @@ class ArtifactClient {
                 rawResult: null,
                 limitations: result.limitations,
                 subject: subjectFor(this.target.sourcePath ?? this.target.path, result.manifest),
-                locations: result.occurrences.items.map(({ logical_path: path }) => ({
+                locations: result.occurrences.map(({ logical_path: path }) => ({
                     kind: "artifact-path",
                     path,
                 })),
@@ -118,24 +125,11 @@ class ArtifactClient {
         return Promise.resolve();
     }
     async inspectArtifact(parameters, options) {
-        const parsed = artifactInspectionInputSchema.parse(parameters);
+        const parsed = artifactInventoryInputSchema.parse(parameters);
         const inventoryParameters = artifactInventoryInputSchema.parse({
-            node_offset: 0,
-            node_limit: parsed.max_observations,
-            occurrence_offset: 0,
-            occurrence_limit: parsed.max_observations,
-            edge_offset: 0,
-            edge_limit: parsed.max_relationships,
             native_mount_approved: parsed.native_mount_approved,
             integrity_policy: parsed.integrity_policy,
             integrity_continue_approved: parsed.integrity_continue_approved,
-            max_integrity_mismatches: parsed.max_integrity_mismatches,
-            max_entries: parsed.max_entries,
-            max_total_bytes: parsed.max_total_bytes,
-            max_entry_bytes: parsed.max_entry_bytes,
-            max_compression_ratio: parsed.max_compression_ratio,
-            max_depth: parsed.max_depth,
-            max_path_bytes: parsed.max_path_bytes,
         });
         await options?.progress?.report({
             phase: "inspect_artifact.inventory",
@@ -145,7 +139,7 @@ class ArtifactClient {
         });
         const inventory = await this.inventory(inventoryParameters, options);
         const subject = subjectFor(this.target.sourcePath ?? this.target.path, inventory.manifest);
-        const locations = inventory.occurrences.items.map(({ logical_path: path }) => ({
+        const locations = inventory.occurrences.map(({ logical_path: path }) => ({
             kind: "artifact-path",
             path,
         }));
@@ -157,7 +151,7 @@ class ArtifactClient {
             limitations: inventory.limitations,
             locations,
         });
-        const result = createArtifactInspection(inventoryEvidence, parsed);
+        const result = createArtifactInspection(inventoryEvidence);
         await options?.progress?.report({
             phase: "inspect_artifact.inventory",
             completed: 1,
@@ -172,34 +166,18 @@ class ArtifactClient {
         }));
     }
     inventory(parsed, options) {
-        return inventoryArtifact(this.target.sourcePath ?? this.target.path, limitsFrom(parsed), {
-            nodeOffset: parsed.node_offset,
-            nodeLimit: parsed.node_limit,
-            occurrenceOffset: parsed.occurrence_offset,
-            occurrenceLimit: parsed.occurrence_limit,
-            edgeOffset: parsed.edge_offset,
-            edgeLimit: parsed.edge_limit,
-        }, {
+        return inventoryArtifact(this.target.sourcePath ?? this.target.path, {
             ...(options?.signal === undefined ? {} : { signal: options.signal }),
             nativeMount: resolveNativeMountPolicy(parsed.native_mount_approved === true, this.nativeMountEnabled),
             integrity: resolveArtifactIntegrityPolicy(parsed.integrity_policy === "fail"
                 ? { mode: "fail" }
                 : {
                     mode: parsed.integrity_policy,
-                    maxMismatches: parsed.max_integrity_mismatches,
                 }, this.integrityContinueEnabled),
         });
     }
 }
-const limitsFrom = (input) => ({
-    maxEntries: input.max_entries,
-    maxTotalBytes: input.max_total_bytes,
-    maxEntryBytes: input.max_entry_bytes,
-    maxCompressionRatio: input.max_compression_ratio,
-    maxDepth: input.max_depth,
-    maxPathBytes: input.max_path_bytes,
-});
-const isArtifactOperation = (operation) => ARTIFACT_TOOL_CONTRACTS.some(({ name }) => name === operation);
+const isArtifactOperation = (operation) => ARTIFACT_ANALYSIS_OPERATIONS.includes(operation);
 const translateFailure = (operation, cause) => {
     if (cause instanceof ArtifactReaderFailure)
         return new ArtifactOperationError(operation, cause.reason, cause.details);

package/dist/artifacts/DirectoryArtifactReader.js

@@ -74,15 +74,20 @@ export class DirectoryArtifactReader {
         if (entry.kind !== "file")
             throw new ArtifactReaderFailure("format", "Only regular files can be opened");
         const handle = await open(entry.adapterKey, constants.O_RDONLY | constants.O_NOFOLLOW);
-        const observed = await handle.stat();
-        if (!observed.isFile() ||
-            entry.sourceIdentity === undefined ||
-            observed.dev !== entry.sourceIdentity.device ||
-            observed.ino !== entry.sourceIdentity.inode) {
-            await handle.close();
-            throw new ArtifactReaderFailure("integrity", `Directory entry changed before open: ${entry.path}`);
+        try {
+            const observed = await handle.stat();
+            if (!observed.isFile() ||
+                entry.sourceIdentity === undefined ||
+                observed.dev !== entry.sourceIdentity.device ||
+                observed.ino !== entry.sourceIdentity.inode) {
+                throw new ArtifactReaderFailure("integrity", `Directory entry changed before open: ${entry.path}`);
+            }
+            return handle.createReadStream({ autoClose: true });
+        }
+        catch (cause) {
+            await handle.close().catch(() => undefined);
+            throw cause;
         }
-        return handle.createReadStream({ autoClose: true });
     }
     close() {
         return Promise.resolve();

package/dist/artifacts/MachOSliceArtifactReader.js

@@ -13,11 +13,7 @@ export class MachOSliceArtifactReader {
         this.runner = runner;
     }
     async *entries(signal) {
-        const captured = await this.runner.run("lipo", ["-detailed_info", this.path], {
-            ...(signal === undefined ? {} : { signal }),
-            timeoutMs: 30_000,
-            maxOutputBytes: 4 * 1024 * 1024,
-        });
+        const captured = await this.runner.run("lipo", ["-detailed_info", this.path], signal === undefined ? {} : { signal });
         if (!captured.ok)
             throw new ArtifactReaderFailure(captured.error.reason === "cancelled" ? "cancelled" : "unavailable", "lipo could not enumerate universal Mach-O slices", { cause: captured.error });
         this.#command = {

package/dist/artifacts/NativeDmgArtifactReader.js

@@ -1,13 +1,12 @@
-import { execFile } from "node:child_process";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
-import { promisify } from "node:util";
 import { parse } from "plist";
 import { z } from "zod";
 import { ArtifactReaderFailure, } from "./ArtifactReader.js";
 import { DirectoryArtifactReader } from "./DirectoryArtifactReader.js";
-const execFileAsync = promisify(execFile);
+import { execFileOutput } from "../process/ExecFileOutput.js";
+const DETACH_TIMEOUT_MS = 120_000;
 const attachOutputSchema = z.object({
     "system-entities": z.array(z.object({
         "dev-entry": z.string().startsWith("/dev/"),
@@ -15,11 +14,10 @@ const attachOutputSchema = z.object({
     })),
 });
 const systemHost = {
-    async run(arguments_, signal) {
+    async run(arguments_, signal, options) {
         try {
-            const { stdout } = await execFileAsync("/usr/bin/hdiutil", [...arguments_], {
-                encoding: "utf8",
-                timeout: 120_000,
+            const { stdout } = await execFileOutput("/usr/bin/hdiutil", [...arguments_], {
+                ...(options === undefined ? {} : { timeout: options.timeoutMs }),
                 ...(signal === undefined ? {} : { signal }),
             });
             return { stdout, exitCode: 0 };
@@ -48,7 +46,7 @@ export class NativeDmgArtifactReader {
     }
     /** Verify and attach one image beneath an exclusively owned temporary root. */
     static async create(path, signal, host = systemHost) {
-        if (process.platform !== "darwin")
+        if (process.platform !== "darwin" && host === systemHost)
             throw new ArtifactReaderFailure("unavailable", "Native DMG traversal is available only on macOS");
         const reader = new NativeDmgArtifactReader(path, host);
         await reader.attach(signal);
@@ -73,7 +71,9 @@ export class NativeDmgArtifactReader {
         let detachFailure;
         for (const device of [...this.#devices].reverse()) {
             try {
-                await runChecked(this.host, ["detach", device]);
+                await runChecked(this.host, ["detach", device], undefined, {
+                    timeoutMs: DETACH_TIMEOUT_MS,
+                });
                 this.#provenance.push(command(["detach", device], ["mount"]));
             }
             catch (cause) {
@@ -135,8 +135,8 @@ export class NativeDmgArtifactReader {
         }
     }
 }
-const runChecked = async (host, arguments_, signal) => {
-    const result = await host.run(arguments_, signal);
+const runChecked = async (host, arguments_, signal, options) => {
+    const result = await host.run(arguments_, signal, options);
     if (result.exitCode !== 0)
         throw new ArtifactReaderFailure("unavailable", `hdiutil ${arguments_[0] ?? "operation"} failed with a non-zero exit code`);
     return { stdout: result.stdout, exitCode: 0 };

package/dist/artifacts/NibArchive.js

@@ -0,0 +1,269 @@
+import { TextDecoder } from "node:util";
+const MAGIC = Buffer.from("NIBArchive", "ascii");
+const MAX_RECORDS = 1_000_000;
+/** Decode Apple's length-prefixed NIBArchive representation without loading UI classes. */
+export const decodeNibArchive = (bytes) => {
+    if (bytes.length < 50 || !bytes.subarray(0, MAGIC.length).equals(MAGIC))
+        throw new TypeError("NIBArchive magic or header is invalid");
+    const formatVersion = readU32(bytes, 10);
+    const coderVersion = readU32(bytes, 14);
+    if (formatVersion !== 1)
+        throw new TypeError(`Unsupported NIBArchive format version ${formatVersion}`);
+    const objectCount = readCount(bytes, 18, "object");
+    const objectsOffset = readOffset(bytes, 22, bytes.length, "object");
+    const keyCount = readCount(bytes, 26, "key");
+    const keysOffset = readOffset(bytes, 30, bytes.length, "key");
+    const valueCount = readCount(bytes, 34, "value");
+    const valuesOffset = readOffset(bytes, 38, bytes.length, "value");
+    const classCount = readCount(bytes, 42, "class");
+    const classesOffset = readOffset(bytes, 46, bytes.length, "class");
+    assertOrderedOffsets(bytes.length, [
+        objectsOffset,
+        keysOffset,
+        valuesOffset,
+        classesOffset,
+    ]);
+    const objectRecords = parseObjects(bytes, objectsOffset, keysOffset, objectCount, valueCount, classCount);
+    const keys = parseStrings(bytes, keysOffset, valuesOffset, keyCount, "key");
+    const classes = parseClasses(bytes, classesOffset, bytes.length, classCount);
+    const neededValues = valueIndexes(objectRecords, valueCount);
+    const values = parseValues(bytes, valuesOffset, classesOffset, valueCount, keyCount, neededValues);
+    for (const { value } of values.values()) {
+        if (typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value) &&
+            typeof value.$nib_object_ref === "number" &&
+            value.$nib_object_ref >= objectCount)
+            throw new TypeError("NIBArchive object reference is outside the object table");
+    }
+    const objects = objectRecords.flatMap((object, id) => {
+        const className = classes[object.class_index];
+        if (className === undefined)
+            return [];
+        const fields = {};
+        for (let index = object.value_start; index < object.value_start + object.value_count; index += 1) {
+            const value = values.get(index);
+            if (value === undefined)
+                continue;
+            const key = keys[value.key_index];
+            if (key !== undefined)
+                fields[key] = value.value;
+        }
+        return [{ id, class_name: className, values: fields }];
+    });
+    let connectionObjectCount = 0;
+    for (const object of objects)
+        if (/(?:Outlet|Connection|Segue|ActionConnection)/iu.test(object.class_name))
+            connectionObjectCount += 1;
+    return {
+        format_version: formatVersion,
+        coder_version: coderVersion,
+        object_count: objectCount,
+        connection_object_count: connectionObjectCount,
+        objects,
+        classes,
+        limitations: [
+            "NIBArchive class extensions and unsupported value encodings are retained as unavailable fields.",
+            "NIBArchive object relationships are decoded from serialized references; runtime object creation and execution are not performed.",
+        ],
+    };
+};
+const parseObjects = (bytes, start, end, count, valueCount, classCount) => {
+    const cursor = { offset: start };
+    const output = [];
+    for (let index = 0; index < count; index += 1) {
+        const classIndex = readVarint(bytes, cursor, end);
+        const valueStart = readVarint(bytes, cursor, end);
+        const countForObject = readVarint(bytes, cursor, end);
+        if (classIndex >= classCount ||
+            valueStart > valueCount ||
+            countForObject > valueCount - valueStart)
+            throw new TypeError(`NIBArchive object ${index} references an invalid table range`);
+        output.push({
+            class_index: classIndex,
+            value_start: valueStart,
+            value_count: countForObject,
+        });
+    }
+    if (cursor.offset > end)
+        throw new TypeError("NIBArchive object table overlaps the next table");
+    return output;
+};
+const parseStrings = (bytes, start, end, count, label) => {
+    const cursor = { offset: start };
+    const output = [];
+    for (let index = 0; index < count; index += 1) {
+        const length = readVarint(bytes, cursor, end);
+        const next = checkedEnd(cursor.offset, length, end, `${label} ${index}`);
+        const value = decodeUtf8(bytes, cursor.offset, next, `${label} ${index}`);
+        cursor.offset = next;
+        output.push(value);
+    }
+    return output;
+};
+const parseClasses = (bytes, start, end, count) => {
+    const cursor = { offset: start };
+    const output = [];
+    for (let index = 0; index < count; index += 1) {
+        const length = readVarint(bytes, cursor, end);
+        const extraCount = readVarint(bytes, cursor, end);
+        if (extraCount > 16)
+            throw new TypeError(`NIBArchive class ${index} has too many extension values`);
+        ensureRange(cursor.offset, extraCount * 4, end, `class ${index} extensions`);
+        cursor.offset += extraCount * 4;
+        const next = checkedEnd(cursor.offset, length, end, `class ${index}`);
+        const name = decodeUtf8(bytes, cursor.offset, next, `class ${index}`).replace(/\0+$/u, "");
+        cursor.offset = next;
+        output.push(name);
+    }
+    return output;
+};
+const parseValues = (bytes, start, end, count, keyCount, needed) => {
+    const cursor = { offset: start };
+    const output = new Map();
+    for (let index = 0; index < count; index += 1) {
+        const keyIndex = readVarint(bytes, cursor, end);
+        if (keyIndex >= keyCount)
+            throw new TypeError(`NIBArchive value ${index} references an invalid key`);
+        ensureRange(cursor.offset, 1, end, `value ${index} type`);
+        const type = bytes[cursor.offset++] ?? -1;
+        const value = readValue(bytes, cursor, end, type, index);
+        if (needed.has(index))
+            output.set(index, { key_index: keyIndex, value });
+    }
+    if (cursor.offset > end)
+        throw new TypeError("NIBArchive value table overlaps the next table");
+    return output;
+};
+const readValue = (bytes, cursor, end, type, index) => {
+    switch (type) {
+        case 0:
+            ensureRange(cursor.offset, 1, end, `value ${index}`);
+            return bytes.readInt8(cursor.offset++);
+        case 1:
+            ensureRange(cursor.offset, 2, end, `value ${index}`);
+            {
+                const value = bytes.readInt16LE(cursor.offset);
+                cursor.offset += 2;
+                return value;
+            }
+        case 2:
+            ensureRange(cursor.offset, 4, end, `value ${index}`);
+            {
+                const value = bytes.readInt32LE(cursor.offset);
+                cursor.offset += 4;
+                return value;
+            }
+        case 3:
+            ensureRange(cursor.offset, 8, end, `value ${index}`);
+            {
+                const value = bytes.readBigInt64LE(cursor.offset);
+                cursor.offset += 8;
+                return value <= BigInt(Number.MAX_SAFE_INTEGER) &&
+                    value >= BigInt(Number.MIN_SAFE_INTEGER)
+                    ? Number(value)
+                    : value.toString();
+            }
+        case 4:
+            return true;
+        case 5:
+            return false;
+        case 6:
+            ensureRange(cursor.offset, 4, end, `value ${index}`);
+            {
+                const value = bytes.readFloatLE(cursor.offset);
+                cursor.offset += 4;
+                return Number.isFinite(value) ? value : null;
+            }
+        case 7:
+            ensureRange(cursor.offset, 8, end, `value ${index}`);
+            {
+                const value = bytes.readDoubleLE(cursor.offset);
+                cursor.offset += 8;
+                return Number.isFinite(value) ? value : null;
+            }
+        case 8: {
+            const length = readVarint(bytes, cursor, end);
+            const next = checkedEnd(cursor.offset, length, end, `value ${index} data`);
+            const encoded = bytes.subarray(cursor.offset, next).toString("base64");
+            cursor.offset = next;
+            return { $nib_data_base64: encoded };
+        }
+        case 9:
+            return null;
+        case 10:
+            ensureRange(cursor.offset, 4, end, `value ${index} reference`);
+            {
+                const objectIndex = bytes.readUInt32LE(cursor.offset);
+                cursor.offset += 4;
+                return { $nib_object_ref: objectIndex };
+            }
+        default:
+            throw new TypeError(`NIBArchive value ${index} has unsupported type ${type}`);
+    }
+};
+const valueIndexes = (objects, total) => {
+    const indexes = new Set();
+    for (const object of objects)
+        for (let index = object.value_start; index < object.value_start + object.value_count; index += 1)
+            indexes.add(index);
+    if (indexes.size > total)
+        throw new TypeError("NIBArchive object value ranges exceed the value table");
+    return indexes;
+};
+const readCount = (bytes, offset, label) => {
+    const count = readU32(bytes, offset);
+    if (count > MAX_RECORDS)
+        throw new TypeError(`NIBArchive ${label} count exceeds the decoder bound`);
+    return count;
+};
+const readOffset = (bytes, offset, fileLength, label) => {
+    const value = readU32(bytes, offset);
+    if (value < 50 || value > fileLength)
+        throw new TypeError(`NIBArchive ${label} table offset is invalid`);
+    return value;
+};
+const readU32 = (bytes, offset) => {
+    ensureRange(offset, 4, bytes.length, "header");
+    return bytes.readUInt32LE(offset);
+};
+const decodeUtf8 = (bytes, start, end, label) => {
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(start, end));
+    }
+    catch {
+        throw new TypeError(`NIBArchive ${label} is not valid UTF-8`);
+    }
+};
+const readVarint = (bytes, cursor, end) => {
+    let value = 0;
+    let shift = 0;
+    for (let index = 0; index < 5; index += 1) {
+        ensureRange(cursor.offset, 1, end, "variable integer");
+        const byte = bytes[cursor.offset++] ?? 0;
+        value += (byte & 0x7f) * 2 ** shift;
+        if ((byte & 0x80) !== 0) {
+            if (value > 0x7fff_ffff)
+                throw new TypeError("NIBArchive variable integer is out of range");
+            return value;
+        }
+        shift += 7;
+    }
+    throw new TypeError("NIBArchive variable integer is too long");
+};
+const checkedEnd = (start, length, limit, label) => {
+    if (!Number.isSafeInteger(length) || length < 0 || start + length > limit)
+        throw new TypeError(`NIBArchive ${label} exceeds its table`);
+    return start + length;
+};
+const ensureRange = (start, length, limit, label) => {
+    checkedEnd(start, length, limit, label);
+};
+const assertOrderedOffsets = (length, offsets) => {
+    let previous = 50;
+    for (const offset of offsets) {
+        if (offset < previous || offset > length)
+            throw new TypeError("NIBArchive table offsets are out of order");
+        previous = offset;
+    }
+};