@rigxyz/tapd 0.1.0 → 0.4.0

package/dist/index.d.ts

@@ -65,15 +65,22 @@ type WalkResult = {
 };
 declare function walk(rootDir: string, opts: {
     ignore: Ignore;
+    /**
+     * Mount points (posix, relative to rootDir) to hard-exclude — import
+     * subdirectories materialized by mirror subscriptions. Never scanned,
+     * never uploaded into this binding. Non-overridable by .tapignore.
+     */
+    excludePaths?: ReadonlyArray<string>;
 }): WalkResult;
 
 /**
- * Thin fetch wrapper around the Phase 1 relay routes.
+ * Thin fetch wrapper around the relay routes.
  *
- * Module-level `createBinding` is unauthenticated (Phase 3 will Clerk-gate
- * it). Everything else binds to a (baseUrl, bindingId, token) triple via
- * the `RelayClient` class, since every binding-scoped route needs the
- * same three values on every call.
+ * Module-level `createBinding` and `acceptInvite` are user-authenticated
+ * via a relay-issued session bearer (Phase 3.5 replaced the
+ * X-Tap-User-Id placeholder). Binding-scoped routes use the
+ * `RelayClient` class which carries a (baseUrl, bindingId, capability
+ * token) triple.
  *
  * `RelayError` carries the route + status + parsed body so caller logic
  * can map specific 400s ("object_not_uploaded", "case_collision_with",
@@ -88,15 +95,14 @@ declare class RelayError extends Error {
     constructor(route: string, status: number, body: unknown);
 }
 /**
- * Create a new binding. User-authenticated via the X-Tap-User-Id header
- * (Phase 3 placeholder; Clerk JWT later). The response carries the
- * owner's first capability token, returned exactly once.
+ * Create a new binding. User-authenticated via a relay-issued session
+ * bearer. The response carries the owner's first capability token,
+ * returned exactly once.
  */
 declare function createBinding(opts: {
     baseUrl: string;
     request: CreateBindingRequest;
-    userId: string;
-    email?: string;
+    accessToken: string;
     fetch?: FetchLike$1;
 }): Promise<CreateBindingResponse>;
 type RelayClientOptions = {
@@ -129,6 +135,8 @@ declare class RelayClient {
     listChanges(opts?: {
         after?: string;
         limit?: number;
+        path?: string;
+        untilInclusive?: string;
     }): Promise<ChangesSinceResponse>;
     /**
      * Mint a new invite (owner-only). Returns the secret + a ready-to-share
@@ -144,6 +152,22 @@ declare class RelayClient {
         revoked: boolean;
         alreadyRevoked: boolean;
     }>;
+    listMembers(): Promise<{
+        members: Array<{
+            userId: string;
+            role: string;
+            email: string | null;
+            joinedAt: string;
+        }>;
+    }>;
+    removeMember(userId: string): Promise<{
+        removed: boolean;
+        tokensRevoked: number;
+    }>;
+    setMemberRole(userId: string, role: "owner" | "editor" | "viewer"): Promise<{
+        changed: boolean;
+        role: string;
+    }>;
     getManifest(opts?: {
         after?: string;
         limit?: number;
@@ -248,7 +272,8 @@ declare function hashFile(absPath: string): Promise<string>;
 type InitOptions = {
     rootDir: string;
     relayUrl: string;
-    ownerUserId: string;
+    /** User access token (from credentials). */
+    accessToken: string;
     bindingName: string;
     deviceLabel?: string;
     /** Test seam: override fetch (used to drive the in-process relay). */
@@ -296,8 +321,11 @@ declare function init(opts: InitOptions): Promise<InitResult>;
 type JoinOptions = {
     rootDir: string;
     inviteUrl: string;
-    userId: string;
-    email?: string;
+    /**
+     * User access token from credentials. Required for member invites
+     * (role !== null), optional for pure-capability invites.
+     */
+    accessToken?: string | null;
     deviceLabel?: string;
     /** Test seam: override fetch. */
     fetch?: typeof fetch;
@@ -392,6 +420,19 @@ declare function conflictSidecarPath(path: string, ev: {
     id: string;
     actorDeviceId: string | null;
 }): string;
+/**
+ * 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.
+ * - `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
+ *   scanAndPush to drain sidecars or re-submit kept files, so the primary
+ *   guards would instead let edited imported content linger forever.
+ */
+type ApplyMode = "primary" | "mirror";
 type ApplyEventError = {
     eventId: string;
     path: string;
@@ -421,6 +462,8 @@ declare function applyOnce(opts: {
     client: RelayClient;
     stateDb: StateDb;
     limit?: number;
+    /** Defaults to "primary". See ApplyMode. */
+    mode?: ApplyMode;
 }): Promise<ApplyResult>;
 
 /**
@@ -451,8 +494,260 @@ declare function scanAndPush(opts: {
     client: RelayClient;
     stateDb: StateDb;
     ignore: Ignore;
+    /** Import mount points to hard-exclude from the scan. See walk(). */
+    excludePaths?: ReadonlyArray<string>;
 }): Promise<ScanAndPushResult>;
 
+/**
+ * Rig imports — read-only live mirrors of another binding into a
+ * subdirectory (see ~/Code/rig/docs/rig-imports.md).
+ *
+ * This module owns the *declaration* side: the ImportSpec shape, on-disk
+ * path helpers, and the security-critical validator. The daemon wiring
+ * (mirror subscriptions, orchestration) lives in start.ts; the
+ * apply-time behavior (remote-wins) lives in applier.ts (mode: "mirror").
+ *
+ * The validator is the single highest-risk part of the feature: a bad
+ * mount point is how an import could silently re-share — or, because
+ * mirror mode is remote-authoritative, destroy — primary content. Treat
+ * every rule here as security code, not input hygiene.
+ */
+type ImportSpec = {
+    /** Boring slug — becomes the token filename + state-db dir name. */
+    name: string;
+    bindingId: string;
+    relayUrl: string;
+    /** Per-import capability token (read + subscribe). Machine-local. */
+    token: string;
+    /** Mount point: subdirectory relative to the rig root (posix). */
+    path: string;
+};
+/**
+ * On-disk shape of a per-import mount file
+ * (`.rig/tap/imports/<name>.local.json`). Machine-local, gitignored,
+ * never synced — mirrors `tap-binding.local.json`. Carries the capability
+ * secret plus enough to start a mirror subscription without parsing
+ * `rig.toml` (tapd has no TOML parser; the daemon reads JSON like it does
+ * for the primary binding). `ops` is persisted from the accept-invite
+ * response so the daemon can refuse a token that lacks read+subscribe.
+ */
+type ImportMountFile = {
+    bindingId: string;
+    relayUrl: string;
+    token: string;
+    ops: ReadonlyArray<"read" | "write" | "subscribe">;
+    /** Mount point: subdirectory relative to the rig root (posix). */
+    path: string;
+    /** Import-edge id from the relay (inter-rig graph). Lets `rig import remove`
+     * tombstone the exact edge. Absent for anonymous imports / pre-edge mounts. */
+    edgeId?: string;
+};
+type ImportValidationError = {
+    name: string;
+    path: string;
+    reason: string;
+};
+declare function validateImportName(name: string): string | null;
+/**
+ * Canonicalize a declared import path to a posix form with `.` and empty
+ * segments collapsed (`./sources/alex` and `sources/./alex` → `sources/alex`).
+ * `..` is deliberately preserved so validateImportPath can reject it. This
+ * canonical form is what the daemon uses for BOTH the mirror root and the
+ * primary writer's exclude set — they must be byte-identical or a mirror
+ * could materialize at `sources/alex` while the writer excludes
+ * `./sources/alex` (which never matches walker paths) and re-uploads it.
+ */
+declare function normalizeImportPath(p: string): string;
+/**
+ * Static + symlink validation of a single mount point. Returns a reason
+ * string on rejection, or null if the path is a legal mount.
+ *
+ * The mount may not exist on disk yet (first materialization hasn't
+ * run), so we can't realpath the full path. Instead we realpath the
+ * nearest existing ancestor and re-attach the not-yet-created remainder,
+ * then assert the result stays inside the (realpathed) rig root. This
+ * catches a symlinked ancestor that escapes the root even before the
+ * mount dir exists.
+ */
+declare function validateImportPath(rootDir: string, importPath: string): string | null;
+/**
+ * Validate a batch of imports against each other and against the
+ * primary's already-tracked content. Never throws — returns the imports
+ * that passed plus a structured error per rejection, so the orchestrator
+ * can degrade a bad mount without taking down the daemon.
+ */
+declare function validateImports(opts: {
+    rootDir: string;
+    imports: ReadonlyArray<ImportSpec>;
+    /** Paths the primary binding already tracks (state-db listPaths). */
+    primaryTrackedPaths: ReadonlyArray<string>;
+}): {
+    valid: ImportSpec[];
+    errors: ImportValidationError[];
+};
+/** `.rig/tap/state.local.db` — the primary binding's cursor/state. */
+declare function primaryStateDbPath(rootDir: string): string;
+/** `.rig/tap/imports/<name>/state.local.db` — per-import cursor/state. */
+declare function importStateDbPath(rootDir: string, name: string): string;
+/** `.rig/tap/imports` — holds `<name>.local.json` token files + `<name>/` state dirs. */
+declare function importsDir(rootDir: string): string;
+/** `.rig/tap/imports/<name>.local.json` — per-import token file. */
+declare function importMountFile(rootDir: string, name: string): string;
+declare function writeImportMount(rootDir: string, name: string, mount: ImportMountFile): void;
+/**
+ * Read + validate a single mount file. Returns the spec on success or a
+ * structured reason on failure — never throws, so one broken mount can be
+ * degraded without taking down the daemon (gotcha #7).
+ */
+declare function readImportMount(rootDir: string, name: string): {
+    ok: true;
+    spec: ImportSpec;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Enumerate `.rig/tap/imports/*.local.json` and resolve each to an
+ * ImportSpec. Broken mount files are reported, not thrown. This is the
+ * daemon's source of truth for which mirrors to run — read fresh at every
+ * `tapd start` (v1 "reload" = restart).
+ */
+declare function loadImportMounts(rootDir: string): {
+    ready: ImportSpec[];
+    broken: ImportValidationError[];
+};
+
+/**
+ * A single binding's apply loop: SSE subscriber + poll fallback +
+ * apply-mutex → applyOnce. This is the "download direction" of the
+ * daemon, extracted from start.ts so it can run N times — once for the
+ * primary binding (mode "primary") and once per import (mode "mirror").
+ *
+ * It does NOT own the watcher or scanAndPush — that "upload direction"
+ * stays attached only to the primary binding, in start.ts. A mirror is a
+ * degenerate daemon: apply-only, no uploader.
+ *
+ * Each subscription owns its own state DB (separate cursor per binding)
+ * and its own RelayClient. stop() closes the state DB, so the caller
+ * must stop any writer that shares it FIRST.
+ */
+
+/** Minimal connection config — the apply side never needs deviceId. */
+type SubscriptionConfig = {
+    bindingId: string;
+    relayUrl: string;
+    token: string;
+};
+type SubscriptionHandle = {
+    /** Stop SSE + poll, drain the in-flight apply, then close the state DB. */
+    stop(): Promise<void>;
+    /** Force one apply cycle now (through the mutex). */
+    applyNow(): Promise<ApplyResult>;
+    /** Underlying state DB. Caller MUST NOT close it — stop() does. */
+    stateDb: StateDb;
+};
+type StartSubscriptionOptions = {
+    /** Directory this binding materializes into (primary root, or a mount subdir). */
+    rootDir: string;
+    config: SubscriptionConfig;
+    /** Separate db per binding → separate cursor. */
+    stateDbPath: string;
+    mode: ApplyMode;
+    fetch?: typeof fetch;
+    pollSeconds?: number;
+    /** Test seam — disable SSE (poll-only). */
+    noSse?: boolean;
+    sseHeartbeatTimeoutMs?: number;
+};
+declare function startSubscription(opts: StartSubscriptionOptions): Promise<SubscriptionHandle>;
+
+/**
+ * `tapd import` — accept an invite to another binding and mount it
+ * read-only into a subdirectory of this rig (see rig-imports.md).
+ *
+ * Mirror of `join.ts`, but instead of making this folder a binding root
+ * it writes a per-import mount file (`.rig/tap/imports/<name>.local.json`)
+ * that the daemon picks up as a mirror subscription. Nothing about the
+ * primary binding (if any) changes.
+ *
+ *   1. Canonicalize + validate the mount (name slug, path, symlink/parent
+ *      collisions, overlap with other mounts + primary content) BEFORE any
+ *      network call — reusing validateImports so the rules can't drift.
+ *   2. Parse the invite URL → (baseUrl, secret).
+ *   3. acceptInvite → { bindingId, token: { secret, ops } }.
+ *   4. Refuse a token without read+subscribe (a mirror can't run on it).
+ *   5. Write the mount file (mode 0600). The daemon must be (re)started to
+ *      pick it up — v1 "reload" = restart.
+ */
+declare class ImportValidationFailed extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
+declare class ImportTokenScopeError extends Error {
+    readonly ops?: ReadonlyArray<string> | undefined;
+    constructor(ops?: ReadonlyArray<string> | undefined);
+}
+type AddImportOptions = {
+    rootDir: string;
+    inviteUrl: string;
+    /** Mount point (subdir, relative to the rig root). */
+    path: string;
+    /** Slug; defaults to the last path segment. */
+    name?: string;
+    accessToken?: string | null;
+    deviceLabel?: string;
+    fetch?: typeof fetch;
+};
+type AddImportResult = {
+    name: string;
+    path: string;
+    bindingId: string;
+    ops: ReadonlyArray<"read" | "write" | "subscribe">;
+    /** Import-edge id recorded by the relay (absent for anonymous imports). */
+    edgeId?: string;
+    /** False when we sent our binding as the importer but the relay couldn't
+     * verify membership — the edge was recorded as a personal import (you → S),
+     * not rig → S. The CLI surfaces this as a warning. Undefined when we sent no
+     * binding (import-only) or no edge was recorded. */
+    importerBindingVerified?: boolean;
+};
+declare function addImport(opts: AddImportOptions): Promise<AddImportResult>;
+/**
+ * Outcome of the best-effort server-side revoke half of a remove:
+ *  - revoked     — edge tombstoned + token revoked on the relay
+ *  - not-creator — 403: the grant belongs to another user; left active
+ *  - gone        — 404: already revoked/removed server-side
+ *  - no-edge     — anonymous / pre-edge mount; nothing to revoke
+ *  - no-token    — not logged in; can't reach the user plane (local-only)
+ *  - offline     — relay unreachable / unexpected error
+ */
+type RemoveImportRevoke = "revoked" | "not-creator" | "gone" | "no-edge" | "no-token" | "offline";
+type RemoveImportResult = {
+    /** False if there was no mount file by that name. */
+    removed: boolean;
+    /** The mount point that was removed (for an optional purge), if known. */
+    path: string | null;
+    /** Whether the materialized subdir was deleted (--purge). */
+    purged: boolean;
+    /** What happened to the server-side grant. */
+    revoke: RemoveImportRevoke;
+};
+/**
+ * Remove a mount: relinquish the grant on the relay (best-effort), then delete
+ * the local token file + per-import state dir. With `purge`, also delete the
+ * materialized subdir. The local removal ALWAYS happens — even offline, even
+ * when the grant isn't ours — so the daemon stops mirroring locally. The
+ * caller restarts the daemon. See docs/inter-rig-graph.md §7.
+ */
+declare function removeImport(opts: {
+    rootDir: string;
+    name: string;
+    purge?: boolean;
+    /** Hub token for the self-revoke. Omit → local-only ("no-token"). */
+    accessToken?: string | null;
+    fetch?: typeof fetch;
+}): Promise<RemoveImportResult>;
+
 /**
  * SSE consumer for the relay's /stream endpoint.
  *
@@ -496,21 +791,24 @@ type SseSubscriber = {
 declare function subscribe(opts: SseSubscriberOptions): SseSubscriber;
 
 /**
- * `tapd start` — the daemon main loop.
+ * `tapd start` — the daemon orchestrator.
+ *
+ * A daemon = N subscriptions (apply loops) + 1 writer (watcher + scan).
+ *   - The **primary** binding gets a subscription (mode "primary") AND
+ *     the writer: chokidar → debounced `scanAndPush` pushes local diffs
+ *     upstream.
+ *   - Each **import** gets an apply-only subscription (mode "mirror")
+ *     materializing another binding into a subdirectory, read-only. No
+ *     writer — a mirror never pushes.
  *
- * Three concurrent jobs (Phase 4):
- *   - SSE subscriber: opens /v1/bindings/:id/stream and triggers
- *     applyOnce on every push. Fast path — latency is network +
- *     download time, not pollSeconds.
- *   - poll loop: every `pollSeconds`, runs applyOnce as a fallback
- *     for SSE outages (and for multi-relay deployments where the SSE
- *     bus is single-process; see relay's event-bus.ts).
- *   - watcher: chokidar emits add / change / unlink / addDir / unlinkDir.
- *     Debounced rescan calls `scanAndPush` so file diffs flow upstream.
+ * The subscription machinery (SSE + poll + apply-mutex) lives in
+ * subscription.ts; this file wires the pieces together and owns the
+ * primary writer.
  *
- * All three share the state DB and the same RelayClient. Echo
- * suppression in `applyEvent` prevents a self-write from being applied
- * back over the same bytes.
+ * 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
+ * — the "accidental re-share".
  */
 
 type StartOptions = {
@@ -518,6 +816,13 @@ type StartOptions = {
     pollSeconds?: number;
     /** Quiescence window before the watcher triggers a rescan. */
     debounceMs?: number;
+    /**
+     * Read-only imports to mount into subdirectories. When omitted, the
+     * daemon loads them from `.rig/tap/imports/*.local.json` (the normal
+     * path). Pass explicitly to bypass disk loading (tests / programmatic).
+     * Each carries its own binding + capability token.
+     */
+    imports?: ReadonlyArray<ImportSpec>;
     /** Test seam — override fetch (passed to RelayClient + SSE subscriber). */
     fetch?: typeof fetch;
     /** Test seam — disable the chokidar watcher (poll loop only). */
@@ -527,16 +832,25 @@ type StartOptions = {
     /** SSE watchdog window in ms. Default 45s. */
     sseHeartbeatTimeoutMs?: number;
 };
+/** A live import mount — exposed for status + tests. */
+type ImportHandle = {
+    name: string;
+    path: string;
+    applyNow(): Promise<ApplyResult>;
+    stateDb: StateDb;
+};
 type DaemonHandle = {
-    /** Cleanly shut down the watcher + poll loop + close the state DB. */
+    /** Cleanly shut down the writer + every subscription + close state DBs. */
     stop(): Promise<void>;
-    /** Force one apply cycle now. Useful for tests + `tapd status`. */
+    /** Force one primary apply cycle now. No-op for an import-only daemon. */
     applyNow(): Promise<ApplyResult>;
-    /** Force one upstream scan+push now. Useful for tests + `tapd status`. */
+    /** Force one upstream scan+push now. No-op for an import-only daemon. */
     scanNow(): Promise<ScanAndPushResult>;
-    /** Underlying state DB. Caller MUST NOT close it — stop() does that. */
+    /** Primary state DB (or first mount's, if import-only). Do NOT close it. */
     stateDb: StateDb;
+    /** Live import mounts, in declaration order (valid ones only). */
+    imports: ImportHandle[];
 };
 declare function start(opts: StartOptions): Promise<DaemonHandle>;
 
-export { AlreadyInitializedError, AlreadyJoinedError, type ApplyResult, BINDING_CONFIG_PATH, BUILTIN_IGNORE_LINES, type BindingConfig, type DaemonHandle, type InitOptions, type InitResult, InvalidInviteUrlError, type JoinOptions, type JoinResult, type LocalPathState, type MintInviteOptions, NotInitializedError, RelayClient, type RelayClientOptions, RelayError, STATE_KEY_CONFLICT_COUNT, type ScanAndPushResult, type SseSubscriber, type SseSubscriberOptions, type StartOptions, type StateDb, type WalkFile, type WalkResult, type WalkWarning, applyOnce, bindingConfigFile, conflictSidecarPath, createBinding, hashFile, init, isAlwaysExcluded, join, list as listInvites, loadIgnore, mint as mintInvite, openStateDb, parseInviteUrl, readBindingConfig, revoke as revokeInvite, scanAndPush, subscribe as sseSubscribe, start, walk, writeBindingConfig };
+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, 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, removeImport, revoke as revokeInvite, scanAndPush, subscribe as sseSubscribe, start, startSubscription, validateImportName, validateImportPath, validateImports, walk, writeBindingConfig, writeImportMount };

package/dist/index.js

@@ -4,61 +4,93 @@ import {
   AlreadyJoinedError,
   BINDING_CONFIG_PATH,
   BUILTIN_IGNORE_LINES,
+  ImportTokenScopeError,
+  ImportValidationFailed,
   InvalidInviteUrlError,
   NotInitializedError,
   RelayClient,
   RelayError,
   STATE_KEY_CONFLICT_COUNT,
+  addImport,
   applyOnce,
   bindingConfigFile,
   conflictSidecarPath,
   createBinding,
   hashFile,
+  importMountFile,
+  importStateDbPath,
+  importsDir,
   init,
   isAlwaysExcluded,
   join,
   list,
   loadIgnore,
+  loadImportMounts,
   mint,
+  normalizeImportPath,
   openStateDb,
   parseInviteUrl,
+  primaryStateDbPath,
   readBindingConfig,
+  readImportMount,
+  removeImport,
   revoke,
   scanAndPush,
   start,
+  startSubscription,
   subscribe,
+  validateImportName,
+  validateImportPath,
+  validateImports,
   walk,
-  writeBindingConfig
-} from "./chunk-RQC73B5Y.js";
+  writeBindingConfig,
+  writeImportMount
+} from "./chunk-YPZ2UNI5.js";
 export {
   AlreadyInitializedError,
   AlreadyJoinedError,
   BINDING_CONFIG_PATH,
   BUILTIN_IGNORE_LINES,
+  ImportTokenScopeError,
+  ImportValidationFailed,
   InvalidInviteUrlError,
   NotInitializedError,
   RelayClient,
   RelayError,
   STATE_KEY_CONFLICT_COUNT,
+  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,
+  removeImport,
   revoke as revokeInvite,
   scanAndPush,
   subscribe as sseSubscribe,
   start,
+  startSubscription,
+  validateImportName,
+  validateImportPath,
+  validateImports,
   walk,
-  writeBindingConfig
+  writeBindingConfig,
+  writeImportMount
 };
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigxyz/tapd",
-  "version": "0.1.0",
+  "version": "0.4.0",
   "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>",