@guilz-dev/belay 0.8.0 → 0.9.0

package/dist/core/scrub.js

@@ -1,15 +1,34 @@
+import { StringDecoder } from 'node:string_decoder';
+const AUTHORIZATION_SCHEMES = ['bearer', 'basic', 'token'];
+const GENERIC_AUTH_HEADERS = ['X-Api-Key', 'X-Auth-Token', 'Private-Token'];
+const KEY_VALUE_SECRET_NAMES = [
+    'api_key',
+    'api-key',
+    'apikey',
+    'token',
+    'secret',
+    'password',
+    'passwd',
+    'credential',
+];
+function regexAlternation(values) {
+    return values.map((value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
+}
+const AUTHORIZATION_SCHEME_ALTERNATION = regexAlternation(AUTHORIZATION_SCHEMES);
+const GENERIC_AUTH_HEADER_ALTERNATION = regexAlternation(GENERIC_AUTH_HEADERS);
+const KEY_VALUE_SECRET_NAME_ALTERNATION = regexAlternation(KEY_VALUE_SECRET_NAMES);
 const UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/gi;
 const TIMESTAMP_PATTERN = /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z\b/g;
 const APPROVAL_ID_PATTERN = /\bbelay_[a-z0-9]{8,}\b/gi;
 const TOKEN_PREFIX_PATTERN = /\/belay-approve\s+\S+/gi;
 const BEARER_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/=-]{8,}\b/gi;
-const AUTH_HEADER_PATTERN = /(?<!["'])\bAuthorization:\s*(?:Bearer|Basic|Token)?\s*\S+/gi;
+const AUTH_HEADER_PATTERN = new RegExp(`(?<!["'])\\bAuthorization:\\s*(?:${AUTHORIZATION_SCHEME_ALTERNATION})?\\s*\\S+`, 'gi');
 const DOUBLE_QUOTED_AUTH_HEADER_PATTERN = /"Authorization:\s*[^"]*"/gi;
 const SINGLE_QUOTED_AUTH_HEADER_PATTERN = /'Authorization:\s*[^']*'/gi;
-const GENERIC_AUTH_HEADER_PATTERN = /(?<!["'])\b(?:X-Api-Key|X-Auth-Token|Private-Token):\s*\S+/gi;
-const DOUBLE_QUOTED_GENERIC_AUTH_HEADER_PATTERN = /"(X-Api-Key|X-Auth-Token|Private-Token):\s*[^"]*"/gi;
-const SINGLE_QUOTED_GENERIC_AUTH_HEADER_PATTERN = /'(X-Api-Key|X-Auth-Token|Private-Token):\s*[^']*'/gi;
-const KEY_VALUE_SECRET_PATTERN = /\b(api[_-]?key|token|secret|password|passwd|credential)\b\s*[:=]\s*['"]?[^\s'"]{4,}/gi;
+const GENERIC_AUTH_HEADER_PATTERN = new RegExp(`(?<!["'])\\b(?:${GENERIC_AUTH_HEADER_ALTERNATION}):\\s*\\S+`, 'gi');
+const DOUBLE_QUOTED_GENERIC_AUTH_HEADER_PATTERN = new RegExp(`"(${GENERIC_AUTH_HEADER_ALTERNATION}):\\s*[^"]*"`, 'gi');
+const SINGLE_QUOTED_GENERIC_AUTH_HEADER_PATTERN = new RegExp(`'(${GENERIC_AUTH_HEADER_ALTERNATION}):\\s*[^']*'`, 'gi');
+const KEY_VALUE_SECRET_PATTERN = new RegExp(`\\b(${KEY_VALUE_SECRET_NAME_ALTERNATION})\\b\\s*[:=]\\s*['"]?[^\\s'"]{4,}`, 'gi');
 const URL_CREDENTIALS_PATTERN = /\b([A-Za-z][A-Za-z0-9+.-]*:\/\/)([^/\s:@]+):([^@\s/]+)@/g;
 const MYSQL_INLINE_PASSWORD_PATTERN = /(\s-p)([^\s]+)/g;
 const HIGH_ENTROPY_PATTERN = /\b[A-Za-z0-9+/]{40,}={0,2}\b/g;
@@ -69,6 +88,481 @@ export function scrubString(value, options = {}) {
     }
     return scrubbed;
 }
+export const STREAMING_SCRUBBER_MAX_BUFFER_BYTES = 256;
+const UUID_SHAPE = [
+    ...Array(8).fill('hex'),
+    '-',
+    ...Array(4).fill('hex'),
+    '-',
+    'version',
+    ...Array(3).fill('hex'),
+    '-',
+    'variant',
+    ...Array(3).fill('hex'),
+    '-',
+    ...Array(12).fill('hex'),
+];
+const TIMESTAMP_SHAPE = [
+    'digit',
+    'digit',
+    'digit',
+    'digit',
+    '-',
+    'digit',
+    'digit',
+    '-',
+    'digit',
+    'digit',
+    'T',
+    'digit',
+    'digit',
+    ':',
+    'digit',
+    'digit',
+    ':',
+    'digit',
+    'digit',
+];
+function isWordCharacter(character) {
+    return character !== undefined && /[A-Za-z0-9_]/.test(character);
+}
+function matchesShapeCharacter(character, expected) {
+    if (expected === 'hex')
+        return /[0-9a-f]/i.test(character);
+    if (expected === 'digit')
+        return /\d/.test(character);
+    if (expected === 'version')
+        return /[1-5]/.test(character);
+    if (expected === 'variant')
+        return /[89ab]/i.test(character);
+    return character === expected;
+}
+function shapePrefixMatches(value, shape) {
+    const length = Math.min(value.length, shape.length);
+    for (let index = 0; index < length; index += 1) {
+        const character = value[index];
+        const expected = shape[index];
+        if (!character || !expected || !matchesShapeCharacter(character, expected))
+            return false;
+    }
+    return true;
+}
+function configuredMarkers(options) {
+    const markers = [];
+    if (options.maskAuthHeaders) {
+        for (const quote of ['"', "'"]) {
+            markers.push({
+                kind: 'quoted_authorization',
+                literal: `${quote}Authorization:`,
+                quote,
+            });
+            for (const header of GENERIC_AUTH_HEADERS) {
+                markers.push({
+                    kind: 'quoted_generic_header',
+                    literal: `${quote}${header}:`,
+                    quote,
+                });
+            }
+        }
+        markers.push({
+            kind: 'authorization',
+            literal: 'Authorization:',
+            requiresWordBoundary: true,
+        });
+        for (const header of GENERIC_AUTH_HEADERS) {
+            markers.push({ kind: 'generic_header', literal: `${header}:`, requiresWordBoundary: true });
+        }
+    }
+    if (options.maskBearerTokens) {
+        markers.push({ kind: 'bearer', literal: 'Bearer', requiresWordBoundary: true });
+    }
+    if (options.maskKeyValueSecrets) {
+        for (const name of KEY_VALUE_SECRET_NAMES) {
+            markers.push({ kind: 'key_name', literal: name, requiresWordBoundary: true });
+        }
+        markers.push({ kind: 'url_authority', literal: '://' });
+    }
+    if (options.maskApprovalIds) {
+        markers.push({ kind: 'approval_command', literal: '/belay-approve' }, { kind: 'approval_id', literal: 'belay_', requiresWordBoundary: true });
+    }
+    return markers;
+}
+/**
+ * Creates a deterministic scrubber for unbounded process output.
+ *
+ * Only bounded, undecided grammar prefixes are retained. Once a bounded sensitive marker is
+ * recognized, the scrubber enters a suppression state before consuming any unbounded whitespace,
+ * credential value, or URL authority. URL authorities are conservatively hidden in full because a
+ * streaming parser cannot know whether an arbitrarily long username will later be followed by a
+ * password separator without retaining it.
+ */
+export function createStreamingScrubber(options = {}) {
+    const resolved = resolvedScrubOptions(options);
+    const markers = configuredMarkers(resolved);
+    const decoder = new StringDecoder('utf8');
+    let pending = '';
+    let previousRawCharacter;
+    let state;
+    const consumeRaw = (length) => {
+        const consumed = pending.slice(0, length);
+        pending = pending.slice(length);
+        if (consumed)
+            previousRawCharacter = consumed.at(-1);
+        return consumed;
+    };
+    const markerAtStart = () => {
+        const lowerPending = pending.toLowerCase();
+        let awaiting = false;
+        for (const candidate of markers) {
+            if (candidate.requiresWordBoundary && isWordCharacter(previousRawCharacter))
+                continue;
+            const lowerLiteral = candidate.literal.toLowerCase();
+            if (lowerLiteral.startsWith(lowerPending) && pending.length < candidate.literal.length) {
+                awaiting = true;
+                continue;
+            }
+            if (lowerPending.startsWith(lowerLiteral)) {
+                return {
+                    kind: candidate.kind,
+                    length: candidate.literal.length,
+                    quote: candidate.quote,
+                };
+            }
+        }
+        if (resolved.maskKeyValueSecrets && /^\s$/.test(pending[0] ?? '')) {
+            if (pending.length === 1)
+                return 'awaiting';
+            if (pending[1] === '-' && pending.length === 2)
+                return 'awaiting';
+            if (pending[1] === '-' && pending[2]?.toLowerCase() === 'p') {
+                return { kind: 'mysql_password', length: 3 };
+            }
+        }
+        return awaiting ? 'awaiting' : undefined;
+    };
+    const uuidAtStart = (final) => {
+        if (isWordCharacter(previousRawCharacter) || !/[0-9a-f]/i.test(pending[0] ?? ''))
+            return;
+        if (!shapePrefixMatches(pending, UUID_SHAPE))
+            return;
+        if (pending.length < UUID_SHAPE.length)
+            return 'awaiting';
+        if (pending.length === UUID_SHAPE.length && !final)
+            return 'awaiting';
+        return !isWordCharacter(pending[UUID_SHAPE.length]) ? 'complete' : undefined;
+    };
+    const timestampAtStart = () => {
+        if (isWordCharacter(previousRawCharacter) || !/\d/.test(pending[0] ?? ''))
+            return;
+        if (!shapePrefixMatches(pending, TIMESTAMP_SHAPE))
+            return;
+        return pending.length < TIMESTAMP_SHAPE.length ? 'awaiting' : 'complete';
+    };
+    const highEntropyAtStart = () => {
+        if (!resolved.maskHighEntropyStrings || isWordCharacter(previousRawCharacter))
+            return;
+        if (!/[A-Za-z0-9]/.test(pending[0] ?? ''))
+            return;
+        let runLength = 0;
+        while (runLength < pending.length && /[A-Za-z0-9+/]/.test(pending[runLength] ?? '')) {
+            runLength += 1;
+        }
+        if (runLength >= 40)
+            return 'complete';
+        return runLength === pending.length ? 'awaiting' : undefined;
+    };
+    const drain = (final) => {
+        let output = '';
+        while (pending) {
+            if (state?.kind === 'quoted_value') {
+                const end = pending.indexOf(state.quote);
+                if (end < 0) {
+                    consumeRaw(pending.length);
+                    break;
+                }
+                consumeRaw(end);
+                output += consumeRaw(1);
+                state = undefined;
+                continue;
+            }
+            if (state?.kind === 'key_separator') {
+                const character = pending[0] ?? '';
+                if (/\s/.test(character)) {
+                    output += consumeRaw(1);
+                    continue;
+                }
+                if (character === ':' || character === '=') {
+                    output += `${consumeRaw(1)}<redacted>`;
+                    state = { kind: 'key_value', phase: 'leading' };
+                    continue;
+                }
+                state = undefined;
+                continue;
+            }
+            if (state?.kind === 'bearer_wait' || state?.kind === 'approval_wait') {
+                const character = pending[0] ?? '';
+                if (/\s/.test(character)) {
+                    consumeRaw(1);
+                    output += state.kind === 'bearer_wait' ? ' <redacted>' : ' <approval-id>';
+                    state =
+                        state.kind === 'bearer_wait'
+                            ? { kind: 'bearer_value', phase: 'leading' }
+                            : { kind: 'non_whitespace_value', phase: 'leading' };
+                    continue;
+                }
+                state = undefined;
+                continue;
+            }
+            if (state?.kind === 'key_value') {
+                const character = pending[0] ?? '';
+                if (state.phase === 'leading') {
+                    if (/\s/.test(character)) {
+                        consumeRaw(1);
+                        continue;
+                    }
+                    if (character === '"' || character === "'") {
+                        output += consumeRaw(1);
+                        state = { kind: 'quoted_value', quote: character };
+                        continue;
+                    }
+                    state = { kind: 'key_value', phase: 'unquoted' };
+                    continue;
+                }
+                if (/[\s'"]/.test(character)) {
+                    output += consumeRaw(1);
+                    state = undefined;
+                    continue;
+                }
+                consumeRaw(1);
+                continue;
+            }
+            if (state?.kind === 'non_whitespace_value') {
+                const character = pending[0] ?? '';
+                if (state.phase === 'leading') {
+                    if (/\s/.test(character)) {
+                        consumeRaw(1);
+                        continue;
+                    }
+                    state = { kind: 'non_whitespace_value', phase: 'value' };
+                    continue;
+                }
+                if (/\s/.test(character)) {
+                    output += consumeRaw(1);
+                    state = undefined;
+                    continue;
+                }
+                consumeRaw(1);
+                continue;
+            }
+            if (state?.kind === 'bearer_value') {
+                const character = pending[0] ?? '';
+                if (state.phase === 'leading') {
+                    if (/\s/.test(character)) {
+                        consumeRaw(1);
+                        continue;
+                    }
+                    if (!/[A-Za-z0-9._~+/=-]/.test(character)) {
+                        state = undefined;
+                        continue;
+                    }
+                    state = { kind: 'bearer_value', phase: 'value' };
+                    continue;
+                }
+                if (!/[A-Za-z0-9._~+/=-]/.test(character)) {
+                    state = undefined;
+                    continue;
+                }
+                consumeRaw(1);
+                continue;
+            }
+            if (state?.kind === 'authorization_value') {
+                const character = pending[0] ?? '';
+                if (state.phase === 'leading' || state.phase === 'after_scheme') {
+                    if (/\s/.test(character)) {
+                        consumeRaw(1);
+                        continue;
+                    }
+                    state =
+                        state.phase === 'leading'
+                            ? { kind: 'authorization_value', phase: 'first_word', firstWord: '' }
+                            : { kind: 'authorization_value', phase: 'credential', firstWord: '' };
+                    continue;
+                }
+                if (state.phase === 'first_word') {
+                    if (/\s/.test(character)) {
+                        const isScheme = AUTHORIZATION_SCHEMES.includes(state.firstWord.toLowerCase());
+                        consumeRaw(1);
+                        if (isScheme) {
+                            state = { kind: 'authorization_value', phase: 'after_scheme', firstWord: '' };
+                        }
+                        else {
+                            output += character;
+                            state = undefined;
+                        }
+                        continue;
+                    }
+                    const firstWord = `${state.firstWord}${character}`.slice(0, 7);
+                    consumeRaw(1);
+                    const couldBeScheme = AUTHORIZATION_SCHEMES.some((scheme) => scheme.startsWith(firstWord.toLowerCase()));
+                    state = couldBeScheme
+                        ? { kind: 'authorization_value', phase: 'first_word', firstWord }
+                        : { kind: 'authorization_value', phase: 'credential', firstWord: '' };
+                    continue;
+                }
+                if (/\s/.test(character)) {
+                    output += consumeRaw(1);
+                    state = undefined;
+                    continue;
+                }
+                consumeRaw(1);
+                continue;
+            }
+            if (state?.kind === 'approval_id_value') {
+                const character = pending[0] ?? '';
+                if (/[A-Za-z0-9]/.test(character)) {
+                    consumeRaw(1);
+                    continue;
+                }
+                state = undefined;
+                continue;
+            }
+            if (state?.kind === 'url_authority') {
+                const character = pending[0] ?? '';
+                if (/[\s/]/.test(character)) {
+                    state = undefined;
+                    continue;
+                }
+                consumeRaw(1);
+                continue;
+            }
+            if (state?.kind === 'timestamp_suffix') {
+                const character = pending[0] ?? '';
+                if (character === 'Z') {
+                    consumeRaw(1);
+                    state = undefined;
+                    continue;
+                }
+                if (character === '.') {
+                    consumeRaw(1);
+                    state = { kind: 'timestamp_fraction' };
+                    continue;
+                }
+                state = undefined;
+                continue;
+            }
+            if (state?.kind === 'timestamp_fraction') {
+                const character = pending[0] ?? '';
+                if (/\d/.test(character)) {
+                    consumeRaw(1);
+                    continue;
+                }
+                if (character === 'Z')
+                    consumeRaw(1);
+                state = undefined;
+                continue;
+            }
+            if (state?.kind === 'high_entropy_value') {
+                const character = pending[0] ?? '';
+                if (/[A-Za-z0-9+/=]/.test(character)) {
+                    consumeRaw(1);
+                    continue;
+                }
+                state = undefined;
+                continue;
+            }
+            // Resolve the bounded high-entropy candidate before literal key names. Otherwise a token
+            // beginning with e.g. "token" could be mistaken for a failed key/value prefix and emitted.
+            const entropy = highEntropyAtStart();
+            if (entropy === 'awaiting' && !final)
+                break;
+            if (entropy === 'complete') {
+                consumeRaw(40);
+                output += '<high-entropy>';
+                state = { kind: 'high_entropy_value' };
+                continue;
+            }
+            const marker = markerAtStart();
+            if (marker === 'awaiting' && !final)
+                break;
+            if (marker && marker !== 'awaiting') {
+                const rawMarker = consumeRaw(marker.length);
+                switch (marker.kind) {
+                    case 'quoted_authorization':
+                    case 'quoted_generic_header':
+                        output += `${rawMarker} <redacted>`;
+                        state = { kind: 'quoted_value', quote: marker.quote ?? '"' };
+                        break;
+                    case 'authorization':
+                        output += `${rawMarker} <redacted>`;
+                        state = { kind: 'authorization_value', phase: 'leading', firstWord: '' };
+                        break;
+                    case 'generic_header':
+                        output += `${rawMarker} <redacted>`;
+                        state = { kind: 'non_whitespace_value', phase: 'leading' };
+                        break;
+                    case 'key_name':
+                        output += rawMarker;
+                        state = { kind: 'key_separator' };
+                        break;
+                    case 'bearer':
+                        output += rawMarker;
+                        state = { kind: 'bearer_wait' };
+                        break;
+                    case 'approval_command':
+                        output += rawMarker;
+                        state = { kind: 'approval_wait' };
+                        break;
+                    case 'approval_id':
+                        output += '<approval-id>';
+                        state = { kind: 'approval_id_value' };
+                        break;
+                    case 'mysql_password':
+                        output += `${rawMarker}<redacted>`;
+                        state = { kind: 'non_whitespace_value', phase: 'value' };
+                        break;
+                    case 'url_authority':
+                        output += `${rawMarker}<redacted>`;
+                        state = { kind: 'url_authority' };
+                        break;
+                }
+                continue;
+            }
+            const uuid = uuidAtStart(final);
+            if (uuid === 'awaiting' && !final)
+                break;
+            if (uuid === 'complete') {
+                consumeRaw(UUID_SHAPE.length);
+                output += '<uuid>';
+                continue;
+            }
+            const timestamp = timestampAtStart();
+            if (timestamp === 'awaiting' && !final)
+                break;
+            if (timestamp === 'complete') {
+                consumeRaw(TIMESTAMP_SHAPE.length);
+                output += '<timestamp>';
+                state = { kind: 'timestamp_suffix' };
+                continue;
+            }
+            output += consumeRaw(1);
+        }
+        return output;
+    };
+    return {
+        get bufferedBytes() {
+            return Buffer.byteLength(pending);
+        },
+        write(chunk) {
+            const bytes = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+            pending += decoder.write(bytes);
+            return drain(false);
+        },
+        end() {
+            pending += decoder.end();
+            return drain(true);
+        },
+    };
+}
 export function scrubValue(value, options = DEFAULT_SCRUB_OPTIONS) {
     if (typeof value === 'string') {
         return scrubString(value, options);

package/dist/core/standing-allow.d.ts

@@ -1,6 +1,5 @@
 import type { BelayConfigV4 } from './config.js';
 import type { GatedActionKind } from './gate-contract.js';
-import type { ClassifyResult } from './types.js';
 export type StandingAllowSource = 'operator' | 'availability-reconfirmed';
 export interface StandingAllowEntry {
     kind: GatedActionKind;
@@ -16,29 +15,10 @@ export interface StandingAllowFile {
     version: 1;
     entries: StandingAllowEntry[];
 }
-export interface StandingAllowMatch {
-    source: StandingAllowSource;
-    entryId?: string;
-}
-/** Default TTL for operator / availability-reconfirmed standing-allow entries. */
-export declare const DEFAULT_STANDING_ALLOW_TTL_MS: number;
 export declare function standingAllowFile(config: BelayConfigV4, repoLocalStateDir: string): string;
-export declare function isTier0StandingAllowBlocked(result: ClassifyResult): boolean;
 export declare function compactStandingAllow(state: StandingAllowFile, now?: number): StandingAllowFile;
 export declare function loadStandingAllow(filePath: string): Promise<StandingAllowFile>;
 export declare function saveStandingAllow(filePath: string, state: StandingAllowFile): Promise<void>;
-export declare function resolveStandingAllowMatch(params: {
-    kind: GatedActionKind;
-    result: ClassifyResult;
-    repoRoot: string;
-    state: StandingAllowFile;
-    now?: number;
-}): StandingAllowMatch | null;
-export declare function addStandingAllowEntry(state: StandingAllowFile, entry: Omit<StandingAllowEntry, 'createdAt' | 'expiresAt'> & {
-    createdAt?: string;
-    expiresAt?: string;
-    ttlMs?: number;
-}): StandingAllowFile;
 export declare function revokeStandingAllowEntry(state: StandingAllowFile, params: {
     kind: GatedActionKind;
     fingerprint: string;

package/dist/core/standing-allow.js

@@ -6,29 +6,9 @@ const EMPTY_STANDING_ALLOW = {
     version: 1,
     entries: [],
 };
-/** Default TTL for operator / availability-reconfirmed standing-allow entries. */
-export const DEFAULT_STANDING_ALLOW_TTL_MS = 30 * 24 * 60 * 60 * 1000;
-/** Reasons that must never be silenced via standing-allow (defense in depth with signal checks). */
-const STANDING_ALLOW_BLOCKED_REASONS = new Set([
-    'external_effect',
-    'tier1_catastrophic',
-    'protected_artifact',
-    'pipe_to_shell',
-    'command_substitution',
-    'outside_repo_mutation',
-    'outside_repo_redirect',
-    'control_plane_mutation',
-]);
 export function standingAllowFile(config, repoLocalStateDir) {
     return `${belayStateDir(config, repoLocalStateDir)}/standing-allow.json`;
 }
-export function isTier0StandingAllowBlocked(result) {
-    if (result.reason.startsWith('tier0_') || STANDING_ALLOW_BLOCKED_REASONS.has(result.reason)) {
-        return true;
-    }
-    const signals = result.assessment?.signals ?? [];
-    return signals.some((signal) => signal === 'tier0_external' || signal === 'tier1_catastrophic');
-}
 function isExpired(iso, now = Date.now()) {
     const parsed = Date.parse(iso);
     return Number.isNaN(parsed) || parsed <= now;
@@ -92,57 +72,6 @@ export async function saveStandingAllow(filePath, state) {
     const compacted = compactStandingAllow(state);
     await writeFile(filePath, `${JSON.stringify(compacted, null, 2)}\n`, 'utf8');
 }
-function matchStateEntry(params) {
-    const now = params.now ?? Date.now();
-    const match = params.state.entries.find((entry) => entry.kind === params.kind &&
-        entry.fingerprint === params.fingerprint &&
-        !isExpired(entry.expiresAt, now) &&
-        (entry.repoRoot === undefined || entry.repoRoot === params.repoRoot));
-    if (!match) {
-        return null;
-    }
-    return { source: match.source, entryId: match.fingerprint };
-}
-export function resolveStandingAllowMatch(params) {
-    if (params.kind === 'shell') {
-        return null;
-    }
-    if (params.result.verdict !== 'deny_pending_approval') {
-        return null;
-    }
-    if (isTier0StandingAllowBlocked(params.result)) {
-        return null;
-    }
-    return matchStateEntry({
-        kind: params.kind,
-        fingerprint: params.result.fingerprint,
-        repoRoot: params.repoRoot,
-        state: params.state,
-        now: params.now,
-    });
-}
-export function addStandingAllowEntry(state, entry) {
-    const createdAt = entry.createdAt ?? new Date().toISOString();
-    const ttlMs = entry.ttlMs ?? DEFAULT_STANDING_ALLOW_TTL_MS;
-    const expiresAt = entry.expiresAt ?? new Date(Date.parse(createdAt) + ttlMs).toISOString();
-    const next = {
-        kind: entry.kind,
-        fingerprint: entry.fingerprint,
-        source: entry.source,
-        reason: entry.reason,
-        createdAt,
-        expiresAt,
-        ...(entry.summary ? { summary: entry.summary } : {}),
-        ...(entry.repoRoot ? { repoRoot: entry.repoRoot } : {}),
-    };
-    const filtered = state.entries.filter((existing) => !(existing.kind === next.kind &&
-        existing.fingerprint === next.fingerprint &&
-        existing.repoRoot === next.repoRoot));
-    return compactStandingAllow({
-        version: 1,
-        entries: [...filtered, next],
-    });
-}
 export function revokeStandingAllowEntry(state, params) {
     const before = state.entries.length;
     const entries = state.entries.filter((entry) => {

package/dist/core/transactional/apply-observed-changes.d.ts

@@ -7,6 +7,7 @@ export interface ApplyObservedChangesParams {
     sourceRoot: string;
     targetRoot: string;
     changes: ObservedFileChange[];
+    beforeMutation?: () => Promise<void>;
     afterApply?: () => Promise<void>;
 }
 export declare function applyObservedChanges(params: ApplyObservedChangesParams): Promise<void>;

package/dist/core/transactional/apply-observed-changes.js

@@ -201,6 +201,7 @@ export async function applyObservedChanges(params) {
     const backupRoot = await mkdtemp(path.join(os.tmpdir(), 'belay-tx-rollback-'));
     const rollbackActions = [];
     let mutationAttempted = false;
+    let resourceIdentityChanged = false;
     try {
         for (const change of sortedChanges(changes)) {
             const target = joinRelativePath(targetRoot, change.relativePath);
@@ -232,6 +233,13 @@ export async function applyObservedChanges(params) {
                 await assertParentChainSafe(targetRoot, change.relativePath);
                 rollbackActions.push({ type: 'remove', target, relativePath: change.relativePath });
             }
+            try {
+                await params.beforeMutation?.();
+            }
+            catch (error) {
+                resourceIdentityChanged = true;
+                throw error;
+            }
             mutationAttempted = true;
             await applySingleChange(sourceRoot, targetRoot, change);
         }
@@ -248,6 +256,9 @@ export async function applyObservedChanges(params) {
     catch (error) {
         if (!mutationAttempted)
             throw error;
+        if (resourceIdentityChanged) {
+            throw new Error(TRANSACTIONAL_APPLY_ROLLBACK_FAILED, { cause: error });
+        }
         const rollbackOk = await rollbackAppliedChanges(rollbackActions, changes, targetRoot, backupRoot);
         if (!rollbackOk) {
             throw new Error(TRANSACTIONAL_APPLY_ROLLBACK_FAILED);