@rpamis/comet 0.4.0-beta.7 → 0.4.0-beta.9

package/dist/domains/comet-native/native-snapshot.js

@@ -3,7 +3,9 @@ import { spawn } from 'node:child_process';
 import { promises as fs } from 'fs';
 import path from 'path';
 import { atomicWriteJson } from './native-atomic-file.js';
+import { DEFAULT_NATIVE_SNAPSHOT_CONFIG, normalizeNativeSnapshotPattern, readProjectConfig, } from './native-config.js';
 import { sha256Text } from './native-hash.js';
+import { hasComparableNativeFileObject, sameNativeFileObject } from './native-file-identity.js';
 import { isInsidePath, resolveContainedNativePath } from './native-paths.js';
 import { readNativeProtectedTextFile } from './native-protected-file.js';
 import { nativeSensitiveRelativePathReason } from './native-sensitive-paths.js';
@@ -27,8 +29,16 @@ const MANIFEST_KEYS = new Set([
     'omitted',
     'omittedCount',
     'omissionOverflow',
+    'policy',
 ]);
-const LIMIT_KEYS = new Set(['maxFiles', 'maxFileBytes', 'maxTotalBytes', 'maxManifestBytes']);
+const LIMIT_KEYS = new Set([
+    'maxFiles',
+    'maxFileBytes',
+    'maxTotalBytes',
+    'maxManifestBytes',
+    'maxDurationMs',
+]);
+const POLICY_KEYS = new Set(['schema', 'include', 'exclude', 'hash']);
 const CAPTURE_KEYS = new Set(['provider', 'gitSelection', 'physicalSelection', 'projection']);
 const GIT_PROJECTION_KEYS = new Set(['provider', 'selection']);
 const GIT_SELECTION_KEYS = new Set([
@@ -1026,6 +1036,157 @@ function isChangedDuringReadError(error) {
 function serializedManifestBytes(manifest) {
     return Buffer.byteLength(JSON.stringify(manifest, null, 2) + '\n');
 }
+function snapshotPolicyHash(include, exclude) {
+    return sha256Text(`comet.native.snapshot-policy.v1\n${JSON.stringify({ include, exclude, hash: 'sha256' })}`);
+}
+function epsilonClosure(tokens, positions, checkpoint) {
+    const closure = new Set(positions);
+    const pending = [...positions];
+    while (pending.length > 0) {
+        if (checkpoint && !checkpoint())
+            return null;
+        const position = pending.pop();
+        const token = tokens[position];
+        if (token &&
+            (token.kind === 'star' || token.kind === 'globstar' || token.kind === 'globstar-slash') &&
+            !closure.has(position + 1)) {
+            closure.add(position + 1);
+            pending.push(position + 1);
+        }
+    }
+    return closure;
+}
+function cooperativePatternCheckpoint(hasBudget) {
+    let operationsUntilCheck = 0;
+    return () => {
+        if (operationsUntilCheck > 0) {
+            operationsUntilCheck -= 1;
+            return true;
+        }
+        if (!hasBudget())
+            return false;
+        operationsUntilCheck = 63;
+        return true;
+    };
+}
+export function compileNativeSnapshotPattern(pattern) {
+    const normalized = normalizeNativeSnapshotPattern(pattern, 'Native snapshot pattern');
+    const tokens = [];
+    for (let index = 0; index < normalized.length; index += 1) {
+        const character = normalized[index];
+        if (character === '*' && normalized[index + 1] === '*') {
+            index += 1;
+            if (normalized[index + 1] === '/') {
+                index += 1;
+                tokens.push({ kind: 'globstar-slash' });
+            }
+            else {
+                tokens.push({ kind: 'globstar' });
+            }
+        }
+        else if (character === '*') {
+            tokens.push({ kind: 'star' });
+        }
+        else if (character === '?') {
+            tokens.push({ kind: 'question' });
+        }
+        else {
+            tokens.push({ kind: 'literal', value: character });
+        }
+    }
+    return (relative, hasBudget) => {
+        const checkpoint = hasBudget ? cooperativePatternCheckpoint(hasBudget) : undefined;
+        if (checkpoint && !checkpoint())
+            return false;
+        let positions = epsilonClosure(tokens, new Set([0]), checkpoint);
+        if (positions === null)
+            return false;
+        for (const character of relative) {
+            if (checkpoint && !checkpoint())
+                return false;
+            const next = new Set();
+            for (const position of positions) {
+                if (checkpoint && !checkpoint())
+                    return false;
+                const token = tokens[position];
+                if (!token)
+                    continue;
+                if (token.kind === 'literal' && token.value === character) {
+                    next.add(position + 1);
+                }
+                else if (token.kind === 'question' && character !== '/') {
+                    next.add(position + 1);
+                }
+                else if (token.kind === 'star' && character !== '/') {
+                    next.add(position);
+                }
+                else if (token.kind === 'globstar') {
+                    next.add(position);
+                }
+                else if (token.kind === 'globstar-slash') {
+                    next.add(position);
+                    if (character === '/')
+                        next.add(position + 1);
+                }
+            }
+            positions = epsilonClosure(tokens, next, checkpoint);
+            if (positions === null)
+                return false;
+            if (positions.size === 0)
+                return false;
+        }
+        return epsilonClosure(tokens, positions, checkpoint)?.has(tokens.length) ?? false;
+    };
+}
+function resolveSnapshotPolicy(value) {
+    if (value === undefined)
+        return undefined;
+    const include = [
+        ...new Set(value.include.map((item) => normalizeNativeSnapshotPattern(item, 'include'))),
+    ].sort((left, right) => left.localeCompare(right, 'en'));
+    const exclude = [
+        ...new Set(value.exclude.map((item) => normalizeNativeSnapshotPattern(item, 'exclude'))),
+    ].sort((left, right) => left.localeCompare(right, 'en'));
+    if (include.length === 0)
+        throw new Error('Native snapshot policy include must not be empty');
+    const hash = snapshotPolicyHash(include, exclude);
+    if ('hash' in value && value.hash !== hash) {
+        throw new Error('Native snapshot policy hash is invalid');
+    }
+    return {
+        manifest: {
+            schema: 'comet.native.snapshot-policy.v1',
+            include,
+            exclude,
+            hash,
+        },
+        includeMatchers: include.map(compileNativeSnapshotPattern),
+        excludeMatchers: exclude.map(compileNativeSnapshotPattern),
+    };
+}
+function snapshotPolicyIncludes(policy, relative, execution) {
+    if (!policy)
+        return true;
+    const hasBudget = () => nativeSnapshotExecutionHasBudget(execution);
+    let included = false;
+    for (const matcher of policy.includeMatchers) {
+        if (!hasBudget())
+            return false;
+        if (matcher(relative, hasBudget)) {
+            included = true;
+            break;
+        }
+    }
+    if (!included)
+        return false;
+    for (const matcher of policy.excludeMatchers) {
+        if (!hasBudget())
+            return false;
+        if (matcher(relative, hasBudget))
+            return false;
+    }
+    return true;
+}
 function foldSnapshotOverflowHash(previous, kind, value) {
     const payload = JSON.stringify(value);
     return sha256Text(`${previous}\n${Buffer.byteLength(kind)}:${kind}\n${Buffer.byteLength(payload)}:${payload}`);
@@ -1047,10 +1208,13 @@ function takeLastCompactableOmission(omissions) {
     return null;
 }
 function sameFileIdentity(left, right) {
-    if (left.dev !== 0 || left.ino !== 0 || right.dev !== 0 || right.ino !== 0) {
-        return left.dev === right.dev && left.ino === right.ino;
+    const leftObject = { ...left, birthtime: left.birthtimeMs };
+    const rightObject = { ...right, birthtime: right.birthtimeMs };
+    if (hasComparableNativeFileObject(leftObject, rightObject)) {
+        return sameNativeFileObject(leftObject, rightObject);
     }
-    return (left.birthtimeMs === right.birthtimeMs &&
+    return (sameNativeFileObject(leftObject, rightObject) &&
+        left.birthtimeMs === right.birthtimeMs &&
         left.ctimeMs === right.ctimeMs &&
         left.size === right.size);
 }
@@ -1399,7 +1563,29 @@ export function parseNativeContentSnapshotManifest(value) {
         maxFileBytes: positiveInteger(limitValue.maxFileBytes, 'Native snapshot maxFileBytes'),
         maxTotalBytes: positiveInteger(limitValue.maxTotalBytes, 'Native snapshot maxTotalBytes'),
         maxManifestBytes: positiveInteger(limitValue.maxManifestBytes, 'Native snapshot maxManifestBytes'),
+        ...(limitValue.maxDurationMs === undefined
+            ? {}
+            : {
+                maxDurationMs: positiveInteger(limitValue.maxDurationMs, 'Native snapshot maxDurationMs'),
+            }),
     };
+    let policy;
+    if (manifest.policy !== undefined) {
+        const policyValue = record(manifest.policy, 'Native snapshot policy');
+        rejectUnknown(policyValue, POLICY_KEYS, 'Native snapshot policy');
+        if (policyValue.schema !== 'comet.native.snapshot-policy.v1') {
+            throw new Error('Native snapshot policy schema is invalid');
+        }
+        if (!Array.isArray(policyValue.include) || !Array.isArray(policyValue.exclude)) {
+            throw new Error('Native snapshot policy patterns must be arrays');
+        }
+        policy = resolveSnapshotPolicy({
+            include: policyValue.include,
+            exclude: policyValue.exclude,
+            hash: policyValue.hash,
+            schema: 'comet.native.snapshot-policy.v1',
+        }).manifest;
+    }
     if (!Array.isArray(manifest.entries) || !Array.isArray(manifest.omitted)) {
         throw new Error('Native content snapshot entries and omissions must be arrays');
     }
@@ -1476,6 +1662,7 @@ export function parseNativeContentSnapshotManifest(value) {
         createdAt: manifest.createdAt,
         complete: manifest.complete,
         limits,
+        ...(policy ? { policy } : {}),
         entries,
         omitted,
         omittedCount,
@@ -1615,13 +1802,20 @@ export function nativeBaselineManifestFile(paths, name) {
     return path.join(changeDir, 'runtime', 'baseline-manifest.json');
 }
 export async function createNativeContentSnapshot(paths, options = {}) {
-    const execution = createNativeSnapshotExecution(options);
     const limits = {
         maxFiles: options.limits?.maxFiles ?? DEFAULT_NATIVE_SNAPSHOT_LIMITS.maxFiles,
         maxFileBytes: options.limits?.maxFileBytes ?? DEFAULT_NATIVE_SNAPSHOT_LIMITS.maxFileBytes,
         maxTotalBytes: options.limits?.maxTotalBytes ?? DEFAULT_NATIVE_SNAPSHOT_LIMITS.maxTotalBytes,
         maxManifestBytes: options.limits?.maxManifestBytes ?? DEFAULT_NATIVE_SNAPSHOT_LIMITS.maxManifestBytes,
+        ...(options.limits?.maxDurationMs === undefined
+            ? {}
+            : { maxDurationMs: options.limits.maxDurationMs }),
     };
+    const policy = resolveSnapshotPolicy(options.policy);
+    const execution = createNativeSnapshotExecution({
+        ...options,
+        deadlineMs: options.deadlineMs ?? limits.maxDurationMs,
+    });
     const gitSelectionLimits = resolveNativeGitSelectionLimits(options.gitSelectionLimits);
     const physicalSelectionLimits = resolveNativePhysicalSelectionLimits(options.physicalSelectionLimits);
     if (limits.maxFiles < 1 ||
@@ -2049,6 +2243,10 @@ export async function createNativeContentSnapshot(paths, options = {}) {
                 continue;
             if (remainingNativeSnapshotTime(execution) < 1)
                 break;
+            if (!snapshotPolicyIncludes(policy, record.path, execution))
+                continue;
+            if (remainingNativeSnapshotTime(execution) < 1)
+                break;
             const target = path.resolve(projectRoot, ...record.path.split('/'));
             let stat;
             try {
@@ -2112,6 +2310,12 @@ export async function createNativeContentSnapshot(paths, options = {}) {
         for (const relative of selectionPaths(gitSelection)) {
             if (!isSnapshotProjectRef(paths, relative))
                 continue;
+            if (remainingNativeSnapshotTime(execution) < 1)
+                break;
+            if (!snapshotPolicyIncludes(policy, relative, execution))
+                continue;
+            if (remainingNativeSnapshotTime(execution) < 1)
+                break;
             const target = path.resolve(projectRoot, ...relative.split('/'));
             if (target === configFile ||
                 target === selectionFile ||
@@ -2243,6 +2447,7 @@ export async function createNativeContentSnapshot(paths, options = {}) {
         createdAt: (options.now ?? new Date()).toISOString(),
         complete: omittedCount === 0,
         limits,
+        ...(policy ? { policy: policy.manifest } : {}),
         entries,
         omitted,
         omittedCount,
@@ -2282,6 +2487,21 @@ export async function createNativeContentSnapshot(paths, options = {}) {
     }
     return manifest;
 }
+export async function createNativeCurrentContentSnapshot(paths, baseline, options = {}) {
+    const config = await readProjectConfig(paths.projectRoot);
+    const settings = config?.native.snapshot ?? DEFAULT_NATIVE_SNAPSHOT_CONFIG;
+    return createNativeContentSnapshot(paths, {
+        ...options,
+        policy: baseline.policy,
+        limits: {
+            maxFiles: settings.max_files,
+            maxFileBytes: settings.max_total_bytes,
+            maxTotalBytes: settings.max_total_bytes,
+            maxDurationMs: settings.max_duration_ms,
+        },
+        deadlineMs: settings.max_duration_ms,
+    });
+}
 export async function writeNativeBaselineManifest(paths, name, manifest) {
     const file = nativeBaselineManifestFile(paths, name);
     await resolveContainedNativePath(paths.nativeRoot, file);