rea-agents 3.0.0 → 3.2.0

package/dist/application/InterfaceBuilderAnalysis.js

@@ -0,0 +1,266 @@
+import { createHash } from "node:crypto";
+import { parse, parseBinary } from "plist";
+import { DirectoryArtifactReader } from "../artifacts/DirectoryArtifactReader.js";
+import { decodeNibArchive, } from "../artifacts/NibArchive.js";
+import { buildInterfaceBuilderAnalysis, interfaceBuilderLimitsSchema, } from "../domain/interfaceBuilderGraph.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+const MAX_DOCUMENT_BYTES = 64 * 1024 * 1024;
+/** Decode compiled Interface Builder archives from a local app bundle. */
+export const analyzeInterfaceBuilderBundle = async (input) => {
+    const limits = interfaceBuilderLimitsSchema.parse(input.limits ?? {});
+    const reader = new DirectoryArtifactReader(input.bundlePath);
+    const documents = [];
+    const invalid = [];
+    let omitted = 0;
+    let attempted = 0;
+    try {
+        for await (const entry of reader.entries(input.signal)) {
+            if (entry.kind !== "file" || !isInterfaceBuilderArchive(entry.path))
+                continue;
+            if (attempted >= limits.max_documents) {
+                omitted += 1;
+                continue;
+            }
+            attempted += 1;
+            try {
+                const bytes = await readEntry(reader, entry, input.signal);
+                const raw = bytes.subarray(0, 10).toString("ascii") === "NIBArchive"
+                    ? projectNibArchive(decodeNibArchive(bytes))
+                    : decodePlist(bytes);
+                const documentHash = createHash("sha256").update(bytes).digest("hex");
+                documents.push({
+                    relativePath: entry.path,
+                    archiveSha256: documentHash,
+                    documentKind: entry.path.includes(".storyboardc/")
+                        ? "storyboard_scene"
+                        : "nib",
+                    raw,
+                });
+            }
+            catch (cause) {
+                if (input.signal?.aborted === true)
+                    throw cause;
+                invalid.push(`${entry.path}: ${cause instanceof Error ? cause.message : "archive decode failed"}`);
+            }
+        }
+    }
+    finally {
+        await reader.close();
+    }
+    const result = buildInterfaceBuilderAnalysis({
+        targetSha256: input.targetSha256,
+        toolVersion: "rea-interface-builder/1",
+        documents,
+        limits,
+    });
+    return {
+        ...result,
+        graph: {
+            ...result.graph,
+            coverage: [
+                ...result.graph.coverage,
+                {
+                    facet: "archive_decode",
+                    status: invalid.length > 0 ? "partial" : "complete",
+                    reason: invalid.length > 0 ? "one_or_more_archives_invalid" : null,
+                    examined: attempted,
+                    omitted,
+                },
+            ],
+            truncated: result.graph.truncated || omitted > 0 || invalid.length > 0,
+        },
+        limitations: [
+            ...result.limitations,
+            "Compiled Interface Builder archives are private serialized object graphs. The decoder reports only recognized keyed-archive objects and connections; unrecognized object classes and fields remain unknown.",
+            ...(invalid.length === 0
+                ? []
+                : [
+                    `Some Interface Builder archives could not be decoded: ${invalid.slice(0, 16).join("; ")}`,
+                ]),
+        ],
+    };
+};
+/** Project decoded NIB records into the same bounded graph input as ibtool. */
+const projectNibArchive = (archive) => {
+    const byId = new Map(archive.objects.map((object) => [object.id, object]));
+    const dereference = (value) => {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            return value;
+        const ref = value.$nib_object_ref;
+        if (typeof ref !== "number")
+            return value;
+        const target = byId.get(ref);
+        if (target === undefined)
+            return undefined;
+        if (target.class_name.replace(/\0+$/u, "") === "NSString") {
+            const data = target.values["NS.bytes"];
+            if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+                const encoded = data.$nib_data_base64;
+                if (typeof encoded === "string")
+                    return Buffer.from(encoded, "base64").toString("utf8");
+            }
+        }
+        return { objectID: String(ref) };
+    };
+    const referencedString = (value) => {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            return null;
+        const ref = value.$nib_object_ref;
+        if (typeof ref !== "number")
+            return null;
+        const target = byId.get(ref);
+        const data = target?.values["NS.bytes"];
+        if (target?.class_name.replace(/\0+$/u, "") !== "NSString")
+            return null;
+        if (typeof data !== "object" || data === null || Array.isArray(data))
+            return null;
+        const encoded = data.$nib_data_base64;
+        return typeof encoded === "string"
+            ? Buffer.from(encoded, "base64").toString("utf8")
+            : null;
+    };
+    const runtimeClass = (objectId) => {
+        const object = byId.get(objectId);
+        if (object === undefined)
+            return null;
+        const storedClass = object.class_name.replace(/\0+$/u, "");
+        return storedClass === "NSClassSwapper"
+            ? (referencedString(object.values.NSClassName) ?? storedClass)
+            : storedClass;
+    };
+    const objects = Object.fromEntries(archive.objects
+        .filter((object) => {
+        const name = runtimeClass(object.id) ?? "";
+        return !/^(?:NSObject|NSIBObjectData|NSString|NSMutableString|NSNumber|NSArray|NSMutableArray|NSSet|NSMutableSet|NSDictionary|NSMutableDictionary|NSApplication|NSNib.*Connector)$/u.test(name);
+    })
+        .map((object) => {
+        const className = runtimeClass(object.id) ?? object.class_name.replace(/\0+$/u, "");
+        const strings = Object.entries(object.values).flatMap(([key, value]) => {
+            const resolved = dereference(value);
+            return typeof resolved === "string" ? [[key, resolved]] : [];
+        });
+        const name = strings.find(([key]) => /(?:title|label|identifier|accessibility|name|contents)/iu.test(key ?? ""))?.[1] ?? className;
+        return [
+            String(object.id),
+            {
+                customClass: className,
+                label: name,
+                objectID: String(object.id),
+                nibValues: Object.fromEntries(Object.entries(object.values).map(([key, value]) => [
+                    key,
+                    dereference(value) ?? null,
+                ])),
+            },
+        ];
+    }));
+    const connections = {};
+    const hierarchy = [];
+    const reference = (value) => {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            return null;
+        return typeof value.$nib_object_ref === "number"
+            ? value.$nib_object_ref
+            : null;
+    };
+    for (const object of archive.objects) {
+        const className = object.class_name.replace(/\0+$/u, "");
+        const source = reference(object.values.NSSource);
+        const destination = reference(object.values.NSDestination);
+        if (className.includes("Connector") && source !== null) {
+            const label = referencedString(object.values.NSLabel);
+            const type = className.includes("Outlet")
+                ? "outlet"
+                : className.includes("Control")
+                    ? "action"
+                    : className;
+            const controlAction = className.includes("Control");
+            const connectionSource = controlAction ? destination : source;
+            const connectionDestination = controlAction ? source : destination;
+            if (connectionSource === null)
+                continue;
+            (connections[String(connectionSource)] ??= []).push({
+                type,
+                "destination-id": connectionDestination === null ? null : String(connectionDestination),
+                label,
+                source_id: String(connectionSource),
+                archive_object_id: String(object.id),
+            });
+        }
+    }
+    const hierarchyFor = (objectId, seen, depth) => {
+        if (depth > 32 || seen.has(objectId))
+            return null;
+        const object = byId.get(objectId);
+        if (object === undefined)
+            return null;
+        const nextSeen = new Set(seen).add(objectId);
+        const children = [];
+        for (const [key, value] of Object.entries(object.values)) {
+            if (!/(?:subviews|contentview|childviewcontrollers|view)$/iu.test(key))
+                continue;
+            const direct = reference(value);
+            if (direct === null)
+                continue;
+            const target = byId.get(direct);
+            if (target === undefined)
+                continue;
+            if (/array|set/iu.test(target.class_name)) {
+                for (const candidate of Object.values(target.values)) {
+                    const child = reference(candidate);
+                    const nested = child === null ? null : hierarchyFor(child, nextSeen, depth + 1);
+                    if (nested !== null)
+                        children.push(nested);
+                }
+            }
+            else {
+                const nested = hierarchyFor(direct, nextSeen, depth + 1);
+                if (nested !== null)
+                    children.push(nested);
+            }
+        }
+        return { objectID: String(objectId), children };
+    };
+    const ibData = archive.objects.find(({ class_name }) => class_name.replace(/\0+$/u, "") === "NSIBObjectData");
+    const rootId = reference(ibData?.values.NSRoot);
+    const hierarchyRoots = rootId === null ? [] : [rootId];
+    for (const hierarchyRoot of hierarchyRoots) {
+        const root = hierarchyFor(hierarchyRoot, new Set(), 0);
+        if (root !== null)
+            hierarchy.push(root);
+    }
+    return jsonValueSchema.parse({
+        "com.apple.ibtool.document.objects": objects,
+        "com.apple.ibtool.document.connections": connections,
+        "com.apple.ibtool.document.hierarchy": hierarchy,
+        "com.apple.ibtool.document.classes": Object.fromEntries(archive.classes.map((name) => [name.replace(/\0+$/u, ""), {}])),
+    });
+};
+const isInterfaceBuilderArchive = (path) => {
+    const lower = path.toLowerCase();
+    return lower.endsWith(".nib") || lower.endsWith("/objects.nib");
+};
+const readEntry = async (reader, entry, signal) => {
+    if (entry.declaredSize !== null && entry.declaredSize > MAX_DOCUMENT_BYTES)
+        throw new RangeError("archive exceeds the 64 MiB per-document decode limit");
+    const stream = await reader.open(entry, signal);
+    const chunks = [];
+    let length = 0;
+    for await (const chunk of stream) {
+        const bytes = Buffer.isBuffer(chunk)
+            ? chunk
+            : Buffer.from(chunk);
+        length += bytes.length;
+        if (length > MAX_DOCUMENT_BYTES) {
+            stream.destroy();
+            throw new RangeError("archive exceeded the 64 MiB per-document decode limit");
+        }
+        chunks.push(bytes);
+    }
+    return Buffer.concat(chunks, length);
+};
+const decodePlist = (bytes) => {
+    const parsed = bytes.subarray(0, 8).toString("ascii") === "bplist00"
+        ? parseBinary(bytes)
+        : parse(bytes.toString("utf8"));
+    return jsonValueSchema.parse(parsed);
+};

