@gmickel/gno 1.34.6 → 1.36.0

package/src/serve/watch-reconciliation-fallback-disk.ts

@@ -6,17 +6,24 @@
  * @module src/serve/watch-reconciliation-fallback-disk
  */
 
+// node:path — Bun has no path join helper.
+import { join } from "node:path";
+
 import type { Collection } from "../config/types";
+import type { DirectoryAvailabilityPort } from "../ingestion/source-availability";
 
-import { matchesCollectionExclusion } from "../core/path-rules";
+import {
+  matchesCollectionExclusion,
+  matchesCollectionSubtreeExclusion,
+} from "../core/path-rules";
 import { collectionToWalkConfig, matchesWalkPath } from "../ingestion";
+import { findUnprovenAvailabilityPrefix } from "../ingestion/source-availability";
 import { defaultFs, openDirByRel } from "./watch-snapshot-scan";
 import {
   isMissingFsError,
   joinWatcherRelPath,
   parentWatcherDir,
   type WatcherSnapshotFs,
-  type WatcherSnapshotStat,
 } from "./watch-snapshot-types";
 
 export interface FallbackBudget {
@@ -47,7 +54,12 @@ export function fallbackFs(): WatcherSnapshotFs {
 }
 
 export type DiskListResult =
-  | { status: "ok"; paths: string[]; rootDirNames: string[] }
+  | {
+      status: "ok";
+      paths: string[];
+      rootDirNames: string[];
+      unprovenPrefixes: string[];
+    }
   | { status: "overflow" }
   | { status: "error"; cause: unknown };
 
@@ -60,128 +72,207 @@ export async function listEligibleDiskSources(
   dirRel: string,
   collection: Collection,
   fs: WatcherSnapshotFs,
-  budget: FallbackBudget
+  budget: FallbackBudget,
+  directoryAvailability?: DirectoryAvailabilityPort
 ): Promise<DiskListResult> {
   const walkConfig = collectionToWalkConfig(collection, 0);
   const paths: string[] = [];
   const rootDirNames: string[] = [];
+  const unprovenPrefixes: string[] = [];
   const queue: string[] = [dirRel];
   let head = 0;
 
   while (head < queue.length) {
     const current = queue[head] as string;
     head += 1;
+    if (
+      current !== "" &&
+      matchesCollectionSubtreeExclusion(current, walkConfig.exclude)
+    ) {
+      continue;
+    }
     budget.visitedDirs += 1;
     if (budgetExceeded(budget)) {
       return { status: "overflow" };
     }
 
     const remaining = Math.max(0, budget.limit - budget.visitedDirs + 1);
-    const opened = await openDirByRel(rootAbs, current, fs);
-    if (opened.status === "missing") {
-      continue;
-    }
-    if (opened.status !== "ok") {
-      return {
-        status: "error",
-        cause:
-          opened.status === "scan_failed"
-            ? opened.cause
-            : new Error(`Disk scan failed under ${current || "."}`),
-      };
-    }
-
-    let listed;
-    try {
-      listed = await fs.readDir(opened.handle, remaining);
-    } catch (cause) {
-      await fs.closeDir(opened.handle);
-      if (isMissingFsError(cause)) {
+    if (directoryAvailability?.mode === "local") {
+      if (!fs.readDirectChildrenSync) {
+        unprovenPrefixes.push(current);
         continue;
       }
-      return { status: "error", cause };
-    }
-
-    if (listed.status === "overflow") {
-      await fs.closeDir(opened.handle);
-      return { status: "overflow" };
-    }
-
-    const names = [...listed.names].sort((a, b) =>
-      a < b ? -1 : a > b ? 1 : 0
-    );
-    for (const name of names) {
-      if (name === "" || name === "." || name === "..") {
+      const absPath = current === "" ? rootAbs : join(rootAbs, current);
+      const guarded = directoryAvailability.readDirectory(absPath, () =>
+        fs.readDirectChildrenSync!(rootAbs, current, remaining)
+      );
+      if (guarded.kind !== "available") {
+        unprovenPrefixes.push(current);
         continue;
       }
-      if (name.includes("/") || name.includes("\\") || name.includes("\0")) {
-        await fs.closeDir(opened.handle);
+      const listed = guarded.value;
+      if (listed.status === "missing") {
+        continue;
+      }
+      if (listed.status === "overflow") {
+        return { status: "overflow" };
+      }
+      if (listed.status !== "present") {
         return {
           status: "error",
-          cause: new Error(`Invalid directory entry name: ${name}`),
+          cause:
+            listed.status === "scan_failed"
+              ? listed.cause
+              : new Error(`Disk scan failed under ${current || "."}`),
         };
       }
-
-      let stat: WatcherSnapshotStat;
-      try {
-        stat = await fs.lstatChild(opened.handle, name);
-      } catch (cause) {
-        await fs.closeDir(opened.handle);
-        if (isMissingFsError(cause)) {
-          return { status: "error", cause };
+      for (const [name, fingerprint] of listed.entries) {
+        const childRel = joinWatcherRelPath(current, name);
+        if (fingerprint.kind === "directory") {
+          if (matchesCollectionSubtreeExclusion(childRel, walkConfig.exclude)) {
+            continue;
+          }
+          if (current === "") {
+            rootDirNames.push(name);
+          }
+          queue.push(childRel);
+        } else if (matchesCollectionExclusion(childRel, walkConfig.exclude)) {
+          continue;
+        } else if (fingerprint.kind === "symlink") {
+          if (matchesWalkPath(childRel, walkConfig)) {
+            paths.push(childRel);
+          }
+        } else if (
+          fingerprint.kind === "file" &&
+          matchesWalkPath(childRel, walkConfig)
+        ) {
+          paths.push(childRel);
+        }
+        if (paths.length > budget.limit) {
+          return { status: "overflow" };
         }
-        return { status: "error", cause };
       }
+      continue;
+    }
 
-      const childRel = joinWatcherRelPath(current, name);
-      if (matchesCollectionExclusion(childRel, walkConfig.exclude)) {
-        continue;
+    const scanCurrent = async (): Promise<
+      | { status: "ok" }
+      | { status: "overflow" }
+      | { status: "error"; cause: unknown }
+    > => {
+      const opened = await openDirByRel(rootAbs, current, fs);
+      if (opened.status === "missing") {
+        return { status: "ok" };
+      }
+      if (opened.status !== "ok") {
+        return {
+          status: "error",
+          cause:
+            opened.status === "scan_failed"
+              ? opened.cause
+              : new Error(`Disk scan failed under ${current || "."}`),
+        };
       }
 
-      // Never follow symlinks; eligible link paths stay leaf candidates.
-      if (stat.isSymbolicLink()) {
-        if (matchesWalkPath(childRel, walkConfig)) {
+      try {
+        const listed = await fs.readDir(opened.handle, remaining);
+        if (listed.status === "overflow") {
+          return { status: "overflow" };
+        }
+        const names = [...listed.names].sort((a, b) =>
+          a < b ? -1 : a > b ? 1 : 0
+        );
+        for (const name of names) {
+          if (name === "" || name === "." || name === "..") {
+            continue;
+          }
+          if (
+            name.includes("/") ||
+            name.includes("\\") ||
+            name.includes("\0")
+          ) {
+            return {
+              status: "error",
+              cause: new Error(`Invalid directory entry name: ${name}`),
+            };
+          }
+
+          const stat = await fs.lstatChild(opened.handle, name);
+          const childRel = joinWatcherRelPath(current, name);
+          if (stat.isDirectory()) {
+            if (
+              matchesCollectionSubtreeExclusion(childRel, walkConfig.exclude)
+            ) {
+              continue;
+            }
+            if (current === "") {
+              rootDirNames.push(name);
+            }
+            queue.push(childRel);
+            continue;
+          }
+          if (matchesCollectionExclusion(childRel, walkConfig.exclude)) {
+            continue;
+          }
+          if (stat.isSymbolicLink()) {
+            if (matchesWalkPath(childRel, walkConfig)) {
+              paths.push(childRel);
+              if (paths.length > budget.limit) {
+                return { status: "overflow" };
+              }
+            }
+            continue;
+          }
+          if (!stat.isFile() || !matchesWalkPath(childRel, walkConfig)) {
+            continue;
+          }
           paths.push(childRel);
           if (paths.length > budget.limit) {
-            await fs.closeDir(opened.handle);
             return { status: "overflow" };
           }
         }
-        continue;
-      }
-
-      if (stat.isDirectory()) {
-        if (current === "") {
-          rootDirNames.push(name);
-        }
-        queue.push(childRel);
-        continue;
-      }
-
-      if (!stat.isFile() || !matchesWalkPath(childRel, walkConfig)) {
-        continue;
-      }
-      paths.push(childRel);
-      if (paths.length > budget.limit) {
+        return { status: "ok" };
+      } catch (cause) {
+        return { status: "error", cause };
+      } finally {
         await fs.closeDir(opened.handle);
-        return { status: "overflow" };
       }
+    };
+
+    const scanned = await scanCurrent();
+    if (scanned.status !== "ok") {
+      return scanned;
     }
-    await fs.closeDir(opened.handle);
   }
 
-  return { status: "ok", paths, rootDirNames };
+  return { status: "ok", paths, rootDirNames, unprovenPrefixes };
 }
 
 export async function inspectNoFollowPresence(
   rootAbs: string,
   relPath: string,
-  fs: WatcherSnapshotFs
+  fs: WatcherSnapshotFs,
+  directoryAvailability?: DirectoryAvailabilityPort
 ): Promise<
   | { status: "present"; indexable: boolean }
   | { status: "missing" }
   | { status: "error"; cause: unknown }
 > {
+  if (directoryAvailability?.mode === "local") {
+    const unproven = await findUnprovenAvailabilityPrefix(
+      rootAbs,
+      relPath,
+      directoryAvailability
+    );
+    if (unproven) {
+      return {
+        status: "error",
+        cause: new Error(
+          `Source absence is unproven under ${unproven.relPath || "."}: ${unproven.code}`
+        ),
+      };
+    }
+  }
   const parent = parentWatcherDir(relPath);
   if (parent === null) {
     return { status: "missing" };
@@ -190,31 +281,79 @@ export async function inspectNoFollowPresence(
   if (base === "" || base.includes("/")) {
     return { status: "error", cause: new Error(`Invalid path: ${relPath}`) };
   }
-  const opened = await openDirByRel(rootAbs, parent, fs);
-  if (opened.status === "missing") {
-    return { status: "missing" };
-  }
-  if (opened.status !== "ok") {
-    return {
-      status: "error",
-      cause:
-        opened.status === "scan_failed"
-          ? opened.cause
-          : new Error("Failed to open parent for presence check"),
-    };
-  }
-  try {
-    const stat = await fs.lstatChild(opened.handle, base);
-    // Only regular files / symlinks are indexable sources. Directory, FIFO,
-    // device, and other specials prove the prior file source is gone.
-    const indexable = stat.isFile() || stat.isSymbolicLink();
-    return { status: "present", indexable };
-  } catch (cause) {
-    if (isMissingFsError(cause)) {
+  const inspectParent = async (): Promise<
+    | { status: "present"; indexable: boolean }
+    | { status: "missing" }
+    | { status: "error"; cause: unknown }
+  > => {
+    const opened = await openDirByRel(rootAbs, parent, fs);
+    if (opened.status === "missing") {
       return { status: "missing" };
     }
-    return { status: "error", cause };
-  } finally {
-    await fs.closeDir(opened.handle);
+    if (opened.status !== "ok") {
+      return {
+        status: "error",
+        cause:
+          opened.status === "scan_failed"
+            ? opened.cause
+            : new Error("Failed to open parent for presence check"),
+      };
+    }
+    try {
+      const stat = await fs.lstatChild(opened.handle, base);
+      // Only regular files / symlinks are indexable sources. Directory, FIFO,
+      // device, and other specials prove the prior file source is gone.
+      const indexable = stat.isFile() || stat.isSymbolicLink();
+      return { status: "present", indexable };
+    } catch (cause) {
+      if (isMissingFsError(cause)) {
+        return { status: "missing" };
+      }
+      return { status: "error", cause };
+    } finally {
+      await fs.closeDir(opened.handle);
+    }
+  };
+
+  if (directoryAvailability?.mode === "local") {
+    if (!fs.lstatChildByRelSync) {
+      return {
+        status: "error",
+        cause: new Error(
+          "Synchronous anchored child metadata is unavailable in local mode"
+        ),
+      };
+    }
+    const parentAbs = parent === "" ? rootAbs : join(rootAbs, parent);
+    const guarded = directoryAvailability.readDirectory(parentAbs, () => {
+      try {
+        return {
+          status: "present" as const,
+          stat: fs.lstatChildByRelSync!(rootAbs, parent, base),
+        };
+      } catch (cause) {
+        if (isMissingFsError(cause)) {
+          return { status: "missing" as const };
+        }
+        throw cause;
+      }
+    });
+    if (guarded.kind !== "available") {
+      return {
+        status: "error",
+        cause: new Error(
+          `Source absence is unproven under ${parent || "."}: ${guarded.code}`
+        ),
+      };
+    }
+    if (guarded.value.status === "missing") {
+      return { status: "missing" };
+    }
+    return {
+      status: "present",
+      indexable:
+        guarded.value.stat.isFile() || guarded.value.stat.isSymbolicLink(),
+    };
   }
+  return inspectParent();
 }

package/src/serve/watch-reconciliation-fallback.ts

@@ -12,11 +12,17 @@ import { stat } from "node:fs/promises";
 import { normalize } from "node:path";
 
 import type { Collection } from "../config/types";
+import type { DirectoryAvailabilityPort } from "../ingestion/source-availability";
 import type { SqliteAdapter } from "../store/sqlite/adapter";
 import type { StoreResult } from "../store/types";
 
-import { matchesCollectionExclusion } from "../core/path-rules";
-import { collectionToWalkConfig, matchesWalkPath } from "../ingestion";
+import { matchesCollectionSubtreeExclusion } from "../core/path-rules";
+import {
+  collectionToWalkConfig,
+  findUnprovenAvailabilityPrefix,
+  matchesWalkPath,
+  relPathUnderAnyPrefix,
+} from "../ingestion";
 import {
   budgetExceeded,
   fallbackFs,
@@ -43,6 +49,7 @@ export async function fallbackClassifyDirtyHints(options: {
   sourcePathMax: number;
   /** Test seam for unsupported-platform fail-closed proofs. */
   fs?: WatcherSnapshotFs;
+  directoryAvailability?: DirectoryAvailabilityPort;
 }): Promise<ClassificationResult> {
   const { collection, store, rootAbs, dirtyHints } = options;
   const budgetLimit = Math.min(options.sourcePathMax, WATCHER_FALLBACK_BUDGET);
@@ -60,12 +67,23 @@ export async function fallbackClassifyDirtyHints(options: {
   const diskSeen = new Set<string>();
   const fs = options.fs ?? fallbackFs();
   const root = normalize(rootAbs);
+  const directoryAvailability = options.directoryAvailability;
 
   // No anchored handles: never path-walk or infer deletions. Caller must use
   // durable full-collection reconciliation (syncCollection) instead. Prove
   // the root is currently available first so a missing mount/root cannot be
   // mistaken for a genuinely empty collection by the full walk.
   if (!fs.supportsAnchoredHandles) {
+    if (directoryAvailability?.mode === "local") {
+      const unproven = await findUnprovenAvailabilityPrefix(
+        root,
+        ".gno-probe",
+        directoryAvailability
+      );
+      if (unproven) {
+        return { status: "full_reconcile", reason: "unsupported_fs" };
+      }
+    }
     try {
       const rootStat = await stat(root);
       if (!rootStat.isDirectory()) {
@@ -121,7 +139,10 @@ export async function fallbackClassifyDirtyHints(options: {
     if (budgetExceeded(budget)) {
       return overflowResult(dir);
     }
-    if (dir !== "" && matchesCollectionExclusion(dir, walkConfig.exclude)) {
+    if (
+      dir !== "" &&
+      matchesCollectionSubtreeExclusion(dir, walkConfig.exclude)
+    ) {
       continue;
     }
 
@@ -130,7 +151,8 @@ export async function fallbackClassifyDirtyHints(options: {
       dir,
       collection,
       fs,
-      budget
+      budget,
+      directoryAvailability
     );
     if (disk.status === "error") {
       return { status: "error", cause: disk.cause, stage: "scan" };
@@ -169,6 +191,9 @@ export async function fallbackClassifyDirtyHints(options: {
       if (!matchesWalkPath(path, walkConfig)) {
         continue;
       }
+      if (relPathUnderAnyPrefix(path, disk.unprovenPrefixes)) {
+        continue;
+      }
       if (diskSeen.has(path)) {
         candidates.add(path);
         budget.candidates = candidates.size;
@@ -184,7 +209,12 @@ export async function fallbackClassifyDirtyHints(options: {
 
   const provenRemovals: string[] = [];
   for (const path of removals) {
-    const presence = await inspectNoFollowPresence(root, path, fs);
+    const presence = await inspectNoFollowPresence(
+      root,
+      path,
+      fs,
+      directoryAvailability
+    );
     if (presence.status === "missing") {
       provenRemovals.push(path);
     } else if (presence.status === "present") {

package/src/serve/watch-reconciliation-shared.ts

@@ -13,7 +13,11 @@ import type { Collection } from "../config/types";
 import type { CollectionSyncResult } from "../ingestion";
 
 import { matchesCollectionExclusion } from "../core/path-rules";
-import { collectionToWalkConfig, matchesWalkPath } from "../ingestion";
+import {
+  collectionToWalkConfig,
+  isSourceAvailabilitySkip,
+  matchesWalkPath,
+} from "../ingestion";
 import {
   normalizeWatcherRelPath,
   parentWatcherDir,
@@ -64,7 +68,8 @@ export type PathPresence =
 export type ClassificationFullReconcileReason =
   | "unsupported_fs"
   | "budget_overflow"
-  | "snapshot_overflow";
+  | "snapshot_overflow"
+  | "snapshot_unproven_subtree";
 
 export type ClassificationResult =
   | {
@@ -172,7 +177,7 @@ export function hasFileLevelSyncError(result: CollectionSyncResult): boolean {
   if (result.files?.some((file) => file.status === "error")) {
     return true;
   }
-  return result.errors.length > 0;
+  return result.errors.some((error) => !isSourceAvailabilitySkip(error.code));
 }
 
 /**

package/src/serve/watch-reconciliation.ts

@@ -107,6 +107,12 @@ export async function classifyDirtyHints(options: {
     if (diff.status === "fallback" && diff.reason === "overflow") {
       return { status: "full_reconcile", reason: "snapshot_overflow" };
     }
+    if (diff.status === "fallback" && diff.reason === "unproven_subtree") {
+      return {
+        status: "full_reconcile",
+        reason: "snapshot_unproven_subtree",
+      };
+    }
     // Fall through for scan/metadata failure — previous snapshot uncommitted.
   }
 
@@ -118,5 +124,6 @@ export async function classifyDirtyHints(options: {
     sourcePathMax,
     // Only anchored FS may walk; unsupported injects fail-closed handles.
     fs: snapshotOptions?.fs,
+    directoryAvailability: snapshotOptions?.directoryAvailability,
   });
 }

package/src/serve/watch-service-flush.ts

@@ -16,8 +16,11 @@ import type { WatcherSnapshot, WatcherSnapshotFs } from "./watch-snapshot";
 
 import {
   collectionToWalkConfig,
+  createDirectoryAvailability,
   defaultSyncService,
   matchesWalkPath,
+  memoizeDirectoryAvailability,
+  resolveSourceAvailability,
 } from "../ingestion";
 import {
   classifyDirtyHints,
@@ -171,6 +174,10 @@ export async function flushCollectionOnce(
     let needsFullFromAmbiguous = false;
 
     if (dirtyHints.length > 0) {
+      const availabilityMode = resolveSourceAvailability(
+        input.collection,
+        input.getCurrentSyncOptions()
+      );
       const classified = await classifyDirtyHints({
         collection: input.collection,
         store: input.store,
@@ -183,6 +190,9 @@ export async function flushCollectionOnce(
           ...(input.snapshotEntryCeiling !== undefined
             ? { entryCeiling: input.snapshotEntryCeiling }
             : {}),
+          directoryAvailability: memoizeDirectoryAvailability(
+            createDirectoryAvailability(availabilityMode)
+          ),
         },
       });
       if (input.disposed()) {

package/src/serve/watch-service-lifecycle.ts

@@ -13,6 +13,7 @@ import type { Collection } from "../config/types";
 import type { SyncOptions } from "../ingestion";
 import type { WatcherSnapshot } from "./watch-snapshot";
 
+import { resolveSourceAvailability } from "../ingestion/source-availability";
 import { emptyPending, type CollectionPending } from "./watch-service-state";
 
 export interface WatchLifecycleHost {
@@ -65,6 +66,7 @@ export function watcherCollectionFingerprint(
     exclude: collection.exclude,
     languageHint: collection.languageHint ?? null,
     recordAdapters: collection.recordAdapters ?? null,
+    sourceAvailability: resolveSourceAvailability(collection, syncOptions),
     limits: syncOptions.limits ?? null,
     concurrency: syncOptions.concurrency ?? null,
     contentTypeRules: syncOptions.contentTypeRules ?? null,

package/src/serve/watch-service-snapshot.ts

@@ -8,12 +8,18 @@
 import { normalize } from "node:path";
 
 import type { Collection } from "../config/types";
+import type { SyncOptions } from "../ingestion";
 import type {
   WatcherSnapshot,
   WatcherSnapshotBuildResult,
   WatcherSnapshotOptions,
 } from "./watch-snapshot";
 
+import {
+  createDirectoryAvailability,
+  memoizeDirectoryAvailability,
+  resolveSourceAvailability,
+} from "../ingestion";
 import { buildWatcherSnapshot } from "./watch-snapshot";
 
 export interface SnapshotInitHost {
@@ -26,6 +32,8 @@ export interface SnapshotInitHost {
   getInit: (collectionName: string) => Promise<void> | undefined;
   setInit: (collectionName: string, init: Promise<void> | undefined) => void;
   onReadyWithPending: (collectionName: string) => void;
+  /** Current run-level overrides; omitted by narrow unit-test hosts. */
+  getSyncOptions?: () => SyncOptions;
   /** Optional injectable builder for hung/slow-init tests. */
   buildSnapshot?: (
     rootAbs: string,
@@ -44,7 +52,14 @@ export function beginSnapshotInit(
   const generation = host.getGeneration(collection.name);
   const root = normalize(collection.path);
   let init!: Promise<void>;
-  init = runSnapshotInit(host, collection.name, root, generation, () => init);
+  init = runSnapshotInit(
+    host,
+    collection.name,
+    root,
+    generation,
+    () => init,
+    collection
+  );
   host.setInit(collection.name, init);
   void init.catch(() => undefined);
 }
@@ -54,11 +69,20 @@ async function runSnapshotInit(
   collectionName: string,
   root: string,
   generation: number,
-  getInit: () => Promise<void>
+  getInit: () => Promise<void>,
+  collection: Collection
 ): Promise<void> {
   try {
     const builder = host.buildSnapshot ?? buildWatcherSnapshot;
-    const built = await builder(root);
+    const availabilityMode = resolveSourceAvailability(
+      collection,
+      host.getSyncOptions?.()
+    );
+    const built = await builder(root, {
+      directoryAvailability: memoizeDirectoryAvailability(
+        createDirectoryAvailability(availabilityMode)
+      ),
+    });
     if (host.disposed()) {
       return;
     }