@rigxyz/tapd 0.6.7 → 0.6.9

package/dist/index.d.ts

@@ -237,6 +237,7 @@ type StateDb = {
     listPaths(): string[];
     setMeta(key: string, value: string): void;
     getMeta(key: string): string | null;
+    deleteMeta(key: string): void;
     close(): void;
 };
 declare function openStateDb(dbPath: string): StateDb;
@@ -443,11 +444,18 @@ declare function revoke(opts: {
 /**
  * Apply remote change events to the local filesystem.
  *
- * Phase 2 keeps this simple: last-write-wins, no conflict materialization
- * (Phase 4 adds it). Echo suppression is handled via the state DB:
- * if the remote event's hash matches our last_seen_hash for the path,
- * we know it's our own write coming back through the poll loop and skip
- * the download.
+ * Echo suppression is handled via the state DB: an event at or before the
+ * path's last_applied_change_id (our own push coming back, or a version
+ * already superseded here), or whose hash matches our last_seen_hash, is
+ * skipped without a download.
+ *
+ * A change made on both sides is first three-way merged (merge.ts) against
+ * the version this device last synced; a clean merge becomes the file and
+ * is uploaded on top of the remote change. Otherwise the remote stays the
+ * file and the local edit moves to a `.conflict-from.<this device>.<chg>`
+ * copy — a local copy that hasn't seen a newer remote version must never
+ * replace it (the 2026-09-30 clear-harbor incident). Identical bytes on
+ * both sides are not a conflict.
  *
  * Materialization is atomic: download to `<file>.tap-tmp.<rand>` then
  * `rename` into place. Atomic on POSIX; on Windows, `fs.rename` falls
@@ -479,8 +487,8 @@ declare function conflictSidecarPath(path: string, ev: {
  * Apply mode.
  *
  * - `primary`: the local copy has write authority. Local-divergence
- *   guards protect unpushed edits (sidecars, keep-on-delete, refuse to
- *   clobber a dir) on the assumption scanAndPush carries them upstream.
+ *   guards protect unpushed edits (conflict copies, keep-on-delete,
+ *   refuse to clobber a dir).
  * - `mirror`: a read-only import of another binding. The mount has no
  *   local authority, so **remote always wins** across every event type —
  *   every divergence guard flips to remote-authoritative. There is no
@@ -502,8 +510,8 @@ type ApplyResult = {
     errors: ReadonlyArray<ApplyEventError>;
 };
 /**
- * One iteration of the apply loop: poll `GET /changes?after=<cursor>`,
- * materialize each event, update the cursor.
+ * One iteration of the apply loop: page through `GET /changes?after=<cursor>`
+ * until caught up, materialize each event, update the cursor.
  *
  * Per-event errors (hash mismatch, file/directory collision, disk full,
  * etc.) are caught, logged, and recorded to the state DB — the cursor
@@ -521,6 +529,62 @@ declare function applyOnce(opts: {
     mode?: ApplyMode;
 }): Promise<ApplyResult>;
 
+/**
+ * Line-based three-way merge for a file changed on both sides (layer 0:
+ * deterministic, no AI). The applier tries it before falling back to a
+ * conflict copy: base = the version this device last synced, ours = the
+ * local file, theirs = the remote version being applied.
+ *
+ * The merge itself is node-diff3's `diff3Merge` (overlapping or touching
+ * hunks are a conflict; the same change on both sides is not). Two things
+ * are layered around it:
+ *
+ * - Only text it can't corrupt: valid UTF-8, no NUL, ≤ 1 MB per side, and
+ *   not a format where a clean line merge can still be wrong (TOML, YAML,
+ *   lockfiles, CSV/TSV). A merged `.json` must still parse.
+ * - Bounded work. node-diff3's LCS slows down sharply on many repeated
+ *   lines (a 5,000-line doc that is one-third blank lines takes seconds),
+ *   and this runs on the daemon's event loop. So the lines all three
+ *   versions share at the start and end are set aside, the rest is cut at
+ *   lines that occur exactly once in every version and in the same order
+ *   (a merge can't move them), and each piece is merged on its own. Text
+ *   still too repetitive to merge quickly gives up — a conflict copy,
+ *   never a hang.
+ *
+ * Line endings: if every version uses one style, lines are compared
+ * without it and the result takes the style a side switched to (ours if
+ * both did), else the base's. A file mixing styles is merged as raw lines.
+ * The trailing newline follows the same rule.
+ */
+
+/**
+ * One auto-merge: this device's edit to `path` and another member's change
+ * `theirsChangeId`, both made on top of `baseChangeId`. Successive merges
+ * into an edit not yet uploaded update one record (`theirsChangeId` is
+ * then the newest remote change merged in). `changeId` is the upload that
+ * carried the merged file, once it went up.
+ */
+type MergeRecord = {
+    path: string;
+    at: string;
+    baseChangeId: string | null;
+    theirsChangeId: string;
+    theirsDeviceId: string | null;
+    /** The local bytes before the merge (not stored on the relay). */
+    oursHash: string;
+    resultHash: string;
+    changeId?: string;
+};
+declare function readMerges(stateDb: StateDb): MergeRecord[];
+type MergeResult = {
+    ok: true;
+    bytes: Buffer;
+} | {
+    ok: false;
+    reason: string;
+};
+declare function mergeText(path: string, base: Buffer, ours: Buffer, theirs: Buffer): MergeResult;
+
 /**
  * Claude Code context provider (Context Layer § 4, docs/context-layer-design-doc.md).
  *
@@ -627,6 +691,8 @@ declare function scanAndPush(opts: {
      * map and the batch simply carries no intent.
      */
     resolveIntents?: (changedPaths: ReadonlyArray<string>) => Promise<Map<string, IntentAssignment>>;
+    /** Internal: this is the re-scan that uploads merges a stale_base refusal produced. */
+    afterMerge?: boolean;
 }): Promise<ScanAndPushResult>;
 
 /**
@@ -774,6 +840,19 @@ type SubscriptionHandle = {
     stop(): Promise<void>;
     /** Force one apply cycle now (through the mutex). */
     applyNow(): Promise<ApplyResult>;
