@gmickel/gno 1.34.6 → 1.35.0

package/README.md

@@ -117,7 +117,7 @@ gno daemon --detach  # headless indexing + resident MCP gateway
 
 <!-- public-truth:current-version -->
 
-> Current release: **v1.34.5** — see [CHANGELOG.md](./CHANGELOG.md)
+> Current release: **v1.35.0** — see [CHANGELOG.md](./CHANGELOG.md)
 
 <!-- /public-truth -->
 
@@ -174,6 +174,17 @@ gno daemon --detach  # headless indexing + resident MCP gateway
   `local_only`, `lan`, or `remote` boundary that follows mixed and derived
   evidence through resident serving, inference, publishing, exports, Capsules,
   and traces. Authentication never overrides policy.
+- **Source availability (`any` | `local`)**: opt-in `local` refuses
+  cloud-placeholder materialization on the macOS File Provider layouts covered
+  by physical evidence (Google Drive, iCloud Drive, and OneDrive for both
+  validated immediate SharePoint library roots). Hierarchical directory
+  classification + guarded content recheck; skips are not conversion errors;
+  unproven prefixes preserve indexed descendants. Distinct from egress.
+  Unsupported platforms fail closed; no claim of zero provider activity or
+  universal provider support. On the controlled 5,000-file all-local corpus,
+  production `any` regressed -1.1280% and hierarchical `local` added 1.1841%
+  median traversal overhead (2 warmups, 9 samples per lane; same corpus and
+  interleaved pre-implementation/current production walkers).
 - **Read-only integrity audits**: `gno audit` and MCP `gno_audit` inspect local
   links, declared provenance, and source/index freshness offline. Stable,
   bounded findings distinguish complete, partial, unavailable, and changing

package/browser-extension/artifacts/gno-browser-clipper-v1.35.0.zip.sha256

@@ -0,0 +1 @@
+c1e214bba1c0a9a6f54bfd334f7a95c8c5e28e84b12b9f91064e7312e0411882  gno-browser-clipper-v1.35.0.zip

package/browser-extension/dist/manifest.json

@@ -21,5 +21,5 @@
   "content_security_policy": {
     "extension_pages": "script-src 'self'; object-src 'none'; connect-src http://127.0.0.1:*"
   },
-  "version": "1.34.6"
+  "version": "1.35.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "1.34.6",
+  "version": "1.35.0",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",

package/spec/cli.md

@@ -411,6 +411,10 @@ collections:
     exclude: [.git, node_modules]
     updateCmd: git pull
     languageHint: en
+    # Source content availability (distinct from egressPolicy):
+    # any (default) = legacy reads; local = opt-in no-materialization guard
+    # (macOS File Provider). Unsupported platforms fail closed under local.
+    sourceAvailability: any
     models:
       embed: file:/models/embed.gguf
 contexts:
@@ -446,6 +450,39 @@ protection remain authoritative.
 `graphHints` is active: ordered hints type
 projected wiki/markdown edges and surface in graph traversal/diagnose metadata.
 
+`collections[].sourceAvailability` is optional; omitted means `any`. Exact
+values: `any` | `local`. There is no separate public knob beyond these two
+modes and no claim that availability is egress policy. `any` preserves
+historical source reads. `local` is opt-in and establishes a platform-aware
+no-materialization content-read boundary (currently macOS File Provider via
+process-scoped `IOPOL_TYPE_VFS_MATERIALIZE_DATALESS_FILES` plus hierarchical
+memoized per-directory availability classification and a content-boundary
+recheck shared by full/targeted/watch ingestion, sniff/hash/conversion, and
+record import). Unsupported platforms/filesystems and policy-setup failure fail
+closed with distinct codes (`SOURCE_AVAILABILITY_UNSUPPORTED`,
+`SOURCE_AVAILABILITY_POLICY_FAILED`, `SOURCE_AVAILABILITY_UNKNOWN`).
+Cloud-placeholder refusal (`EDEADLK`) surfaces as a skipped file with
+`CLOUD_PLACEHOLDER` / `CLOUD_PARTIAL`, not a conversion error. Local mode also
+refuses descent into dataless or availability-unknown directories
+(`DATALESS_DIRECTORY` skip, or the fail-closed codes above) and preserves
+previously indexed descendants under those unproven prefixes rather than
+marking them inactive. Eligible files have no availability `errorCode`.
+Evidence-qualified scope: Google Drive, iCloud Drive, and OneDrive only for the
+tested OS/provider configuration; OneDrive only for both validated immediate
+SharePoint library roots. No Windows/Linux guarantee; metadata/provider
+bookkeeping may occur; GNO does not pin/evict/download as product behavior.
+Source availability is distinct from `egressPolicy` (where derived content may
+travel).
+
+The fixture-scoped post-implementation performance contract is recorded by
+`benchmark-local`: at least 2 warmups and 9 retained samples per lane, raw
+samples plus median/p95/min/max/stddev, explicit contamination, and separate
+discovery/traversal, availability metadata, sniff/read/hash, conversion, and
+embedding phases. The controlled 5,000-file all-local production comparison
+used the same corpus and interleaved pre-implementation/current walkers; it
+passed the current-`any` ≤3% gate at -1.1280% and the hierarchical-`local` ≤10%
+gate at +1.1841%. It is not a provider-latency guarantee.
+
 ---
 
 ### gno setup

