reverseport 0.0.0-stage → 1.2.0

package/dist/application/harmony/HarmonyApplicationService.js

@@ -0,0 +1,17 @@
+import { harmonyApplicationProjectionInputSchema, projectHarmonyApplication, } from "../../domain/harmony/harmonyApplication.js";
+import { HARMONY_APPLICATION_PROVIDER } from "../InvestigationProviders.js";
+import { projectInventoryEvidence } from "../InventoryProjectionEvidence.js";
+const OPERATION = "project_harmony_application_graph";
+/** Project authenticated HarmonyOS package inventory Evidence into application evidence. */
+export const projectHarmonyApplicationEvidence = (rawInput) => {
+    return projectInventoryEvidence({
+        rawInput,
+        schema: harmonyApplicationProjectionInputSchema,
+        project: projectHarmonyApplication,
+        operation: OPERATION,
+        predicateType: "rea.harmony-application-graph",
+        provider: HARMONY_APPLICATION_PROVIDER,
+        subjectFormat: (first) => first.subject?.format ?? "unknown",
+        protocolError: "HarmonyOS application projection produced an invalid result",
+    });
+};

package/dist/application/homebrew.js

@@ -0,0 +1,67 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+/** Standard executable names and locations used to discover Homebrew. */
+const HOMEBREW_COMMANDS = [
+    "brew",
+    "/opt/homebrew/bin/brew",
+    "/usr/local/bin/brew",
+];
+/**
+ * Return the first defined result from standard Homebrew executables.
+ * A probe returning `undefined` means that location was unavailable or failed;
+ * other falsy values are successful results and stop discovery.
+ */
+export const probeHomebrew = async (probe) => {
+    for (const command of HOMEBREW_COMMANDS) {
+        const result = await probe(command);
+        if (result !== undefined)
+            return result;
+    }
+    return undefined;
+};
+const caskDirectoriesSchema = z
+    .object({ appdir: z.string().min(1).optional() })
+    .loose();
+const caskConfigSchema = z
+    .object({
+    default: caskDirectoriesSchema.optional(),
+    env: caskDirectoriesSchema.optional(),
+    explicit: caskDirectoriesSchema.optional(),
+})
+    .loose();
+/**
+ * Read the application directory Homebrew recorded when it installed a cask,
+ * in Homebrew's precedence: explicit option, then environment, then default.
+ * Reading the Caskroom avoids `brew` cask commands, which refresh Homebrew's
+ * API and bootsnap caches.
+ */
+export const installedCaskAppdir = async (caskroom, token, home) => {
+    let text;
+    try {
+        text = await readFile(join(caskroom, token, ".metadata", "config.json"), "utf8");
+    }
+    catch (cause) {
+        // An absent or unreadable receipt means the cask is not installed here.
+        void cause;
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (cause) {
+        // A malformed receipt does not identify an application directory.
+        void cause;
+        return undefined;
+    }
+    const config = caskConfigSchema.safeParse(parsed);
+    if (!config.success)
+        return undefined;
+    const appdir = config.data.explicit?.appdir ??
+        config.data.env?.appdir ??
+        config.data.default?.appdir;
+    if (appdir === undefined)
+        return undefined;
+    return appdir.startsWith("~/") ? join(home, appdir.slice(2)) : appdir;
+};

package/dist/application/investigation/EvidenceLedger.js

@@ -0,0 +1,338 @@
+import canonicalize from "canonicalize";
+import { createEvidenceBundle, createImmutableEvidenceBundle, describeEvidenceBundleFailure, parseEvidenceBundle, validateResidualUnknownAddition, } from "../../domain/evidenceBundle.js";
+import { AnalysisInputError } from "../../domain/analysisErrorCore.js";
+import { EvidenceIntegrityError } from "../../domain/evidenceErrors.js";
+import { UnknownRegistryError } from "../../domain/unknownRegistryError.js";
+import { immutableEvidence, parseEvidence, } from "../../domain/evidence.js";
+import { createResidualUnknown, updateResidualUnknown, } from "../../domain/residualUnknown.js";
+import { err, ok } from "../../domain/result.js";
+import { compareUnicodeCodePoints } from "../../domain/unicodeCodePointOrder.js";
+/** Session-owned set of immutable evidence records. */
+export class EvidenceLedger {
+    #records = new Map();
+    #unknownRevisions = new Map();
+    #unknownHeads = new Map();
+    /** Record evidence idempotently; conflicting content is rejected. */
+    record(input) {
+        let evidence;
+        try {
+            evidence = immutableEvidence(input);
+        }
+        catch (cause) {
+            return err(new EvidenceIntegrityError("Evidence record validation failed", {
+                cause,
+            }));
+        }
+        const existing = this.#records.get(evidence.evidence_id);
+        if (existing !== undefined) {
+            // A borrowed record is already authenticated and deeply immutable. Its
+            // identity cannot change between reads, so comparing document-sized
+            // canonical strings again would add no integrity check.
+            if (existing === evidence)
+                return ok("duplicate");
+            return recordsAgree(existing, evidence)
+                ? ok("duplicate")
+                : err(new EvidenceIntegrityError("Conflicting evidence record"));
+        }
+        this.#records.set(evidence.evidence_id, evidence);
+        return ok("added");
+    }
+    /** Validate an entire bundle before atomically merging its records. */
+    import(input) {
+        let bundle;
+        try {
+            bundle = parseEvidenceBundle(input);
+        }
+        catch (cause) {
+            const failure = describeEvidenceBundleFailure(input, cause);
+            if (failure.kind === "single-record")
+                return err(new AnalysisInputError("import_evidence_bundle", {
+                    cause,
+                    userMessage: failure.message,
+                }));
+            return err(new EvidenceIntegrityError("Evidence bundle validation failed", {
+                cause,
+                userMessage: failure.message,
+            }));
+        }
+        // A record-only bundle cannot change the already-valid unknown graph. The
+        // bundle parser has validated every incoming record and its manifests, so
+        // checking ID conflicts and committing only the additions preserves the
+        // atomic merge without rebuilding and reparsing the entire ledger.
+        if (bundle.unknowns.length === 0) {
+            const additions = new Map();
+            const replacements = new Map();
+            let metadataChanged = false;
+            for (const evidence of bundle.records) {
+                const existing = this.#records.get(evidence.evidence_id);
+                if (existing !== undefined) {
+                    if (!recordsAgree(existing, evidence))
+                        return err(new EvidenceIntegrityError("Conflicting evidence record"));
+                    if (canonicalize(existing) !== canonicalize(evidence)) {
+                        replacements.set(evidence.evidence_id, evidence);
+                        metadataChanged = true;
+                    }
+                    continue;
+                }
+                additions.set(evidence.evidence_id, evidence);
+            }
+            for (const [id, evidence] of replacements)
+                this.#records.set(id, immutableEvidence(evidence));
+            for (const [id, evidence] of additions)
+                this.#records.set(id, immutableEvidence(evidence));
+            return ok({
+                recordsAdded: additions.size,
+                unknownsAdded: 0,
+                changed: additions.size > 0 || metadataChanged,
+                metadataChanged,
+            });
+        }
+        const pending = new Map(this.#records);
+        let metadataChanged = false;
+        for (const evidence of bundle.records) {
+            const existing = pending.get(evidence.evidence_id);
+            if (existing !== undefined && !recordsAgree(existing, evidence))
+                return err(new EvidenceIntegrityError("Conflicting evidence record"));
+            if (existing !== undefined &&
+                canonicalize(existing) !== canonicalize(evidence))
+                metadataChanged = true;
+            pending.set(evidence.evidence_id, evidence);
+        }
+        const pendingUnknowns = new Map(this.#unknownRevisions);
+        let unknownsAdded = 0;
+        for (const unknown of bundle.unknowns) {
+            const key = unknownRevisionKey(unknown);
+            const existing = pendingUnknowns.get(key);
+            if (existing !== undefined &&
+                existing.revision_digest !== unknown.revision_digest)
+                return err(new EvidenceIntegrityError("Conflicting unknown revision"));
+            pendingUnknowns.set(key, unknown);
+            if (existing === undefined)
+                unknownsAdded += 1;
+        }
+        const checked = this.#validateCandidate(pending, pendingUnknowns);
+        if (!checked.ok) {
+            if (checked.error instanceof UnknownRegistryError)
+                return err(new EvidenceIntegrityError("Evidence bundle unknown registry failed", {
+                    cause: checked.error,
+                }));
+            return err(checked.error);
+        }
+        const added = pending.size - this.#records.size;
+        this.#commit(pending, pendingUnknowns);
+        return ok({
+            recordsAdded: added,
+            unknownsAdded,
+            changed: added > 0 || unknownsAdded > 0 || metadataChanged,
+            metadataChanged,
+        });
+    }
+    /** Export records in deterministic, semantically irrelevant ID order. */
+    export() {
+        return structuredClone(createEvidenceBundle([...this.#records.values()], [...this.#unknownRevisions.values()]));
+    }
+    /** Borrow a sealed canonical bundle for serialization without copying its records. */
+    forSerialization() {
+        return createImmutableEvidenceBundle([...this.#records.values()], [...this.#unknownRevisions.values()]);
+    }
+    /** Check whether one immutable Evidence ID is present in this ledger. */
+    has(evidenceId) {
+        return this.#records.has(evidenceId);
+    }
+    /** Return a detached immutable Evidence value by semantic ID. */
+    get(evidenceId) {
+        const evidence = this.#records.get(evidenceId);
+        return evidence === undefined ? undefined : structuredClone(evidence);
+    }
+    /** Borrow authenticated immutable Evidence for read-only analysis without a full clone. */
+    forAnalysis(evidenceId) {
+        return this.#records.get(evidenceId);
+    }
+    /** Create one approved unknown and atomically append its mutation evidence. */
+    recordUnknown(input, mutationEvidence) {
+        let parsedMutation;
+        try {
+            parsedMutation = parseEvidence(mutationEvidence);
+        }
+        catch (cause) {
+            return err(new EvidenceIntegrityError("Unknown mutation evidence is invalid", {
+                cause,
+            }));
+        }
+        let unknown;
+        try {
+            unknown = createResidualUnknown(input, parsedMutation.evidence_id, parsedMutation.subject?.digest.sha256 ?? null);
+        }
+        catch (cause) {
+            return err(new UnknownRegistryError("invalid-transition", { cause }));
+        }
+        if (this.#unknownHeads.has(unknown.unknown_id))
+            return err(new UnknownRegistryError("already-exists"));
+        return this.#appendUnknown(unknown, parsedMutation);
+    }
+    /** Atomically record derived Evidence and a linked residual unknown. */
+    recordWithUnknown(evidenceInput, input, mutationInput) {
+        let evidence;
+        let mutation;
+        try {
+            evidence = parseEvidence(evidenceInput);
+            mutation = parseEvidence(mutationInput);
+        }
+        catch (cause) {
+            return err(new EvidenceIntegrityError("Atomic Evidence validation failed", {
+                cause,
+            }));
+        }
+        const existingEvidence = this.#records.get(evidence.evidence_id);
+        if (existingEvidence !== undefined &&
+            !recordsAgree(existingEvidence, evidence))
+            return err(new EvidenceIntegrityError("Conflicting evidence record"));
+        let unknown;
+        try {
+            unknown = createResidualUnknown(input, mutation.evidence_id, mutation.subject?.digest.sha256 ?? null);
+        }
+        catch (cause) {
+            return err(new UnknownRegistryError("invalid-transition", { cause }));
+        }
+        const existingUnknown = this.#unknownHeads.get(unknown.unknown_id);
+        if (existingUnknown !== undefined) {
+            if (existingUnknown.revision !== 1 ||
+                existingUnknown.revision_digest !== unknown.revision_digest)
+                return err(new UnknownRegistryError("already-exists"));
+            const checked = this.#appendIncremental([evidence]);
+            if (!checked.ok)
+                return checked;
+            return ok(null);
+        }
+        const checked = this.#appendIncremental([evidence, mutation], unknown);
+        if (!checked.ok)
+            return checked;
+        return ok(structuredClone(unknown));
+    }
+    /** Apply one approved full-state update using optimistic revision matching. */
+    updateUnknown(input, mutationEvidence) {
+        const current = this.#unknownHeads.get(input.unknown_id);
+        if (current === undefined)
+            return err(new UnknownRegistryError("not-found"));
+        if (current.revision !== input.expected_revision)
+            return err(new UnknownRegistryError("revision-conflict"));
+        let unknown;
+        try {
+            unknown = updateResidualUnknown(current, input, mutationEvidence.evidence_id);
+        }
+        catch (cause) {
+            return err(new UnknownRegistryError("invalid-transition", { cause }));
+        }
+        return this.#appendUnknown(unknown, mutationEvidence);
+    }
+    /** Query current heads in stable ID order. */
+    listUnknowns(filters = {}) {
+        return [...this.#unknownHeads.values()]
+            .filter((unknown) => (filters.status === undefined || unknown.status === filters.status) &&
+            (filters.severity === undefined ||
+                unknown.severity === filters.severity) &&
+            (filters.domain === undefined || unknown.domain === filters.domain))
+            .sort((left, right) => compareUnicodeCodePoints(left.unknown_id, right.unknown_id))
+            .map((unknown) => structuredClone(unknown));
+    }
+    /** Return current resolution validity; imported invalid states are rejected. */
+    verifyUnknownResolution(unknownId) {
+        const unknown = this.#unknownHeads.get(unknownId);
+        if (unknown === undefined)
+            return err(new UnknownRegistryError("not-found"));
+        return ok({
+            valid: unknown.status === "resolved",
+            truthVerified: unknown.resolution?.disposition === "verified",
+            unknown: structuredClone(unknown),
+        });
+    }
+    /** Clear records when the owning session closes. */
+    clear() {
+        this.#records.clear();
+        this.#unknownRevisions.clear();
+        this.#unknownHeads.clear();
+    }
+    #appendUnknown(unknown, mutationEvidenceInput) {
+        let mutationEvidence;
+        try {
+            mutationEvidence = parseEvidence(mutationEvidenceInput);
+        }
+        catch (cause) {
+            return err(new EvidenceIntegrityError("Unknown mutation evidence is invalid", {
+                cause,
+            }));
+        }
+        const checked = this.#appendIncremental([mutationEvidence], unknown);
+        if (!checked.ok)
+            return checked;
+        return ok(structuredClone(unknown));
+    }
+    #appendIncremental(records, unknown) {
+        const additions = new Map();
+        for (const evidence of records) {
+            const existing = additions.get(evidence.evidence_id) ??
+                this.#records.get(evidence.evidence_id);
+            if (existing !== undefined) {
+                if (!recordsAgree(existing, evidence))
+                    return err(new EvidenceIntegrityError("Conflicting evidence record"));
+                continue;
+            }
+            additions.set(evidence.evidence_id, evidence);
+        }
+        const unknownKey = unknown === undefined ? undefined : unknownRevisionKey(unknown);
+        if (unknownKey !== undefined && this.#unknownRevisions.has(unknownKey))
+            return err(new UnknownRegistryError("integrity"));
+        if (unknown !== undefined)
+            try {
+                validateResidualUnknownAddition(unknown, {
+                    get: (id) => additions.get(id) ?? this.#records.get(id),
+                    has: (id) => additions.has(id) || this.#records.has(id),
+                }, this.#unknownHeads);
+            }
+            catch (cause) {
+                return err(new UnknownRegistryError("integrity", { cause }));
+            }
+        for (const [id, evidence] of additions)
+            this.#records.set(id, immutableEvidence(evidence));
+        if (unknown !== undefined && unknownKey !== undefined) {
+            this.#unknownRevisions.set(unknownKey, unknown);
+            this.#unknownHeads.set(unknown.unknown_id, unknown);
+        }
+        return ok(undefined);
+    }
+    #validateCandidate(records, unknowns) {
+        try {
+            createImmutableEvidenceBundle([...records.values()], [...unknowns.values()]);
+        }
+        catch (cause) {
+            return err(new UnknownRegistryError("integrity", { cause }));
+        }
+        return ok(undefined);
+    }
+    #commit(records, unknowns) {
+        this.#records.clear();
+        for (const [id, evidence] of records)
+            this.#records.set(id, immutableEvidence(evidence));
+        this.#unknownRevisions.clear();
+        this.#unknownHeads.clear();
+        for (const [key, unknown] of unknowns) {
+            this.#unknownRevisions.set(key, unknown);
+            const head = this.#unknownHeads.get(unknown.unknown_id);
+            if (head === undefined || head.revision < unknown.revision)
+                this.#unknownHeads.set(unknown.unknown_id, unknown);
+        }
+    }
+}
+const unknownRevisionKey = (unknown) => `${unknown.unknown_id}:${String(unknown.revision)}`;
+const recordsAgree = (left, right) => canonicalize(withoutLocalPath(left)) ===
+    canonicalize(withoutLocalPath(right));
+const withoutLocalPath = (evidence) => ({
+    ...evidence,
+    subject: evidence.subject === null
+        ? null
+        : {
+            ...evidence.subject,
+            name: "<non-identity-name>",
+            local_path: "<non-identity-local-path>",
+        },
+});

package/dist/application/investigation/InspectEvidenceBundle.js

@@ -0,0 +1,18 @@
+import { AnalysisInputError } from "../../domain/analysisErrorCore.js";
+import { err, ok } from "../../domain/result.js";
+import { summarizeEvidenceBundle, } from "../../domain/evidenceRecordSummary.js";
+/** Select complete bundle delivery or discovery metadata without analysis payloads. */
+export const inspectEvidenceBundle = (bundle, options) => {
+    if (options.detail === "complete" && options.filters !== undefined)
+        return err(new AnalysisInputError("get_evidence_bundle", undefined, [
+            {
+                path: ["filters"],
+                reason: "invalid_value",
+                message: "Record filters require detail: summary; complete returns the canonical bundle.",
+                expected: "detail: summary",
+            },
+        ]));
+    return ok(options.detail === "summary"
+        ? summarizeEvidenceBundle(bundle, options.filters)
+        : bundle);
+};

package/dist/application/investigation/InvestigationRecordPort.js

@@ -0,0 +1 @@
+export {};

package/dist/application/investigation/InvestigationRecords.js

@@ -0,0 +1,65 @@
+import { EvidenceLedger } from "./EvidenceLedger.js";
+import { unknownMutationEvidence } from "./UnknownEvidence.js";
+/** One investigation's validated record owner, independent of binary execution. */
+export class InvestigationRecords {
+    #evidence = new EvidenceLedger();
+    /** Record immutable Evidence idempotently; reject conflicting content. */
+    recordEvidence(evidence) {
+        return this.#evidence.record(evidence);
+    }
+    /** Check one semantic Evidence ID without exposing stored values. */
+    hasEvidence(evidenceId) {
+        return this.#evidence.has(evidenceId);
+    }
+    /** Return a detached Evidence value for one semantic ID. */
+    evidenceById(evidenceId) {
+        return this.#evidence.get(evidenceId);
+    }
+    /** Borrow an immutable authenticated record for a read-only application workflow. */
+    evidenceForAnalysis(evidenceId) {
+        return this.#evidence.forAnalysis(evidenceId);
+    }
+    /** Export a detached deterministic bundle of Evidence and Unknown revisions. */
+    exportEvidenceBundle() {
+        return this.#evidence.export();
+    }
+    /** Borrow a sealed bundle snapshot for complete JSON serialization. */
+    evidenceBundleForSerialization() {
+        return this.#evidence.forSerialization();
+    }
+    /** Atomically merge a bundle and report changes for the owner's post-commit observers. */
+    mergeEvidenceBundle(bundle) {
+        return this.#evidence.import(bundle);
+    }
+    /** Clear records when the owning runtime applies its existing lifecycle policy. */
+    clear() {
+        this.#evidence.clear();
+    }
+    /** Record an Unknown with an explicitly supplied Evidence subject, if any. */
+    recordUnknown(input, target) {
+        return this.#evidence.recordUnknown(input, unknownMutationEvidence(target, { operation: "record_unknown", input }));
+    }
+    /** Commit derived Evidence and its Unknown atomically without an implicit subject. */
+    recordEvidenceWithUnknown(evidence, input) {
+        return this.#evidence.recordWithUnknown(evidence, input, unknownMutationEvidence(undefined, {
+            operation: "record_unknown",
+            input,
+        }));
+    }
+    /** Update an optimistic revision with an explicitly supplied Evidence subject. */
+    updateUnknown(input, target) {
+        const evidence = unknownMutationEvidence(target, {
+            operation: "update_unknown",
+            input,
+        });
+        return this.#evidence.updateUnknown(input, evidence);
+    }
+    /** Return detached current Unknown revisions matching the selected filters. */
+    listUnknowns(filters = {}) {
+        return this.#evidence.listUnknowns(filters);
+    }
+    /** Verify registry consistency without asserting the answer is true. */
+    verifyUnknownResolution(unknownId) {
+        return this.#evidence.verifyUnknownResolution(unknownId);
+    }
+}

package/dist/application/investigation/UnknownEvidence.js

@@ -0,0 +1,37 @@
+import { createEvidence } from "../../domain/evidence.js";
+/** Provider identity for analyst-authored residual-unknown mutations. */
+const UNKNOWN_REGISTRY_PROVIDER = {
+    id: "rea-unknown-registry",
+    name: "REA residual unknown registry",
+    version: "1",
+};
+/** Create immutable evidence for one approved residual-unknown mutation. */
+export const unknownMutationEvidence = (target, mutation) => createEvidence(target, UNKNOWN_REGISTRY_PROVIDER, {
+    predicateType: "rea.residual-unknown-mutation",
+    operation: mutation.operation,
+    parameters: { ...mutation.input },
+    result: mutation.operation === "record_unknown"
+        ? {
+            action: "record",
+            question: mutation.input.question,
+            required_authority: mutation.input.required_authority,
+            required_confidence: mutation.input.required_confidence,
+        }
+        : { action: "update", status: mutation.input.status },
+    confidence: "derived",
+    authority: "analyst-inference",
+    evidenceLinks: unknownEvidenceLinks(mutation.input),
+    limitations: [
+        "Registry mutation evidence records analyst intent, not proof of the answer.",
+    ],
+});
+/** Deduplicate evidence links carried by an unknown mutation. */
+const unknownEvidenceLinks = (input) => [
+    ...new Set([
+        ...input.supporting_evidence_ids,
+        ...input.contradicting_evidence_ids,
+        ...("resolution" in input && input.resolution !== null
+            ? input.resolution.evidence_ids
+            : []),
+    ]),
+];

package/dist/application/javascript/ElectronActiveEvidence.js

@@ -0,0 +1,29 @@
+import { digestCanonicalValue } from "../../domain/canonicalDigest.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { jsonObjectSchema, jsonValueSchema } from "../../domain/jsonValue.js";
+/** Commit the selected Electron experiment and its observed result. */
+export const createElectronActiveEvidence = (input, result, provider) => createEvidence(undefined, provider, {
+    predicateType: "rea.electron-active-scenario",
+    operation: "capture_electron_scenario",
+    parameters: parameters(input),
+    result: jsonValueSchema.parse(result),
+    confidence: "observed",
+    authority: "controlled-replay",
+    environment: {
+        id: `${result.application.electron_version}@unknown`,
+        platform: "unknown",
+        architecture: "unknown",
+        isolation: "none",
+    },
+    limitations: [
+        ...result.limitations,
+        "Application host platform and architecture were not observed.",
+    ],
+});
+const parameters = (input) => {
+    const scenario = jsonObjectSchema.parse(input);
+    return {
+        ...scenario,
+        scenario_sha256: digestCanonicalValue(scenario, "Electron scenario"),
+    };
+};

package/dist/application/javascript/ElectronActiveObservationPort.js

@@ -0,0 +1 @@
+export {};

package/dist/application/javascript/ElectronActiveObservationService.js

@@ -0,0 +1,51 @@
+import { dirname } from "node:path";
+import { realpath } from "node:fs/promises";
+import { AnalysisCapabilityUnavailableError, AnalysisInputError, } from "../../domain/analysisErrorCore.js";
+import { err } from "../../domain/result.js";
+import { createElectronActiveEvidence } from "./ElectronActiveEvidence.js";
+const OPERATION = "capture_electron_scenario";
+const PROVIDER_ID = "rea-playwright-electron-active";
+const canonicalizeInput = async (input) => {
+    try {
+        const [executablePath, applicationPath] = await Promise.all([
+            realpath(input.executable_path),
+            realpath(input.application_path),
+        ]);
+        const applicationRoot = input.application_root === undefined
+            ? dirname(applicationPath)
+            : await realpath(input.application_root);
+        return {
+            ok: true,
+            value: {
+                ...input,
+                executable_path: executablePath,
+                application_path: applicationPath,
+                application_root: applicationRoot,
+            },
+        };
+    }
+    catch (cause) {
+        return err(new AnalysisInputError(OPERATION, { cause }, [
+            {
+                path: ["application_path"],
+                reason: "invalid_format",
+                message: "Electron executable, application, and root must resolve to existing paths",
+            },
+        ]));
+    }
+};
+/** Canonicalize request paths and execute one provider-owned Electron run. */
+export const captureElectronScenario = async (provider, input, options = {}) => {
+    const canonical = await canonicalizeInput(input);
+    if (!canonical.ok)
+        return canonical;
+    if (provider === undefined)
+        return err(new AnalysisCapabilityUnavailableError(PROVIDER_ID, OPERATION, "active Electron observation provider is not configured"));
+    const captured = await provider.capture(canonical.value, options);
+    return captured.ok
+        ? {
+            ok: true,
+            value: createElectronActiveEvidence(canonical.value, captured.value, provider.identity()),
+        }
+        : captured;
+};