@legioncodeinc/nectar 0.0.1

package/dist/projection/store-adapter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Thin adapter over {@link HiveGraphStore} for projection generation (PRD-011).
+ *
+ * The exported store lists each nectar's absolute latest version via
+ * `listLatestVersions`. When that latest row is `described`, it is projected
+ * verbatim. When it is not described, a minimal entry (path + content_hash,
+ * empty title/description) is emitted per the corpus. The edge case where the
+ * absolute latest is pending but an older described version exists requires a
+ * store extension (`listVersionsForNectar` or equivalent); until wired, only
+ * the absolute latest is considered.
+ */
+import type { HiveGraphRow, HiveGraphVersionRow, Tenancy } from "../hive-graph/model.js";
+import type { AsyncHiveGraphStore, HiveGraphStore } from "../hive-graph/store.js";
+/** One nectar row selected for projection output. */
+export interface ProjectionNectarSource {
+    readonly identity: HiveGraphRow;
+    readonly version: HiveGraphVersionRow;
+}
+export interface CollectProjectionSourcesOptions {
+    /**
+     * Optional hook to resolve the latest described version when the store's
+     * absolute latest is not described. Integration can supply this once the
+     * store exposes per-nectar version history.
+     */
+    readonly getLatestDescribedVersion?: (nectar: string) => HiveGraphVersionRow | undefined;
+}
+/** Collect nectar/version pairs from the store, scoped to `tenancy`. */
+export declare function collectProjectionSources(store: HiveGraphStore, tenancy: Tenancy, opts?: CollectProjectionSourcesOptions): ProjectionNectarSource[];
+/**
+ * The async twin of {@link collectProjectionSources} for the durable
+ * {@link AsyncHiveGraphStore} (Deep Lake). The sync store's synchronous
+ * `getLatestDescribedVersion` hook cannot be honored over HTTP, so this reads
+ * both the latest version per nectar and the latest DESCRIBED version per nectar
+ * from the async store and overlays them: a nectar with a described version
+ * carries that version verbatim; a minted-but-undescribed nectar keeps its
+ * latest observed version (a minimal projection entry). This reproduces
+ * {@link pickVersion}'s "described if any, else latest" choice against the
+ * durable store without a sync bridge, and matches the PRD-011c scan (latest
+ * described version per nectar, scoped to the project).
+ */
+export declare function collectProjectionSourcesAsync(store: AsyncHiveGraphStore, tenancy: Tenancy): Promise<ProjectionNectarSource[]>;
+//# sourceMappingURL=store-adapter.d.ts.map

package/dist/projection/store-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-adapter.d.ts","sourceRoot":"","sources":["../../src/projection/store-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACzF,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAElF,qDAAqD;AACrD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC;CACvC;AAED,MAAM,WAAW,+BAA+B;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,yBAAyB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,mBAAmB,GAAG,SAAS,CAAC;CAC1F;AAYD,wEAAwE;AACxE,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,OAAO,EAChB,IAAI,GAAE,+BAAoC,GACzC,sBAAsB,EAAE,CAM1B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,6BAA6B,CACjD,KAAK,EAAE,mBAAmB,EAC1B,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAWnC"}

package/dist/projection/store-adapter.js

