@pellux/goodvibes-sdk 0.18.3 → 0.18.11

package/dist/platform/runtime/retention/policy.js

@@ -0,0 +1,259 @@
+/**
+ * policy.ts
+ *
+ * `RetentionPolicy` — tracks registered checkpoints and decides which ones
+ * must be pruned to satisfy the configured retention limits.
+ *
+ * Each retention class (`short`, `standard`, `forensic`) has independent
+ * age, count, and size ceilings. Pruning candidates are determined in the
+ * following order:
+ *
+ *  1. Age limit  — any record older than `maxAgeMs` is a candidate.
+ *  2. Count limit — oldest records beyond `maxCount` are candidates.
+ *  3. Size limit  — oldest records are candidates until total size fits.
+ *
+ * The actual file deletion is delegated to `SnapshotPruner`.
+ */
+import { SnapshotPruner } from './pruner.js';
+// ---------------------------------------------------------------------------
+// Default retention configuration
+// ---------------------------------------------------------------------------
+/**
+ * Default limits applied when no override is provided.
+ *
+ * - `short`    : 1 h  / 5 checkpoints  / 50 MB
+ * - `standard` : 24 h / 20 checkpoints / 200 MB
+ * - `forensic` : 7 d  / 100 checkpoints / 1 GB
+ */
+export const DEFAULT_RETENTION_CONFIG = {
+    short: {
+        maxAgeMs: 60 * 60 * 1000, // 1 hour
+        maxCount: 5,
+        maxSizeBytes: 50 * 1024 * 1024, // 50 MB
+    },
+    standard: {
+        maxAgeMs: 24 * 60 * 60 * 1000, // 24 hours
+        maxCount: 20,
+        maxSizeBytes: 200 * 1024 * 1024, // 200 MB
+    },
+    forensic: {
+        maxAgeMs: 7 * 24 * 60 * 60 * 1000, // 7 days
+        maxCount: 100,
+        maxSizeBytes: 1024 * 1024 * 1024, // 1 GB
+    },
+};
+// ---------------------------------------------------------------------------
+// RetentionPolicy
+// ---------------------------------------------------------------------------
+/**
+ * Manages the lifecycle of checkpoint records by enforcing per-class
+ * retention limits (age, count, size).
+ *
+ * @example
+ * ```ts
+ * const policy = new RetentionPolicy();
+ * policy.register({
+ *   id: 'cpt_01',
+ *   createdAt: Date.now(),
+ *   sizeBytes: 1024,
+ *   retentionClass: 'standard',
+ *   path: '/tmp/checkpoints/cpt_01.json',
+ * });
+ * const result = await policy.prune();
+ * ```
+ */
+export class RetentionPolicy {
+    _config;
+    _records;
+    _pruner;
+    _clock;
+    /**
+     * @param config - Optional partial override for any retention class limits.
+     *                 Unspecified classes fall back to `DEFAULT_RETENTION_CONFIG`.
+     * @param clock  - Optional clock function returning the current time in ms.
+     *                 Defaults to `Date.now`. Inject a fixed value in tests for
+     *                 deterministic time-based assertions.
+     * @param pruner - Optional pruner implementation. Defaults to `new SnapshotPruner()`.
+     *                 Inject a mock in tests to avoid file-system I/O.
+     */
+    constructor(config, clock = Date.now, pruner) {
+        const merged = {
+            short: { ...DEFAULT_RETENTION_CONFIG.short, ...config?.short },
+            standard: { ...DEFAULT_RETENTION_CONFIG.standard, ...config?.standard },
+            forensic: { ...DEFAULT_RETENTION_CONFIG.forensic, ...config?.forensic },
+        };
+        // Validate merged config values.
+        for (const cls of ['short', 'standard', 'forensic']) {
+            const c = merged[cls];
+            if (c.maxAgeMs < 0) {
+                throw new RangeError(`RetentionPolicy: ${cls}.maxAgeMs must be >= 0, got ${c.maxAgeMs}`);
+            }
+            if (c.maxCount <= 0) {
+                throw new RangeError(`RetentionPolicy: ${cls}.maxCount must be > 0, got ${c.maxCount}`);
+            }
+            if (c.maxSizeBytes < 0) {
+                throw new RangeError(`RetentionPolicy: ${cls}.maxSizeBytes must be >= 0, got ${c.maxSizeBytes}`);
+            }
+        }
+        this._config = merged;
+        this._records = new Map();
+        this._pruner = pruner ?? new SnapshotPruner();
+        this._clock = clock;
+    }
+    // -------------------------------------------------------------------------
+    // Public API
+    // -------------------------------------------------------------------------
+    /**
+     * Register a new checkpoint for retention tracking.
+     *
+     * If a record with the same `id` already exists it is silently replaced,
+     * allowing callers to update metadata (e.g. size after write).
+     *
+     * @param record - The checkpoint record to track.
+     */
+    register(record) {
+        this._records.set(record.id, record);
+    }
+    /**
+     * Unregister a checkpoint record (e.g. after it has been pruned externally).
+     *
+     * @param id - The checkpoint ID to remove from tracking.
+     * @returns `true` if the record was found and removed, `false` otherwise.
+     */
+    unregister(id) {
+        return this._records.delete(id);
+    }
+    /**
+     * Prune checkpoints that exceed retention limits.
+     *
+     * Evaluates each retention class independently and delegates file removal
+     * to `SnapshotPruner`. Successfully deleted records are removed from the
+     * internal tracking map.
+     *
+     * @param options - Optional prune options (e.g. `dryRun: true` to preview
+     *                  what would be deleted without touching the file system).
+     * @returns Aggregated `PruneResult` across all classes.
+     */
+    async prune(options) {
+        const candidates = this._collectCandidates();
+        const result = await this._pruner.delete(candidates, options);
+        // Remove successfully deleted records from tracking (skip on dry run).
+        if (!result.dryRun) {
+            for (const id of result.deletedIds) {
+                this._records.delete(id);
+            }
+        }
+        return result;
+    }
+    /**
+     * Return current retention statistics per class.
+     *
+     * Useful for surfacing storage pressure in diagnostics panels.
+     */
+    getRetainedCount() {
+        const counts = {
+            short: 0,
+            standard: 0,
+            forensic: 0,
+        };
+        const sizes = {
+            short: 0,
+            standard: 0,
+            forensic: 0,
+        };
+        for (const record of this._records.values()) {
+            counts[record.retentionClass] += 1;
+            sizes[record.retentionClass] += record.sizeBytes;
+        }
+        return {
+            counts,
+            sizes,
+            totalCount: this._records.size,
+            totalBytes: sizes.short + sizes.standard + sizes.forensic,
+        };
+    }
+    /**
+     * Return the current `RetentionConfig` in effect (defaults merged with overrides).
+     *
+     * Returns a deep clone so callers cannot mutate the internal configuration
+     * through nested object references.
+     */
+    getConfig() {
+        return {
+            short: { ...this._config.short },
+            standard: { ...this._config.standard },
+            forensic: { ...this._config.forensic },
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Private helpers
+    // -------------------------------------------------------------------------
+    /**
+     * Collect records that violate any limit for their class.
+     *
+     * Evaluation order: age → count → size.
+     * Records violating multiple limits are included once.
+     */
+    _collectCandidates() {
+        const classes = ['short', 'standard', 'forensic'];
+        const candidateSet = new Set();
+        const candidates = [];
+        for (const cls of classes) {
+            const config = this._config[cls];
+            const classRecords = this._getClassRecords(cls);
+            const clsCandidates = this._evaluateClass(classRecords, config);
+            for (const record of clsCandidates) {
+                if (!candidateSet.has(record.id)) {
+                    candidateSet.add(record.id);
+                    candidates.push(record);
+                }
+            }
+        }
+        return candidates;
+    }
+    /**
+     * Return all records for a given retention class, sorted oldest-first.
+     */
+    _getClassRecords(cls) {
+        return Array.from(this._records.values())
+            .filter((r) => r.retentionClass === cls)
+            .sort((a, b) => a.createdAt - b.createdAt);
+    }
+    /**
+     * Apply age, count, and size limits to a sorted list of class records.
+     *
+     * @param sorted  - Records sorted oldest-first.
+     * @param config  - Limits for this class.
+     * @returns Records that should be pruned.
+     */
+    _evaluateClass(sorted, config) {
+        const now = this._clock();
+        const pruneSet = new Set();
+        // 1. Age limit
+        for (const record of sorted) {
+            if (now - record.createdAt > config.maxAgeMs) {
+                pruneSet.add(record.id);
+            }
+        }
+        // 2. Count limit — retain only the newest `maxCount` records.
+        const retained = sorted.filter((r) => !pruneSet.has(r.id));
+        if (retained.length > config.maxCount) {
+            const overflow = retained.length - config.maxCount;
+            // Remove oldest first (sorted array is oldest-first).
+            for (let i = 0; i < overflow; i++) {
+                pruneSet.add(retained[i].id);
+            }
+        }
+        // 3. Size limit — trim oldest until total size fits.
+        const afterCount = retained.filter((r) => !pruneSet.has(r.id));
+        let totalSize = afterCount.reduce((sum, r) => sum + r.sizeBytes, 0);
+        for (const record of afterCount) {
+            if (totalSize <= config.maxSizeBytes) {
+                break;
+            }
+            pruneSet.add(record.id);
+            totalSize -= record.sizeBytes;
+        }
+        return sorted.filter((r) => pruneSet.has(r.id));
+    }
+}

package/dist/platform/runtime/retention/pruner.d.ts

@@ -0,0 +1,54 @@
+/**
+ * pruner.ts
+ *
+ * `SnapshotPruner` — handles safe file-system deletion of expired checkpoint
+ * artifacts on behalf of `RetentionPolicy`.
+ *
+ * Safety contract:
+ *  - The path must be a non-empty string before any I/O is attempted.
+ *  - Each deletion is attempted independently; failures do not abort others.
+ *  - Results are collected and returned as a `PruneResult` for audit.
+ */
+import type { CheckpointRecord, PruneOptions, PruneResult } from './types.js';
+/**
+ * Deletes checkpoint artifacts from the file system.
+ *
+ * Accepts an array of `CheckpointRecord` values, validates each path, and
+ * performs deletion. Results are aggregated into a single `PruneResult`.
+ *
+ * @example
+ * ```ts
+ * const pruner = new SnapshotPruner();
+ * const result = await pruner.delete(candidates);
+ * console.log(`Deleted ${result.deletedCount} checkpoints`);
+ * ```
+ */
+export declare class SnapshotPruner {
+    /**
+     * Delete the provided checkpoint records from the file system.
+     *
+     * Each record is processed independently so that a single failure does not
+     * prevent deletion of other candidates.
+     *
+     * @param candidates - Records whose artifacts should be removed.
+     * @returns `PruneResult` summarising successes and failures.
+     */
+    delete(candidates: readonly CheckpointRecord[], options?: PruneOptions): Promise<PruneResult>;
+    /**
+     * Validate that a path is safe to delete.
+     *
+     * Returns an error message string if the path is invalid, or `null` if safe.
+     *
+     * Guards:
+     *  - Path must be a non-empty string.
+     *  - Path must be absolute (prevent accidental relative-path deletions).
+     *  - Raw path must not contain `..` segments checked BEFORE normalization.
+     *    (After `path.normalize()`, traversal sequences are resolved and the `..`
+     *    check becomes dead code — e.g. `/foo/../../etc/passwd` normalizes to
+     *    `/etc/passwd` which no longer contains `..`.  We therefore inspect the
+     *    raw input first.)
+     *  - Normalized path must still be absolute as a belt-and-suspenders check.
+     */
+    private _validatePath;
+}
+//# sourceMappingURL=pruner.d.ts.map

package/dist/platform/runtime/retention/pruner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pruner.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/retention/pruner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAuB,YAAY,EAAE,WAAW,EAAkB,MAAM,YAAY,CAAC;AAOnH;;;;;;;;;;;;GAYG;AACH,qBAAa,cAAc;IACzB;;;;;;;;OAQG;IACG,MAAM,CACV,UAAU,EAAE,SAAS,gBAAgB,EAAE,EACvC,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,WAAW,CAAC;IAwEvB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,aAAa;CAwBtB"}

package/dist/platform/runtime/retention/pruner.js

@@ -0,0 +1,153 @@
+/**
+ * pruner.ts
+ *
+ * `SnapshotPruner` — handles safe file-system deletion of expired checkpoint
+ * artifacts on behalf of `RetentionPolicy`.
+ *
+ * Safety contract:
+ *  - The path must be a non-empty string before any I/O is attempted.
+ *  - Each deletion is attempted independently; failures do not abort others.
+ *  - Results are collected and returned as a `PruneResult` for audit.
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { summarizeError } from '../../utils/error-display.js';
+// ---------------------------------------------------------------------------
+// SnapshotPruner
+// ---------------------------------------------------------------------------
+/**
+ * Deletes checkpoint artifacts from the file system.
+ *
+ * Accepts an array of `CheckpointRecord` values, validates each path, and
+ * performs deletion. Results are aggregated into a single `PruneResult`.
+ *
+ * @example
+ * ```ts
+ * const pruner = new SnapshotPruner();
+ * const result = await pruner.delete(candidates);
+ * console.log(`Deleted ${result.deletedCount} checkpoints`);
+ * ```
+ */
+export class SnapshotPruner {
+    /**
+     * Delete the provided checkpoint records from the file system.
+     *
+     * Each record is processed independently so that a single failure does not
+     * prevent deletion of other candidates.
+     *
+     * @param candidates - Records whose artifacts should be removed.
+     * @returns `PruneResult` summarising successes and failures.
+     */
+    async delete(candidates, options = {}) {
+        const { dryRun = false } = options;
+        const deletedIds = [];
+        const candidateIds = [];
+        const failedIds = [];
+        const errors = {};
+        let reclaimedBytes = 0;
+        // Build per-class accumulators.
+        const byClass = {
+            short: { deletedIds: [], candidateIds: [], failedIds: [], reclaimedBytes: 0 },
+            standard: { deletedIds: [], candidateIds: [], failedIds: [], reclaimedBytes: 0 },
+            forensic: { deletedIds: [], candidateIds: [], failedIds: [], reclaimedBytes: 0 },
+        };
+        for (const record of candidates) {
+            const validationError = this._validatePath(record.path);
+            if (validationError !== null) {
+                failedIds.push(record.id);
+                errors[record.id] = validationError;
+                byClass[record.retentionClass].failedIds.push(record.id);
+                continue;
+            }
+            if (dryRun) {
+                // In dry-run mode record the candidate separately — no deletedIds populated.
+                candidateIds.push(record.id);
+                byClass[record.retentionClass].candidateIds.push(record.id);
+                continue;
+            }
+            try {
+                await fs.unlink(record.path);
+                deletedIds.push(record.id);
+                reclaimedBytes += record.sizeBytes;
+                byClass[record.retentionClass].deletedIds.push(record.id);
+                byClass[record.retentionClass].reclaimedBytes += record.sizeBytes;
+            }
+            catch (err) {
+                failedIds.push(record.id);
+                errors[record.id] = errorMessage(err);
+                byClass[record.retentionClass].failedIds.push(record.id);
+            }
+        }
+        const toPerClass = (cls) => ({
+            deletedCount: byClass[cls].deletedIds.length,
+            reclaimedBytes: byClass[cls].reclaimedBytes,
+            deletedIds: byClass[cls].deletedIds,
+            candidateIds: byClass[cls].candidateIds,
+            failedIds: byClass[cls].failedIds,
+        });
+        return {
+            deletedCount: deletedIds.length,
+            reclaimedBytes,
+            deletedIds,
+            candidateIds,
+            failedIds,
+            errors,
+            dryRun,
+            byClass: {
+                short: toPerClass('short'),
+                standard: toPerClass('standard'),
+                forensic: toPerClass('forensic'),
+            },
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Private helpers
+    // -------------------------------------------------------------------------
+    /**
+     * Validate that a path is safe to delete.
+     *
+     * Returns an error message string if the path is invalid, or `null` if safe.
+     *
+     * Guards:
+     *  - Path must be a non-empty string.
+     *  - Path must be absolute (prevent accidental relative-path deletions).
+     *  - Raw path must not contain `..` segments checked BEFORE normalization.
+     *    (After `path.normalize()`, traversal sequences are resolved and the `..`
+     *    check becomes dead code — e.g. `/foo/../../etc/passwd` normalizes to
+     *    `/etc/passwd` which no longer contains `..`.  We therefore inspect the
+     *    raw input first.)
+     *  - Normalized path must still be absolute as a belt-and-suspenders check.
+     */
+    _validatePath(filePath) {
+        if (typeof filePath !== 'string' || filePath.trim().length === 0) {
+            return 'path is empty or not a string';
+        }
+        // Check the RAW path for traversal BEFORE normalize() resolves them away.
+        // Matches `..` only when bounded by path separators or string boundaries,
+        // so legitimate names like `v1..2` are accepted.
+        if (/(?:^|[/\\])\.\.\.?(?:[/\\]|$)/.test(filePath)) {
+            return `path contains traversal segments: ${filePath}`;
+        }
+        if (!path.isAbsolute(filePath)) {
+            return `path is not absolute: ${filePath}`;
+        }
+        // Belt-and-suspenders: ensure the normalized form is still absolute.
+        const normalized = path.normalize(filePath);
+        if (!path.isAbsolute(normalized)) {
+            return `normalized path is not absolute: ${filePath}`;
+        }
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Extract a human-readable message from an unknown thrown value.
+ */
+function errorMessage(err) {
+    if (err instanceof Error) {
+        return err.message;
+    }
+    return summarizeError(err);
+}

package/dist/platform/runtime/retention/types.d.ts

@@ -0,0 +1,138 @@
+/**
+ * types.ts
+ *
+ * Core types for the snapshot retention and pruning policy subsystem.
+ *
+ * Retention classes control how long checkpoints and compaction snapshots
+ * are kept before pruning. Each class has independent age, count, and size
+ * limits that are enforced by the pruning lifecycle.
+ */
+/**
+ * Classification of a checkpoint's retention profile.
+ *
+ * - `short`    — ephemeral checkpoints; pruned aggressively (default for microcompact)
+ * - `standard` — normal session checkpoints; 24 h window (default for autocompact/collapse)
+ * - `forensic` — long-lived audit snapshots; 7-day window (crash reports, manual pins)
+ */
+export type RetentionClass = 'short' | 'standard' | 'forensic';
+/**
+ * Limits applied to a single retention class.
+ *
+ * Pruning removes checkpoints that violate ANY of the three limits.
+ */
+export interface RetentionClassConfig {
+    /** Maximum age of a checkpoint in milliseconds. Older entries are pruned. */
+    maxAgeMs: number;
+    /** Maximum number of checkpoints to retain in this class. */
+    maxCount: number;
+    /** Maximum total size (bytes) of all retained checkpoints in this class. */
+    maxSizeBytes: number;
+}
+/**
+ * Full configuration for all three retention classes.
+ *
+ * Pass a partial override to `RetentionPolicy` to tune individual limits
+ * without replacing all defaults.
+ */
+export interface RetentionConfig {
+    /** Aggressive pruning for short-lived ephemeral checkpoints. */
+    short: RetentionClassConfig;
+    /** Standard 24-hour retention for normal session checkpoints. */
+    standard: RetentionClassConfig;
+    /** Long-lived forensic/audit checkpoints kept for 7 days. */
+    forensic: RetentionClassConfig;
+}
+/**
+ * Metadata record for a single tracked checkpoint.
+ *
+ * This is the unit stored and evaluated by the retention policy. It wraps
+ * the checkpoint identity (id, timestamps) with the file-system path needed
+ * for safe deletion.
+ */
+export interface CheckpointRecord {
+    /** Unique checkpoint identifier (e.g. `cpt_<ulid>`). */
+    id: string;
+    /** Unix timestamp (ms) when the checkpoint was created. */
+    createdAt: number;
+    /** Size of the checkpoint on disk in bytes. */
+    sizeBytes: number;
+    /** Retention class this checkpoint belongs to. */
+    retentionClass: RetentionClass;
+    /** Absolute file-system path for the checkpoint artifact. */
+    path: string;
+}
+/**
+ * Options for a `SnapshotPruner.delete()` invocation.
+ */
+export interface PruneOptions {
+    /**
+     * When `true`, the pruner returns what WOULD be deleted without performing
+     * any file-system operations. Useful for previewing prune impact.
+     */
+    dryRun?: boolean;
+}
+/**
+ * Outcome of a single `SnapshotPruner.prune()` invocation.
+ */
+export interface PruneResult {
+    /** Number of checkpoints successfully deleted (0 when dryRun is true). */
+    deletedCount: number;
+    /** Total bytes reclaimed across all deleted checkpoints (0 when dryRun). */
+    reclaimedBytes: number;
+    /**
+     * IDs of checkpoints that were actually deleted.
+     * Empty when `dryRun` is true — see `candidateIds` instead.
+     */
+    deletedIds: readonly string[];
+    /**
+     * IDs of checkpoints that WOULD be deleted (dry-run mode only).
+     * Always empty when `dryRun` is false.
+     */
+    candidateIds: readonly string[];
+    /** IDs of checkpoints that failed to delete (path missing or I/O error). */
+    failedIds: readonly string[];
+    /** Errors keyed by checkpoint ID for failed deletions. */
+    errors: Readonly<Record<string, string>>;
+    /** Whether this result was produced in dry-run mode (no actual deletions). */
+    dryRun: boolean;
+    /** Per-class breakdown of deletion results. */
+    byClass: Readonly<Record<RetentionClass, PerClassPruneResult>>;
+}
+/**
+ * Per-retention-class breakdown within a `PruneResult`.
+ */
+export interface PerClassPruneResult {
+    /** Number of checkpoints deleted in this class (0 in dry-run). */
+    deletedCount: number;
+    /** Bytes reclaimed in this class (0 in dry-run). */
+    reclaimedBytes: number;
+    /** IDs of checkpoints actually deleted in this class (empty in dry-run). */
+    deletedIds: readonly string[];
+    /** IDs of checkpoints that WOULD be deleted in this class (dry-run only). */
+    candidateIds: readonly string[];
+    /** IDs that failed to delete in this class. */
+    failedIds: readonly string[];
+}
+/**
+ * Interface implemented by `SnapshotPruner` and test mocks alike.
+ *
+ * `RetentionPolicy` depends on this interface rather than the concrete class,
+ * enabling full injection in tests without touching the file system.
+ */
+export interface Pruner {
+    delete(candidates: readonly CheckpointRecord[], options?: PruneOptions): Promise<PruneResult>;
+}
+/**
+ * Per-class summary produced by `RetentionPolicy.getRetainedCount()`.
+ */
+export interface RetentionStats {
+    /** Number of retained checkpoints per class. */
+    counts: Record<RetentionClass, number>;
+    /** Total size (bytes) of retained checkpoints per class. */
+    sizes: Record<RetentionClass, number>;
+    /** Total number of retained checkpoints across all classes. */
+    totalCount: number;
+    /** Total bytes across all retained checkpoints. */
+    totalBytes: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/platform/runtime/retention/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/retention/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,UAAU,GAAG,UAAU,CAAC;AAM/D;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,gEAAgE;IAChE,KAAK,EAAE,oBAAoB,CAAC;IAC5B,iEAAiE;IACjE,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,6DAA6D;IAC7D,QAAQ,EAAE,oBAAoB,CAAC;CAChC;AAMD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,wDAAwD;IACxD,EAAE,EAAE,MAAM,CAAC;IACX,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,cAAc,EAAE,cAAc,CAAC;IAC/B,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;CACd;AAMD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,0EAA0E;IAC1E,YAAY,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,cAAc,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B;;;OAGG;IACH,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,4EAA4E;IAC5E,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,0DAA0D;IAC1D,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACzC,8EAA8E;IAC9E,MAAM,EAAE,OAAO,CAAC;IAChB,+CAA+C;IAC/C,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,cAAc,EAAE,mBAAmB,CAAC,CAAC,CAAC;CAChE;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,kEAAkE;IAClE,YAAY,EAAE,MAAM,CAAC;IACrB,oDAAoD;IACpD,cAAc,EAAE,MAAM,CAAC;IACvB,4EAA4E;IAC5E,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,6EAA6E;IAC7E,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,+CAA+C;IAC/C,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B;AAMD;;;;;GAKG;AACH,MAAM,WAAW,MAAM;IACrB,MAAM,CAAC,UAAU,EAAE,SAAS,gBAAgB,EAAE,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CAC/F;AAMD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;IACvC,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;IACtC,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/dist/platform/runtime/retention/types.js

@@ -0,0 +1,10 @@
+/**
+ * types.ts
+ *
+ * Core types for the snapshot retention and pruning policy subsystem.
+ *
+ * Retention classes control how long checkpoints and compaction snapshots
+ * are kept before pruning. Each class has independent age, count, and size
+ * limits that are enforced by the pruning lifecycle.
+ */
+export {};

package/dist/platform/runtime/sandbox/qemu-wrapper-template.d.ts

@@ -0,0 +1,2 @@
+export declare function renderQemuWrapperTemplate(): string;
+//# sourceMappingURL=qemu-wrapper-template.d.ts.map

package/dist/platform/runtime/sandbox/qemu-wrapper-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qemu-wrapper-template.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/sandbox/qemu-wrapper-template.ts"],"names":[],"mappings":"AAAA,wBAAgB,yBAAyB,IAAI,MAAM,CAsPlD"}