@aigne/afs-did-space 1.12.0-beta.5

package/dist/memory-tree-index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-tree-index.mjs","names":[],"sources":["../src/memory-tree-index.ts"],"sourcesContent":["/**\n * MemoryTreeIndex — in-memory implementation of TreeIndex for testing.\n *\n * Task 2.4a: maintains an in-memory `changelog` array that mirrors the\n * D1/libsql changelog table. No persistence, no libsql dependency — the goal\n * is a pure-data-structure impl so tests can assert against the same row\n * shape that production code will see on the wire. Access the array via\n * `getChangelogSnapshot()`.\n */\n\nimport { watermarkPrefix, watermarkWritePrefix } from \"./changelog-schema.js\";\nimport { validateDeviceId } from \"./changelog-write.js\";\nimport { ancestorDirs, nameOf, parentOf } from \"./d1-tree-index.js\";\nimport {\n  applyDirtyUpsert,\n  type DirtyPathRow,\n  type DirtyPathStoredRow,\n  type ListDirtyPathOptions,\n} from \"./dirty-path-queue.js\";\nimport {\n  INLINE_CONTENT_HARD_CAP,\n  type InlineContentOptions,\n  type ResolvedInlineConfig,\n  resolveInlineConfig,\n  resolveInlineContent,\n  utf8ByteLength,\n} from \"./inline-content.js\";\nimport { prefixRange } from \"./prefix-range.js\";\nimport { resolveParentDirStamp } from \"./timestamp.js\";\nimport {\n  type BatchDeleteEntry,\n  type BatchDeleteEntryResult,\n  type BatchIndexContext,\n  type BatchPutEntry,\n  type BatchPutEntryResult,\n  buildKeysetCursor,\n  type ChangelogEntry,\n  compareTreeSortValues,\n  keysetAfter,\n  loopBatchDeleteEntries,\n  loopBatchPutEntries,\n  type PutOpts,\n  parseTreeCursor,\n  type TreeEntry,\n  type TreeIndex,\n  type TreeIndexListEntriesResult,\n  type TreeIndexListOptions,\n  type TreeIndexListResult,\n  treeEntryMetadataEqual,\n} from \"./tree-index.js\";\nimport {\n  parseRecordText,\n  runTreeQueryInMemory,\n  type TreeQueryCandidate,\n  type TreeQueryResult,\n  type TreeQuerySpec,\n} from \"./tree-query.js\";\n\n/**\n * Sort-value extraction for the ordered (explicit orderBy) listing path —\n * mirrors the SQL impls' column semantics: `name`/`path` are strings,\n * numbers stay numbers, missing mimeType is NULL (sorts last).\n */\nfunction orderSortValue(\n  path: string,\n  entry: Pick<TreeEntry, \"size\" | \"mtime\" | \"ctime\" | \"mimeType\">,\n  orderBy: NonNullable<TreeIndexListOptions[\"orderBy\"]>,\n): string | number | null {\n  switch (orderBy) {\n    case \"name\":\n      return nameOf(path);\n    case \"path\":\n      return path;\n    case \"mimeType\":\n      return entry.mimeType ?? null;\n    default:\n      return entry[orderBy];\n  }\n}\n\n/**\n * Apply the includeContent projection to an in-memory page: stored inline\n * content is surfaced ONLY under `{ includeContent: true }` — mirroring the\n * SQL impls, whose default SELECT never projects the content column.\n */\nfunction projectContent(\n  page: TreeIndexListEntriesResult,\n  options?: TreeIndexListOptions,\n): TreeIndexListEntriesResult {\n  if (options?.includeContent) return page;\n  return {\n    ...page,\n    entries: page.entries.map((e) => {\n      if (e.content === undefined) return e;\n      const { content: _content, ...rest } = e;\n      return rest;\n    }),\n  };\n}\n\nexport class MemoryTreeIndex implements TreeIndex {\n  private entries = new Map<string, TreeEntry>();\n  /**\n   * DIR rows with their timestamps. Was a `Set<string>` (existence only);\n   * upgraded to a `Map` carrying `{ ctime, mtime }` so Rule R2 (feed-sort\n   * §5.3) can stamp a direct parent's ctime and `collectChildren` can surface\n   * it (the SQL backends sort doc-mode dir rows by `e.ctime`) — keeping the\n   * memory backend in lockstep with D1/SQLite.\n   */\n  private dirEntries = new Map<string, { ctime: number; mtime: number }>();\n  /** Phase 2: in-memory mirror of the `changelog` table. */\n  private changelog: ChangelogEntry[] = [];\n  /**\n   * index-follower-dirty-path — in-memory mirror of the `ds_dirty_path` table.\n   * Keyed `${scope}\\x00${path}`, updated through {@link applyDirtyUpsert} on\n   * every changelog append so its merge/guard semantics match the SQL trigger\n   * byte-for-byte. There is no DB trigger here, so {@link pushChangelog} is the\n   * single hook every write path funnels through.\n   */\n  private dirtyMap = new Map<string, DirtyPathStoredRow>();\n  /** Monotonic seq counter mirroring `AUTOINCREMENT` in the SQL impl. */\n  private nextSeq = 1;\n  /** Live Update Resilience §11.4 — in-memory mirror of `prefix_watermark`. */\n  private watermarks = new Map<string, number>();\n  /**\n   * Dedup-on-write secondary index (#1159) — in-memory mirror of the\n   * `(scope, dedup_scope, dedup_key)` partial UNIQUE index. Keyed\n   * `${dedupScope}\\x00${dedupKey}` → path. Maintained on put/delete; enforces\n   * uniqueness (the SQL backends get it from the DB index).\n   */\n  private dedupIndex = new Map<string, string>();\n  /** Logical scope string baked into every changelog row (default \"\"). */\n  private readonly scope: string;\n  private readonly inline: ResolvedInlineConfig;\n\n  constructor(opts?: { scope?: string } & InlineContentOptions) {\n    this.scope = opts?.scope ?? \"\";\n    this.inline = resolveInlineConfig(opts);\n  }\n\n  /**\n   * Return a read-only snapshot of the in-memory changelog.\n   *\n   * Used by unit tests to assert that the correct row shape was appended on\n   * each put/delete. Production code never calls this.\n   */\n  getChangelogSnapshot(): readonly ChangelogEntry[] {\n    return this.changelog;\n  }\n\n  /**\n   * The single append hook for the in-memory changelog. Mirrors the SQL\n   * `AFTER INSERT ON ds_changelog` trigger: it appends the row AND folds it into\n   * the dirty map via {@link applyDirtyUpsert} (same latest_seq guard + backoff\n   * reset). Every write path (`put` / `delete` / `deleteByPrefix`; `putBatch`\n   * and the batch* methods loop those) funnels through here, so the dirty map\n   * covers all six TreeIndex write methods for free — the Memory-backend twin of\n   * the trigger's \"covers every write face by construction\".\n   */\n  private pushChangelog(row: ChangelogEntry, now: number): void {\n    this.changelog.push(row);\n    const key = `${row.scope}\\x00${row.path}`;\n    this.dirtyMap.set(\n      key,\n      applyDirtyUpsert(this.dirtyMap.get(key), {\n        scope: row.scope,\n        path: row.path,\n        latestSeq: row.seq,\n        op: row.op,\n        cid: row.cid,\n        mtime: row.mtime,\n        updatedAt: now,\n      }),\n    );\n  }\n\n  async get(path: string, _opts?: { includeContent?: boolean }): Promise<TreeEntry | null> {\n    // includeContent is a SQL-projection hint; the in-memory row already holds\n    // content at zero marshalling cost, so it is honored as a no-op here.\n    return this.entries.get(path) ?? null;\n  }\n\n  async getDirTimes(dirPath: string): Promise<{ ctime: number; mtime: number } | null> {\n    const dir = this.dirEntries.get(dirPath);\n    return dir ? { ctime: dir.ctime, mtime: dir.mtime } : null;\n  }\n\n  async put(path: string, entry: TreeEntry, opts: PutOpts): Promise<{ oldCid?: string }> {\n    validateDeviceId(opts.deviceId);\n    const existing = this.entries.get(path);\n    // Code-level equivalent of the SQL impls' DDL hard cap (no DDL here).\n    const inlineContent = await resolveInlineContent(entry, this.inline);\n    // Skip-if-unchanged: re-writing identical content at an existing path is a\n    // no-op (cid IS the content hash + the optimistic-concurrency version).\n    // Matching cid+mimeType ⇒ nothing changed, so skip the changelog row +\n    // entry rewrite. Same contract as D1TreeIndex.put / SqliteTreeIndex.put.\n    //\n    // EXCEPTION (inline write-through re-fill): when inline caching is on, the\n    // inline `content` must also already match what this write would store —\n    // otherwise a row whose cid matches but whose inline copy was lost\n    // (legacy/unfilled / externally voided) would never be re-filled. Skip only\n    // when the stored copy already equals the would-be one.\n    if (\n      existing &&\n      existing.cid === entry.cid &&\n      existing.mimeType === entry.mimeType &&\n      treeEntryMetadataEqual(existing.metadata, entry.metadata)\n    ) {\n      // Metadata-aware skip (did-space-metadata G4): a metadata-only change\n      // keeps the same cid — fall through to re-store so it lands.\n      if (this.inline.inlineCache !== \"on\" || (existing.content ?? null) === inlineContent) {\n        return { oldCid: existing.cid };\n      }\n      // Inline copy out of sync — fall through to re-store (re-fill or clear).\n    }\n    if (inlineContent !== null && utf8ByteLength(inlineContent) > INLINE_CONTENT_HARD_CAP) {\n      throw new Error(`inline content exceeds hard cap (${INLINE_CONTENT_HARD_CAP} bytes)`);\n    }\n    const stored: TreeEntry = {\n      cid: entry.cid,\n      size: entry.size,\n      mtime: entry.mtime,\n      ctime: existing?.ctime ?? entry.ctime,\n      mimeType: entry.mimeType,\n    };\n    // Stored only when resolved — an overwrite without inline content clears\n    // any prior copy (never stale relative to the new cid).\n    if (inlineContent !== null) stored.content = inlineContent;\n    // Application metadata (planning/agent-hub/metadata-foundation.md).\n    // Memory backend mirrors SQL behaviour: overwrite always replaces; missing\n    // or empty meta clears the prior value (no stale persistence).\n    if (entry.metadata && Object.keys(entry.metadata).length > 0) {\n      stored.metadata = { ...entry.metadata };\n    }\n    // Dedup-on-write columns (#1159): COALESCE — a write that omits them (a\n    // plain edit of a dedup row) preserves the existing dedup identity so the\n    // row never drops out of the index; a dedup write / reindex sets them.\n    // Mirror of the SQL upserts' `COALESCE(excluded.dedup_*, ds_entries.dedup_*)`.\n    const nextDedupScope = entry.dedupScope ?? existing?.dedupScope;\n    const nextDedupKey = entry.dedupKey ?? existing?.dedupKey;\n    if (nextDedupKey != null) {\n      this.assertDedupUnique(nextDedupScope, nextDedupKey, path);\n      stored.dedupScope = nextDedupScope;\n      stored.dedupKey = nextDedupKey;\n    }\n    this.updateDedupMapping(existing, nextDedupScope, nextDedupKey, path);\n    this.entries.set(path, stored);\n    // Auto-create parent directories\n    this.ensureParentDirs(path);\n    // Rule R2 (feed-sort §5.3): stamp the DIRECT parent's ctime/mtime from this\n    // write's application createdAt (when present). This is an UNCONDITIONAL\n    // Map.set — independent of the `.has()` early-exit in ensureParentDirs, so\n    // an already-existing direct parent is overwritten (mirrors the SQL\n    // `ON CONFLICT DO UPDATE`); ancestors are never propagated to.\n    const dirStamp = resolveParentDirStamp(entry.metadata);\n    if (dirStamp) {\n      const directParent = parentOf(path);\n      if (directParent) this.dirEntries.set(directParent, dirStamp);\n    }\n\n    if (!opts.skipChangelog) {\n      this.pushChangelog(\n        {\n          seq: this.nextSeq++,\n          scope: this.scope,\n          path,\n          op: \"put\",\n          cid: entry.cid,\n          old_cid: existing?.cid ?? null,\n          size: entry.size,\n          mtime: entry.mtime,\n          device_id: opts.deviceId,\n        },\n        Date.now(),\n      );\n      this.bumpWatermark(watermarkWritePrefix(path));\n    }\n\n    return { oldCid: existing?.cid };\n  }\n\n  /** Inline content this entry would store — drives loopBatchPutEntries' content-aware skip. */\n  inlineForEntry(entry: TreeEntry): Promise<string | null> {\n    return resolveInlineContent(entry, this.inline);\n  }\n\n  // ========== Dedup-on-write secondary index (#1159) ==========\n\n  private dedupMapKey(dedupScope: string | undefined, dedupKey: string): string {\n    return `${dedupScope ?? \"\"}\\x00${dedupKey}`;\n  }\n\n  /** Mirror the `(scope, dedup_scope, dedup_key)` UNIQUE constraint. */\n  private assertDedupUnique(dedupScope: string | undefined, dedupKey: string, path: string): void {\n    const held = this.dedupIndex.get(this.dedupMapKey(dedupScope, dedupKey));\n    if (held !== undefined && held !== path) {\n      // Message mirrors SQLite so any string-based detection stays uniform.\n      throw new Error(\"UNIQUE constraint failed: ds_entries.dedup_scope, ds_entries.dedup_key\");\n    }\n  }\n\n  private dropDedupMapping(dedupScope: string | undefined, dedupKey: string, path: string): void {\n    const k = this.dedupMapKey(dedupScope, dedupKey);\n    if (this.dedupIndex.get(k) === path) this.dedupIndex.delete(k);\n  }\n\n  /** Re-point the dedup map for `path`: drop its stale mapping, set the new one. */\n  private updateDedupMapping(\n    existing: TreeEntry | undefined,\n    nextDedupScope: string | undefined,\n    nextDedupKey: string | undefined,\n    path: string,\n  ): void {\n    if (existing?.dedupKey != null) {\n      this.dropDedupMapping(existing.dedupScope, existing.dedupKey, path);\n    }\n    if (nextDedupKey != null) {\n      this.dedupIndex.set(this.dedupMapKey(nextDedupScope, nextDedupKey), path);\n    }\n  }\n\n  async findByDedupKey(\n    dedupScope: string,\n    dedupKey: string,\n  ): Promise<({ path: string } & TreeEntry) | null> {\n    const path = this.dedupIndex.get(this.dedupMapKey(dedupScope, dedupKey));\n    if (path === undefined) return null;\n    const entry = this.entries.get(path);\n    return entry ? { path, ...entry } : null;\n  }\n\n  async setDedupKey(\n    path: string,\n    dedupScope: string,\n    dedupKey: string,\n    opts: PutOpts,\n  ): Promise<void> {\n    validateDeviceId(opts.deviceId);\n    const entry = this.entries.get(path);\n    if (!entry) return; // no-op for a missing path (contract parity with SQL)\n    this.assertDedupUnique(dedupScope, dedupKey, path);\n    this.updateDedupMapping(entry, dedupScope, dedupKey, path);\n    entry.dedupScope = dedupScope;\n    entry.dedupKey = dedupKey;\n  }\n\n  /** Bump a collection root's watermark by 1 (lazy-create at 1). No-op for null. */\n  private bumpWatermark(prefix: string | null): void {\n    if (prefix === null) return;\n    this.watermarks.set(prefix, (this.watermarks.get(prefix) ?? 0) + 1);\n  }\n\n  async getPrefixWatermark(prefix: string): Promise<number | null> {\n    const wmPrefix = watermarkPrefix(prefix);\n    if (wmPrefix === null) return null;\n    return this.watermarks.get(wmPrefix) ?? 0;\n  }\n\n  async delete(path: string, opts: PutOpts): Promise<void> {\n    validateDeviceId(opts.deviceId);\n    const existing = this.entries.get(path);\n    this.entries.delete(path);\n    if (existing?.dedupKey != null) {\n      this.dropDedupMapping(existing.dedupScope, existing.dedupKey, path);\n    }\n    // Clean up empty parent directories\n    this.cleanEmptyParents(path);\n\n    if (existing && !opts.skipChangelog) {\n      this.pushChangelog(\n        {\n          seq: this.nextSeq++,\n          scope: this.scope,\n          path,\n          op: \"delete\",\n          cid: null,\n          old_cid: existing.cid,\n          size: null,\n          // T1.5: client mtime when supplied (echo prevention + LWW), else server clock.\n          mtime: opts.mtime ?? Date.now(),\n          device_id: opts.deviceId,\n        },\n        Date.now(),\n      );\n      this.bumpWatermark(watermarkWritePrefix(path));\n    }\n  }\n\n  private cleanEmptyParents(path: string): void {\n    for (const dirPath of ancestorDirs(path)) {\n      if (!this.dirEntries.has(dirPath)) break;\n\n      // Check if dir still has any children (files or subdirs)\n      let hasChildren = false;\n      for (const p of this.entries.keys()) {\n        if (parentOf(p) === dirPath) {\n          hasChildren = true;\n          break;\n        }\n      }\n      if (!hasChildren) {\n        for (const d of this.dirEntries.keys()) {\n          if (d !== dirPath && parentOf(d) === dirPath) {\n            hasChildren = true;\n            break;\n          }\n        }\n      }\n\n      if (hasChildren) break;\n      this.dirEntries.delete(dirPath);\n    }\n  }\n\n  private static readonly VALID_ORDER_BY = new Set([\n    \"path\",\n    \"mtime\",\n    \"size\",\n    \"ctime\",\n    \"mimeType\",\n    \"name\",\n  ]);\n\n  /**\n   * Ordered + keyset-paged listing shared by listEntries/listChildren when\n   * an explicit orderBy is set — same semantics as the SQL impls (NULL\n   * mimeType last in both directions, unique-tie keyset resume, v2 cursor).\n   */\n  private orderedPage<T extends { path: string } & TreeEntry>(\n    rows: T[],\n    options: TreeIndexListOptions,\n    tieOf: (row: T) => string,\n  ): TreeIndexListEntriesResult {\n    const orderBy = options.orderBy!;\n    if (!MemoryTreeIndex.VALID_ORDER_BY.has(orderBy)) {\n      throw new Error(`Invalid orderBy: ${orderBy}`);\n    }\n    const order = options.order === \"desc\" ? \"desc\" : \"asc\";\n    const limit = options.limit ?? 1000;\n    const parsed = parseTreeCursor(options.cursor, true);\n\n    const sorted = [...rows].sort((a, b) => {\n      const cmp = compareTreeSortValues(\n        orderSortValue(a.path, a, orderBy),\n        orderSortValue(b.path, b, orderBy),\n        order,\n      );\n      if (cmp !== 0) return cmp;\n      const at = tieOf(a);\n      const bt = tieOf(b);\n      const tieCmp = at === bt ? 0 : at < bt ? -1 : 1;\n      return order === \"desc\" ? -tieCmp : tieCmp;\n    });\n\n    const filtered =\n      parsed.kind === \"v2\"\n        ? sorted.filter((row) =>\n            keysetAfter(orderSortValue(row.path, row, orderBy), tieOf(row), parsed.cursor, order),\n          )\n        : sorted;\n\n    const hasMore = filtered.length > limit;\n    const selected = hasMore ? filtered.slice(0, limit) : filtered;\n    const last = selected[selected.length - 1];\n    return {\n      entries: selected,\n      hasMore,\n      cursor:\n        hasMore && last\n          ? buildKeysetCursor(orderSortValue(last.path, last, orderBy), tieOf(last))\n          : undefined,\n    };\n  }\n\n  async list(prefix: string, options?: TreeIndexListOptions): Promise<TreeIndexListResult> {\n    const limit = options?.limit ?? 1000;\n    const orderBy = options?.orderBy ?? \"path\";\n    const order = options?.order ?? \"asc\";\n    const cursor = options?.cursor;\n\n    if (!MemoryTreeIndex.VALID_ORDER_BY.has(orderBy)) {\n      throw new Error(`Invalid orderBy: ${orderBy}`);\n    }\n\n    if (limit === 0) {\n      return { entries: [], hasMore: false };\n    }\n\n    // Collect matching entries (files only for backward compat)\n    const matched: Array<{ path: string; entry: TreeEntry }> = [];\n    for (const [p, e] of this.entries) {\n      if (p.startsWith(prefix)) {\n        matched.push({ path: p, entry: e });\n      }\n    }\n\n    // Sort\n    matched.sort((a, b) => {\n      let cmp: number;\n      if (orderBy === \"path\") {\n        cmp = a.path.localeCompare(b.path);\n      } else if (orderBy === \"name\") {\n        cmp = nameOf(a.path).localeCompare(nameOf(b.path));\n      } else if (orderBy === \"mimeType\") {\n        cmp = (a.entry.mimeType ?? \"\").localeCompare(b.entry.mimeType ?? \"\");\n      } else {\n        cmp = (a.entry[orderBy] as number) - (b.entry[orderBy] as number);\n      }\n      return order === \"desc\" ? -cmp : cmp;\n    });\n\n    // Apply cursor (filter entries after cursor value)\n    let filtered = matched;\n    if (cursor) {\n      filtered = matched.filter((item) => {\n        let val: string | number;\n        if (orderBy === \"path\") {\n          val = item.path;\n        } else if (orderBy === \"name\") {\n          val = nameOf(item.path);\n        } else if (orderBy === \"mimeType\") {\n          val = item.entry.mimeType ?? \"\";\n        } else {\n          val = item.entry[orderBy] as number;\n        }\n        const strVal = String(val);\n        const stringKey = orderBy === \"path\" || orderBy === \"name\" || orderBy === \"mimeType\";\n        if (order === \"asc\") {\n          return stringKey ? strVal > cursor : Number(strVal) > Number(cursor);\n        }\n        return stringKey ? strVal < cursor : Number(strVal) < Number(cursor);\n      });\n    }\n\n    const hasMore = filtered.length > limit;\n    const selected = hasMore ? filtered.slice(0, limit) : filtered;\n\n    let nextCursor: string | undefined;\n    if (hasMore && selected.length > 0) {\n      const last = selected[selected.length - 1]!;\n      if (orderBy === \"path\") {\n        nextCursor = last.path;\n      } else if (orderBy === \"name\") {\n        nextCursor = nameOf(last.path);\n      } else if (orderBy === \"mimeType\") {\n        nextCursor = last.entry.mimeType ?? \"\";\n      } else {\n        nextCursor = String(last.entry[orderBy]);\n      }\n    }\n\n    return {\n      entries: selected.map((s) => ({ path: s.path })),\n      hasMore,\n      cursor: nextCursor,\n    };\n  }\n\n  async listEntries(\n    prefix: string,\n    options?: TreeIndexListOptions,\n  ): Promise<TreeIndexListEntriesResult> {\n    const limit = options?.limit ?? 1000;\n    const orderBy = options?.orderBy ?? \"path\";\n    const order = options?.order ?? \"asc\";\n\n    if (!MemoryTreeIndex.VALID_ORDER_BY.has(orderBy)) {\n      throw new Error(`Invalid orderBy: ${orderBy}`);\n    }\n\n    if (limit === 0) {\n      return { entries: [], hasMore: false };\n    }\n\n    // Explicit orderBy → ordered keyset path (path is the unique tiebreak).\n    if (options?.orderBy !== undefined) {\n      const rows: Array<{ path: string } & TreeEntry> = [];\n      for (const [p, e] of this.entries) {\n        if (p.startsWith(prefix)) rows.push({ path: p, ...e });\n      }\n      return projectContent(\n        this.orderedPage(rows, options, (row) => row.path),\n        options,\n      );\n    }\n\n    const parsedCursor = parseTreeCursor(options?.cursor, false);\n    const cursor = parsedCursor.kind === \"legacy\" ? parsedCursor.value : undefined;\n\n    const matched: Array<{ path: string; entry: TreeEntry }> = [];\n    for (const [p, e] of this.entries) {\n      if (p.startsWith(prefix)) {\n        matched.push({ path: p, entry: e });\n      }\n    }\n\n    matched.sort((a, b) => {\n      let cmp: number;\n      if (orderBy === \"path\") {\n        cmp = a.path.localeCompare(b.path);\n      } else if (orderBy === \"name\") {\n        cmp = nameOf(a.path).localeCompare(nameOf(b.path));\n      } else if (orderBy === \"mimeType\") {\n        cmp = (a.entry.mimeType ?? \"\").localeCompare(b.entry.mimeType ?? \"\");\n      } else {\n        cmp = (a.entry[orderBy] as number) - (b.entry[orderBy] as number);\n      }\n      return order === \"desc\" ? -cmp : cmp;\n    });\n\n    let filtered = matched;\n    if (cursor) {\n      filtered = matched.filter((item) => {\n        let val: string | number;\n        if (orderBy === \"path\") {\n          val = item.path;\n        } else if (orderBy === \"name\") {\n          val = nameOf(item.path);\n        } else if (orderBy === \"mimeType\") {\n          val = item.entry.mimeType ?? \"\";\n        } else {\n          val = item.entry[orderBy] as number;\n        }\n        const strVal = String(val);\n        const stringKey = orderBy === \"path\" || orderBy === \"name\" || orderBy === \"mimeType\";\n        if (order === \"asc\") {\n          return stringKey ? strVal > cursor : Number(strVal) > Number(cursor);\n        }\n        return stringKey ? strVal < cursor : Number(strVal) < Number(cursor);\n      });\n    }\n\n    const hasMore = filtered.length > limit;\n    const selected = hasMore ? filtered.slice(0, limit) : filtered;\n\n    let nextCursor: string | undefined;\n    if (hasMore && selected.length > 0) {\n      const last = selected[selected.length - 1]!;\n      if (orderBy === \"path\") {\n        nextCursor = last.path;\n      } else if (orderBy === \"name\") {\n        nextCursor = nameOf(last.path);\n      } else if (orderBy === \"mimeType\") {\n        nextCursor = last.entry.mimeType ?? \"\";\n      } else {\n        nextCursor = String(last.entry[orderBy]);\n      }\n    }\n\n    return {\n      entries: selected.map((s) => {\n        const e: { path: string } & TreeEntry = {\n          path: s.path,\n          cid: s.entry.cid,\n          size: s.entry.size,\n          mtime: s.entry.mtime,\n          ctime: s.entry.ctime,\n          mimeType: s.entry.mimeType,\n        };\n        if (options?.includeContent && s.entry.content !== undefined) e.content = s.entry.content;\n        return e;\n      }),\n      hasMore,\n      cursor: nextCursor,\n    };\n  }\n\n  async hasChildren(prefix: string): Promise<boolean> {\n    for (const p of this.entries.keys()) {\n      if (p.startsWith(prefix)) return true;\n    }\n    return false;\n  }\n\n  async count(prefix: string): Promise<number> {\n    let n = 0;\n    for (const p of this.entries.keys()) {\n      if (p.startsWith(prefix)) n++;\n    }\n    return n;\n  }\n\n  async deleteByPrefix(prefix: string, opts: PutOpts): Promise<number> {\n    validateDeviceId(opts.deviceId);\n\n    // Snapshot the files we are about to delete so we can log them to the\n    // changelog with their prior cid. Dir entries are scaffolding — not logged.\n    const snapshot: Array<{ path: string; cid: string }> = [];\n    for (const [p, e] of this.entries) {\n      if (p.startsWith(prefix)) snapshot.push({ path: p, cid: e.cid });\n    }\n\n    let n = 0;\n    for (const p of [...this.entries.keys()]) {\n      if (p.startsWith(prefix)) {\n        this.entries.delete(p);\n        n++;\n      }\n    }\n    // Also clean dir entries\n    for (const d of [...this.dirEntries.keys()]) {\n      if (d.startsWith(prefix)) {\n        this.dirEntries.delete(d);\n      }\n    }\n    // Drop dedup mappings whose target path fell under the prefix (#1159).\n    for (const [k, targetPath] of [...this.dedupIndex]) {\n      if (targetPath.startsWith(prefix)) this.dedupIndex.delete(k);\n    }\n\n    if (!opts.skipChangelog) {\n      // T1.5: client mtime when supplied (echo prevention + LWW), else server clock.\n      const now = opts.mtime ?? Date.now();\n      const updatedAt = Date.now();\n      for (const row of snapshot) {\n        this.pushChangelog(\n          {\n            seq: this.nextSeq++,\n            scope: this.scope,\n            path: row.path,\n            op: \"delete\",\n            cid: null,\n            old_cid: row.cid,\n            size: null,\n            mtime: now,\n            device_id: opts.deviceId,\n          },\n          updatedAt,\n        );\n      }\n      // One bump per prefix delete (the collection root the subtree lives under),\n      // only when something was actually deleted.\n      if (snapshot.length > 0) this.bumpWatermark(watermarkPrefix(prefix));\n    }\n\n    return n;\n  }\n\n  // ========== v2 methods ==========\n\n  /**\n   * THE single source of direct-children candidates — files with their own\n   * entry fields/content plus dir rows with the optional `<dir><docFile>`\n   * sub-file join. Shared by `listChildren` (join-free form post-T4.3) and\n   * `query` (doc surface) so the child-candidate semantics cannot drift —\n   * the in-memory mirror of `buildChildrenFrom` in tree-query.ts.\n   */\n  private collectChildren(parent: string, docFile?: string): TreeQueryCandidate[] {\n    const children: TreeQueryCandidate[] = [];\n    for (const [p, e] of this.entries) {\n      if (parentOf(p) !== parent) continue;\n      const candidate: TreeQueryCandidate = {\n        path: p,\n        name: nameOf(p),\n        kind: \"file\",\n        cid: e.cid,\n        size: e.size,\n        mtime: e.mtime,\n        ctime: e.ctime,\n        mimeType: e.mimeType,\n        content: e.content,\n      };\n      if (e.metadata) candidate.metadata = e.metadata as Record<string, unknown>;\n      children.push(candidate);\n    }\n    for (const [dirPath, dirMeta] of this.dirEntries) {\n      if (parentOf(dirPath) !== parent) continue;\n      const child: TreeQueryCandidate = {\n        path: dirPath,\n        name: nameOf(dirPath),\n        kind: \"dir\",\n        cid: \"\",\n        size: 0,\n        // Rule R2 (feed-sort §5.3): dir-row timestamps now come from the\n        // dirEntries Map (was hardcoded 0) so doc-mode `orderBy ctime` matches\n        // the SQL backends' `e.ctime`.\n        mtime: dirMeta.mtime,\n        ctime: dirMeta.ctime,\n      };\n      if (docFile) {\n        const sub = this.entries.get(dirPath + docFile);\n        if (sub?.content !== undefined) {\n          child.content = sub.content;\n          child.contentCid = sub.cid;\n        }\n        // doc-mode metadata flows from the file row (mirror of the SQL\n        // backends' `cf.metadata AS cf_metadata` and the row mapper's\n        // `cf_metadata ?? metadata` fallback in tree-query.ts).\n        if (sub?.metadata) {\n          child.metadata = sub.metadata as Record<string, unknown>;\n        }\n      }\n      children.push(child);\n    }\n    return children;\n  }\n\n  async listChildren(\n    parent: string,\n    options?: TreeIndexListOptions,\n  ): Promise<TreeIndexListEntriesResult> {\n    const limit = options?.limit ?? 1000;\n    const order = options?.order ?? \"asc\";\n\n    if (limit === 0) {\n      return { entries: [], hasMore: false };\n    }\n\n    // Dir-per-record joins moved to the query engine's doc form (T4.3) —\n    // listChildren candidates are always join-free now.\n    const children: Array<{ path: string } & TreeEntry> = this.collectChildren(parent).map(\n      ({ name: _name, kind: _kind, record: _record, contentCid: _cc, ...row }) => row,\n    );\n\n    // Explicit orderBy → ordered keyset path (name is the unique tiebreak).\n    if (options?.orderBy !== undefined) {\n      return projectContent(\n        this.orderedPage(children, options, (row) => nameOf(row.path)),\n        options,\n      );\n    }\n\n    const parsedCursor = parseTreeCursor(options?.cursor, false);\n    const cursor = parsedCursor.kind === \"legacy\" ? parsedCursor.value : undefined;\n\n    // Sort by name\n    children.sort((a, b) => {\n      const cmp = nameOf(a.path).localeCompare(nameOf(b.path));\n      return order === \"desc\" ? -cmp : cmp;\n    });\n\n    // Apply cursor\n    let filtered = children;\n    if (cursor) {\n      filtered = children.filter((item) => {\n        const n = nameOf(item.path);\n        return order === \"asc\" ? n > cursor : n < cursor;\n      });\n    }\n\n    const hasMore = filtered.length > limit;\n    const selected = hasMore ? filtered.slice(0, limit) : filtered;\n\n    return projectContent(\n      {\n        entries: selected,\n        hasMore,\n        cursor:\n          hasMore && selected.length > 0 ? nameOf(selected[selected.length - 1]!.path) : undefined,\n      },\n      options,\n    );\n  }\n\n  async countChildren(parent: string): Promise<number> {\n    let count = 0;\n    for (const p of this.entries.keys()) {\n      if (parentOf(p) === parent) count++;\n    }\n    for (const dirPath of this.dirEntries.keys()) {\n      if (parentOf(dirPath) === parent) count++;\n    }\n    return count;\n  }\n\n  /**\n   * Collection query (afs-collection-query Phase 1) — JS executor over the\n   * same candidate set the SQL impls compile (lockstep-tested).\n   */\n  async query(parent: string, spec: TreeQuerySpec): Promise<TreeQueryResult> {\n    // Same shared candidate source as listChildren (record parsing happens\n    // HERE so plain list paths never pay JSON.parse). Shape rules:\n    // - file form (no doc): FILE children only; record = own inline content.\n    // - doc form: ALL children; only dir rows carry a doc record (file\n    //   children keep missing-field semantics — same as the SQL engine).\n    const candidates = this.collectChildren(parent, spec.doc)\n      .filter((c) => (spec.doc ? true : c.kind === \"file\"))\n      .map((c) => {\n        if (!spec.doc || c.kind === \"dir\") return { ...c, record: parseRecordText(c.content) };\n        return { ...c, content: undefined, contentCid: undefined };\n      });\n\n    return runTreeQueryInMemory(candidates, spec);\n  }\n\n  async countChildrenMany(parents: string[]): Promise<Map<string, number>> {\n    // Mirror countChildren (files + dir scaffolding), restricted to the\n    // requested parents — page-bounded semantics shared with the SQL impls.\n    const want = new Set(parents);\n    const map = new Map<string, number>();\n    const bump = (childPath: string) => {\n      const par = parentOf(childPath);\n      if (want.has(par)) map.set(par, (map.get(par) ?? 0) + 1);\n    };\n    for (const p of this.entries.keys()) bump(p);\n    for (const dirPath of this.dirEntries.keys()) bump(dirPath);\n    return map;\n  }\n\n  async aggregate(prefix: string): Promise<{ fileCount: number; totalSize: number }> {\n    let fileCount = 0;\n    let totalSize = 0;\n    for (const [p, e] of this.entries) {\n      if (p.startsWith(prefix)) {\n        fileCount++;\n        totalSize += e.size;\n      }\n    }\n    return { fileCount, totalSize };\n  }\n\n  /** Batch metadata read — loop over get (no IN-merge needed off-CF). */\n  async getMany(paths: string[]): Promise<Map<string, TreeEntry | null>> {\n    const map = new Map<string, TreeEntry | null>();\n    for (const path of paths) map.set(path, await this.get(path));\n    return map;\n  }\n\n  /** Batch sync fast path — loop reference semantics (conformance-pinned\n   *  equivalent of the merged D1 implementation). */\n  async batchPutEntries(\n    entries: BatchPutEntry[],\n    ctx?: BatchIndexContext,\n  ): Promise<BatchPutEntryResult[]> {\n    return loopBatchPutEntries(this, entries, ctx);\n  }\n\n  /** Delete twin of {@link batchPutEntries} (loop reference semantics). */\n  async batchDeleteEntries(\n    entries: BatchDeleteEntry[],\n    ctx?: BatchIndexContext,\n  ): Promise<BatchDeleteEntryResult[]> {\n    return loopBatchDeleteEntries(this, entries, ctx);\n  }\n\n  async putBatch(entries: Array<{ path: string; entry: TreeEntry }>, opts: PutOpts): Promise<void> {\n    for (const { path, entry } of entries) {\n      await this.put(path, entry, opts);\n    }\n  }\n\n  async listModifiedSince(\n    prefix: string,\n    since: number,\n    options?: TreeIndexListOptions,\n  ): Promise<TreeIndexListEntriesResult> {\n    const limit = options?.limit ?? 1000;\n    const order = options?.order ?? \"asc\";\n    const cursor = options?.cursor;\n\n    if (limit === 0) {\n      return { entries: [], hasMore: false };\n    }\n\n    const matched: Array<{ path: string } & TreeEntry> = [];\n    for (const [p, e] of this.entries) {\n      if (p.startsWith(prefix) && e.mtime > since) {\n        matched.push({ path: p, ...e });\n      }\n    }\n\n    matched.sort((a, b) => {\n      const cmp = a.path.localeCompare(b.path);\n      return order === \"desc\" ? -cmp : cmp;\n    });\n\n    let filtered = matched;\n    if (cursor) {\n      filtered = matched.filter((item) =>\n        order === \"asc\" ? item.path > cursor : item.path < cursor,\n      );\n    }\n\n    const hasMore = filtered.length > limit;\n    const selected = hasMore ? filtered.slice(0, limit) : filtered;\n\n    return projectContent(\n      {\n        entries: selected,\n        hasMore,\n        cursor: hasMore && selected.length > 0 ? selected[selected.length - 1]!.path : undefined,\n      },\n      options,\n    );\n  }\n\n  async getMaxSeq(): Promise<number> {\n    const compactedBelow = await this.getCompactedBelowSeq();\n    if (this.changelog.length === 0) return compactedBelow;\n    return Math.max(Math.max(...this.changelog.map((r) => r.seq)), compactedBelow);\n  }\n\n  /**\n   * Read-auth reference check (design §4.1) — three-way, scoped, optionally\n   * prefix-local. See {@link TreeIndex.isReferenced}. This impl is single-scope\n   * (every row shares `this.scope`), so the scope filter is implicit; only the\n   * path-prefix restriction is applied.\n   */\n  async isReferenced(cid: string, pathPrefix = \"\"): Promise<boolean> {\n    if (!cid) return false;\n    for (const [path, entry] of this.entries) {\n      if (entry.cid === cid && path.startsWith(pathPrefix)) return true;\n    }\n    for (const row of this.changelog) {\n      if (!row.path.startsWith(pathPrefix)) continue;\n      if (row.cid === cid || row.old_cid === cid) return true;\n    }\n    return false;\n  }\n\n  /**\n   * Batch read-auth (design §7.2 / §14) — in-memory three-way equivalent to\n   * per-cid {@link isReferenced}. No bound-param cap (no sharding), but the\n   * result MUST agree cid-for-cid with the SQL backends.\n   */\n  async isReferencedMany(cids: string[], pathPrefix = \"\"): Promise<Set<string>> {\n    const want = new Set(cids.filter((c) => c));\n    const referenced = new Set<string>();\n    if (want.size === 0) return referenced;\n    for (const [path, entry] of this.entries) {\n      if (entry.cid && want.has(entry.cid) && path.startsWith(pathPrefix)) {\n        referenced.add(entry.cid);\n      }\n    }\n    for (const row of this.changelog) {\n      if (!row.path.startsWith(pathPrefix)) continue;\n      if (row.cid && want.has(row.cid)) referenced.add(row.cid);\n      if (row.old_cid && want.has(row.old_cid)) referenced.add(row.old_cid);\n    }\n    return referenced;\n  }\n\n  async getChangelogSince(\n    sinceSeq: number,\n    limit: number,\n  ): Promise<{ entries: ChangelogEntry[]; hasMore: boolean; cursor: number }> {\n    const after = this.changelog.filter((r) => r.seq > sinceSeq).sort((a, b) => a.seq - b.seq);\n    const safeLimit = limit > 0 ? limit : 0;\n    const page = after.slice(0, safeLimit);\n    const hasMore = after.length > safeLimit;\n    // cursor = max inner seq observed in this page; never goes backwards.\n    const cursor = page.length > 0 ? page[page.length - 1]!.seq : sinceSeq;\n    return { entries: page.map((r) => ({ ...r })), hasMore, cursor };\n  }\n\n  async getCompactedBelowSeq(): Promise<number> {\n    return 0;\n  }\n\n  // ========== Source-side dirty queue (index-follower-dirty-path §7) ==========\n  //\n  // Pure-Map mirror of the SQL backends' `ds_dirty_path` queries — the\n  // `dirtyMap` is maintained by {@link pushChangelog}. Range/guard/backoff\n  // semantics match D1/SQLite: prefixRange window, `next_attempt_at <= now`\n  // ready filter, `(next_attempt_at, updated_at)` ordering, latest_seq guards.\n\n  async listDirtyPaths(options: ListDirtyPathOptions): Promise<DirtyPathRow[]> {\n    const now = options.now ?? Date.now();\n    const limit = options.limit > 0 ? options.limit : 0;\n    if (limit === 0) return [];\n    const [lo, hi] = prefixRange(options.prefix);\n    return [...this.dirtyMap.values()]\n      .filter(\n        (r) => r.scope === this.scope && r.path >= lo && r.path < hi && r.nextAttemptAt <= now,\n      )\n      .sort((a, b) => a.nextAttemptAt - b.nextAttemptAt || a.updatedAt - b.updatedAt)\n      .slice(0, limit)\n      .map((r) => ({\n        path: r.path,\n        latestSeq: r.latestSeq,\n        op: r.op,\n        cid: r.cid,\n        mtime: r.mtime,\n        attempts: r.attempts,\n      }));\n  }\n\n  async ackDirtyPath(path: string, latestSeq: number): Promise<boolean> {\n    const key = `${this.scope}\\x00${path}`;\n    const row = this.dirtyMap.get(key);\n    if (row && row.latestSeq === latestSeq) {\n      this.dirtyMap.delete(key);\n      return true;\n    }\n    return false;\n  }\n\n  async markDirtyPathError(\n    path: string,\n    latestSeq: number,\n    error: string,\n    nextAttemptAt: number,\n  ): Promise<boolean> {\n    const key = `${this.scope}\\x00${path}`;\n    const row = this.dirtyMap.get(key);\n    if (row && row.latestSeq === latestSeq) {\n      this.dirtyMap.set(key, {\n        ...row,\n        attempts: row.attempts + 1,\n        lastError: error,\n        nextAttemptAt,\n      });\n      return true;\n    }\n    return false;\n  }\n\n  // ========== Private helpers ==========\n\n  private ensureParentDirs(filePath: string): void {\n    // New ancestor dirs scaffold at insert time (mirrors the SQL backends'\n    // `INSERT OR IGNORE ... ctime=now`). The direct parent's Rule-R2 stamp is\n    // applied separately in put() — it must overwrite even an existing row, so\n    // it cannot live behind this `.has()` early-exit (feed-sort §5.3).\n    const now = Date.now();\n    for (const dirPath of ancestorDirs(filePath)) {\n      if (this.dirEntries.has(dirPath)) break;\n      this.dirEntries.set(dirPath, { ctime: now, mtime: now });\n    }\n  }\n}\n"],"mappings":"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"}