@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/wireErrorTriage.js

@@ -1,5 +1,6 @@
 import { readErrorNumber, readErrorString, readErrorStringList } from './wireFailureShape.js';
 import { capForDisplay } from './fleetTaskDesc.js';
+import { readOwnDataValue } from './ownKey.js';
 import { fleetLeaseUnavailableFromError } from './wireRefusalCopy.js';
 import { DRAINING_ERROR_CODE, isCorruptSessionCode, RESUME_AT_ERROR_CODE_PREFIX, RESUME_POLICY_FOLD_CODE, RESUME_RETRY_LATER_CODES, RESUME_USAGE_WINDOW_EXHAUSTED, SCENARIO_NOT_ALLOWED_ERROR_CODE, } from './engineErrorCodes.js';
 export const WIRE_NETWORK_ERROR_PATTERN = /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|EHOSTUNREACH|ENETUNREACH|EPIPE|socket hang up|UND_ERR|terminated|other side closed/i;
@@ -87,6 +88,40 @@ export function drainingRetryDelayMs(err, attempt, opts) {
     const ladder = opts?.ladder && opts.ladder.length > 0 ? opts.ladder : [1_000, 2_000, 4_000];
     return ladder[Math.min(attempt, ladder.length - 1)] ?? 1_000;
 }