package/dist/application/InventoryProjectionEvidence.js

@@ -3,7 +3,7 @@ import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js"
 import { createEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
-/** Parse one inventory projection and wrap its deterministic result in Evidence v2. */
+/** Parse one inventory projection and wrap its deterministic result in Evidence. */
 export const projectInventoryEvidence = (options) => {
     const parsed = options.schema.safeParse(options.rawInput);
     if (!parsed.success)
@@ -22,7 +22,9 @@ export const projectInventoryEvidence = (options) => {
             operation: options.operation,
             parameters: {
                 inventory_evidence_ids: [...result.source_evidence_ids],
-                limits: jsonValueSchema.parse(parsed.data.limits),
+                ...("limits" in parsed.data && parsed.data.limits !== undefined
+                    ? { limits: jsonValueSchema.parse(parsed.data.limits) }
+                    : {}),
             },
             result: jsonValueSchema.parse(result),
             rawResult: null,

package/dist/application/InvestigationProviders.js

@@ -6,7 +6,7 @@ export const REA_WORKFLOW_PROVIDER = {
     version: "1",
 };
 /** Commit a workflow result to the exact upstream deep-analysis profile. */
-export const workflowAnalysisProfile = (upstream) => createAnalysisProfile(REA_WORKFLOW_PROVIDER, 1, {
+export const workflowAnalysisProfile = (upstream) => createAnalysisProfile(REA_WORKFLOW_PROVIDER, {
     upstream_analysis_profile: upstream,
 });
 /** Provider identity for deterministic artifact inventories. */

package/dist/application/JavaScriptApplicationEvidence.js

@@ -1,13 +1,13 @@
 import { createEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { JAVASCRIPT_APPLICATION_PROVIDER } from "./InvestigationProviders.js";
-/** Create Evidence v2 for one deterministic local JavaScript application graph. */
+/** Create Evidence for one deterministic local JavaScript application graph. */
 export const createJavaScriptApplicationEvidence = (input, result) => createEvidence({
     path: result.input_path,
     sha256: result.root_artifact_sha256,
     format: result.format,
 }, JAVASCRIPT_APPLICATION_PROVIDER, {
-    predicateType: `rea.javascript-application-analysis/v${String(result.schema_version)}`,
+    predicateType: "rea.javascript-application-analysis",
     operation: "analyze_javascript_application",
     parameters: parameters(input),
     result: jsonValueSchema.parse(result),
@@ -20,7 +20,4 @@ export const createJavaScriptApplicationEvidence = (input, result) => createEvid
 });
 const parameters = (input) => ({
     format: input.format,
-    approved: input.approved,
-    source_map_read_approved: input.source_map_read_approved,
-    limits: input.limits,
 });

package/dist/application/JavaScriptApplicationEvidenceGraph.js

@@ -7,18 +7,15 @@ import { managedApplicationGraphResultSchema } from "../domain/managedApplicatio
 export const parseApplicationGraphEvidence = (input) => {
     const evidence = parseEvidence(input);
     if (evidence.operation === "analyze_javascript_application" &&
-        [
-            "rea.javascript-application-analysis/v1",
-            "rea.javascript-application-analysis/v2",
-        ].includes(evidence.predicate_type) &&
+        evidence.predicate_type === "rea.javascript-application-analysis" &&
         providerMatches(evidence, JAVASCRIPT_APPLICATION_PROVIDER))
         return staticApplicationSource(evidence);
     if (evidence.operation === "reconcile_javascript_runtime" &&
-        evidence.predicate_type === "rea.javascript-runtime-reconciliation/v1" &&
+        evidence.predicate_type === "rea.javascript-runtime-reconciliation" &&
         providerMatches(evidence, JAVASCRIPT_RUNTIME_RECONCILIATION_PROVIDER))
         return staticRuntimeSource(evidence);
     if (evidence.operation === "project_managed_application_graph" &&
-        evidence.predicate_type === "rea.managed-application-graph/v1" &&
+        evidence.predicate_type === "rea.managed-application-graph" &&
         providerMatches(evidence, MANAGED_WORKFLOW_PROVIDER))
         return managedApplicationSource(evidence);
     throw new TypeError("Application workflow requires authenticated analyze_javascript_application, reconcile_javascript_runtime, or project_managed_application_graph Evidence");
@@ -28,9 +25,8 @@ const staticApplicationSource = (evidence) => {
         evidence.confidence !== "derived")
         throw new TypeError("JavaScript application Evidence authority or confidence is invalid");
     const result = javascriptApplicationAnalysisResultSchema.parse(evidence.normalized_result);
-    if (evidence.predicate_type !==
-        `rea.javascript-application-analysis/v${String(result.schema_version)}`)
-        throw new TypeError("JavaScript application Evidence predicate does not match its result schema version");
+    if (evidence.predicate_type !== "rea.javascript-application-analysis")
+        throw new TypeError("JavaScript application Evidence predicate does not match its result shape");
     analyzeJavaScriptApplicationInputSchema.parse({
         input_path: result.input_path,
         ...evidence.parameters,
@@ -41,7 +37,7 @@ const staticApplicationSource = (evidence) => {
         graph: result.graph,
         kind: "static-application",
         rootArtifactSha256: result.root_artifact_sha256,
-        semanticGraph: result.schema_version === 2 ? result.semantic_graph : null,
+        semanticGraph: result.semantic_graph,
     };
 };
 const staticRuntimeSource = (evidence) => {

package/dist/application/JavaScriptApplicationService.js

@@ -1,57 +1,34 @@
 import { z } from "zod";
 import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
 import { analyzeJavaScriptApplicationInputSchema, javascriptApplicationAnalysisResultSchema, } from "../domain/javascriptApplicationAnalysis.js";
-import { AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisProtocolError, ArtifactOperationError, PermissionRequiredError, } from "../domain/errors.js";
+import { AnalysisInputError, AnalysisProtocolError, ArtifactOperationError, } from "../domain/errors.js";
 import { projectInputIssues } from "../domain/inputIssueProjection.js";
 import { err, ok } from "../domain/result.js";
 import { createJavaScriptApplicationEvidence } from "./JavaScriptApplicationEvidence.js";
 import { reconstructJavaScriptArtifact } from "./JavaScriptArtifactReconstruction.js";
 const OPERATION = "analyze_javascript_application";
-/** Authorize and statically analyze one local JavaScript/Electron application. */
-export const analyzeJavaScriptApplication = async (authority, rawInput, options = {}) => {
+/** Statically analyze one local JavaScript/Electron application. */
+export const analyzeJavaScriptApplication = async (rawInput, options = {}) => {
     const parsed = analyzeJavaScriptApplicationInputSchema.safeParse(rawInput);
     if (!parsed.success)
         return err(new AnalysisInputError(OPERATION, undefined, projectInputIssues(parsed.error.issues, rawInput)));
-    return analyzeJavaScriptApplicationValidated(authority, parsed.data, options);
+    return analyzeJavaScriptApplicationValidated(parsed.data, options);
 };
 /** Analyze input already parsed by a trusted adapter boundary. */
-export const analyzeJavaScriptApplicationValidated = async (authority, input, options = {}) => {
-    if (authority === undefined)
-        return err(new AnalysisCapabilityUnavailableError("rea-javascript-application", OPERATION, "JavaScript application permission policy is not configured"));
-    const authorized = await authority.authorize({
-        capability: "investigation_input",
-        roots: [input.input_path],
-        executables: [],
-        environment_names: [],
-        network: "none",
-        mount: false,
-        operation_identity: `${OPERATION}:${input.input_path}`,
-    }, "read");
-    if (!authorized.ok)
-        return err(authorized.error instanceof PermissionRequiredError
-            ? authorized.error
-            : new ArtifactOperationError(OPERATION, "path", {
-                logicalPath: input.input_path,
-                declaredSha256: null,
-                calculatedSha256: null,
-                unpacked: false,
-            }));
+export const analyzeJavaScriptApplicationValidated = async (input, options = {}) => {
     await options.progress?.report({
         phase: "analyze_javascript_application",
         completed: 0,
         total: 1,
-        message: "Inventorying and parsing approved application artifacts",
+        message: "Inventorying and parsing application artifacts",
     });
     try {
         const reconstructed = await reconstructJavaScriptArtifact({
             input_path: input.input_path,
             format: input.format,
-            source_map_read_approved: input.source_map_read_approved,
-            limits: input.limits,
         }, options.signal);
         const { electron_summary: summary, ...application } = reconstructed;
         const result = javascriptApplicationAnalysisResultSchema.parse({
-            schema_version: 2,
             ...application,
             summary,
             limitations: reconstructed.graph.limitations,

package/dist/application/JavaScriptApplicationWorkflowEvidence.js

@@ -3,7 +3,7 @@ import { jsonValueSchema } from "../domain/jsonValue.js";
 import { JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
 /** Create derived Evidence for one bounded application-graph feature trace. */
 export const createApplicationFeatureTraceEvidence = (parameters, result) => createEvidence(undefined, JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, {
-    predicateType: "rea.application-feature-trace/v1",
+    predicateType: "rea.application-feature-trace",
     operation: "trace_application_feature",
     parameters,
     result: jsonValueSchema.parse(result),
@@ -16,7 +16,7 @@ export const createApplicationFeatureTraceEvidence = (parameters, result) => cre
 });
 /** Create derived Evidence for one bounded JavaScript semantic trace. */
 export const createJavaScriptSemanticTraceEvidence = (parameters, result) => createEvidence(undefined, JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, {
-    predicateType: "rea.javascript-semantic-trace/v1",
+    predicateType: "rea.javascript-semantic-trace",
     operation: "trace_javascript_semantics",
     parameters,
     result: jsonValueSchema.parse(result),
@@ -29,7 +29,7 @@ export const createJavaScriptSemanticTraceEvidence = (parameters, result) => cre
 });
 /** Create derived Evidence for one tiered application version comparison. */
 export const createApplicationVersionComparisonEvidence = (parameters, result) => createEvidence(undefined, JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, {
-    predicateType: "rea.application-version-comparison/v1",
+    predicateType: "rea.application-version-comparison",
     operation: "compare_application_versions",
     parameters,
     result: jsonValueSchema.parse(result),
@@ -42,7 +42,7 @@ export const createApplicationVersionComparisonEvidence = (parameters, result) =
 });
 /** Create derived Evidence for one historical-source to bundle comparison. */
 export const createSourceToBundleComparisonEvidence = (parameters, result) => createEvidence(undefined, JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, {
-    predicateType: "rea.source-to-bundle-comparison/v1",
+    predicateType: "rea.source-to-bundle-comparison",
     operation: "compare_source_to_bundle",
     parameters,
     result: jsonValueSchema.parse(result),
@@ -55,7 +55,7 @@ export const createSourceToBundleComparisonEvidence = (parameters, result) => cr
 });
 /** Create derived Evidence for one bounded static export-shape comparison. */
 export const createJavaScriptExportShapeComparisonEvidence = (parameters, result) => createEvidence(undefined, JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, {
-    predicateType: "rea.javascript-export-shape-comparison/v1",
+    predicateType: "rea.javascript-export-shape-comparison",
     operation: "compare_javascript_export_shapes",
     parameters,
     result: jsonValueSchema.parse(result),

package/dist/application/JavaScriptApplicationWorkflowService.js

@@ -32,14 +32,12 @@ export const traceApplicationFeatureEvidenceValidated = (input) => {
             nativeEvidence,
             seed: input.seed,
             direction: input.direction,
-            limits: input.limits,
         });
         return ok(createApplicationFeatureTraceEvidence({
             application_evidence_id: source.evidence.evidence_id,
             native_evidence_ids: nativeEvidence.map(({ evidence_id: id }) => id),
             seed: input.seed,
             direction: input.direction,
-            limits: input.limits,
         }, result));
     }
     catch (cause) {
@@ -75,14 +73,12 @@ export const compareApplicationVersionsEvidenceValidated = (input) => {
             },
             leftNativeEvidence: leftNative,
             rightNativeEvidence: rightNative,
-            limits: input.limits,
         });
         return ok(createApplicationVersionComparisonEvidence({
             left_evidence_id: left.evidence.evidence_id,
             right_evidence_id: right.evidence.evidence_id,
             left_native_evidence_ids: leftNative.map(({ evidence_id: id }) => id),
             right_native_evidence_ids: rightNative.map(({ evidence_id: id }) => id),
-            limits: input.limits,
         }, result));
     }
     catch (cause) {
@@ -101,12 +97,10 @@ export const compareSourceToBundleEvidenceValidated = (input) => {
                 rootArtifactSha256: application.rootArtifactSha256,
                 graph: application.graph,
             },
-            limits: input.limits,
         });
         return ok(createSourceToBundleComparisonEvidence({
             reference_root_sha256: input.reference.root_sha256,
             application_evidence_id: application.evidence.evidence_id,
-            limits: input.limits,
         }, result));
     }
     catch (cause) {
@@ -143,7 +137,6 @@ export const compareJavaScriptExportShapesEvidenceValidated = (input) => {
                 modulePath: input.right_module_path,
                 exportName: input.right_export_name,
             },
-            limits: input.limits,
         });
         return ok(createJavaScriptExportShapeComparisonEvidence({
             left_evidence_id: left.evidence.evidence_id,
@@ -152,7 +145,6 @@ export const compareJavaScriptExportShapesEvidenceValidated = (input) => {
             left_export_name: input.left_export_name,
             right_module_path: input.right_module_path,
             right_export_name: input.right_export_name,
-            limits: input.limits,
         }, result));
     }
     catch (cause) {