+    /**
+     * Apply every remote change, then run `fn` before any other apply
+     * starts — so an upload only ever goes out from a tree that has seen the
+     * relay's latest. `{ ok: false }` (fn not run) when the changes couldn't
+     * be fetched.
+     */
+    catchUpThen<T>(fn: () => Promise<T>): Promise<{
+        ok: true;
+        value: T;
+    } | {
+        ok: false;
+        error: unknown;
+    }>;
     /** Underlying state DB. Caller MUST NOT close it — stop() does. */
     stateDb: StateDb;
 };
@@ -946,6 +1025,12 @@ declare function subscribe(opts: SseSubscriberOptions): SseSubscriber;
  * subscription.ts; this file wires the pieces together and owns the
  * primary writer.
  *
+ * Every upload goes through the primary subscription's catchUpThen: remote
+ * changes are applied first, under the same lock. When they can't be
+ * fetched (relay down, offline) nothing is uploaded — a copy that hasn't
+ * seen the latest remote changes must not be pushed over them — and the
+ * push is retried.
+ *
  * Critical invariant: import mount points are HARD-excluded from the
  * primary writer (watcher `ignored` + walker `excludePaths`), so a
  * mirrored subtree is never re-uploaded into the primary's own binding
@@ -1014,4 +1099,4 @@ type DaemonHandle = {
 };
 declare function start(opts: StartOptions): Promise<DaemonHandle>;
 