@@ -0,0 +1,42 @@
+function pickVersion(latest, getLatestDescribed) {
+    if (latest.describeStatus === "described")
+        return latest;
+    const described = getLatestDescribed?.(latest.nectar);
+    if (described !== undefined)
+        return described;
+    return latest;
+}
+/** Collect nectar/version pairs from the store, scoped to `tenancy`. */
+export function collectProjectionSources(store, tenancy, opts = {}) {
+    const out = [];
+    for (const { identity, version: latest } of store.listLatestVersions(tenancy)) {
+        out.push({ identity, version: pickVersion(latest, opts.getLatestDescribedVersion) });
+    }
+    return out;
+}
+/**
+ * The async twin of {@link collectProjectionSources} for the durable
+ * {@link AsyncHiveGraphStore} (Deep Lake). The sync store's synchronous
+ * `getLatestDescribedVersion` hook cannot be honored over HTTP, so this reads
+ * both the latest version per nectar and the latest DESCRIBED version per nectar
+ * from the async store and overlays them: a nectar with a described version
+ * carries that version verbatim; a minted-but-undescribed nectar keeps its
+ * latest observed version (a minimal projection entry). This reproduces
+ * {@link pickVersion}'s "described if any, else latest" choice against the
+ * durable store without a sync bridge, and matches the PRD-011c scan (latest
+ * described version per nectar, scoped to the project).
+ */
+export async function collectProjectionSourcesAsync(store, tenancy) {
+    const [latest, described] = await Promise.all([
+        store.listLatestVersions(tenancy),
+        store.listLatestDescribedVersions(tenancy),
+    ]);
+    const describedByNectar = new Map();
+    for (const { identity, version } of described)
+        describedByNectar.set(identity.nectar, version);
+    return latest.map(({ identity, version }) => ({
+        identity,
+        version: describedByNectar.get(identity.nectar) ?? version,
+    }));
+}
+//# sourceMappingURL=store-adapter.js.map

package/dist/projection/store-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-adapter.js","sourceRoot":"","sources":["../../src/projection/store-adapter.ts"],"names":[],"mappings":"AA6BA,SAAS,WAAW,CAClB,MAA2B,EAC3B,kBAAqF;IAErF,IAAI,MAAM,CAAC,cAAc,KAAK,WAAW;QAAE,OAAO,MAAM,CAAC;IACzD,MAAM,SAAS,GAAG,kBAAkB,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACtD,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC9C,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,wBAAwB,CACtC,KAAqB,EACrB,OAAgB,EAChB,OAAwC,EAAE;IAE1C,MAAM,GAAG,GAA6B,EAAE,CAAC;IACzC,KAAK,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,KAAK,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,CAAC;QAC9E,GAAG,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,yBAAyB,CAAC,EAAE,CAAC,CAAC;IACvF,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,6BAA6B,CACjD,KAA0B,EAC1B,OAAgB;IAEhB,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QAC5C,KAAK,CAAC,kBAAkB,CAAC,OAAO,CAAC;QACjC,KAAK,CAAC,2BAA2B,CAAC,OAAO,CAAC;KAC3C,CAAC,CAAC;IACH,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAA+B,CAAC;IACjE,KAAK,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,SAAS;QAAE,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/F,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;QAC5C,QAAQ;QACR,OAAO,EAAE,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,OAAO;KAC3D,CAAC,CAAC,CAAC;AACN,CAAC"}

package/dist/projection/write.d.ts