+export function isInStreamDrainingEnd(frame) {
+    try {
+        if (typeof frame !== 'object' || frame === null)
+            return false;
+        if (typeof readOwnDataValue(frame, 'status') === 'number')
+            return false;
+        const typeSlot = Object.getOwnPropertyDescriptor(frame, 'type');
+        const outerType = typeSlot !== undefined && Object.hasOwn(typeSlot, 'value') ? typeSlot.value : undefined;
+        if (outerType === 'error')
+            return readOwnDataValue(frame, 'errorCode') === DRAINING_ERROR_CODE;
+        if (typeSlot !== undefined && outerType !== 'unknown')
+            return false;
+        if (readOwnDataValue(frame, 'event') !== 'error')
+            return false;
+        const data = readOwnDataValue(frame, 'data');
+        if (typeof data !== 'object' || data === null)
+            return false;
+        const dataType = readOwnDataValue(data, 'type');
+        if (dataType !== undefined && dataType !== 'error')
+            return false;
+        return readOwnDataValue(data, 'errorCode') === DRAINING_ERROR_CODE;
+    }
+    catch {
+        return false;
+    }
+}
+export const STREAM_DRAINING_RECONNECT_MAX = 3;
+export function streamDrainingDecision(frame, attempt, opts) {
+    if (!isInStreamDrainingEnd(frame))
+        return { giveUp: 'not_draining_end' };
+    if (!Number.isSafeInteger(attempt) || attempt < 0 || attempt >= STREAM_DRAINING_RECONNECT_MAX)
+        return { giveUp: 'attempts_exhausted' };
+    return { reconnectAfterMs: drainingRetryDelayMs(null, attempt, opts?.ladder !== undefined ? { ladder: opts.ladder } : undefined) };
+}
 export function scenarioDenyFromError(err) {
     if (typeof err !== 'object' || err === null)
         return null;

package/dist/wireFailureShape.d.ts

@@ -8,11 +8,21 @@ interface WireFailureShape {
     bodyVerdict?: string;
     bodyCurrentName?: string;
     message: string;
+    ownMessage?: string;
 }
+export declare const THROWN_SLOT_UNREADABLE: unique symbol;
+export declare function readThrownSlot(o: unknown, key: string, own?: boolean): unknown;
+export declare function thrownIsInstanceOf<C extends abstract new (...args: never[]) => unknown>(e: unknown, cls: C): e is InstanceType<C>;
 export declare function readErrorNumber(o: object, key: string): number | undefined;
 export declare function readErrorRecord(o: object, key: string): object | undefined;
 export declare function readErrorString(o: object, key: string): string | undefined;
 export declare function readErrorStringList(o: object, key: string): readonly string[] | undefined;
 export declare function readErrorStrictStringList(o: object, key: string): readonly string[] | undefined;
 export declare function wireFailureShapeOf(e: unknown): WireFailureShape;
+export declare const WIRE_FAILURE_UNRENDERABLE_TEXT = "the call failed with an error this client could not render";
+export declare function wireFailureTextsOf(e: unknown): {
+    reason: string;
+    log: string;
+};
+export declare function readRefusalField(o: object): string | undefined;
 export {};

package/dist/wireFailureShape.js

@@ -1,9 +1,24 @@
-function readGuarded(o, key) {
+export const THROWN_SLOT_UNREADABLE = Symbol('thrown-slot-unreadable');
+export function readThrownSlot(o, key, own = false) {
     try {
+        if (own && !Object.hasOwn(o, key))
+            return undefined;
         return o[key];
     }
     catch {
-        return undefined;
+        return THROWN_SLOT_UNREADABLE;
+    }
+}
+function readGuarded(o, key) {
+    const v = readThrownSlot(o, key);
+    return v === THROWN_SLOT_UNREADABLE ? undefined : v;
+}
+export function thrownIsInstanceOf(e, cls) {
+    try {
+        return e instanceof cls;
+    }
+    catch {
+        return false;
     }
 }
 function readErrorSlot(obj, key, accept) {
@@ -97,7 +112,14 @@ export function wireFailureShapeOf(e) {
     catch {
         extraUnreadable = true;
     }
-    const extraObj = typeof extra === 'object' && extra !== null && !Array.isArray(extra) ? extra : undefined;
+    let extraObj;
+    try {
+        extraObj = typeof extra === 'object' && extra !== null && !Array.isArray(extra) ? extra : undefined;
+    }
+    catch {
+        extraObj = undefined;
+        extraUnreadable = true;
+    }
     let committedPresent = false;
     let committedRaw;
     if (extraObj !== undefined) {
@@ -133,12 +155,13 @@ export function wireFailureShapeOf(e) {
     const bodyName = ownString('name');
     const bodyVerdict = ownString('verdict');
     const bodyCurrentName = ownString('currentName');
+    const ownMessage = typeof rawMessage === 'string' && rawMessage !== '' ? rawMessage : undefined;
     let message;
     try {
-        message = typeof rawMessage === 'string' && rawMessage !== '' ? rawMessage : String(e);
+        message = ownMessage !== undefined ? ownMessage : String(e);
     }
     catch {
-        message = 'the call failed with an error this client could not render';
+        message = WIRE_FAILURE_UNRENDERABLE_TEXT;
     }
     const sec = typeof retryAfterMs === 'number' && Number.isFinite(retryAfterMs) && retryAfterMs >= 0
         ? Math.ceil(retryAfterMs / 1000)
@@ -160,5 +183,49 @@ export function wireFailureShapeOf(e) {
         ...(bodyVerdict !== undefined ? { bodyVerdict } : {}),
         ...(bodyCurrentName !== undefined ? { bodyCurrentName } : {}),
         message,
+        ...(ownMessage !== undefined ? { ownMessage } : {}),
     };
 }
+export const WIRE_FAILURE_UNRENDERABLE_TEXT = 'the call failed with an error this client could not render';
+export function wireFailureTextsOf(e) {
+    const { ownMessage } = wireFailureShapeOf(e);
+    let log;
+    try {
+        log = String(e).slice(0, 300);
+    }
+    catch {
+        log = '<unprintable thrown value>';
+    }
+    if (ownMessage !== undefined)
+        return { reason: ownMessage, log };
+    if (typeof e === 'string')
+        return { reason: e !== '' ? e : WIRE_FAILURE_UNRENDERABLE_TEXT, log };
+    if (typeof e === 'number' || typeof e === 'boolean' || typeof e === 'bigint')
+        return { reason: String(e), log };
+    return { reason: WIRE_FAILURE_UNRENDERABLE_TEXT, log };
+}
+export function readRefusalField(o) {
+    const str = (rec) => {
+        let v;
+        try {
+            v = rec.field;
+        }
+        catch {
+            return undefined;
+        }
+        return typeof v === 'string' && v !== '' ? v : undefined;
+    };
+    let extra;
+    try {
+        extra = o.extra;
+    }
+    catch {
+        extra = undefined;
+    }
+    if (typeof extra === 'object' && extra !== null && !Array.isArray(extra)) {
+        const fromExtra = str(extra);
+        if (fromExtra !== undefined)
+            return fromExtra;
+    }
+    return str(o);
+}

package/dist/wireRefusalCopy.d.ts

@@ -1,4 +1,4 @@
-import { FLEET_LEASE_UNAVAILABLE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
 import type { TaskRequestLike } from './request/taskRequest.js';
 export declare const CONFLICT_APPROVAL_SETTLED = "conflict.approval_settled";
 export declare const CONFLICT_RUN_NOT_RUNNING = "conflict.run_not_running";
@@ -83,3 +83,8 @@ export interface HookMatcherRefusal {
     readonly canonical: string;
 }
 export declare function hookMatcherRefusalFromError(err: unknown): HookMatcherRefusal | undefined;
+export interface AutonomyLaneRefusalDetail {
+    readonly code: typeof REQUEST_AUTONOMY_LANE_REFUSED;
+}
+export declare function autonomyLaneRefusalFromError(err: unknown): AutonomyLaneRefusalDetail | null;
+export declare function autonomyLaneRefusalContent(): string;

package/dist/wireRefusalCopy.js

@@ -1,6 +1,6 @@
-import { readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList } from './wireFailureShape.js';
+import { readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList, readRefusalField } from './wireFailureShape.js';
 import { readOwnNonEmptyString } from './ownKey.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_FIELD_CONFLICT, RESUME_POLICY_FOLD_CODE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, RESUME_POLICY_FOLD_CODE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
@@ -11,24 +11,31 @@ function readStringField(o, key) {
     return typeof v === 'string' && v !== '' ? v : undefined;
 }
 export function cancelConflictFromError(err) {
+    let o;
     try {
         if (err === null || typeof err !== 'object')
             return null;
-        const o = err;
+        o = err;
         const rawStatus = o.status ?? o.statusCode;
         const is409 = rawStatus === 409 || (rawStatus === undefined && o.name === 'ConflictError');
         if (!is409)
             return null;
-        const code = readStringField(o, 'errorCode');
-        if (code === CONFLICT_APPROVAL_SETTLED)
-            return { kind: 'approval_settled', code };
-        if (code === CONFLICT_RUN_NOT_RUNNING)
-            return { kind: 'run_not_running', code };
-        return { kind: 'unrecognized', ...(code !== undefined ? { code } : {}) };
     }
     catch {
         return null;
     }
+    let code;
+    try {
+        code = readStringField(o, 'errorCode');
+    }
+    catch {
+        code = undefined;
+    }
+    if (code === CONFLICT_APPROVAL_SETTLED)
+        return { kind: 'approval_settled', code };
+    if (code === CONFLICT_RUN_NOT_RUNNING)
+        return { kind: 'run_not_running', code };
+    return { kind: 'unrecognized', ...(code !== undefined ? { code } : {}) };
 }
 export function cancelConflictContent(detail) {
     switch (detail.kind) {
@@ -177,23 +184,7 @@ export function scenarioAssignmentUnknownFromError(err) {
 const SETTLED_BY_NOT_IN_PROOF = 'settled_by_not_in_proof';
 const DECIDED_BY_NOT_IN_PROOF = 'decided_by_not_in_proof';
 const RETIRED_DECISION_KEY = 'settledBy';
-const RESUME_OUTCOME_INVALID = 'resume_outcome_invalid';
 const APPROVAL_NON_BINDING_FIELDS = new Set(['hostDecision', 'approver']);
-function readRefusalField(o) {
-    let extra;
-    try {
-        extra = o.extra;
-    }
-    catch {
-        extra = undefined;
-    }
-    if (typeof extra === 'object' && extra !== null && !Array.isArray(extra)) {
-        const fromExtra = readStringField(extra, 'field');
-        if (fromExtra !== undefined)
-            return fromExtra;
-    }
-    return readStringField(o, 'field');
-}
 export function denyAttributionRefusalFromError(err, sentAttributionKey) {
     try {
         if (err === null || typeof err !== 'object')
@@ -619,3 +610,10 @@ export function hookMatcherRefusalFromError(err) {
         return undefined;
     }
 }
+export function autonomyLaneRefusalFromError(err) {
+    return effectiveWireErrorCode(err) === REQUEST_AUTONOMY_LANE_REFUSED ? { code: REQUEST_AUTONOMY_LANE_REFUSED } : null;
+}
+export function autonomyLaneRefusalContent() {
+    return ('The engine did not start this leader run: this deployment runs in plan-only autonomy, and a leader run has no way to have its plan reviewed, ' +
+        'so nothing was started · Submit the work as a regular run instead, or ask whoever operates the engine to change its autonomy setting');
+}

package/dist/wiringInstructionsAttribution.d.ts

@@ -0,0 +1,10 @@
+import { type CallerCwdReading } from './callerCwdCapability.js';
+export declare function legCwdOfBody(body: object | null | undefined, callerCwd: CallerCwdReading | undefined): string | undefined;
+export interface InstructionsAttributionInput {
+    legCwd: string | undefined;
+    currentCwd: string;
+    realPathOf: (path: string) => string;
+}
+export declare function engineSelectedInstructionsFile(view: {
+    readonly selected: readonly string[];
+} | null | undefined, input: InstructionsAttributionInput): string | undefined;

package/dist/wiringInstructionsAttribution.js

@@ -0,0 +1,67 @@
+import { callerCwdAdmitted } from './callerCwdCapability.js';
+import { displayUntrusted } from './displayUntrusted.js';
+import { readOutboundBodyField } from './fileHistoryLegNotice.js';
+export function legCwdOfBody(body, callerCwd) {
+    if (!callerCwdAdmitted(callerCwd))
+        return undefined;
+    const r = readOutboundBodyField(body, 'cwd');
+    return r.kind === 'value' && typeof r.value === 'string' && r.value.length > 0 ? r.value : undefined;
+}
+function realOf(realPathOf, path) {
+    try {
+        if (typeof realPathOf !== 'function')
+            return undefined;
+        const r = realPathOf(path);
+        return typeof r === 'string' && r.length > 0 ? r : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function safeRelativeMember(member) {
+    if (typeof member !== 'string' || member.length === 0)
+        return false;
+    if (displayUntrusted(member) !== member)
+        return false;
+    if (member.includes('\\') || member.startsWith('/') || /^[A-Za-z]:/.test(member))
+        return false;
+    return member.split('/').every((seg) => seg !== '' && seg !== '..');
+}
+function isSep(path, c) {
+    return c === '/' || (!path.startsWith('/') && c === '\\');
+}
+function trimSeps(path) {
+    let end = path.length;
+    while (end > 0 && isSep(path, path.charAt(end - 1)))
+        end--;
+    return path.slice(0, end);
+}
+function strictlyWithin(child, dir) {
+    const trimmed = trimSeps(dir);
+    if (!child.startsWith(trimmed) || child.length <= trimmed.length)
+        return false;
+    return isSep(dir, child.charAt(trimmed.length));
+}
+export function engineSelectedInstructionsFile(view, input) {
+    try {
+        if (view === null || typeof view !== 'object' || input === null || typeof input !== 'object')
+            return undefined;
+        const { legCwd, currentCwd, realPathOf } = input;
+        if (typeof legCwd !== 'string' || legCwd.length === 0 || legCwd !== currentCwd)
+            return undefined;
+        const selected = view.selected;
+        if (!Array.isArray(selected) || selected.length === 0)
+            return undefined;
+        const member = selected[0];
+        if (!safeRelativeMember(member))
+            return undefined;
+        const realDir = realOf(realPathOf, currentCwd);
+        const realFile = realOf(realPathOf, `${trimSeps(currentCwd)}/${member}`);
+        if (realDir === undefined || realFile === undefined || !strictlyWithin(realFile, realDir))
+            return undefined;
+        return member;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/workflowClient.js

@@ -5,6 +5,7 @@ import { makeEngineWireClient } from './engineWireSdk.js';
 import { engineWireDebugEnabled } from './engineWireTarget.js';
 import { hostLog } from './host.js';
 import { isReadCredentialRefusal } from './readCredentialRefusal.js';
+import { createStreamDrainingLegs } from './streamDrainingLegs.js';
 function coerceRunStatus(s) {
     switch (s) {
         case 'completed':
@@ -584,6 +585,7 @@ async function consumeWorkflowActivity(l, cfg) {
         emitActivityTick(l);
         return;
     }
+    const drains = createStreamDrainingLegs();
     while (!l.closed && !l.abort.signal.aborted) {
         let sawFrame = false;
         let threw = false;
@@ -597,6 +599,8 @@ async function consumeWorkflowActivity(l, cfg) {
                     return;
                 sawFrame = true;
                 l.connected = true;
+                if (drains.see(frame))
+                    continue;
                 try {
                     foldWorkflowActivityFrame(l, frame);
                 }
@@ -615,6 +619,7 @@ async function consumeWorkflowActivity(l, cfg) {
             }
         }
         l.connected = false;
+        const drained = drains.legEnded(threw ? 'threw' : 'returned');
         if (!sawFrame && !threw) {
             l.closed = true;
             l.closedReason = 'terminal';
@@ -632,9 +637,21 @@ async function consumeWorkflowActivity(l, cfg) {
                 return;
             }
         }
+        let waitMs = WORKFLOW_ACTIVITY_RECONNECT_MS;
+        if (drained !== undefined) {
+            const decision = drained;
+            if ('giveUp' in decision) {
+                l.closed = true;
+                l.closedReason = 'error';
+                l.lastError = 'the engine kept ending this stream because it is going down (drain end frames)';
+                emitActivityTick(l);
+                return;
+            }
+            waitMs = decision.reconnectAfterMs;
+        }
         emitActivityTick(l);
         if (!l.closed && !l.abort.signal.aborted) {
-            await abortableSleep(WORKFLOW_ACTIVITY_RECONNECT_MS, l.abort.signal);
+            await abortableSleep(waitMs, l.abort.signal);
         }
     }
     emitActivityTick(l);
@@ -777,8 +794,8 @@ export function createLiveWorkflowSource(config) {
         connected = false;
         unauthorized = isReadCredentialRefusal(err);
         if (err instanceof APIError) {
-            code = err.status;
             degraded = err.status === 501 || err.status === 404;
+            code = degraded ? err.status : null;
             lastError = `${err.status} ${err.message}`;
         }
         else {

package/dist/workflowsJournalCapability.d.ts

@@ -14,5 +14,4 @@ export declare function noteEngineCapsForWorkflowsJournal(baseUrl: string, caps:
 export declare function observedWorkflowsJournal(baseUrl?: string | undefined): WorkflowsJournalReading;
 export declare function workflowsJournalAvailable(reading: WorkflowsJournalReading): 'yes' | 'no' | 'unknown';
 export declare function workflowsJournalDoctorDetail(reading: WorkflowsJournalReading): string;
-export declare function forgetWorkflowsJournalReading(baseUrl: string | undefined): void;
 export declare function __resetWorkflowsJournalReadingsForTests(): void;

package/dist/workflowsJournalCapability.js

@@ -1,16 +1,20 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectWorkflowsJournalCapability(caps) {
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    if (!Object.hasOwn(caps, 'workflowsJournal'))
-        return { kind: 'not_reported' };
-    const v = caps.workflowsJournal;
-    if (v === undefined)
-        return { kind: 'not_reported' };
-    if (typeof v !== 'boolean')
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const v = ownDataField(caps, 'workflowsJournal');
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        if (typeof v !== 'boolean')
+            return undefined;
+        return v ? { kind: 'present' } : { kind: 'absent' };
+    }
+    catch {
         return undefined;
-    return v ? { kind: 'present' } : { kind: 'absent' };
+    }
 }
 const reader = createEngineCapReader({
     name: 'workflowsJournal',
@@ -42,9 +46,6 @@ export function workflowsJournalDoctorDetail(reading) {
             return 'workflow journal on — a workflow’s execution journal can be read';
     }
 }
-export function forgetWorkflowsJournalReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetWorkflowsJournalReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/writeProtectionCapability.d.ts

@@ -28,5 +28,4 @@ export declare function noteEngineCapsForWriteProtection(baseUrl: string, caps:
 export declare function observedWriteProtection(baseUrl?: string | undefined): WriteProtectionReading;
 export declare function writeProtectionDoctorDetail(reading: WriteProtectionReading): string;
 export declare function writeProtectionPostureDetail(posture: WriteProtectionPostureView): string;
-export declare function forgetWriteProtectionReading(baseUrl: string | undefined): void;
 export declare function __resetWriteProtectionReadingsForTests(): void;

package/dist/writeProtectionCapability.js

@@ -1,31 +1,34 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectWriteProtectionCapability(caps) {
-    if (caps === null || typeof caps !== 'object')
-        return undefined;
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    if (!Object.hasOwn(caps, 'writeProtection'))
-        return { kind: 'not_reported' };
-    const wp = caps.writeProtection;
-    if (wp === null)
-        return { kind: 'none' };
-    if (wp === undefined)
-        return { kind: 'not_reported' };
-    if (typeof wp !== 'object' || Array.isArray(wp))
-        return undefined;
-    const w = wp;
-    const armed = w.armed;
-    const replaced = w.replaced;
-    const rows = w.rows;
-    if (typeof armed !== 'boolean')
-        return undefined;
-    if (typeof replaced !== 'boolean')
-        return undefined;
-    if (typeof rows !== 'number' || !Number.isInteger(rows) || rows < 0)
+    try {
+        if (caps === null || typeof caps !== 'object')
+            return undefined;
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const wp = ownDataField(caps, 'writeProtection');
+        if (wp === null)
+            return { kind: 'none' };
+        if (wp === undefined)
+            return { kind: 'not_reported' };
+        if (typeof wp !== 'object' || Array.isArray(wp))
+            return undefined;
+        const armed = ownDataField(wp, 'armed');
+        const replaced = ownDataField(wp, 'replaced');
+        const rows = ownDataField(wp, 'rows');
+        if (typeof armed !== 'boolean')
+            return undefined;
+        if (typeof replaced !== 'boolean')
+            return undefined;
+        if (typeof rows !== 'number' || !Number.isInteger(rows) || rows < 0)
+            return undefined;
+        return { kind: 'present', view: { armed, rows, replaced } };
+    }
+    catch {
         return undefined;
-    return { kind: 'present', view: { armed, rows, replaced } };
+    }
 }
 export function projectWriteProtectionPosture(wiring) {
     if (wiring === null || typeof wiring !== 'object')
@@ -109,9 +112,6 @@ export function writeProtectionPostureDetail(posture) {
         : '';
     return `source ${source} · ${String(posture.rows.length)} ${posture.rows.length === 1 ? 'name' : 'names'}: ${shown}${more}${dropped}`;
 }
-export function forgetWriteProtectionReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetWriteProtectionReadingsForTests() {
     reader.__resetForTests();
 }