@noy-db/hub 0.6.0-pre.4 → 0.6.0-pre.5

package/dist/broker/index.js

@@ -30,7 +30,7 @@ function withBroker(config) {
   const cache = /* @__PURE__ */ new Map();
   return {
     async enroll(ctx) {
-      const { enrollSeed } = await import("../seed-NPF3BZGQ.js");
+      const { enrollSeed } = await import("../seed-RZRHXL5E.js");
       return enrollSeed({ ...ctx, config });
     },
     async rotate(ctx) {
@@ -39,7 +39,7 @@ function withBroker(config) {
       const inFlight = scoped.map(([, e]) => e.inFlight).filter((p) => p !== void 0);
       await Promise.allSettled(inFlight);
       for (const [key] of scoped) cache.delete(key);
-      const { rotateSeed } = await import("../seed-NPF3BZGQ.js");
+      const { rotateSeed } = await import("../seed-RZRHXL5E.js");
       return rotateSeed({ ...ctx, config });
     },
     credentialSource(ctx, profile) {
@@ -56,7 +56,7 @@ function withBroker(config) {
         const skewMs = config.skewMs ?? DEFAULT_SKEW_MS;
         const capturedEntry = entry;
         const inFlight = (async () => {
-          const { mintStoreCredentials } = await import("../seed-NPF3BZGQ.js");
+          const { mintStoreCredentials } = await import("../seed-RZRHXL5E.js");
           const creds = await mintStoreCredentials({ ...ctx, config }, profile);
           capturedEntry.cached = { creds, validUntil: cacheFloor(creds, skewMs) };
           return creds;

package/dist/cargo/index.js

@@ -6,7 +6,7 @@ import {
   diffVault,
   unsealDeks,
   withCargo
-} from "../chunk-HY6Y2P4Y.js";
+} from "../chunk-LJNGRBEG.js";
 import {
   extractPartition,
   walkClosure
@@ -16,7 +16,7 @@ import {
   isDeedVault,
   liberateVault,
   loadDeedMarker
-} from "../chunk-WDDHMAAO.js";
+} from "../chunk-W3AEW5CF.js";
 import "../chunk-FZ6NYJ7L.js";
 import "../chunk-FFDNKRCY.js";
 import "../chunk-PL2GHSCM.js";
@@ -33,7 +33,7 @@ import "../chunk-XWX7GL56.js";
 import "../chunk-CDB2HVQW.js";
 import {
   CustodyApi
-} from "../chunk-XMC2ZTRD.js";
+} from "../chunk-BA2L5K25.js";
 import "../chunk-4VUPLMZ6.js";
 import "../chunk-2BMRJ6LQ.js";
 import {
@@ -46,7 +46,7 @@ import {
 } from "../chunk-IGJCYUT5.js";
 import "../chunk-7G6VDWXB.js";
 import "../chunk-UHXCLPGC.js";
-import "../chunk-RW3XKAF3.js";
+import "../chunk-WB24CH3C.js";
 import "../chunk-5JY5TSVY.js";
 import "../chunk-AHLJSVRL.js";
 import {

package/dist/{chunk-7V2OGKES.js → chunk-7OWLS6MF.js}

@@ -65,7 +65,7 @@ import {
 import {
   CustodyApi,
   NO_CUSTODY
-} from "./chunk-XMC2ZTRD.js";
+} from "./chunk-BA2L5K25.js";
 import {
   DEFAULT_POSTURE,
   ViaGraph
@@ -109,8 +109,10 @@ import {
 } from "./chunk-PEOZ34EM.js";
 import {
   NO_PERIODS,
-  purgeMarkersOn
-} from "./chunk-MYG6WIRJ.js";
+  purgeMarkersOn,
+  resolvePeriodKey,
+  samePartition
+} from "./chunk-PXCBVDFY.js";
 import {
   PERIODS_COLLECTION,
   PERIOD_ARCHIVES_COLLECTION,
@@ -215,7 +217,7 @@ import {
   saveShamirRecoveryEntries,
   updateAuthenticator,
   writeMagicLinkGrant
-} from "./chunk-O42AUQCP.js";
+} from "./chunk-CXJTWRBD.js";
 import {
   assertKeyringOpenAllowed,
   buildRecipientKeyringFile,
@@ -230,7 +232,7 @@ import {
   listUsers,
   loadKeyring,
   updateKeyringIdentity
-} from "./chunk-RW3XKAF3.js";
+} from "./chunk-WB24CH3C.js";
 import {
   persistDirectoryConfig,
   readDirectoryConfig
@@ -6120,6 +6122,18 @@ var DeferredNumberingStore = class {
 };
 
 // src/with-audit/periods/vault-facade.ts
+function hasPartition(partition) {
+  return partition !== void 0 && partition.length > 0;
+}
+function scopeSuffix(options) {
+  return hasPartition(options?.partition) ? ` in partition [${options.partition.join(", ")}]` : "";
+}
+function assertVaultWide(op, period, why) {
+  if (!hasPartition(period.partition)) return;
+  throw new ValidationError(
+    `${op}: period "${period.name}" is partitioned ([${period.partition.join(", ")}]), and ${op} ${why} \u2014 it cannot be scoped to one timeline, because the store sees only ciphertext and cannot tell which partition a stored record belongs to. Close partitioned periods for their sealing semantics; run ${op} against an unpartitioned period covering the same window.`
+  );
+}
 var VaultPeriods = class {
   constructor(deps) {
     this.deps = deps;
@@ -6134,11 +6148,11 @@ var VaultPeriods = class {
   periodCache = null;
   async closePeriod(options) {
     const existing = await this.loadPeriodsCache();
-    this.deps.strategy.validatePeriodName(options.name, existing);
+    this.deps.strategy.validatePeriodName(options.name, existing, options.partition);
     if (typeof options.endDate !== "string" || options.endDate.length === 0) {
       throw new ValidationError("closePeriod: endDate must be a non-empty ISO string.");
     }
-    const anchor = await this.deps.strategy.chainAnchor(existing);
+    const anchor = await this.deps.strategy.chainAnchor(existing, options.partition);
     const record = {
       name: options.name,
       kind: "closed",
@@ -6147,21 +6161,26 @@ var VaultPeriods = class {
       closedBy: this.deps.userId(),
       priorPeriodHash: anchor.priorPeriodHash,
       ...anchor.priorPeriodName !== void 0 && { priorPeriodName: anchor.priorPeriodName },
-      ...options.dateField !== void 0 && { dateField: options.dateField }
+      ...options.dateField !== void 0 && { dateField: options.dateField },
+      ...hasPartition(options.partition) && { partition: options.partition }
     };
-    const envelope = await this.writeReserved(PERIODS_COLLECTION, record.name, record);
-    await this.deps.strategy.appendPeriodLedgerEntry(this.deps.getLedgerOrNull(), this.deps.userId(), envelope, record.name);
+    const storageKey = resolvePeriodKey(record.name, record.partition);
+    const envelope = await this.writeReserved(PERIODS_COLLECTION, storageKey, record);
+    await this.deps.strategy.appendPeriodLedgerEntry(this.deps.getLedgerOrNull(), this.deps.userId(), envelope, storageKey);
     existing.push(record);
     this.periodCache = existing;
     return record;
   }
   async openPeriod(options) {
     const existing = await this.loadPeriodsCache();
-    this.deps.strategy.validatePeriodName(options.name, existing);
-    const prior = existing.find((p) => p.name === options.fromPeriod);
+    this.deps.strategy.validatePeriodName(options.name, existing, options.partition);
+    const prior = existing.find(
+      (p) => p.name === options.fromPeriod && samePartition(p.partition, options.partition)
+    );
     if (!prior) {
+      const where = hasPartition(options.partition) ? ` in partition [${options.partition.join(", ")}]` : "";
       throw new ValidationError(
-        `openPeriod: fromPeriod "${options.fromPeriod}" does not exist in this vault.`
+        `openPeriod: fromPeriod "${options.fromPeriod}" does not exist in this vault${where}.`
       );
     }
     if (prior.kind !== "closed") {
@@ -6191,7 +6210,7 @@ var VaultPeriods = class {
       }
       openingCollections.push(collName);
     }
-    const anchor = await this.deps.strategy.chainAnchor(existing);
+    const anchor = await this.deps.strategy.chainAnchor(existing, options.partition);
     const record = {
       name: options.name,
       kind: "opened",
@@ -6202,10 +6221,12 @@ var VaultPeriods = class {
       closedBy: this.deps.userId(),
       priorPeriodHash: anchor.priorPeriodHash,
       priorPeriodName: anchor.priorPeriodName ?? prior.name,
-      ...openingCollections.length > 0 && { openingCollections }
+      ...openingCollections.length > 0 && { openingCollections },
+      ...hasPartition(options.partition) && { partition: options.partition }
     };
-    const envelope = await this.writeReserved(PERIODS_COLLECTION, record.name, record);
-    await this.deps.strategy.appendPeriodLedgerEntry(this.deps.getLedgerOrNull(), this.deps.userId(), envelope, record.name);
+    const storageKey = resolvePeriodKey(record.name, record.partition);
+    const envelope = await this.writeReserved(PERIODS_COLLECTION, storageKey, record);
+    await this.deps.strategy.appendPeriodLedgerEntry(this.deps.getLedgerOrNull(), this.deps.userId(), envelope, storageKey);
     existing.push(record);
     this.periodCache = existing;
     return record;
@@ -6219,10 +6240,11 @@ var VaultPeriods = class {
    * read only. Idempotent: a second call is a no-op that returns the
    * same merged record without re-purging or re-appending a ledger entry.
    */
-  async freezePeriod(name) {
+  async freezePeriod(name, options) {
     const existing = await this.loadPeriodsCache();
-    const period = existing.find((p) => p.name === name);
-    if (!period) throw new ValidationError(`freezePeriod: no period named "${name}".`);
+    const period = this.findPeriod(existing, name, options);
+    if (!period) throw new ValidationError(`freezePeriod: no period named "${name}"${scopeSuffix(options)}.`);
+    assertVaultWide("freezePeriod", period, "purges delete markers by write-time across the whole store");
     if (period.kind !== "closed") {
       throw new ValidationError(
         `freezePeriod: period "${name}" is "${period.kind}"; only a closed period can be frozen.`
@@ -6262,10 +6284,11 @@ var VaultPeriods = class {
    * through to cold) and idempotent: a second call is a no-op returning the
    * same merged record.
    */
-  async archivePeriod(name) {
+  async archivePeriod(name, options) {
     const existing = await this.loadPeriodsCache();
-    const period = existing.find((p) => p.name === name);
-    if (!period) throw new ValidationError(`archivePeriod: no period named "${name}".`);
+    const period = this.findPeriod(existing, name, options);
+    if (!period) throw new ValidationError(`archivePeriod: no period named "${name}"${scopeSuffix(options)}.`);
+    assertVaultWide("archivePeriod", period, "relocates records by write-time across the whole store");
     if (period.kind !== "closed") {
       throw new ValidationError(
         `archivePeriod: period "${name}" is "${period.kind}"; only a closed period can be archived.`
@@ -6300,10 +6323,11 @@ var VaultPeriods = class {
    * Idempotent once run; with no push-only targets it writes no companion and
    * is re-runnable.
    */
-  async purgePeriodTargets(name) {
+  async purgePeriodTargets(name, options) {
     const existing = await this.loadPeriodsCache();
-    const period = existing.find((p) => p.name === name);
-    if (!period) throw new ValidationError(`purgePeriodTargets: no period named "${name}".`);
+    const period = this.findPeriod(existing, name, options);
+    if (!period) throw new ValidationError(`purgePeriodTargets: no period named "${name}"${scopeSuffix(options)}.`);
+    assertVaultWide("purgePeriodTargets", period, "sweeps delete markers by write-time off whole sync targets");
     if (period.kind !== "closed") {
       throw new ValidationError(
         `purgePeriodTargets: period "${name}" is "${period.kind}"; only a closed period can be target-purged.`
@@ -6363,8 +6387,15 @@ var VaultPeriods = class {
       purgedMarkerCount: freeze.purgedMarkerCount
     };
   }
-  /** Return every closed / opened period in `closedAt` order, merged with any freeze + archive companions. */
-  async listPeriods() {
+  /**
+   * Return every closed / opened period in `closedAt` order, merged with any
+   * freeze + archive companions.
+   *
+   * With no argument this spans EVERY timeline — the pre-#1005 behaviour, and
+   * the right default for an audit sweep. Pass `{ partition }` to scope to one
+   * timeline; `{ partition: [] }` (or omitting it) means the vault-wide one.
+   */
+  async listPeriods(options) {
     this.periodCache = null;
     const all = await this.loadPeriodsCache();
     const freezeIds = await this.deps.adapter.list(this.deps.vault, PERIOD_FREEZES_COLLECTION);
@@ -6385,7 +6416,8 @@ var VaultPeriods = class {
       const tp = await this.readReserved(PERIOD_TARGET_PURGES_COLLECTION, id);
       if (tp) targetPurges.set(tp.period, tp);
     }
-    return all.map((p) => {
+    const scoped = options === void 0 ? all : all.filter((p) => samePartition(p.partition, options.partition));
+    return scoped.map((p) => {
       const f = freezes.get(p.name);
       let merged = f ? this.mergeFreeze(p, f) : p;
       const a = archives.get(p.name);
@@ -6395,21 +6427,34 @@ var VaultPeriods = class {
       return merged;
     });
   }
-  /** Look up a single period by name, merged with its freeze + archive + target-purge companions if any. Returns `null` if not found. */
-  async getPeriod(name) {
+  /**
+   * Look up a single period by name within one timeline, merged with its
+   * freeze + archive + target-purge companions if any. Returns `null` if not
+   * found.
+   *
+   * Names are only unique per partition (#1005), so this resolves against the
+   * VAULT-WIDE timeline unless `{ partition }` says otherwise — matching how
+   * every pre-partition period is stored.
+   */
+  async getPeriod(name, options) {
     const all = await this.loadPeriodsCache();
-    const period = all.find((p) => p.name === name);
+    const period = this.findPeriod(all, name, options);
     if (!period) return null;
-    const freeze = await this.readReserved(PERIOD_FREEZES_COLLECTION, name);
-    const archive = await this.readReserved(PERIOD_ARCHIVES_COLLECTION, name);
+    const key = resolvePeriodKey(name, options?.partition);
+    const freeze = await this.readReserved(PERIOD_FREEZES_COLLECTION, key);
+    const archive = await this.readReserved(PERIOD_ARCHIVES_COLLECTION, key);
     let merged = freeze ? this.mergeFreeze(period, freeze) : period;
     if (archive) merged = this.mergeArchive(merged, archive);
-    const targetPurge = await this.readReserved(PERIOD_TARGET_PURGES_COLLECTION, name);
+    const targetPurge = await this.readReserved(PERIOD_TARGET_PURGES_COLLECTION, key);
     if (targetPurge) merged = this.mergeTargetPurge(merged, targetPurge);
     return merged;
   }
-  /** Called by the gate bus before put/delete. */
-  async assertTsWritable(existing, incoming) {
+  /** Resolve one period within the timeline named by `options` (vault-wide when absent). */
+  findPeriod(all, name, options) {
+    return all.find((p) => p.name === name && samePartition(p.partition, options?.partition));
+  }
+  /** Called by the gate bus before put/delete. `collection` selects the subject mapping (#1005). */
+  async assertTsWritable(existing, incoming, collection) {
     if (existing === null && incoming === null) return;
     if (this.periodCache === null) {
       this.periodCache = await this.deps.strategy.loadPeriods(
@@ -6419,7 +6464,12 @@ var VaultPeriods = class {
       );
     }
     if (this.periodCache.length === 0) return;
-    this.deps.strategy.assertTsWritable(existing, incoming, this.periodCache);
+    this.deps.strategy.assertTsWritable(
+      existing,
+      incoming,
+      this.periodCache,
+      collection !== void 0 ? { collection, ...this.deps.strategy.partitionOf !== void 0 && { resolve: this.deps.strategy.partitionOf } } : void 0
+    );
   }
   async loadPeriodsCache() {
     if (this.periodCache !== null) return this.periodCache;
@@ -10609,13 +10659,13 @@ var Vault = class {
   async openPeriod(options) {
     return this.periods.openPeriod(options);
   }
-  /** Return every closed / opened period in `closedAt` order. */
-  async listPeriods() {
-    return this.periods.listPeriods();
+  /** Every closed / opened period in `closedAt` order; ALL timelines unless `{ partition }` scopes it (#1005). */
+  async listPeriods(options) {
+    return this.periods.listPeriods(options);
   }
-  /** Look up a single period by name. Returns `null` if not found. */
-  async getPeriod(name) {
-    return this.periods.getPeriod(name);
+  /** One period by name within a timeline (vault-wide unless `{ partition }`). `null` if not found. */
+  async getPeriod(name, options) {
+    return this.periods.getPeriod(name, options);
   }
   /**
    * Freeze a closed period (#604): purges in-window delete markers and
@@ -10625,8 +10675,8 @@ var Vault = class {
    * and purging re-opens the #589 resurrection window for a peer offline
    * since before the cutoff (see periods.ts's "Freeze" section).
    */
-  async freezePeriod(name) {
-    return this.periods.freezePeriod(name);
+  async freezePeriod(name, options) {
+    return this.periods.freezePeriod(name, options);
   }
   /**
    * Archive a closed period (#613): relocates its in-window records from the
@@ -10635,8 +10685,8 @@ var Vault = class {
    * the chained `_periods` record. Non-destructive (reads fall through to
    * cold) and idempotent. Requires a routeStore with a cold route.
    */
-  async archivePeriod(name) {
-    return this.periods.archivePeriod(name);
+  async archivePeriod(name, options) {
+    return this.periods.archivePeriod(name, options);
   }
   /**
    * Target-purge a closed+frozen period (#615): sweeps delete markers off the
@@ -10646,12 +10696,12 @@ var Vault = class {
    * frozen first. Idempotent; a vault with no push-only targets writes no
    * companion and is re-runnable.
    */
-  async purgePeriodTargets(name) {
-    return this.periods.purgePeriodTargets(name);
+  async purgePeriodTargets(name, options) {
+    return this.periods.purgePeriodTargets(name, options);
   }
   /** @internal — called by the gate bus before put/delete. */
-  async _assertTsWritable(existing, incoming) {
-    return this.periods.assertTsWritable(existing, incoming);
+  async _assertTsWritable(existing, incoming, collection) {
+    return this.periods.assertTsWritable(existing, incoming, collection);
   }
   /** List all collection names in this vault. */
   async collections() {
@@ -13051,7 +13101,7 @@ var Noydb = class {
       const v = this.vaultCache.get(e.vault);
       if (!v) return;
       const existing = e.op === "create" ? null : { ts: e.existingTs ?? null, record: e.existing ?? null };
-      await v._assertTsWritable(existing, e.incoming);
+      await v._assertTsWritable(existing, e.incoming, e.collection);
     });
     this.subsystemBus.registerGate("beforeDelete", async (e) => {
       if (e.internal) return;
@@ -13059,7 +13109,8 @@ var Noydb = class {
       if (!v) return;
       await v._assertTsWritable(
         { ts: e.existingTs ?? null, record: e.existing ?? null },
-        null
+        null,
+        e.collection
       );
     });
   }
@@ -14363,4 +14414,4 @@ export {
   Noydb,
   createNoydb
 };
-//# sourceMappingURL=chunk-7V2OGKES.js.map
+//# sourceMappingURL=chunk-7OWLS6MF.js.map