@@ -0,0 +1,79 @@
+import type { Tenancy } from "../hive-graph/model.js";
+import type { AsyncHiveGraphStore, HiveGraphStore } from "../hive-graph/store.js";
+import { type PortableProjection } from "./format.js";
+import { type BuildProjectionFromStoreOptions, type BuildProjectionOptions } from "./generate.js";
+export interface Timer {
+    set(fn: () => void, ms: number): unknown;
+    clear(handle: unknown): void;
+}
+/** Default timer backed by Node's global timers. */
+export declare const realTimer: Timer;
+export declare const DEFAULT_WRITE_DEBOUNCE_MS = 30000;
+export interface WriteProjectionOptions {
+    /** Project root; final path is join(root, relPath). */
+    readonly projectRoot: string;
+    readonly relPath?: string;
+    readonly pid?: number;
+    readonly nowMs?: number;
+}
+export declare function projectionFinalPath(projectRoot: string, relPath?: string): string;
+/**
+ * Serialize and write atomically (temp + rename). A crash mid-write leaves the
+ * prior final file intact (AC-1).
+ */
+export declare function writeProjectionAtomic(doc: PortableProjection, opts: WriteProjectionOptions): string;
+export interface ProjectionWriterOptions {
+    readonly projectRoot: string;
+    readonly relPath?: string;
+    readonly debounceMs?: number;
+    readonly timer?: Timer;
+    readonly pid?: number;
+    readonly nowMs?: () => number;
+}
+/**
+ * Debounced writer for triggers #1 (end of brooding) and #2 (end of enricher
+ * cycle). Coalesces rapid rewrites into one flush after `debounceMs`.
+ */
+export declare class ProjectionWriter {
+    private readonly projectRoot;
+    private readonly relPath;
+    private readonly debounceMs;
+    private readonly timer;
+    private readonly pid;
+    private readonly nowMs;
+    private pending;
+    private handle;
+    constructor(opts: ProjectionWriterOptions);
+    /** Queue a debounced rewrite (AC-2). */
+    scheduleWrite(doc: PortableProjection): void;
+    /** Cancel a pending debounced write without flushing. */
+    cancelPending(): void;
+    /** Flush immediately if a write is queued (for tests). */
+    flushNow(): string | null;
+    get hasPending(): boolean;
+    private flushPending;
+}
+export interface RebuildProjectionOptions extends WriteProjectionOptions, BuildProjectionFromStoreOptions {
+}
+/**
+ * Full regeneration from the store (trigger #3). Scans latest described per
+ * nectar and writes immediately, bypassing debounce (AC-3).
+ */
+export declare function rebuildProjection(store: HiveGraphStore, tenancy: Tenancy, opts: RebuildProjectionOptions): {
+    doc: PortableProjection;
+    path: string;
+};
+export interface RebuildProjectionAsyncOptions extends WriteProjectionOptions, BuildProjectionOptions {
+}
+/**
+ * Full regeneration from the durable {@link AsyncHiveGraphStore} (Deep Lake),
+ * trigger #3 (PRD-011c). The async twin of {@link rebuildProjection}: it scans
+ * the latest described version per nectar (scoped to the project) and writes
+ * immediately, bypassing debounce (AC-3). The `nectar rebuild-projection`
+ * CLI verb calls this against the real `DeepLakeHiveGraphStore`.
+ */
+export declare function rebuildProjectionAsync(store: AsyncHiveGraphStore, tenancy: Tenancy, opts: RebuildProjectionAsyncOptions): Promise<{
+    doc: PortableProjection;
+    path: string;
+}>;
+//# sourceMappingURL=write.d.ts.map

package/dist/projection/write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../src/projection/write.ts"],"names":[],"mappings":"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"}

package/dist/projection/write.js

