@noy-db/hub 0.8.0 → 0.9.0-pre.1

package/dist/kernel/query/sort-key.d.ts

@@ -33,9 +33,7 @@
  * against its own kind.
  */
 export type KeyKind = 0 | 1 | 2;
-export declare const KIND_NUMBER: KeyKind;
 export declare const KIND_STRING: KeyKind;
-export declare const KIND_DATE: KeyKind;
 export interface SortKey {
     readonly kind: KeyKind;
     /** `number` for {@link KIND_NUMBER} and {@link KIND_DATE}, `string` otherwise. */

package/dist/kernel/rejection-seal.d.ts

@@ -0,0 +1,13 @@
+import type { EnclaveKey } from '../capsule/index.js';
+import type { EncryptedEnvelope, SyncRejection } from './types.js';
+/** core#107 — where replicated refusals live. Reserved, declared in `reserved-mirror.ts`. */
+export declare const REJECTIONS_COLLECTION = "_sync_rejections";
+/** `<collection>::<id>` — one live refusal per record, newer `_v` supersedes. */
+export declare const rejectionKey: (collection: string, id: string) => string;
+export declare function sealRejection(collection: string, id: string, rejection: SyncRejection, dek: EnclaveKey, version: number): Promise<EncryptedEnvelope>;
+/**
+ * `null` when this device cannot open it. Never throws: a member who does not
+ * hold the collection's DEK receives the envelope like everybody else (the
+ * mirror is DEK-free and copies it unconditionally) and must skip it quietly.
+ */
+export declare function openRejection(collection: string, id: string, envelope: EncryptedEnvelope, dek: EnclaveKey): Promise<SyncRejection | null>;

package/dist/kernel/sync-wiring.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The vault-side seams every sync engine of a vault is wired with — at
+ * `openVault()` and again on `attachSyncTarget()` (core#90). One function so
+ * the two paths cannot drift: `sync` used to be construction-only, which forced
+ * pilot-1's direct cloud shape (a target whose credentials come from
+ * `vault.broker()`, reachable only once the vault is open) into a two-phase
+ * open with a reconstruct in between. Attaching after open needs exactly the
+ * wiring open does, plus a replay of the conflict resolvers collections
+ * registered before the target existed — hence `conflictResolvers` on the host.
+ *
+ * @internal
+ */
+import type { Vault } from './vault.js';
+import type { CollectionConflictResolver, EncryptedEnvelope, SyncRejection } from './types.js';
+type WiredEngine = {
+    setCacheInvalidator(fn: (collection: string, id: string, action: 'put' | 'delete') => Promise<void>): void;
+    setGraphBatchController(c: {
+        begin(): void;
+        flush(): Promise<void>;
+    }): void;
+    setReservedLookupSource(s: {
+        collections(): readonly string[];
+    }): void;
+    setReservedDictExpander(fn: (names: readonly string[]) => readonly string[]): void;
+    setPeriodPullSource(s: {
+        periods(): Promise<readonly unknown[]>;
+    }): void;
+    setRosterReload(seam: {
+        userId: string;
+        reload: () => Promise<void>;
+    }): void;
+    setAdmission(a: {
+        admit(collection: string, id: string, envelope: EncryptedEnvelope, origin?: 'sync-apply' | 'push-recheck'): Promise<{
+            admitted: true;
+        } | {
+            admitted: false;
+            reason: string;
+        }>;
+    }): void;
+    setRejectionCourier(c: {
+        seal(collection: string, id: string, rejection: SyncRejection, version: number): Promise<EncryptedEnvelope | null>;
+        open(collection: string, id: string, envelope: EncryptedEnvelope): Promise<SyncRejection | null>;
+    }): void;
+    setCollectionNames(fn: () => readonly string[]): void;
+    registerConflictResolver(name: string, resolver: CollectionConflictResolver): void;
+};
+export interface EngineWiringHost {
+    readonly user: string;
+    readonly keyringCache: ReadonlyMap<string, {
+        readonly deks: ReadonlyMap<string, unknown>;
+    }>;
+    readonly conflictResolvers: ReadonlyMap<string, ReadonlyMap<string, CollectionConflictResolver>>;
+}
+export declare function wireEngine(host: EngineWiringHost, name: string, comp: Vault, engine: WiredEngine): void;
+export {};

package/dist/kernel/tx-write-gate.d.ts

@@ -15,8 +15,8 @@
  *     base (two writes, one version bump).
  *
  * Neither raised an error on either side, and the loss was **store-capability
- * dependent** — `to-memory` declares `txAtomic` and takes the atomic commit
- * path, `to-browser-idb` does not and takes the per-op replay — so an app
+ * dependent** — `memoryStore({ full: true })` declares `txAtomic` and takes the
+ * atomic commit path, `to-browser-idb` does not and takes the per-op replay — so an app
  * tested on a memory store could ship lossy on IndexedDB.
  *
  * ## The remedy: make the pre-flight's read honest
@@ -56,8 +56,6 @@
  *
  * @internal
  */
-/** The shared `(vault, collection, id)` key shape. @internal */
-export declare function writeGateKey(vault: string, collection: string, id: string): string;
 /**
  * Run one logical write registered against `(vault, collection, id)` so a
  * concurrent commit can drain it. Returns / throws exactly what `fn` does —