@deftai/directive-core 0.95.0 → 0.97.0

package/dist/cache/archive.js

@@ -0,0 +1,636 @@
+/**
+ * Reversible archive for closed github-issue cache entries (#1137).
+ *
+ * Distinct from `cachePrune` (TTL / expires_at hard-delete). This module moves
+ * closed-and-aged live entries under `.deft-cache/archived/github-issue/...`
+ * with `archive-meta.json`, and can list/restore them. Operator-invoked only;
+ * never wired into check / session-start / sync.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { assertProjectionContained, ProjectionContainmentError, } from "../fs/projection-containment.js";
+import { hasArtifactSuffix, resolveLifecycleRoot } from "../layout/resolve.js";
+import { issueNumbersFromPlan } from "../triage/queue/scope-walk.js";
+import { DEFAULT_PRUNE_OLDER_THAN_DAYS, GH_KEY_RE, REPO_RE } from "./constants.js";
+import { CacheError } from "./errors.js";
+import { appendAudit, atomicWriteText } from "./io.js";
+import { entryDir, validateKey } from "./paths.js";
+import { parseIso, systemClock, utcIso } from "./time.js";
+export { ProjectionContainmentError as CacheArchiveContainmentError };
+/** Archive age default matches TTL prune window but is a separate concept (#1137). */
+export const DEFAULT_ARCHIVE_OLDER_THAN_DAYS = DEFAULT_PRUNE_OLDER_THAN_DAYS;
+export const ARCHIVE_SOURCE_GITHUB_ISSUE = "github-issue";
+export const ARCHIVED_ROOT_SEGMENT = "archived";
+export const ARCHIVE_META_FILENAME = "archive-meta.json";
+const OPEN_LIFECYCLE_FOLDERS = ["proposed", "pending", "active"];
+const TERMINAL_DECISIONS = new Set(["reject", "mark-duplicate"]);
+function assertWritableCachePath(cacheRoot, ...segments) {
+    const cacheAbs = resolve(cacheRoot);
+    const projectDir = dirname(cacheAbs);
+    const target = segments.length > 0 ? join(cacheAbs, ...segments) : cacheAbs;
+    assertProjectionContained(projectDir, target);
+    return target;
+}
+/** Live entry dir for a github-issue key. */
+export function liveEntryDir(source, key, cacheRoot) {
+    return entryDir(source, key, cacheRoot);
+}
+/** Archived entry dir: `.deft-cache/archived/<source>/<owner>/<repo>/<N>/`. */
+export function archivedEntryDir(source, key, cacheRoot) {
+    if (source !== ARCHIVE_SOURCE_GITHUB_ISSUE) {
+        throw new CacheError(`archive source '${source}' not supported in v1 (supports: ${ARCHIVE_SOURCE_GITHUB_ISSUE} only)`);
+    }
+    validateKey(source, key);
+    return join(cacheRoot, ARCHIVED_ROOT_SEGMENT, source, ...key.split("/"));
+}
+function loadPlan(path) {
+    try {
+        const data = JSON.parse(readFileSync(path, { encoding: "utf8" }));
+        if (typeof data !== "object" || data === null)
+            return null;
+        const plan = data.plan;
+        return typeof plan === "object" && plan !== null ? plan : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Parse github issue URI → `{repo: owner/name, number}` when possible. */
+function issueRefFromUri(uri) {
+    const cleaned = uri.replace(/\/+$/, "");
+    // Accept github.com and www.github.com (case-insensitive host).
+    // Digits may include leading zeros (rare URL forms); Number() normalizes.
+    const m = /(?:https?:\/\/)?(?:www\.)?github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)$/i.exec(cleaned);
+    if (m) {
+        // Lowercase owner/repo so protection matches case-folded cache keys (#1137 review).
+        // Leading zeros normalize via Number(); reject 0 / non-positive.
+        const num = Number(m[3]);
+        if (!(num >= 1))
+            return null;
+        return {
+            repo: `${(m[1] ?? "").toLowerCase()}/${(m[2] ?? "").toLowerCase()}`,
+            number: num,
+        };
+    }
+    const slash = cleaned.lastIndexOf("/");
+    const tail = slash >= 0 ? cleaned.slice(slash + 1) : cleaned;
+    if (/^[1-9]\d*$/.test(tail)) {
+        return { repo: "", number: Number(tail) };
+    }
+    return null;
+}
+/**
+ * Open-lifecycle protection set: preferred keys are `owner/repo#N`.
+ * Bare `#N` keys are also recorded when the plan URI has no repo (conservative).
+ */
+export function openLifecycleReferencedKeys(projectRoot) {
+    const out = new Set();
+    let base;
+    try {
+        base = resolveLifecycleRoot(projectRoot);
+    }
+    catch {
+        return out;
+    }
+    for (const folder of OPEN_LIFECYCLE_FOLDERS) {
+        const folderDir = join(base, folder);
+        if (!existsSync(folderDir))
+            continue;
+        for (const name of readdirSync(folderDir)
+            .filter((entry) => hasArtifactSuffix(entry))
+            .sort()) {
+            const plan = loadPlan(join(folderDir, name));
+            if (plan === null)
+                continue;
+            const refs = plan.references;
+            if (!Array.isArray(refs))
+                continue;
+            for (const ref of refs) {
+                if (typeof ref !== "object" || ref === null)
+                    continue;
+                const typed = ref;
+                const uri = typed.uri;
+                if (typeof uri !== "string")
+                    continue;
+                const parsed = issueRefFromUri(uri);
+                if (parsed) {
+                    if (parsed.repo) {
+                        // Repo-scoped protection only — multi-repo caches stay independent.
+                        out.add(`${parsed.repo}#${parsed.number}`);
+                    }
+                    else {
+                        out.add(`#${parsed.number}`);
+                    }
+                    continue;
+                }
+                // Non-github URI with numeric tail: bare-number protect (conservative).
+                for (const n of issueNumbersFromPlan({ references: [ref] })) {
+                    out.add(`#${n}`);
+                }
+            }
+        }
+    }
+    return out;
+}
+/** True when cache key `owner/repo/N` is protected by open lifecycle refs. */
+export function isLifecycleProtected(cacheKey, protectedKeys) {
+    const m = GH_KEY_RE.exec(cacheKey);
+    if (!m)
+        return false;
+    const repo = `${(m[1] ?? "").toLowerCase()}/${(m[2] ?? "").toLowerCase()}`;
+    const n = m[3] ?? "";
+    // Prefer exact (case-folded) repo match; bare #N only when URI had no repo.
+    return protectedKeys.has(`${repo}#${n}`) || protectedKeys.has(`#${n}`);
+}
+function collectLiveMetaPaths(srcRoot) {
+    const found = [];
+    function walk(dir) {
+        if (!existsSync(dir))
+            return;
+        for (const name of readdirSync(dir, { withFileTypes: true })) {
+            const full = join(dir, name.name);
+            if (name.isDirectory())
+                walk(full);
+            else if (name.name === "meta.json")
+                found.push(full);
+        }
+    }
+    walk(srcRoot);
+    return found;
+}
+function keyFromLiveMetaPath(metaPath, srcRoot) {
+    const parent = dirname(metaPath);
+    const rel = relative(srcRoot, parent);
+    return rel.split(/[/\\]/).join("/");
+}
+function readJsonObject(path) {
+    try {
+        const data = JSON.parse(readFileSync(path, "utf8"));
+        if (typeof data !== "object" || data === null || Array.isArray(data))
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+function issueNumberFromKey(key) {
+    const m = GH_KEY_RE.exec(key);
+    if (!m)
+        return null;
+    const raw = m[3] ?? "";
+    // GH_KEY_RE already requires digits; re-check full-string positive int for SLizard.
+    if (!/^[1-9]\d*$/.test(raw))
+        return null;
+    return Number(raw);
+}
+function repoFromKey(key) {
+    const m = GH_KEY_RE.exec(key);
+    if (!m)
+        return null;
+    return `${m[1]}/${m[2]}`;
+}
+function fileMtimeMs(path) {
+    try {
+        return statSync(path).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Resolve closed age basis: `closed_at` from raw, else `meta.fetched_at`, else
+ * meta.json mtime (#1137).
+ */
+export function resolveClosedAge(raw, meta, metaPath, now) {
+    const closedRaw = raw.closed_at;
+    if (typeof closedRaw === "string" && closedRaw.trim().length > 0) {
+        try {
+            const dt = parseIso(closedRaw);
+            if (!Number.isNaN(dt.getTime())) {
+                return {
+                    closedAt: closedRaw,
+                    ageBasis: "closed_at",
+                    ageMs: Math.max(0, now.getTime() - dt.getTime()),
+                };
+            }
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    const fetched = meta && typeof meta.fetched_at === "string" ? meta.fetched_at : null;
+    if (fetched) {
+        try {
+            const dt = parseIso(fetched);
+            if (!Number.isNaN(dt.getTime())) {
+                return {
+                    closedAt: null,
+                    ageBasis: "fetched_at",
+                    ageMs: Math.max(0, now.getTime() - dt.getTime()),
+                };
+            }
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    const mtime = fileMtimeMs(metaPath);
+    return {
+        closedAt: null,
+        ageBasis: "mtime",
+        ageMs: mtime > 0 ? Math.max(0, now.getTime() - mtime) : 0,
+    };
+}
+/** Align with candidates-log latestDecisions key: `${repo}\0${n}`. */
+function decisionKey(repo, issueNumber) {
+    return `${repo}\0${issueNumber}`;
+}
+function decisionKeyAlt(repo, issueNumber) {
+    return `${repo}#${issueNumber}`;
+}
+/**
+ * Archive closed github-issue cache entries older than the threshold.
+ * Skips (does not half-move) entries still referenced by open lifecycle scopes.
+ */
+export function archiveClosedEntries(options = {}) {
+    const clock = options.clock ?? systemClock;
+    const olderThanDays = options.olderThanDays ?? DEFAULT_ARCHIVE_OLDER_THAN_DAYS;
+    if (olderThanDays < 0 || !Number.isFinite(olderThanDays)) {
+        throw new CacheError(`--older-than-days must be >= 0 (got ${JSON.stringify(olderThanDays)})`);
+    }
+    const source = options.source ?? ARCHIVE_SOURCE_GITHUB_ISSUE;
+    if (source !== ARCHIVE_SOURCE_GITHUB_ISSUE) {
+        throw new CacheError(`archive source '${source}' not supported in v1 (supports: ${ARCHIVE_SOURCE_GITHUB_ISSUE} only)`);
+    }
+    if (options.repo != null && options.repo !== "" && !REPO_RE.test(options.repo)) {
+        throw new CacheError(`invalid --repo '${options.repo}': expected 'owner/repo' (alphanumerics, '.', '_', '-' only)`);
+    }
+    const cacheRoot = options.cacheRoot ?? ".deft-cache";
+    assertWritableCachePath(cacheRoot);
+    const projectRoot = options.projectRoot ?? dirname(resolve(cacheRoot));
+    const dryRun = options.dryRun === true;
+    const thresholdMs = olderThanDays * 24 * 60 * 60 * 1000;
+    const now = clock.now();
+    let protectedKeys;
+    if (options.protectedKeys) {
+        protectedKeys = options.protectedKeys;
+    }
+    else if (options.protectedIssueNumbers) {
+        const synthetic = new Set();
+        for (const n of options.protectedIssueNumbers)
+            synthetic.add(`#${n}`);
+        protectedKeys = synthetic;
+    }
+    else {
+        protectedKeys = openLifecycleReferencedKeys(projectRoot);
+    }
+    const archived = [];
+    const skipped = [];
+    const srcRoot = join(cacheRoot, source);
+    if (!existsSync(srcRoot)) {
+        return {
+            dryRun,
+            olderThanDays,
+            source,
+            repo: options.repo ?? null,
+            archived,
+            skipped,
+            archivedCount: 0,
+            skippedCount: 0,
+        };
+    }
+    for (const metaPath of collectLiveMetaPaths(srcRoot)) {
+        const key = keyFromLiveMetaPath(metaPath, srcRoot);
+        if (!GH_KEY_RE.test(key)) {
+            skipped.push({ source, key, reason: "invalid-key" });
+            continue;
+        }
+        if (options.repo) {
+            const keyRepo = repoFromKey(key);
+            if (keyRepo !== options.repo)
+                continue;
+        }
+        const liveDir = dirname(metaPath);
+        const archiveDir = archivedEntryDir(source, key, cacheRoot);
+        if (existsSync(archiveDir) && !existsSync(liveDir)) {
+            skipped.push({ source, key, reason: "already-archived" });
+            continue;
+        }
+        const rawPath = join(liveDir, "raw.json");
+        if (!existsSync(rawPath)) {
+            skipped.push({ source, key, reason: "missing-raw" });
+            continue;
+        }
+        const raw = readJsonObject(rawPath);
+        if (raw === null) {
+            skipped.push({ source, key, reason: "missing-raw", detail: "unreadable raw.json" });
+            continue;
+        }
+        if (raw.state !== "closed") {
+            skipped.push({ source, key, reason: "not-closed" });
+            continue;
+        }
+        const meta = readJsonObject(metaPath);
+        const age = resolveClosedAge(raw, meta, metaPath, now);
+        if (age.ageMs < thresholdMs) {
+            skipped.push({
+                source,
+                key,
+                reason: "too-recent",
+                detail: `age_days=${(age.ageMs / 86400000).toFixed(2)} basis=${age.ageBasis}`,
+            });
+            continue;
+        }
+        const issueNum = issueNumberFromKey(key);
+        if (isLifecycleProtected(key, protectedKeys)) {
+            skipped.push({
+                source,
+                key,
+                reason: "open-lifecycle-scope",
+                detail: `issue ${key} referenced in proposed/pending/active`,
+            });
+            continue;
+        }
+        let preArchiveDecision = null;
+        if (options.latestDecisions && issueNum !== null) {
+            const keyRepo = repoFromKey(key) ?? "";
+            preArchiveDecision =
+                options.latestDecisions.get(decisionKey(keyRepo, issueNum)) ??
+                    options.latestDecisions.get(decisionKeyAlt(keyRepo, issueNum)) ??
+                    options.latestDecisions.get(String(issueNum)) ??
+                    null;
+        }
+        if (options.terminalDecisionOnly) {
+            if (preArchiveDecision === null || !TERMINAL_DECISIONS.has(preArchiveDecision)) {
+                skipped.push({
+                    source,
+                    key,
+                    reason: "non-terminal-decision",
+                    detail: preArchiveDecision ?? "none",
+                });
+                continue;
+            }
+        }
+        const candidate = {
+            source,
+            key,
+            liveDir,
+            archiveDir,
+            closedAt: age.closedAt,
+            ageBasis: age.ageBasis,
+            ageMs: age.ageMs,
+            preArchiveDecision,
+        };
+        if (!dryRun) {
+            assertWritableCachePath(cacheRoot, ARCHIVED_ROOT_SEGMENT, source, ...key.split("/"));
+            assertWritableCachePath(cacheRoot, source, ...key.split("/"));
+            mkdirSync(dirname(archiveDir), { recursive: true });
+            if (existsSync(archiveDir)) {
+                // Prefer live overwrite of stale archive only when operator re-archives;
+                // refuse silently by skipping to avoid data loss of archived tree.
+                skipped.push({
+                    source,
+                    key,
+                    reason: "already-archived",
+                    detail: "archive path exists; remove or restore first",
+                });
+                continue;
+            }
+            renameSync(liveDir, archiveDir);
+            const archiveMeta = {
+                archived_at: utcIso(clock),
+                reason: options.reason ?? "closed-age-archive",
+                source_path: liveDir.split(/[/\\]/).join("/"),
+                key,
+                source,
+                pre_archive_decision: preArchiveDecision,
+                closed_at: age.closedAt,
+                age_basis: age.ageBasis,
+            };
+            const projectDir = dirname(resolve(cacheRoot));
+            atomicWriteText(join(archiveDir, ARCHIVE_META_FILENAME), `${JSON.stringify(archiveMeta, null, 2)}\n`, { projectRoot: projectDir });
+            appendAudit({
+                event: "cache:archive",
+                source,
+                key,
+                timestamp: utcIso(clock),
+                reason: archiveMeta.reason,
+                archive_dir: archiveDir.split(/[/\\]/).join("/"),
+                closed_at: age.closedAt,
+                age_basis: age.ageBasis,
+                pre_archive_decision: preArchiveDecision,
+            }, cacheRoot);
+        }
+        archived.push(candidate);
+    }
+    return {
+        dryRun,
+        olderThanDays,
+        source,
+        repo: options.repo ?? null,
+        archived,
+        skipped,
+        archivedCount: archived.length,
+        skippedCount: skipped.length,
+    };
+}
+/** List archived entries newest `archived_at` first. */
+export function listArchivedEntries(options = {}) {
+    const source = options.source ?? ARCHIVE_SOURCE_GITHUB_ISSUE;
+    if (source !== ARCHIVE_SOURCE_GITHUB_ISSUE) {
+        throw new CacheError(`archive source '${source}' not supported in v1 (supports: ${ARCHIVE_SOURCE_GITHUB_ISSUE} only)`);
+    }
+    if (options.repo != null && options.repo !== "" && !REPO_RE.test(options.repo)) {
+        throw new CacheError(`invalid --repo '${options.repo}': expected 'owner/repo' (alphanumerics, '.', '_', '-' only)`);
+    }
+    const cacheRoot = options.cacheRoot ?? ".deft-cache";
+    assertWritableCachePath(cacheRoot);
+    const archRoot = join(cacheRoot, ARCHIVED_ROOT_SEGMENT, source);
+    const entries = [];
+    if (existsSync(archRoot)) {
+        for (const metaPath of collectLiveMetaPaths(archRoot)) {
+            // meta.json under archived tree; archive-meta is sibling
+            const entryDirPath = dirname(metaPath);
+            const key = keyFromLiveMetaPath(metaPath, archRoot);
+            if (!GH_KEY_RE.test(key))
+                continue;
+            if (options.repo) {
+                const keyRepo = repoFromKey(key);
+                if (keyRepo !== options.repo)
+                    continue;
+            }
+            const archiveMetaPath = join(entryDirPath, ARCHIVE_META_FILENAME);
+            let meta;
+            if (existsSync(archiveMetaPath)) {
+                const parsed = readJsonObject(archiveMetaPath);
+                meta = {
+                    archived_at: typeof parsed?.archived_at === "string"
+                        ? parsed.archived_at
+                        : utcIso(systemClock, new Date(fileMtimeMs(archiveMetaPath))),
+                    reason: typeof parsed?.reason === "string" ? parsed.reason : "unknown",
+                    source_path: typeof parsed?.source_path === "string" ? parsed.source_path : "",
+                    key: typeof parsed?.key === "string" ? parsed.key : key,
+                    source: typeof parsed?.source === "string" ? parsed.source : source,
+                    pre_archive_decision: typeof parsed?.pre_archive_decision === "string" ? parsed.pre_archive_decision : null,
+                    closed_at: typeof parsed?.closed_at === "string" ? parsed.closed_at : null,
+                    age_basis: typeof parsed?.age_basis === "string" ? parsed.age_basis : undefined,
+                };
+            }
+            else {
+                meta = {
+                    archived_at: utcIso(systemClock, new Date(fileMtimeMs(entryDirPath))),
+                    reason: "unknown",
+                    source_path: "",
+                    key,
+                    source,
+                };
+            }
+            if (options.since) {
+                try {
+                    const sinceDt = parseIso(options.since);
+                    const archivedDt = parseIso(meta.archived_at);
+                    if (archivedDt < sinceDt)
+                        continue;
+                }
+                catch {
+                    /* ignore bad since filter for this entry */
+                }
+            }
+            entries.push({
+                source,
+                key,
+                archiveDir: entryDirPath,
+                archivedAt: meta.archived_at,
+                meta,
+            });
+        }
+    }
+    entries.sort((a, b) => b.archivedAt.localeCompare(a.archivedAt));
+    const limit = options.limit !== undefined && options.limit !== null && options.limit > 0
+        ? options.limit
+        : null;
+    const sliced = limit !== null ? entries.slice(0, limit) : entries;
+    return {
+        entries: sliced,
+        count: sliced.length,
+        source,
+        repo: options.repo ?? null,
+    };
+}
+function filesEqual(a, b) {
+    try {
+        return readFileSync(a).equals(readFileSync(b));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Move an archived entry back to the live cache path.
+ * Idempotent no-op when already live with identical raw.json.
+ * Refuse when live exists with different content unless force.
+ */
+export function restoreFromArchive(options = {}) {
+    const clock = options.clock ?? systemClock;
+    const source = options.source ?? ARCHIVE_SOURCE_GITHUB_ISSUE;
+    if (source !== ARCHIVE_SOURCE_GITHUB_ISSUE) {
+        throw new CacheError(`archive source '${source}' not supported in v1 (supports: ${ARCHIVE_SOURCE_GITHUB_ISSUE} only)`);
+    }
+    const cacheRoot = options.cacheRoot ?? ".deft-cache";
+    assertWritableCachePath(cacheRoot);
+    let key = options.key ?? "";
+    if (!key) {
+        if (options.issue === undefined || options.issue === null) {
+            throw new CacheError("restore requires --issue N or --key owner/repo/N");
+        }
+        if (!Number.isInteger(options.issue) || options.issue < 1) {
+            throw new CacheError(`--issue must be a positive integer (got ${JSON.stringify(options.issue)})`);
+        }
+        if (!options.repo || !REPO_RE.test(options.repo)) {
+            throw new CacheError(`restore with --issue requires --repo owner/name (got ${JSON.stringify(options.repo)})`);
+        }
+        key = `${options.repo}/${options.issue}`;
+    }
+    validateKey(source, key);
+    const liveDir = liveEntryDir(source, key, cacheRoot);
+    const archiveDir = archivedEntryDir(source, key, cacheRoot);
+    if (!existsSync(archiveDir)) {
+        if (existsSync(liveDir)) {
+            return {
+                source,
+                key,
+                status: "already-live",
+                liveDir,
+                archiveDir,
+                detail: "archive missing; live entry present (idempotent)",
+            };
+        }
+        return {
+            source,
+            key,
+            status: "missing",
+            liveDir,
+            archiveDir,
+            detail: "no archived entry and no live entry",
+        };
+    }
+    if (existsSync(liveDir)) {
+        const liveRaw = join(liveDir, "raw.json");
+        const archRaw = join(archiveDir, "raw.json");
+        if (existsSync(liveRaw) && existsSync(archRaw) && filesEqual(liveRaw, archRaw)) {
+            // Identical content — remove archive tree as completed restore cleanup? keep both for safety:
+            // idempotent: report already-live without deleting archive unless force wants clean.
+            return {
+                source,
+                key,
+                status: "already-live",
+                liveDir,
+                archiveDir,
+                detail: "live entry matches archived raw.json",
+            };
+        }
+        if (!options.force) {
+            return {
+                source,
+                key,
+                status: "conflict",
+                liveDir,
+                archiveDir,
+                detail: "live path exists with different content; pass --force to replace",
+            };
+        }
+        assertWritableCachePath(cacheRoot, source, ...key.split("/"));
+        rmSync(liveDir, { recursive: true, force: true });
+    }
+    assertWritableCachePath(cacheRoot, source, ...key.split("/"));
+    assertWritableCachePath(cacheRoot, ARCHIVED_ROOT_SEGMENT, source, ...key.split("/"));
+    mkdirSync(dirname(liveDir), { recursive: true });
+    renameSync(archiveDir, liveDir);
+    // Drop archive-meta from live tree so walkers see a normal entry.
+    const liveArchiveMeta = join(liveDir, ARCHIVE_META_FILENAME);
+    if (existsSync(liveArchiveMeta)) {
+        try {
+            rmSync(liveArchiveMeta, { force: true });
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    appendAudit({
+        event: "cache:restore-from-archive",
+        source,
+        key,
+        timestamp: utcIso(clock),
+        live_dir: liveDir.split(/[/\\]/).join("/"),
+        force: options.force === true,
+    }, cacheRoot);
+    return {
+        source,
+        key,
+        status: "restored",
+        liveDir,
+        archiveDir,
+    };
+}
+//# sourceMappingURL=archive.js.map

package/dist/cache/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./archive.js";
 export * from "./constants.js";
 export * from "./empty-populate.js";
 export * from "./errors.js";

package/dist/cache/index.js

@@ -1,3 +1,4 @@
+export * from "./archive.js";
 export * from "./constants.js";
 export * from "./empty-populate.js";
 export * from "./errors.js";