@@ -0,0 +1,122 @@
+/**
+ * Atomic projection writer and debounced rewrite seam (PRD-011a).
+ *
+ * Mirrors the CodeGraph `writeSnapshotAtomic` pattern: temp file in the same
+ * directory, then `renameSync`. Trigger #1/#2 use the debounced writer; trigger
+ * #3 (`rebuildProjection`) bypasses debounce and writes immediately (AC-3).
+ */
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { DEFAULT_PROJECTION_REL_PATH, canonicalSerialize, } from "./format.js";
+import { buildProjectionFromAsyncStore, buildProjectionFromStore, } from "./generate.js";
+/** Default timer backed by Node's global timers. */
+export const realTimer = {
+    set: (fn, ms) => setTimeout(fn, ms),
+    clear: (handle) => clearTimeout(handle),
+};
+export const DEFAULT_WRITE_DEBOUNCE_MS = 30_000;
+export function projectionFinalPath(projectRoot, relPath = DEFAULT_PROJECTION_REL_PATH) {
+    return join(projectRoot, relPath);
+}
+/**
+ * Serialize and write atomically (temp + rename). A crash mid-write leaves the
+ * prior final file intact (AC-1).
+ */
+export function writeProjectionAtomic(doc, opts) {
+    const relPath = opts.relPath ?? DEFAULT_PROJECTION_REL_PATH;
+    const finalPath = projectionFinalPath(opts.projectRoot, relPath);
+    const dir = dirname(finalPath);
+    mkdirSync(dir, { recursive: true });
+    const baseName = relPath.split(/[/\\]/).pop() ?? "nectars.json";
+    const pid = opts.pid ?? process.pid;
+    const now = opts.nowMs ?? Date.now();
+    const tmpPath = join(dir, `.${baseName}.${pid}.${now}.tmp`);
+    writeFileSync(tmpPath, canonicalSerialize(doc), "utf8");
+    renameSync(tmpPath, finalPath);
+    return finalPath;
+}
+/**
+ * Debounced writer for triggers #1 (end of brooding) and #2 (end of enricher
+ * cycle). Coalesces rapid rewrites into one flush after `debounceMs`.
+ */
+export class ProjectionWriter {
+    projectRoot;
+    relPath;
+    debounceMs;
+    timer;
+    pid;
+    nowMs;
+    pending = null;
+    handle = null;
+    constructor(opts) {
+        this.projectRoot = opts.projectRoot;
+        this.relPath = opts.relPath ?? DEFAULT_PROJECTION_REL_PATH;
+        this.debounceMs = opts.debounceMs ?? DEFAULT_WRITE_DEBOUNCE_MS;
+        this.timer = opts.timer ?? realTimer;
+        this.pid = opts.pid ?? process.pid;
+        this.nowMs = opts.nowMs ?? (() => Date.now());
+    }
+    /** Queue a debounced rewrite (AC-2). */
+    scheduleWrite(doc) {
+        this.pending = doc;
+        if (this.handle !== null)
+            this.timer.clear(this.handle);
+        this.handle = this.timer.set(() => {
+            this.handle = null;
+            this.flushPending();
+        }, this.debounceMs);
+    }
+    /** Cancel a pending debounced write without flushing. */
+    cancelPending() {
+        if (this.handle !== null) {
+            this.timer.clear(this.handle);
+            this.handle = null;
+        }
+        this.pending = null;
+    }
+    /** Flush immediately if a write is queued (for tests). */
+    flushNow() {
+        if (this.handle !== null) {
+            this.timer.clear(this.handle);
+            this.handle = null;
+        }
+        return this.flushPending();
+    }
+    get hasPending() {
+        return this.pending !== null;
+    }
+    flushPending() {
+        const doc = this.pending;
+        if (doc === null)
+            return null;
+        this.pending = null;
+        return writeProjectionAtomic(doc, {
+            projectRoot: this.projectRoot,
+            relPath: this.relPath,
+            pid: this.pid,
+            nowMs: this.nowMs(),
+        });
+    }
+}
+/**
+ * Full regeneration from the store (trigger #3). Scans latest described per
+ * nectar and writes immediately, bypassing debounce (AC-3).
+ */
+export function rebuildProjection(store, tenancy, opts) {
+    const doc = buildProjectionFromStore(store, tenancy, opts);
+    const path = writeProjectionAtomic(doc, opts);
+    return { doc, path };
+}
+/**
+ * Full regeneration from the durable {@link AsyncHiveGraphStore} (Deep Lake),
+ * trigger #3 (PRD-011c). The async twin of {@link rebuildProjection}: it scans
+ * the latest described version per nectar (scoped to the project) and writes
+ * immediately, bypassing debounce (AC-3). The `nectar rebuild-projection`
+ * CLI verb calls this against the real `DeepLakeHiveGraphStore`.
+ */
+export async function rebuildProjectionAsync(store, tenancy, opts) {
+    const doc = await buildProjectionFromAsyncStore(store, tenancy, opts);
+    const path = writeProjectionAtomic(doc, opts);
+    return { doc, path };
+}
+//# sourceMappingURL=write.js.map

package/dist/projection/write.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"write.js","sourceRoot":"","sources":["../../src/projection/write.ts"],"names":[],"mappings":"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"}