package/spec/output-schemas/mcp-job-status.schema.json

@@ -90,7 +90,8 @@
       "properties": {
         "relPath": { "type": "string" },
         "status": {
-          "enum": ["added", "updated", "unchanged", "error", "skipped"]
+          "enum": ["added", "updated", "unchanged", "error", "skipped"],
+          "description": "skipped is used for eligibility refusals (e.g. cloud placeholders, dataless directories) and other non-error skips; error is for fail-closed and I/O failures"
         },
         "docid": { "type": "string" },
         "mirrorHash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
@@ -98,7 +99,10 @@
         "contentTypeSource": {
           "enum": ["frontmatter-type", "prefix", "path-ext", "fallback"]
         },
-        "errorCode": { "type": "string" },
+        "errorCode": {
+          "type": "string",
+          "description": "Machine code for skipped/error outcomes. Source-availability codes include CLOUD_PLACEHOLDER, CLOUD_PARTIAL, DATALESS_DIRECTORY (status=skipped), and SOURCE_AVAILABILITY_UNSUPPORTED, SOURCE_AVAILABILITY_POLICY_FAILED, SOURCE_AVAILABILITY_UNKNOWN, PERMISSION, NOT_FOUND, NOT_FILE, IO_ERROR (fail-closed; unproven prefixes preserve indexed descendants). Distinct from collection egressPolicy."
+        },
         "errorMessage": { "type": "string" },
         "recordImport": {
           "$ref": "gno://schemas/record-import@1.0"

package/src/config/index.ts

@@ -60,6 +60,7 @@ export {
   type Config,
   ConfigSchema,
   DEFAULT_EGRESS_POLICY,
+  DEFAULT_SOURCE_AVAILABILITY,
   HttpGatewayConfigSchema,
   HttpGatewayLimitsSchema,
   CONTENT_TYPE_GRAPH_HINTS,
@@ -84,6 +85,9 @@ export {
   isValidLanguageHint,
   parseScope,
   resolveConfiguredEgressPolicy,
+  SOURCE_AVAILABILITY_MODES,
+  type SourceAvailabilityMode,
+  SourceAvailabilitySchema,
   type ProjectProfileBinding,
   ProjectProfileBindingSchema,
   type ScopeType,

package/src/config/types.ts

@@ -56,6 +56,12 @@ export type EgressPolicy = z.infer<typeof EgressPolicySchema>;
 /** Missing policy is always interpreted as the fail-closed local-only default. */
 export const DEFAULT_EGRESS_POLICY: EgressPolicy = "local_only";
 
+/** Source byte materialization boundary for collection indexing. */
+export const SOURCE_AVAILABILITY_MODES = ["any", "local"] as const;
+export const SourceAvailabilitySchema = z.enum(SOURCE_AVAILABILITY_MODES);
+export type SourceAvailabilityMode = z.infer<typeof SourceAvailabilitySchema>;
+export const DEFAULT_SOURCE_AVAILABILITY: SourceAvailabilityMode = "any";
+
 /** Provenance for an effective collection egress policy. */
 export const EGRESS_POLICY_SOURCES = [
   "explicit",
@@ -138,6 +144,14 @@ export const CollectionSchema = z.object({
    */
   egressPolicyRevision: z.number().int().nonnegative().optional(),
 
+  /**
+   * Source content availability policy for indexing. Distinct from egress:
+   * controls whether cloud placeholders may be materialized, not where data
+   * may leave the machine. Omitted / unset means `any` (legacy read behavior);
+   * `local` is opt-in and fails closed where the platform guard is unavailable.
+   */
+  sourceAvailability: SourceAvailabilitySchema.optional(),
+
   /** Optional per-collection model overrides */
   models: z
     .object({

package/src/core/path-rules.ts

@@ -51,3 +51,37 @@ export function matchesCollectionExclusion(
   }
   return false;
 }
+
+/**
+ * Whether a known directory is the root of a fully excluded subtree.
+ * A trailing `/**` excludes every descendant even though Bun.Glob does not
+ * match the directory root itself. Other partial glob shapes must still be
+ * traversed because they may leave eligible descendants.
+ */
+export function matchesCollectionSubtreeExclusion(
+  relPath: string,
+  excludes: readonly string[]
+): boolean {
+  const normalizedPath = relPath.replaceAll("\\", "/");
+  if (matchesCollectionExclusion(normalizedPath, excludes)) {
+    return true;
+  }
+
+  for (const rawPattern of excludes) {
+    const pattern = rawPattern.replaceAll("\\", "/");
+    if (pattern === "**") {
+      return true;
+    }
+    if (!pattern.endsWith("/**")) {
+      continue;
+    }
+    const subtreeRootPattern = pattern.slice(0, -3);
+    if (
+      subtreeRootPattern.length > 0 &&
+      new Bun.Glob(subtreeRootPattern).match(normalizedPath)
+    ) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/ingestion/index.ts

@@ -11,6 +11,27 @@ export { defaultLanguageDetector, SimpleLanguageDetector } from "./language";
 // Sync service
 export { defaultSyncService, SyncService } from "./sync";
 export { resolveContentTypeRules, withContentTypeRules } from "./sync-options";
+// Source availability (content-boundary guard)
+export {
+  createDirectoryAvailability,
+  createSourceContentReader,
+  DEFAULT_SOURCE_AVAILABILITY,
+  findUnprovenAvailabilityPrefix,
+  isSourceAvailabilitySkip,
+  isUnprovenAbsenceCode,
+  memoizeDirectoryAvailability,
+  relPathUnderAnyPrefix,
+  resolveSourceAvailability,
+  SOURCE_AVAILABILITY_MODES,
+} from "./source-availability";
+export type {
+  DirectoryAvailabilityPort,
+  DirectoryAvailabilityResult,
+  SourceAvailabilityCode,
+  SourceAvailabilityMode,
+  SourceContentReaderPort,
+  SourceReadResult,
+} from "./source-availability";
 // Types
 export type {
   ChunkerPort,

package/src/ingestion/record-container.ts

@@ -58,6 +58,11 @@ interface RecordContainerInput {
   sourceMtime: string;
   sourceSize: number;
   store: StorePort;
+  /**
+   * Optional pre-read source bytes from the guarded content boundary.
+   * When set, record import streams from this buffer and never reopens the path.
+   */
+  sourceBytes?: Uint8Array;
 }
 
 interface AppliedRecordReconciliation {
@@ -283,6 +288,20 @@ const sourceStream = (
   },
 });
 
+const bytesStream = (
+  bytes: Uint8Array,
+  signal?: AbortSignal
+): AsyncIterable<Uint8Array> => ({
+  async *[Symbol.asyncIterator]() {
+    if (signal?.aborted) {
+      throw new Error("record adapter aborted");
+    }
+    if (bytes.byteLength > 0) {
+      yield bytes;
+    }
+  },
+});
+
 const loadPreviousStructure = async (
   store: StorePort,
   existing: DocumentRow | undefined
@@ -443,7 +462,10 @@ export async function processRecordContainer(
       collection: input.collection.name,
       mime: input.mime,
       ext: input.ext,
-      open: (signal) => sourceStream(input.entry.absPath, signal),
+      open: (signal) =>
+        input.sourceBytes
+          ? bytesStream(input.sourceBytes, signal)
+          : sourceStream(input.entry.absPath, signal),
       limits: {
         ...DEFAULT_RECORD_ADAPTER_LIMITS,
         timeoutMs: Math.min(

package/src/ingestion/source-availability/darwin-io.ts

@@ -0,0 +1,295 @@
+/**
+ * Darwin FFI backend for no-materialization I/O policy and guarded content reads.
+ * Provider-neutral; reuses the TN3150 mechanism proven in
+ * scripts/macos-file-provider-smoke.ts (IOPOL_TYPE_VFS_MATERIALIZE_DATALESS_FILES).
+ * No provider SDK; no pin/evict/download/availability mutation.
+ *
+ * @module src/ingestion/source-availability/darwin-io
+ */
+
+// bun:ffi — getiopolicy_np/setiopolicy_np/open/read require libc FFI; no Bun high-level equivalent
+import { dlopen, FFIType, ptr, toArrayBuffer } from "bun:ffi";
+// node:fs constants expose Darwin O_NOFOLLOW; Bun has no file-open flag API.
+import { constants as fsConstants } from "node:fs";
+
+/** TN3150 / File Provider constants (from smoke harness evidence). */
+export const SF_DATALESS = 0x4000_0000;
+export const IOPOL_TYPE_VFS_MATERIALIZE_DATALESS_FILES = 3;
+export const IOPOL_SCOPE_PROCESS = 0;
+export const IOPOL_MATERIALIZE_DATALESS_FILES_OFF = 1;
+/** Darwin errno for guarded dataless materialization refusal. */
+export const DARWIN_EDEADLK = 11;
+export const DARWIN_EACCES = 13;
+export const DARWIN_EPERM = 1;
+export const DARWIN_ENOENT = 2;
+export const DARWIN_EISDIR = 21;
+export const DARWIN_ELOOP = 62;
+export const DARWIN_EIO = 5;
+const OPEN_RDONLY_NOFOLLOW = fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW;
+
+export type DarwinIoPolicyPort = {
+  get: (type: number, scope: number) => number;
+  set: (type: number, scope: number, policy: number) => number;
+  readErrno: () => number;
+};
+
+export type DarwinFileIoPort = {
+  open: (absPath: string, flags: number) => number;
+  read: (fd: number, buf: Uint8Array) => number;
+  close: (fd: number) => number;
+  readErrno: () => number;
+};
+
+/**
+ * No-follow lstat of `st_flags` for SF_DATALESS directory classification.
+ * Distinct from content open/read — used only at directory boundaries.
+ */
+export type DarwinStatPort = {
+  lstatFlags: (
+    absPath: string
+  ) => { ok: true; stFlags: number } | { ok: false; errno: number };
+};
+
+export type DarwinIoBundle = {
+  policy: DarwinIoPolicyPort;
+  file: DarwinFileIoPort;
+  stat: DarwinStatPort;
+};
+
+/** Darwin `struct stat` layout used by the smoke harness (arm64/x86_64). */
+export const DARWIN_STAT_BUF_SIZE = 144;
+export const DARWIN_ST_FLAGS_OFFSET = 116;
+
+type LibSymbols = {
+  getiopolicy_np: (type: number, scope: number) => number;
+  setiopolicy_np: (type: number, scope: number, policy: number) => number;
+  open: (path: ReturnType<typeof ptr>, flags: number) => number;
+  close: (fd: number) => number;
+  read: (fd: number, buf: ReturnType<typeof ptr>, n: bigint) => bigint;
+  lstat: (path: ReturnType<typeof ptr>, buf: ReturnType<typeof ptr>) => number;
+  __error: () => ReturnType<typeof ptr> | null;
+};
+
+let cachedBundle: DarwinIoBundle | null | undefined;
+
+/** Test-only: clear FFI caches between cases. */
+export function resetDarwinIoCachesForTests(): void {
+  cachedBundle = undefined;
+}
+
+function asFn<T extends (...args: never[]) => unknown>(
+  value: unknown
+): T | null {
+  return typeof value === "function" ? (value as T) : null;
+}
+
+function cstr(value: string): Uint8Array {
+  return Buffer.from(`${value}\0`);
+}
+
+function readErrnoFrom(symbols: LibSymbols): number {
+  const p = symbols.__error();
+  if (!p) {
+    return 0;
+  }
+  return new Int32Array(toArrayBuffer(p, 0, 4))[0] ?? 0;
+}
+
+function loadLibSystem(): {
+  library: ReturnType<typeof dlopen>;
+  symbols: LibSymbols;
+} | null {
+  if (process.platform !== "darwin") {
+    return null;
+  }
+  for (const soname of ["libSystem.B.dylib", "libSystem.dylib"]) {
+    try {
+      const library = dlopen(soname, {
+        getiopolicy_np: {
+          args: [FFIType.i32, FFIType.i32],
+          returns: FFIType.i32,
+        },
+        setiopolicy_np: {
+          args: [FFIType.i32, FFIType.i32, FFIType.i32],
+          returns: FFIType.i32,
+        },
+        open: { args: [FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+        close: { args: [FFIType.i32], returns: FFIType.i32 },
+        read: {
+          args: [FFIType.i32, FFIType.ptr, FFIType.u64],
+          returns: FFIType.i64,
+        },
+        lstat: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+        __error: { args: [], returns: FFIType.ptr },
+      });
+      const raw = library.symbols as Record<string, unknown>;
+      const getiopolicy_np = asFn<LibSymbols["getiopolicy_np"]>(
+        raw.getiopolicy_np
+      );
+      const setiopolicy_np = asFn<LibSymbols["setiopolicy_np"]>(
+        raw.setiopolicy_np
+      );
+      const openFn = asFn<LibSymbols["open"]>(raw.open);
+      const closeFn = asFn<LibSymbols["close"]>(raw.close);
+      const readFn = asFn<LibSymbols["read"]>(raw.read);
+      const lstatFn = asFn<LibSymbols["lstat"]>(raw.lstat);
+      const errorFn = asFn<LibSymbols["__error"]>(raw.__error);
+      if (
+        !getiopolicy_np ||
+        !setiopolicy_np ||
+        !openFn ||
+        !closeFn ||
+        !readFn ||
+        !lstatFn ||
+        !errorFn
+      ) {
+        continue;
+      }
+      return {
+        library,
+        symbols: {
+          getiopolicy_np,
+          setiopolicy_np,
+          open: openFn,
+          close: closeFn,
+          read: readFn,
+          lstat: lstatFn,
+          __error: errorFn,
+        },
+      };
+    } catch {
+      // try next soname
+    }
+  }
+  return null;
+}
+
+/** Load Darwin policy + file I/O ports; null when unavailable. */
+export function loadDarwinIo(): DarwinIoBundle | null {
+  if (cachedBundle !== undefined) {
+    return cachedBundle;
+  }
+  const loaded = loadLibSystem();
+  if (!loaded) {
+    cachedBundle = null;
+    return null;
+  }
+  const { symbols } = loaded;
+  const readErrno = (): number => readErrnoFrom(symbols);
+  cachedBundle = {
+    policy: {
+      get: symbols.getiopolicy_np,
+      set: symbols.setiopolicy_np,
+      readErrno,
+    },
+    file: {
+      open: (absPath: string, flags: number): number =>
+        symbols.open(ptr(cstr(absPath)), flags),
+      read: (fd: number, buf: Uint8Array): number =>
+        Number(symbols.read(fd, ptr(buf), BigInt(buf.byteLength))),
+      close: symbols.close,
+      readErrno,
+    },
+    stat: {
+      lstatFlags: (absPath: string) => {
+        const buf = new Uint8Array(DARWIN_STAT_BUF_SIZE);
+        const rc = symbols.lstat(ptr(cstr(absPath)), ptr(buf));
+        if (rc !== 0) {
+          return { ok: false as const, errno: readErrno() };
+        }
+        const stFlags = new DataView(
+          buf.buffer,
+          buf.byteOffset,
+          buf.byteLength
+        ).getUint32(DARWIN_ST_FLAGS_OFFSET, true);
+        return { ok: true as const, stFlags };
+      },
+    },
+  };
+  // Keep library strongly referenced via symbols closure for process lifetime.
+  void loaded.library;
+  return cachedBundle;
+}
+
+/**
+ * Run `fn` under process-scoped IOPOL_MATERIALIZE_DATALESS_FILES_OFF.
+ * Always restores prior policy. Fail-closed on setup/restore failure.
+ */
+export function withNoMaterializePolicy<T>(
+  run: () => T,
+  port: DarwinIoPolicyPort
+):
+  | { ok: true; value: T }
+  | {
+      ok: false;
+      error:
+        | "policy_get_failed"
+        | "policy_set_failed"
+        | "policy_restore_failed";
+    } {
+  let prior: number;
+  try {
+    prior = port.get(
+      IOPOL_TYPE_VFS_MATERIALIZE_DATALESS_FILES,
+      IOPOL_SCOPE_PROCESS
+    );
+  } catch {
+    return { ok: false, error: "policy_get_failed" };
+  }
+  if (prior < 0) {
+    return { ok: false, error: "policy_get_failed" };
+  }
+  let setupResult: number;
+  try {
+    setupResult = port.set(
+      IOPOL_TYPE_VFS_MATERIALIZE_DATALESS_FILES,
+      IOPOL_SCOPE_PROCESS,
+      IOPOL_MATERIALIZE_DATALESS_FILES_OFF
+    );
+  } catch {
+    return { ok: false, error: "policy_set_failed" };
+  }
+  if (setupResult !== 0) {
+    return { ok: false, error: "policy_set_failed" };
+  }
+  let value: T;
+  let thrown: unknown;
+  try {
+    value = run();
+  } catch (error) {
+    thrown = error;
+  }
+  let restoreResult: number;
+  try {
+    restoreResult = port.set(
+      IOPOL_TYPE_VFS_MATERIALIZE_DATALESS_FILES,
+      IOPOL_SCOPE_PROCESS,
+      prior
+    );
+  } catch {
+    return { ok: false, error: "policy_restore_failed" };
+  }
+  if (restoreResult !== 0) {
+    return { ok: false, error: "policy_restore_failed" };
+  }
+  if (thrown !== undefined) {
+    throw thrown;
+  }
+  return { ok: true, value: value! };
+}
+
+export function guardedOpenFlags(): number {
+  return OPEN_RDONLY_NOFOLLOW;
+}
+
+export function classifyGuardedReadErrno(
+  errno: number
+): "EDEADLK" | "EACCES" | "EPERM" | "ENOENT" | "EISDIR" | "ELOOP" | "OTHER" {
+  if (errno === DARWIN_EDEADLK) return "EDEADLK";
+  if (errno === DARWIN_EACCES) return "EACCES";
+  if (errno === DARWIN_EPERM) return "EPERM";
+  if (errno === DARWIN_ENOENT) return "ENOENT";
+  if (errno === DARWIN_EISDIR) return "EISDIR";
+  if (errno === DARWIN_ELOOP) return "ELOOP";
+  return "OTHER";
+}

package/src/ingestion/source-availability/darwin-path.ts

@@ -0,0 +1,58 @@
+/**
+ * Metadata-free recognition of the macOS File Provider layouts covered by the
+ * physical fn-118 evidence. This is intentionally narrower than all paths on
+ * Darwin: unknown storage must not inherit a no-materialization guarantee.
+ */
+
+// node:os — Bun has no home-directory helper.
+import { homedir } from "node:os";
+// node:path — Bun has no path normalization/relative helpers.
+import { isAbsolute, relative, resolve, sep } from "node:path";
+
+export type DarwinFileProviderPathSupport =
+  | "google-drive"
+  | "icloud-drive"
+  | "onedrive-sharepoint"
+  | "unsupported"
+  | "unknown";
+
+export function classifyDarwinFileProviderPath(
+  absPath: string,
+  home: string = homedir()
+): DarwinFileProviderPathSupport {
+  if (!isAbsolute(absPath) || !isAbsolute(home)) {
+    return "unknown";
+  }
+  const relativeHomePath = relative(resolve(home), resolve(absPath));
+  if (
+    relativeHomePath === ".." ||
+    relativeHomePath.startsWith(`..${sep}`) ||
+    isAbsolute(relativeHomePath)
+  ) {
+    return "unsupported";
+  }
+  const parts = relativeHomePath.split(sep);
+  if (
+    parts[0] === "Library" &&
+    parts[1] === "Mobile Documents" &&
+    parts[2] === "com~apple~CloudDocs"
+  ) {
+    return "icloud-drive";
+  }
+  if (parts[0] !== "Library" || parts[1] !== "CloudStorage") {
+    return "unsupported";
+  }
+  const domain = parts[2];
+  if (domain?.startsWith("GoogleDrive-") && parts[3] === "My Drive") {
+    return "google-drive";
+  }
+  if (
+    domain?.startsWith("OneDrive-") &&
+    domain.includes("SharedLibraries") &&
+    typeof parts[3] === "string" &&
+    parts[3].length > 0
+  ) {
+    return "onedrive-sharepoint";
+  }
+  return "unsupported";
+}