-export { type AddImportOptions, type AddImportResult, AlreadyInitializedError, AlreadyJoinedError, type ApplyMode, type ApplyResult, BINDING_CONFIG_PATH, BUILTIN_IGNORE_LINES, type BindingConfig, type DaemonHandle, type ImportHandle, type ImportMountFile, type ImportSpec, ImportTokenScopeError, type ImportValidationError, ImportValidationFailed, type InitOptions, type InitResult, InvalidInviteUrlError, type JoinOptions, type JoinResult, type LocalPathState, type MintInviteOptions, NotInitializedError, type NotSyncedFile, RelayClient, type RelayClientOptions, RelayError, type RemoveImportResult, STATE_KEY_CONFLICT_COUNT, type ScanAndPushResult, type SseSubscriber, type SseSubscriberOptions, type StartOptions, type StartSubscriptionOptions, type StateDb, type SubscriptionConfig, type SubscriptionHandle, type WalkFile, type WalkResult, type WalkWarning, addImport, applyOnce, bindingConfigFile, conflictSidecarPath, createBinding, hashFile, importMountFile, importStateDbPath, importsDir, init, isAlwaysExcluded, join, list as listInvites, loadIgnore, loadImportMounts, mint as mintInvite, normalizeImportPath, openStateDb, parseInviteUrl, primaryStateDbPath, readBindingConfig, readImportMount, readNotSynced, removeImport, revoke as revokeInvite, scanAndPush, subscribe as sseSubscribe, start, startSubscription, validateImportName, validateImportPath, validateImports, walk, writeBindingConfig, writeImportMount };
+export { type AddImportOptions, type AddImportResult, AlreadyInitializedError, AlreadyJoinedError, type ApplyMode, type ApplyResult, BINDING_CONFIG_PATH, BUILTIN_IGNORE_LINES, type BindingConfig, type DaemonHandle, type ImportHandle, type ImportMountFile, type ImportSpec, ImportTokenScopeError, type ImportValidationError, ImportValidationFailed, type InitOptions, type InitResult, InvalidInviteUrlError, type JoinOptions, type JoinResult, type LocalPathState, type MergeRecord, type MintInviteOptions, NotInitializedError, type NotSyncedFile, RelayClient, type RelayClientOptions, RelayError, type RemoveImportResult, STATE_KEY_CONFLICT_COUNT, type ScanAndPushResult, type SseSubscriber, type SseSubscriberOptions, type StartOptions, type StartSubscriptionOptions, type StateDb, type SubscriptionConfig, type SubscriptionHandle, type WalkFile, type WalkResult, type WalkWarning, addImport, applyOnce, bindingConfigFile, conflictSidecarPath, createBinding, hashFile, importMountFile, importStateDbPath, importsDir, init, isAlwaysExcluded, join, list as listInvites, loadIgnore, loadImportMounts, mergeText, mint as mintInvite, normalizeImportPath, openStateDb, parseInviteUrl, primaryStateDbPath, readBindingConfig, readImportMount, readMerges, readNotSynced, removeImport, revoke as revokeInvite, scanAndPush, subscribe as sseSubscribe, start, startSubscription, validateImportName, validateImportPath, validateImports, walk, writeBindingConfig, writeImportMount };

package/dist/index.js

@@ -26,6 +26,7 @@ import {
   list,
   loadIgnore,
   loadImportMounts,
+  mergeText,
   mint,
   normalizeImportPath,
   openStateDb,
@@ -33,6 +34,7 @@ import {
   primaryStateDbPath,
   readBindingConfig,
   readImportMount,
+  readMerges,
   readNotSynced,
   removeImport,
   revoke,
@@ -46,7 +48,7 @@ import {
   walk,
   writeBindingConfig,
   writeImportMount
-} from "./chunk-32K6ANXS.js";
+} from "./chunk-57Z2Y3S2.js";
 export {
   AlreadyInitializedError,
   AlreadyJoinedError,
@@ -74,6 +76,7 @@ export {
   list as listInvites,
   loadIgnore,
   loadImportMounts,
+  mergeText,
   mint as mintInvite,
   normalizeImportPath,
   openStateDb,
@@ -81,6 +84,7 @@ export {
   primaryStateDbPath,
   readBindingConfig,
   readImportMount,
+  readMerges,
   readNotSynced,
   removeImport,
   revoke as revokeInvite,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigxyz/tapd",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "description": "Local daemon for the hosted Tap relay — watches files, hashes content, uploads/downloads objects, applies remote changes. Pairs with @rigxyz/cli for shared-rig sync.",
   "license": "MIT",
   "author": "Dylan Bourgeois <dtsbourg@gmail.com>",
@@ -40,7 +40,8 @@
   "dependencies": {
     "chokidar": "^4.0.1",
     "ignore": "^5.3.0",
-    "kleur": "^4.1.5"
+    "kleur": "^4.1.5",
+    "node-diff3": "3.2.1"
   },
   "devDependencies": {
     "@tap/core": "workspace:*",