package/dist/registration/classify.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Event-to-ladder-step classification (PRD-006b).
+ *
+ * A pure function that maps a debounced path observation to exactly one of the
+ * three inputs the re-association ladder consumes: a new path (exists, no nectar),
+ * a changed path (exists, has a nectar; the ladder still hashes to decide no-op
+ * vs edit), or a missing path (a known nectar's path is gone from disk). A path
+ * that neither exists nor is known is a no-op (for example a temp file created
+ * and deleted inside the debounce window) and classifies to null.
+ *
+ * PRD-018c NEC-034 / AC-018c.8: the `known` lookup takes an optional `fold`
+ * function so a case-insensitive workspace can compare case-folded (the
+ * caller pre-folds `knownPaths`'s entries with the SAME function, service.ts's
+ * `knownPaths()`). `fold` defaults to the identity, preserving case-sensitive
+ * behavior. The RETURNED `relPath` is always `obs.relPath` verbatim - the
+ * fold is a lookup-only concern; stored rows keep the observed on-disk casing.
+ */
+export interface PathObservation {
+    readonly relPath: string;
+    readonly existsOnDisk: boolean;
+}
+export type LadderInputKind = "new-path" | "changed-path" | "missing-path";
+export interface LadderInput {
+    readonly kind: LadderInputKind;
+    readonly relPath: string;
+}
+/**
+ * Classify one observation against the set of paths currently known to the store
+ * (from `store.listLatestVersions(...)` -> version.path). Returns null when there
+ * is nothing to do.
+ */
+export declare function classifyPath(obs: PathObservation, knownPaths: ReadonlySet<string>, fold?: (relPath: string) => string): LadderInput | null;
+//# sourceMappingURL=classify.d.ts.map

package/dist/registration/classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../../src/registration/classify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,cAAc,GAAG,cAAc,CAAC;AAE3E,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,eAAe,EACpB,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,EAC/B,IAAI,GAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAA6B,GACvD,WAAW,GAAG,IAAI,CAOpB"}

package/dist/registration/classify.js

@@ -0,0 +1,32 @@
+/**
+ * Event-to-ladder-step classification (PRD-006b).
+ *
+ * A pure function that maps a debounced path observation to exactly one of the
+ * three inputs the re-association ladder consumes: a new path (exists, no nectar),
+ * a changed path (exists, has a nectar; the ladder still hashes to decide no-op
+ * vs edit), or a missing path (a known nectar's path is gone from disk). A path
+ * that neither exists nor is known is a no-op (for example a temp file created
+ * and deleted inside the debounce window) and classifies to null.
+ *
+ * PRD-018c NEC-034 / AC-018c.8: the `known` lookup takes an optional `fold`
+ * function so a case-insensitive workspace can compare case-folded (the
+ * caller pre-folds `knownPaths`'s entries with the SAME function, service.ts's
+ * `knownPaths()`). `fold` defaults to the identity, preserving case-sensitive
+ * behavior. The RETURNED `relPath` is always `obs.relPath` verbatim - the
+ * fold is a lookup-only concern; stored rows keep the observed on-disk casing.
+ */
+/**
+ * Classify one observation against the set of paths currently known to the store
+ * (from `store.listLatestVersions(...)` -> version.path). Returns null when there
+ * is nothing to do.
+ */
+export function classifyPath(obs, knownPaths, fold = (relPath) => relPath) {
+    const known = knownPaths.has(fold(obs.relPath));
+    if (obs.existsOnDisk) {
+        return { kind: known ? "changed-path" : "new-path", relPath: obs.relPath };
+    }
+    if (known)
+        return { kind: "missing-path", relPath: obs.relPath };
+    return null;
+}
+//# sourceMappingURL=classify.js.map

package/dist/registration/classify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.js","sourceRoot":"","sources":["../../src/registration/classify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAcH;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAC1B,GAAoB,EACpB,UAA+B,EAC/B,OAAoC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO;IAExD,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;IAChD,IAAI,GAAG,CAAC,YAAY,EAAE,CAAC;QACrB,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,UAAU,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC;IAC7E,CAAC;IACD,IAAI,KAAK;QAAE,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC;IACjE,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/registration/copy-detect.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copy-paste detection (PRD-006c), from ai/identity-and-reassociation.md.
+ *
+ * When a new path's content hash equals some existing nectar's LATEST version
+ * hash, that is a copy event: the new file gets a fresh nectar with
+ * `derived_from_nectar` pointing at the source and `fork_content_hash` = the
+ * shared content hash. Otherwise it is a genuinely new file and mints plainly.
+ *
+ * This is the step-5 decision for a new path that is NOT a move (moves are caught
+ * earlier by the ladder's step 3, gated on the source path being gone from disk).
+ */
+import type { Tenancy } from "../hive-graph/model.js";
+import type { HiveGraphStore } from "../hive-graph/store.js";
+export type NewFileDecision = {
+    readonly action: "mint";
+} | {
+    readonly action: "copy";
+    readonly sourceNectar: string;
+    readonly forkContentHash: string;
+};
+export declare function classifyNewFile(store: HiveGraphStore, tenancy: Tenancy, newContentHash: string): NewFileDecision;
+//# sourceMappingURL=copy-detect.d.ts.map

package/dist/registration/copy-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copy-detect.d.ts","sourceRoot":"","sources":["../../src/registration/copy-detect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,MAAM,eAAe,GACvB;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjG,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE,MAAM,GACrB,eAAe,CAUjB"}

package/dist/registration/copy-detect.js

@@ -0,0 +1,12 @@
+export function classifyNewFile(store, tenancy, newContentHash) {
+    const existing = store.latestVersionByHash(tenancy, newContentHash);
+    if (existing !== undefined) {
+        return {
+            action: "copy",
+            sourceNectar: existing.identity.nectar,
+            forkContentHash: newContentHash,
+        };
+    }
+    return { action: "mint" };
+}
+//# sourceMappingURL=copy-detect.js.map

package/dist/registration/copy-detect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"copy-detect.js","sourceRoot":"","sources":["../../src/registration/copy-detect.ts"],"names":[],"mappings":"AAkBA,MAAM,UAAU,eAAe,CAC7B,KAAqB,EACrB,OAAgB,EAChB,cAAsB;IAEtB,MAAM,QAAQ,GAAG,KAAK,CAAC,mBAAmB,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;IACpE,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,OAAO;YACL,MAAM,EAAE,MAAM;YACd,YAAY,EAAE,QAAQ,CAAC,QAAQ,CAAC,MAAM;YACtC,eAAe,EAAE,cAAc;SAChC,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;AAC5B,CAAC"}

package/dist/registration/disk-fs.d.ts

@@ -0,0 +1,41 @@
+/**
+ * A real-disk {@link RegistrationFs} with workspace-path containment (CWE-22).
+ *
+ * This is the concrete filesystem seam the daemon uses to stat, read, and list
+ * files under the workspace root. Every disk access is clamped by
+ * {@link realpathContained}: a path that is absolute, contains a `..` segment,
+ * or (via a symlink) resolves outside the real workspace root is refused before
+ * any `stat`/`read`, and `listPaths` never follows a symlink out of the tree.
+ * Tests and local dev may still inject an in-memory `RegistrationFs`; this is
+ * the production disk implementation.
+ *
+ * PRD-018c NEC-007 point 2 / AC-018c.4: `walk` takes an ignore predicate and
+ * prunes an ignored DIRECTORY at descent time (never `readdirSync`s into it),
+ * instead of enumerating the whole subtree and filtering per yielded path.
+ */
+import { statSync, type Dirent } from "node:fs";
+import type { IgnorePredicate } from "./ignore.js";
+import type { RegistrationFs } from "./service.js";
+/** The directory-listing seam `walk` uses. Injectable so a test can prove descent-time pruning by counting visited directories (default: `node:fs`'s real `readdirSync`). */
+export type ReadDirSync = (dir: string) => Dirent[];
+export declare function createDiskRegistrationFs(root: string, isIgnored?: IgnorePredicate, readDirSync?: ReadDirSync): RegistrationFs;
+/**
+ * Test/wiring seam for {@link probeCaseInsensitiveFs} (CodeRabbit PR-18
+ * finding #5): defaults to `node:fs`'s real `statSync`. Lets a test simulate
+ * the marker vanishing (or an EPERM/AV-interference-shaped fault) between the
+ * write and the re-stat without needing a real filesystem race.
+ */
+export interface ProbeCaseInsensitiveFsIo {
+    statSync: typeof statSync;
+}
+/**
+ * Probe whether `root`'s filesystem is case-insensitive (PRD-018c NEC-034 /
+ * AC-018c.8): a REAL filesystem probe, never a platform guess. Creates a
+ * uniquely-named marker file under `root`, then stats a case-flipped version
+ * of that same name; if it resolves to the identical inode, the volume is
+ * case-insensitive. Fails closed (returns `false`, i.e. case-SENSITIVE, the
+ * behavior-preserving default) when `root` is not writable/statable, so a
+ * probe failure never silently enables case-folding.
+ */
+export declare function probeCaseInsensitiveFs(root: string, io?: ProbeCaseInsensitiveFsIo): boolean;
+//# sourceMappingURL=disk-fs.d.ts.map

package/dist/registration/disk-fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disk-fs.d.ts","sourceRoot":"","sources":["../../src/registration/disk-fs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAwC,QAAQ,EAA6B,KAAK,MAAM,EAAE,MAAM,SAAS,CAAC;AAGjH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,cAAc,CAAC;AAqB/D,6KAA6K;AAC7K,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;AAIpD,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,eAA6B,EACxC,WAAW,GAAE,WAAgC,GAC5C,cAAc,CA2ChB;AA2BD;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,OAAO,QAAQ,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAE,wBAAuC,GAAG,OAAO,CAsCzG"}

package/dist/registration/disk-fs.js

@@ -0,0 +1,175 @@
+/**
+ * A real-disk {@link RegistrationFs} with workspace-path containment (CWE-22).
+ *
+ * This is the concrete filesystem seam the daemon uses to stat, read, and list
+ * files under the workspace root. Every disk access is clamped by
+ * {@link realpathContained}: a path that is absolute, contains a `..` segment,
+ * or (via a symlink) resolves outside the real workspace root is refused before
+ * any `stat`/`read`, and `listPaths` never follows a symlink out of the tree.
+ * Tests and local dev may still inject an in-memory `RegistrationFs`; this is
+ * the production disk implementation.
+ *
+ * PRD-018c NEC-007 point 2 / AC-018c.4: `walk` takes an ignore predicate and
+ * prunes an ignored DIRECTORY at descent time (never `readdirSync`s into it),
+ * instead of enumerating the whole subtree and filtering per yielded path.
+ */
+import { lstatSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { containedPath, isSafeRelPath, realpathContained } from "./paths-safe.js";
+/**
+ * True when `rel` is itself a symlink (NEC-042 item 10 / AC-018l.17). `walk`
+ * already skips every symlink entry, but `statPath`/`existsOnDisk` resolved
+ * through symlinks (`realpathContained`), so a symlinked file registered via a
+ * live watch event was invisible to a resync walk. Skipping symlinks in both
+ * paths gives the watcher and the resync ONE contract (both skip, matching git).
+ * Uses `lstat` (does not follow the link); fails closed (not-a-symlink) when the
+ * path is unsafe or does not exist.
+ */
+function isSymlinkPath(root, rel) {
+    const literal = containedPath(root, rel);
+    if (literal === null)
+        return false;
+    try {
+        return lstatSync(literal).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+const defaultReadDirSync = (dir) => readdirSync(dir, { withFileTypes: true });
+export function createDiskRegistrationFs(root, isIgnored = () => false, readDirSync = defaultReadDirSync) {
+    return {
+        statPath(rel) {
+            if (isSymlinkPath(root, rel))
+                return null; // AC-018l.17: skip symlinks, matching walk
+            const abs = realpathContained(root, rel);
+            if (abs === null)
+                return null; // escapes the workspace, or does not exist
+            let st;
+            try {
+                st = statSync(abs);
+            }
+            catch {
+                return null;
+            }
+            if (!st.isFile())
+                return null;
+            return {
+                sizeBytes: st.size,
+                mtimeObserved: st.mtime.toISOString(),
+                readContent: () => readFileSync(abs),
+            };
+        },
+        existsOnDisk(rel) {
+            if (isSymlinkPath(root, rel))
+                return false; // AC-018l.17: skip symlinks, matching walk
+            const abs = realpathContained(root, rel);
+            if (abs === null)
+                return false;
+            try {
+                return statSync(abs).isFile(); // a directory (or anything non-file) is NOT a tracked path
+            }
+            catch {
+                return false;
+            }
+        },
+        /** True when `rel` currently exists on disk AS A DIRECTORY (PRD-018c NEC-008 / AC-018c.5). */
+        isDirectory(rel) {
+            const abs = realpathContained(root, rel);
+            if (abs === null)
+                return false;
+            try {
+                return statSync(abs).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        },
+        listPaths() {
+            return walk(root, root, isIgnored, readDirSync);
+        },
+    };
+}
+/**
+ * Recursively yield repo-relative, forward-slashed file paths under `dir`,
+ * never following a symlink out of `root`. An ignored directory is pruned at
+ * descent time (AC-018c.4): `readDirSync` is never called on it.
+ */
+function* walk(root, dir, isIgnored, readDirSync) {
+    let entries;
+    try {
+        entries = readDirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.isSymbolicLink())
+            continue; // never follow a symlink (defeats symlink escape)
+        const abs = join(dir, entry.name);
+        const rel = relative(root, abs).replace(/\\/g, "/");
+        if (entry.isDirectory()) {
+            if (isIgnored(rel))
+                continue; // descent-time pruning: never readDirSync an ignored subtree
+            yield* walk(root, abs, isIgnored, readDirSync);
+        }
+        else if (entry.isFile()) {
+            if (isSafeRelPath(rel) && !isIgnored(rel))
+                yield rel;
+        }
+    }
+}
+/**
+ * Probe whether `root`'s filesystem is case-insensitive (PRD-018c NEC-034 /
+ * AC-018c.8): a REAL filesystem probe, never a platform guess. Creates a
+ * uniquely-named marker file under `root`, then stats a case-flipped version
+ * of that same name; if it resolves to the identical inode, the volume is
+ * case-insensitive. Fails closed (returns `false`, i.e. case-SENSITIVE, the
+ * behavior-preserving default) when `root` is not writable/statable, so a
+ * probe failure never silently enables case-folding.
+ */
+export function probeCaseInsensitiveFs(root, io = { statSync }) {
+    const base = `NectarCaseProbe-${process.pid.toString(36)}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    const lowerRel = base.toLowerCase();
+    const upperRel = base.toUpperCase();
+    const lowerAbs = join(root, lowerRel);
+    const upperAbs = join(root, upperRel);
+    try {
+        writeFileSync(lowerAbs, "", { flag: "wx" });
+    }
+    catch {
+        return false; // cannot probe (root missing/unwritable) - assume case-sensitive
+    }
+    try {
+        // CodeRabbit PR-18 finding #5: the post-write `statSync(lowerAbs)` itself
+        // can throw (EPERM, antivirus interference, a marker removed out from
+        // under us) just as readily as the case-flipped `statSync(upperAbs)`
+        // below already accounted for. An uncaught throw here used to bubble out
+        // of RegistrationService construction; wrap it the same way, failing
+        // closed (case-SENSITIVE) rather than crashing the caller.
+        let lowerStat;
+        try {
+            lowerStat = io.statSync(lowerAbs);
+        }
+        catch {
+            return false; // cannot re-stat our own marker -> assume case-sensitive
+        }
+        let upperStat;
+        try {
+            upperStat = io.statSync(upperAbs);
+        }
+        catch {
+            return false; // the case-flipped name does not resolve -> case-sensitive
+        }
+        return lowerStat.ino === upperStat.ino && lowerStat.dev === upperStat.dev;
+    }
+    finally {
+        try {
+            unlinkSync(lowerAbs);
+        }
+        catch {
+            // best-effort cleanup; a leftover probe marker is harmless and tiny
+        }
+    }
+}
+//# sourceMappingURL=disk-fs.js.map