@karmaniverous/stan-cli 0.11.5 → 0.11.7

package/dist/cli/stan.js

@@ -28953,17 +28953,37 @@ const stanDirs = (cwd, stanPath) => {
 
 // src/stan/run/archive/util.ts
 /**
- * Stage imports (if any) under <stanPath>/imports so both full and diff archives
- * see the same staged context. Best‑effort: failures are swallowed.
+ * Stage imports under <stanPath>/imports so both full and diff archives see the same
+ * staged context.
+ *
+ * Behavior:
+ * - Always clear the entire <stanPath>/imports directory first (best‑effort).
+ * - Then, if a map is provided, call core.prepareImports to stage the current labels.
+ *
+ * Notes:
+ * - Core's prepareImports also clears each label directory; we keep that as a
+ *   belt‑and‑suspenders for non‑CLI callers while the CLI clears the root up front
+ *   to remove labels that were dropped from config.
+ * - All operations are best‑effort and swallow errors to avoid impacting the run.
  */
 const stageImports = async (cwd, stanPath, imports) => {
-    if (!imports || typeof imports !== 'object')
-        return;
+    // 1) Clear the entire imports root first (best‑effort).
+    const importsAbs = path.join(cwd, stanPath, 'imports');
     try {
-        await yh({ cwd, stanPath, map: imports });
+        const entries = await readdir(importsAbs, { withFileTypes: true });
+        await Promise.all(entries.map((e) => rm(resolve(importsAbs, e.name), { recursive: true, force: true })));
     }
     catch {
-        // best‑effort; continue without imports
+        // best‑effort; root may not exist yet.
+    }
+    // 2) Stage current map (if any).
+    if (imports && typeof imports === 'object') {
+        try {
+            await yh({ cwd, stanPath, map: imports });
+        }
+        catch {
+            // best‑effort; continue without imports
+        }
     }
 };
 /**
@@ -32234,6 +32254,11 @@ async function handleSnap(opts) {
     try {
         const coreModUnknown = await Promise.resolve().then(function () { return index; });
         const core = coreModUnknown;
+        const ensureOutFn = typeof core.ensureOutputDir === 'function'
+            ? core.ensureOutputDir
+            : typeof core.default?.ensureOutputDir === 'function'
+                ? core.default.ensureOutputDir
+                : null;
         const loadConfigFn = typeof core.loadConfig === 'function'
             ? core.loadConfig
             : typeof core.default?.loadConfig === 'function'
@@ -32245,19 +32270,67 @@ async function handleSnap(opts) {
                 ? core.default.writeArchiveSnapshot
                 : null;
         if (writeSnapshotFn) {
+            // Make sure <stanPath>/diff (and output) exist before writing the snapshot.
+            // This avoids ENOENT when snapping a fresh repo or temp workspace.
+            try {
+                if (ensureOutFn) {
+                    await ensureOutFn(cwd, stanPath, true);
+                }
+            }
+            catch {
+                /* best‑effort directory ensure */
+            }
             let includes = [];
             let excludes = [];
+            // Overlay inputs derived the same way as “run”:
+            // - overlay enabled state from cliDefaults.run.facets
+            // - inactive facets contribute subtree excludes; anchors re-include breadcrumbs
+            let anchors = [];
+            let overlayExcludes = [];
             try {
                 const cfg = loadConfigFn ? await loadConfigFn(cwd) : null;
                 includes = Array.isArray(cfg?.includes) ? cfg.includes : [];
                 excludes = Array.isArray(cfg?.excludes) ? cfg.excludes : [];
+                // Decide overlay enablement from run defaults (snap has no facet flags).
+                const eff = getRunDefaults(cwd);
+                try {
+                    const ov = await computeFacetOverlay({
+                        cwd,
+                        stanPath,
+                        enabled: eff.facets,
+                        activate: [],
+                        deactivate: [],
+                        nakedActivateAll: false,
+                    });
+                    // Always keep anchors (breadcrumbs) materialized in snapshot selection.
+                    anchors = Array.isArray(ov.anchorsOverlay) ? ov.anchorsOverlay : [];
+                    // Only map subtree roots into excludes when overlay is enabled.
+                    overlayExcludes =
+                        ov.enabled && Array.isArray(ov.excludesOverlay)
+                            ? ov.excludesOverlay
+                            : [];
+                }
+                catch {
+                    // best-effort overlay; fall back to engine selection only
+                    anchors = [];
+                    overlayExcludes = [];
+                }
             }
             catch {
                 // best-effort
                 includes = [];
                 excludes = [];
+                anchors = [];
+                overlayExcludes = [];
             }
-            await writeSnapshotFn({ cwd, stanPath, includes, excludes });
+            const excludesFinal = [...excludes, ...overlayExcludes];
+            await writeSnapshotFn({
+                cwd,
+                stanPath,
+                includes,
+                excludes: excludesFinal,
+                anchors,
+            });
         }
     }
     catch {