rea-agents 3.0.0 → 3.2.0

package/dist/domain/webCaptureDiff.js

@@ -1,64 +1,14 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
-import { z } from "zod";
-import { webPageInspectionSchema, } from "./browserObservation.js";
-import { webMcpDiscoverySchema, } from "./webMcpDiscovery.js";
-/** One normalized passive page snapshot accepted by capture comparison. */
-export const captureSnapshotSchema = z.object({
-    inspection: webPageInspectionSchema,
-    webmcp: webMcpDiscoverySchema.nullable().default(null),
-});
-/** Input for deterministic comparison of two normalized web captures. */
-export const compareWebCapturesInputSchema = z.object({
-    before: captureSnapshotSchema,
-    after: captureSnapshotSchema,
-    max_changes: z.number().int().min(1).max(20_000).default(2_000),
-});
-const changeSchema = z.object({
-    identity: z.string(),
-    change: z.enum(["added", "removed", "modified"]),
-});
-const dimensionSchema = z.object({
-    status: z.enum(["changed", "unchanged", "unknown"]),
-    total_changes: z.number().int().min(0),
-    changes: z.array(changeSchema),
-    omitted_changes: z.number().int().min(0),
-    reason: z.string().nullable(),
-});
-const legacyUnknownDimension = {
-    status: "unknown",
-    total_changes: 0,
-    changes: [],
-    omitted_changes: 0,
-    reason: "Dimension was not recorded by this version 1 capture diff.",
-};
-/** Completeness-aware changes across stable browser evidence dimensions. */
-export const webCaptureDiffSchema = z.object({
-    schema_version: z.literal(1),
-    overall_status: z.enum(["changed", "unchanged", "unknown"]),
-    before_target: z.object({ target_id: z.string(), url: z.string() }),
-    after_target: z.object({ target_id: z.string(), url: z.string() }),
-    dimensions: z.object({
-        dom_structure: dimensionSchema,
-        scripts: dimensionSchema,
-        resources: dimensionSchema,
-        network: dimensionSchema,
-        metadata: dimensionSchema,
-        webmcp: dimensionSchema,
-        accessibility: dimensionSchema.default(legacyUnknownDimension),
-        storage: dimensionSchema.default(legacyUnknownDimension),
-    }),
-    limitations: z.array(z.string()),
-});
+import { webCaptureDiffSchema, } from "./webCaptureDiffSchemas.js";
+export { captureSnapshotSchema, compareWebCapturesInputSchema, webCaptureDiffSchema, } from "./webCaptureDiffSchemas.js";
 /** Compare normalized observations without treating incomplete absence as proof. */
 export const compareWebCaptures = (input) => {
-    const remaining = { value: input.max_changes };
     const before = input.before.inspection;
     const after = input.after.inspection;
-    const dimensions = compareWebCaptureDimensions(input, remaining);
+    const dimensions = compareWebCaptureDimensions(input);
     const statuses = Object.values(dimensions).map(({ status }) => status);
     return webCaptureDiffSchema.parse({
-        schema_version: 1,
         overall_status: statuses.includes("changed")
             ? "changed"
             : statuses.includes("unknown")
@@ -96,38 +46,49 @@ const compareIdentities = (before, after) => {
     return changes.sort((left, right) => left.identity.localeCompare(right.identity) ||
         left.change.localeCompare(right.change));
 };
-const compareDimension = (remaining) => (before, after, complete, reason) => {
+const compareDimension = (before, after, complete, reason) => {
     const all = compareIdentities(before, after);
-    const retained = all.slice(0, remaining.value);
-    remaining.value -= retained.length;
-    return {
-        status: all.length > 0 ? "changed" : complete ? "unchanged" : "unknown",
-        total_changes: all.length,
-        changes: retained,
-        omitted_changes: all.length - retained.length,
-        reason: all.length === 0 && !complete ? reason : null,
-    };
+    if (all.length > 0)
+        return {
+            status: "changed",
+            total_changes: all.length,
+            changes: all,
+            reason: null,
+        };
+    return complete
+        ? {
+            status: "unchanged",
+            total_changes: 0,
+            changes: [],
+            reason: null,
+        }
+        : {
+            status: "unknown",
+            total_changes: 0,
+            changes: [],
+            reason,
+        };
 };
-const accessibilityDimension = (before, after, remaining) => {
+const accessibilityDimension = (before, after) => {
     const beforeAccess = accessibilityComparable(before);
     const afterAccess = accessibilityComparable(after);
     const textComparable = beforeAccess.text && afterAccess.text;
     const nodesComparable = beforeAccess.nodes && afterAccess.nodes;
-    return compareDimension(remaining)(singleton("accessibility_tree", digest(accessibilityProjection(before.accessibility, textComparable, nodesComparable))), singleton("accessibility_tree", digest(accessibilityProjection(after.accessibility, textComparable, nodesComparable))), beforeAccess.complete && afterAccess.complete, "Accessibility tree or text capture was incomplete in at least one observation.");
+    return compareDimension(singleton("accessibility_tree", digest(accessibilityProjection(before.accessibility, textComparable, nodesComparable))), singleton("accessibility_tree", digest(accessibilityProjection(after.accessibility, textComparable, nodesComparable))), beforeAccess.complete && afterAccess.complete, "Accessibility tree or text capture was incomplete in at least one observation.");
 };
-const storageDimension = (before, after, remaining) => {
+const storageDimension = (before, after) => {
     const keysComplete = storageKeysComparable(before) && storageKeysComparable(after);
     const usageComplete = before.storage.usage_bytes !== null &&
         after.storage.usage_bytes !== null &&
         before.storage.quota_bytes !== null &&
         after.storage.quota_bytes !== null;
     const comparableFingerprints = storageFingerprintIdentities(before.storage, after.storage);
-    return compareDimension(remaining)(storageMap(before.storage, keysComplete, usageComplete, comparableFingerprints), storageMap(after.storage, keysComplete, usageComplete, comparableFingerprints), storageComparable(before, after, keysComplete, usageComplete), "Storage fingerprints, inventories, usage, or quota were unavailable or truncated in at least one observation.");
+    return compareDimension(storageMap(before.storage, keysComplete, usageComplete, comparableFingerprints), storageMap(after.storage, keysComplete, usageComplete, comparableFingerprints), storageComparable(before, after, keysComplete, usageComplete), "Storage fingerprints, inventories, usage, or quota were unavailable or truncated in at least one observation.");
 };
-const compareWebCaptureDimensions = (input, remaining) => {
+const compareWebCaptureDimensions = (input) => {
     const before = input.before.inspection;
     const after = input.after.inspection;
-    const dimension = compareDimension(remaining);
+    const dimension = compareDimension;
     return {
         dom_structure: dimension(singleton("document", digest(domProjection(before))), singleton("document", digest(domProjection(after))), sectionsComplete(before, ["frames", "dom"]) &&
             sectionsComplete(after, ["frames", "dom"]), "DOM or frame capture was incomplete in at least one observation."),
@@ -140,8 +101,8 @@ const compareWebCaptureDimensions = (input, remaining) => {
         metadata: dimension(singleton("metadata", digest(metadataProjection(before))), singleton("metadata", digest(metadataProjection(after))), sectionsComplete(before, ["metadata"]) &&
             sectionsComplete(after, ["metadata"]), "Safe metadata capture was incomplete in at least one observation."),
         webmcp: dimension(webMcpMap(input.before.webmcp), webMcpMap(input.after.webmcp), webMcpComplete(input.before.webmcp) && webMcpComplete(input.after.webmcp), "WebMCP discovery was unavailable or incomplete in at least one capture."),
-        accessibility: accessibilityDimension(before, after, remaining),
-        storage: storageDimension(before, after, remaining),
+        accessibility: accessibilityDimension(before, after),
+        storage: storageDimension(before, after),
     };
 };
 const keyed = (values, identity) => new Map(values.map((value) => [identity(value), digest(value)]));
@@ -220,28 +181,30 @@ const digest = (value) => {
 };
 const accessibilityComparable = (inspection) => {
     const text = inspection.accessibility.text_capture.status === "included" &&
-        inspection.accessibility.text_capture.excluded_fields === 0 &&
-        inspection.accessibility.text_capture.truncated_fields === 0;
+        inspection.accessibility.text_capture.excluded_fields === 0;
     const nodes = inspection.accessibility.total_nodes ===
         inspection.accessibility.nodes.length;
     const complete = text && nodes && sectionsComplete(inspection, ["accessibility"]);
     return { text, nodes, complete };
 };
 const accessibilityProjection = (accessibility, includeText, includeNodes) => {
-    const result = {
-        total_nodes: accessibility.total_nodes,
-    };
     if (!includeNodes)
-        return result;
+        return { total_nodes: accessibility.total_nodes };
     const nodeIndexes = new Map(accessibility.nodes.map((node, index) => [node.node_id, index]));
-    result.nodes = accessibility.nodes.map((node) => ({
-        parent_index: node.parent_id === null ? null : (nodeIndexes.get(node.parent_id) ?? -1),
-        role: node.role,
-        ignored: node.ignored,
-        states: node.states,
-        ...(includeText ? { name: node.name, description: node.description } : {}),
-    }));
-    return result;
+    return {
+        total_nodes: accessibility.total_nodes,
+        nodes: accessibility.nodes.map((node) => ({
+            parent_index: node.parent_id === null
+                ? null
+                : (nodeIndexes.get(node.parent_id) ?? -1),
+            role: node.role,
+            ignored: node.ignored,
+            states: node.states,
+            ...(includeText
+                ? { name: node.name, description: node.description }
+                : {}),
+        })),
+    };
 };
 const storageKeysComparable = (inspection) => sectionsComplete(inspection, ["storage_keys"]);
 const storageComparable = (before, after, keysComplete, usageComplete) => keysComplete &&

package/dist/domain/webCaptureDiffSchemas.js

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import { webPageInspectionSchema } from "./browserObservation.js";
+import { webMcpDiscoverySchema } from "./webMcpDiscovery.js";
+/** One normalized passive page snapshot accepted by capture comparison. */
+export const captureSnapshotSchema = z.object({
+    inspection: webPageInspectionSchema,
+    webmcp: webMcpDiscoverySchema.nullable().default(null),
+});
+/** Input for deterministic comparison of two normalized web captures. */
+export const compareWebCapturesInputSchema = z.strictObject({
+    before: captureSnapshotSchema,
+    after: captureSnapshotSchema,
+});
+const changeSchema = z.object({
+    identity: z.string(),
+    change: z.enum(["added", "removed", "modified"]),
+});
+const emptyDimensionShape = {
+    total_changes: z.literal(0),
+    changes: z.tuple([]),
+};
+const dimensionSchema = z.union([
+    z
+        .object({
+        status: z.literal("changed"),
+        total_changes: z.number().int().min(1),
+        changes: z.array(changeSchema),
+        reason: z.null(),
+    })
+        .superRefine((dimension, context) => {
+        if (dimension.changes.length !== dimension.total_changes)
+            context.addIssue({
+                code: "custom",
+                message: "Inline changes must equal total changes",
+                path: ["total_changes"],
+            });
+    }),
+    z.object({
+        ...emptyDimensionShape,
+        status: z.literal("unchanged"),
+        reason: z.null(),
+    }),
+    z.object({
+        ...emptyDimensionShape,
+        status: z.literal("unknown"),
+        reason: z.string(),
+    }),
+]);
+const legacyUnknownDimension = {
+    status: "unknown",
+    total_changes: 0,
+    changes: [],
+    reason: "Dimension was not recorded by this version 1 capture diff.",
+};
+/** Completeness-aware changes across stable browser evidence dimensions. */
+export const webCaptureDiffSchema = z
+    .object({
+    overall_status: z.enum(["changed", "unchanged", "unknown"]),
+    before_target: z.object({ target_id: z.string(), url: z.string() }),
+    after_target: z.object({ target_id: z.string(), url: z.string() }),
+    dimensions: z.object({
+        dom_structure: dimensionSchema,
+        scripts: dimensionSchema,
+        resources: dimensionSchema,
+        network: dimensionSchema,
+        metadata: dimensionSchema,
+        webmcp: dimensionSchema,
+        accessibility: dimensionSchema.default(legacyUnknownDimension),
+        storage: dimensionSchema.default(legacyUnknownDimension),
+    }),
+    limitations: z.array(z.string()),
+})
+    .superRefine((comparison, context) => {
+    const statuses = Object.values(comparison.dimensions).map(({ status }) => status);
+    const expected = statuses.includes("changed")
+        ? "changed"
+        : statuses.includes("unknown")
+            ? "unknown"
+            : "unchanged";
+    if (comparison.overall_status !== expected)
+        context.addIssue({
+            code: "custom",
+            message: "Overall status must summarize dimension statuses",
+            path: ["overall_status"],
+        });
+});

package/dist/domain/webContentArtifact.js

@@ -3,10 +3,9 @@ import { z } from "zod";
 /** Self-verifying text artifact used by web-source analysis boundaries. */
 export const webTextArtifactSchema = z
     .object({
-    uri: z.string().regex(/^rea:\/\/web-content\/sha256\/[a-f0-9]{64}$/u),
     sha256: z.string().regex(/^[a-f0-9]{64}$/u),
     bytes: z.number().int().min(0),
-    media_type: z.string().min(1).max(256),
+    media_type: z.string().min(1),
     charset: z.literal("utf-8"),
     text: z.string(),
 })
@@ -25,18 +24,11 @@ export const webTextArtifactSchema = z
             path: ["sha256"],
             message: "Digest mismatch",
         });
-    if (artifact.uri !== webContentUri(digest))
-        context.addIssue({
-            code: "custom",
-            path: ["uri"],
-            message: "Content URI mismatch",
-        });
 });
 /** Build an immutable content-addressed UTF-8 text artifact. */
 export const createWebTextArtifact = (text, mediaType) => {
     const sha256 = createHash("sha256").update(text).digest("hex");
     return {
-        uri: webContentUri(sha256),
         sha256,
         bytes: Buffer.byteLength(text),
         media_type: mediaType,
@@ -44,4 +36,3 @@ export const createWebTextArtifact = (text, mediaType) => {
         text,
     };
 };
-const webContentUri = (sha256) => `rea://web-content/sha256/${sha256}`;

package/dist/domain/webMcpDiscovery.js

@@ -3,21 +3,11 @@ import { browserCompletenessSchema } from "./browserCompleteness.js";
 import { browserAllowedOriginsSchema, browserEndpointSchema, } from "./browserObservation.js";
 import { jsonShapeSchema } from "./jsonShape.js";
 /** Input for passive discovery of page-registered WebMCP tools. */
-export const discoverWebMcpToolsInputSchema = z.object({
+export const discoverWebMcpToolsInputSchema = z.strictObject({
     cdp_endpoint: browserEndpointSchema,
     allowed_origins: browserAllowedOriginsSchema,
-    target_id: z.string().trim().min(1).max(256),
-    approved: z.literal(true),
-    observation_ms: z.number().int().min(0).max(10_000).default(100),
-    max_tools: z.number().int().min(1).max(5_000).default(500),
-    max_schema_bytes: z
-        .number()
-        .int()
-        .min(1)
-        .max(1_024 * 1_024)
-        .default(256 * 1_024),
-    max_schema_nodes: z.number().int().min(1).max(100_000).default(5_000),
-    max_schema_depth: z.number().int().min(1).max(100).default(20),
+    target_id: z.string().trim().min(1),
+    observation_ms: z.number().int().min(0).default(100),
 });
 const browserVersionSchema = z.object({
     product: z.string(),
@@ -51,7 +41,6 @@ const webMcpToolSchema = z.object({
 });
 /** Passive WebMCP inventory; it intentionally has no invocation surface. */
 export const webMcpDiscoverySchema = z.object({
-    schema_version: z.literal(1),
     browser: browserVersionSchema,
     target: z.object({
         target_id: z.string(),

package/dist/domain/webScreenshot.js

@@ -2,15 +2,13 @@ import { createHash } from "node:crypto";
 import { z } from "zod";
 import { browserCompletenessSchema } from "./browserCompleteness.js";
 import { browserAllowedOriginsSchema, browserEndpointSchema, } from "./browserObservation.js";
-const MAX_SCREENSHOT_BYTES = 8 * 1_024 * 1_024;
 /** Self-verifying inline PNG artifact for CLI/MCP parity. */
 export const webScreenshotArtifactSchema = z
     .object({
-    uri: z.string().regex(/^rea:\/\/web-screenshot\/sha256\/[a-f0-9]{64}$/u),
     sha256: z.string().regex(/^[a-f0-9]{64}$/u),
-    bytes: z.number().int().min(1).max(MAX_SCREENSHOT_BYTES),
+    bytes: z.number().int().min(1),
     media_type: z.literal("image/png"),
-    data_base64: z.string().max(Math.ceil((MAX_SCREENSHOT_BYTES * 4) / 3) + 4),
+    data_base64: z.string(),
 })
     .superRefine((artifact, context) => {
     const bytes = decodeCanonicalBase64(artifact.data_base64);
@@ -19,27 +17,17 @@ export const webScreenshotArtifactSchema = z
         return;
     }
     const sha256 = createHash("sha256").update(bytes).digest("hex");
-    if (bytes.byteLength !== artifact.bytes ||
-        sha256 !== artifact.sha256 ||
-        artifact.uri !== `rea://web-screenshot/sha256/${sha256}`)
+    if (bytes.byteLength !== artifact.bytes || sha256 !== artifact.sha256)
         context.addIssue({
             code: "custom",
             message: "Screenshot artifact digest or size mismatch",
         });
 });
 /** Input for one read-only visible-viewport screenshot. */
-export const captureWebScreenshotInputSchema = z.object({
+export const captureWebScreenshotInputSchema = z.strictObject({
     cdp_endpoint: browserEndpointSchema,
     allowed_origins: browserAllowedOriginsSchema,
-    target_id: z.string().trim().min(1).max(256),
-    approved: z.literal(true),
-    screenshot_approved: z.literal(true),
-    maximum_image_bytes: z
-        .number()
-        .int()
-        .min(1)
-        .max(MAX_SCREENSHOT_BYTES)
-        .default(4 * 1_024 * 1_024),
+    target_id: z.string().trim().min(1),
 });
 const browserVersionSchema = z.object({
     product: z.string(),
@@ -48,9 +36,8 @@ const browserVersionSchema = z.object({
     user_agent: z.string(),
     js_version: z.string(),
 });
-/** Bounded screenshot observation with embedded immutable artifact bytes. */
+/** Screenshot observation with embedded immutable artifact bytes. */
 export const webScreenshotSchema = z.object({
-    schema_version: z.literal(1),
     browser: browserVersionSchema,
     target: z.object({
         target_id: z.string(),
@@ -66,17 +53,14 @@ export const webScreenshotSchema = z.object({
     completeness: browserCompletenessSchema,
     limitations: z.array(z.string()),
 });
-/** Input for bounded local pixel comparison of two screenshot artifacts. */
-export const compareWebScreenshotsInputSchema = z.object({
+/** Input for local pixel comparison of two screenshot artifacts. */
+export const compareWebScreenshotsInputSchema = z.strictObject({
     before: webScreenshotArtifactSchema,
     after: webScreenshotArtifactSchema,
     channel_threshold: z.number().int().min(0).max(255).default(0),
-    maximum_pixels: z.number().int().min(1).max(32_000_000).default(16_000_000),
 });
 /** Value-only visual difference metrics; no OCR or image mutation. */
-export const webScreenshotDiffSchema = z.object({
-    schema_version: z.literal(1),
-    status: z.enum(["identical", "different", "dimension_mismatch"]),
+const webScreenshotDiffContextShape = {
     before: z.object({
         width: z.number().int().min(1),
         height: z.number().int().min(1),
@@ -86,18 +70,59 @@ export const webScreenshotDiffSchema = z.object({
         height: z.number().int().min(1),
     }),
     channel_threshold: z.number().int().min(0).max(255),
-    compared_pixels: z.number().int().min(0),
-    changed_pixels: z.number().int().min(0).nullable(),
-    changed_ratio: z.number().min(0).max(1).nullable(),
-    maximum_channel_delta: z.number().int().min(0).max(255).nullable(),
-    mean_absolute_channel_delta: z.number().min(0).max(255).nullable(),
     limitations: z.array(z.string()),
+};
+export const webScreenshotDiffSchema = z
+    .discriminatedUnion("status", [
+    z.object({
+        ...webScreenshotDiffContextShape,
+        status: z.literal("identical"),
+        compared_pixels: z.number().int().positive(),
+        changed_pixels: z.literal(0),
+        changed_ratio: z.literal(0),
+        maximum_channel_delta: z.number().int().min(0).max(255),
+        mean_absolute_channel_delta: z.number().min(0).max(255),
+    }),
+    z.object({
+        ...webScreenshotDiffContextShape,
+        status: z.literal("different"),
+        compared_pixels: z.number().int().positive(),
+        changed_pixels: z.number().int().positive(),
+        changed_ratio: z.number().positive().max(1),
+        maximum_channel_delta: z.number().int().positive().max(255),
+        mean_absolute_channel_delta: z.number().positive().max(255),
+    }),
+    z.object({
+        ...webScreenshotDiffContextShape,
+        status: z.literal("dimension_mismatch"),
+        compared_pixels: z.literal(0),
+        changed_pixels: z.null(),
+        changed_ratio: z.null(),
+        maximum_channel_delta: z.null(),
+        mean_absolute_channel_delta: z.null(),
+    }),
+])
+    .superRefine((diff, context) => {
+    const sameDimensions = diff.before.width === diff.after.width &&
+        diff.before.height === diff.after.height;
+    if (sameDimensions !== (diff.status !== "dimension_mismatch"))
+        context.addIssue({
+            code: "custom",
+            path: ["status"],
+            message: "Screenshot comparison status must match viewport dimensions",
+        });
+    if (diff.status !== "dimension_mismatch" &&
+        diff.compared_pixels !== diff.before.width * diff.before.height)
+        context.addIssue({
+            code: "custom",
+            path: ["compared_pixels"],
+            message: "Compared pixel count must match the shared dimensions",
+        });
 });
-/** Create a content-addressed PNG artifact from already bounded bytes. */
+/** Create a content-addressed PNG artifact from captured bytes. */
 export const createWebScreenshotArtifact = (bytes) => {
     const sha256 = createHash("sha256").update(bytes).digest("hex");
     return webScreenshotArtifactSchema.parse({
-        uri: `rea://web-screenshot/sha256/${sha256}`,
         sha256,
         bytes: bytes.byteLength,
         media_type: "image/png",
@@ -106,9 +131,8 @@ export const createWebScreenshotArtifact = (bytes) => {
 };
 /** Strict canonical base64 decoder used before digest validation. */
 export const decodeCanonicalBase64 = (value) => {
-    if (value.length === 0 || value.length % 4 !== 0 || !BASE64.test(value))
+    if (value.length === 0 || value.length % 4 !== 0)
         return undefined;
     const decoded = Buffer.from(value, "base64");
     return decoded.toString("base64") === value ? decoded : undefined;
 };
-const BASE64 = /^(?:[A-Za-z\d+/]{4})*(?:[A-Za-z\d+/]{2}==|[A-Za-z\d+/]{3}=)?$/u;

package/dist/domain/zipPackageFormat.js

@@ -1,3 +1,10 @@
+/** Recognize local-header, empty-archive, or split-archive ZIP signatures, not archive validity. */
+export const hasZipSignature = (bytes) => bytes.length >= 4 &&
+    bytes[0] === 0x50 &&
+    bytes[1] === 0x4b &&
+    ((bytes[2] === 0x03 && bytes[3] === 0x04) ||
+        (bytes[2] === 0x05 && bytes[3] === 0x06) ||
+        (bytes[2] === 0x07 && bytes[3] === 0x08));
 /**
  * Classify a ZIP-backed package by its complete lower-cased path suffix.
  *

package/dist/dotnet/ManagedArtifactInspector.js

@@ -3,15 +3,6 @@ import { readManagedPeLayout, } from "./ManagedPeReader.js";
 import { managedTableRowCounts, readManagedMetadataInventory, } from "./ManagedMetadataInventory.js";
 import { readManagedMetadataLayout, } from "./ManagedMetadataLayout.js";
 import { ManagedReaderFailure } from "./ManagedReaderFailure.js";
-const emptyPage = (offset, limit) => ({
-    items: [],
-    offset,
-    limit,
-    total: 0,
-    returned: 0,
-    dropped: 0,
-    complete: offset === 0,
-});
 const flagNames = (flags) => {
     const names = [];
     for (const [mask, name] of [
@@ -64,7 +55,6 @@ const peProjection = (layout) => ({
     cli: layout.cli === null ? null : cliProjection(layout.cli),
 });
 const base = (target, bytes, layout) => ({
-    schema_version: 1,
     artifact: {
         path: target.path,
         sha256: target.sha256,
@@ -73,7 +63,7 @@ const base = (target, bytes, layout) => ({
     },
     pe: peProjection(layout),
 });
-const unavailableResult = (target, bytes, layout, limits) => {
+const unavailableResult = (target, bytes, layout) => {
     const malformed = layout.cliDirectoryPresent;
     const issues = layout.cliIssue === null ? [] : [layout.cliIssue];
     const limitations = malformed
@@ -108,9 +98,9 @@ const unavailableResult = (target, bytes, layout, limits) => {
         module: null,
         assembly: null,
         target_frameworks: [],
-        references: emptyPage(limits.referenceOffset, limits.referenceLimit),
-        resources: emptyPage(limits.resourceOffset, limits.resourceLimit),
-        attributes: emptyPage(limits.attributeOffset, limits.attributeLimit),
+        references: [],
+        resources: [],
+        attributes: [],
         coverage: {
             state: malformed ? "partial" : "unavailable",
             issues,
@@ -205,7 +195,7 @@ const runtimeClassification = ({ layout, metadata, inventory, }) => {
         evidence,
     };
 };
-const partialMetadataResult = ({ target, bytes, layout, limits, issue, }) => ({
+const partialMetadataResult = ({ target, bytes, layout, issue, }) => ({
     ...base(target, bytes, layout),
     classification: {
         status: "malformed",
@@ -222,7 +212,7 @@ const partialMetadataResult = ({ target, bytes, layout, limits, issue, }) => ({
         ],
     },
     metadata: {
-        status: issue.code === "limit-exceeded" ? "partial" : "malformed",
+        status: "malformed",
         version: null,
         stream_names: [],
         table_row_counts: {},
@@ -230,12 +220,12 @@ const partialMetadataResult = ({ target, bytes, layout, limits, issue, }) => ({
     module: null,
     assembly: null,
     target_frameworks: [],
-    references: emptyPage(limits.referenceOffset, limits.referenceLimit),
-    resources: emptyPage(limits.resourceOffset, limits.resourceLimit),
-    attributes: emptyPage(limits.attributeOffset, limits.attributeLimit),
+    references: [],
+    resources: [],
+    attributes: [],
     coverage: { state: "partial", issues: [issue] },
     limitations: [
-        "CLI metadata triage stopped at the reported bounded format or resource limit.",
+        "CLI metadata could not be read because the PE/CLI structure is malformed or unsupported.",
     ],
 });
 const mapResources = (bytes, layout, issues) => {
@@ -255,32 +245,16 @@ const mapResources = (bytes, layout, issues) => {
         return null;
     }
 };
-const inventoryPagesComplete = (inventory) => inventory.references.complete &&
-    inventory.resources.complete &&
-    inventory.attributes.complete;
-/** Inspect PE/CLI identity directly from bounded bytes without CLR loading. */
-export const inspectManagedArtifactBytes = (bytes, target, limits) => {
+/** Inspect PE/CLI identity directly from local bytes without CLR loading. */
+export const inspectManagedArtifactBytes = (bytes, target) => {
     const layout = readManagedPeLayout(bytes);
     if (layout.cli === null)
-        return unavailableResult(target, bytes, layout, limits);
+        return unavailableResult(target, bytes, layout);
     const cli = layout.cli;
-    if (cli.metadata.size > limits.maxMetadataBytes)
-        return managedArtifactInspectionSchema.parse(partialMetadataResult({
-            target,
-            bytes,
-            layout,
-            limits,
-            issue: {
-                code: "limit-exceeded",
-                scope: "cli.metadata",
-                offset: cli.headerOffset + 8,
-                detail: `CLI metadata size exceeds max_metadata_bytes ${String(limits.maxMetadataBytes)}`,
-            },
-        }));
     let metadata;
     try {
         const metadataOffset = layout.rvaToOffset(cli.metadata.rva, cli.metadata.size, "cli.metadata");
-        metadata = readManagedMetadataLayout(bytes, metadataOffset, cli.metadata.size, limits.maxTableRows);
+        metadata = readManagedMetadataLayout(bytes, metadataOffset, cli.metadata.size);
     }
     catch (cause) {
         if (!(cause instanceof ManagedReaderFailure))
@@ -289,25 +263,18 @@ export const inspectManagedArtifactBytes = (bytes, target, limits) => {
             target,
             bytes,
             layout,
-            limits,
             issue: cause.issue,
         }));
     }
     const resourceIssues = [];
     const resourceDirectory = mapResources(bytes, layout, resourceIssues);
-    const inventory = readManagedMetadataInventory(bytes, metadata, limits, resourceDirectory);
+    const inventory = readManagedMetadataInventory(bytes, metadata, resourceDirectory);
     const issues = [...resourceIssues, ...inventory.issues];
-    const pagesComplete = inventoryPagesComplete(inventory);
     const limitations = [
-        ...(pagesComplete
-            ? []
-            : [
-                "At least one caller-selected metadata page omits rows; use its offset and total to continue.",
-            ]),
         ...(issues.length === 0
             ? []
             : [
-                "At least one bounded metadata or resource item was unavailable; coverage is partial.",
+                "At least one metadata or resource item could not be read; coverage is partial.",
             ]),
         "Static inspection did not load the assembly, resolve dependencies through a CLR, decompile C#, or execute target code.",
     ];
@@ -331,7 +298,7 @@ export const inspectManagedArtifactBytes = (bytes, target, limits) => {
         resources: inventory.resources,
         attributes: inventory.attributes,
         coverage: {
-            state: pagesComplete && issues.length === 0 ? "complete" : "partial",
+            state: issues.length === 0 ? "complete" : "partial",
             issues,
         },
         limitations,