@noy-db/hub 0.6.0-pre.7 → 0.6.0-pre.9

package/dist/cargo/index.js

@@ -6,7 +6,7 @@ import {
   diffVault,
   unsealDeks,
   withCargo
-} from "../chunk-WNFZI3I5.js";
+} from "../chunk-RV3ARMPN.js";
 import {
   extractPartition,
   walkClosure

package/dist/{chunk-YM75S6N6.js → chunk-2GAJGUNM.js}

@@ -109,17 +109,20 @@ import {
 } from "./chunk-PEOZ34EM.js";
 import {
   NO_PERIODS,
+  isEffectivelyReopened,
   purgeMarkersOn,
   resolvePeriodKey,
+  resolveReopenState,
   samePartition
-} from "./chunk-PXCBVDFY.js";
+} from "./chunk-5O5HRRTV.js";
 import {
   PERIODS_COLLECTION,
   PERIOD_ARCHIVES_COLLECTION,
   PERIOD_FREEZES_COLLECTION,
+  PERIOD_REOPENS_COLLECTION,
   PERIOD_TARGET_PURGES_COLLECTION,
   periodExclusiveUpperBound
-} from "./chunk-JXIDGFKS.js";
+} from "./chunk-HPLWFNG4.js";
 import {
   NO_SHADOW
 } from "./chunk-SMY5X46Z.js";
@@ -3406,7 +3409,7 @@ var Collection = class {
       }
     }
     if (this.materializedViewSource !== void 0) {
-      const { resolveStaleMVOnRead } = await import("./stale-C27ICSB4.js");
+      const { resolveStaleMVOnRead } = await import("./stale-ARHFVL5U.js");
       await resolveStaleMVOnRead(this.materializedViewSource, this.name, this.#dispatchCtx({ collection: this.name, id: "resolve-on-read" }));
     }
     let record;
@@ -3936,7 +3939,7 @@ var Collection = class {
    */
   async dispatchMaterializedViews(id, record, wave) {
     if (this.materializedViewSource === void 0) return;
-    const { dispatchMaterializedViews } = await import("./dispatch-4NSDG6EP.js");
+    const { dispatchMaterializedViews } = await import("./dispatch-FZEAWKVM.js");
     return dispatchMaterializedViews(this.#mvDispatchCtx(this.materializedViewSource), id, record, wave);
   }
   /**
@@ -4438,7 +4441,7 @@ var Collection = class {
    */
   async dispatchMaterializedViewsOnDelete(id) {
     if (this.materializedViewSource === void 0) return { deleted: 0, residueUndecodable: [], residueDeclined: [] };
-    const { dispatchMaterializedViewsOnDelete } = await import("./dispatch-4NSDG6EP.js");
+    const { dispatchMaterializedViewsOnDelete } = await import("./dispatch-FZEAWKVM.js");
     return dispatchMaterializedViewsOnDelete(this.#mvDispatchCtx(this.materializedViewSource), id);
   }
   /**
@@ -4458,7 +4461,7 @@ var Collection = class {
       );
     }
     if (this.materializedViewSource !== void 0) {
-      const { resolveStaleMVOnRead } = await import("./stale-C27ICSB4.js");
+      const { resolveStaleMVOnRead } = await import("./stale-ARHFVL5U.js");
       await resolveStaleMVOnRead(this.materializedViewSource, this.name, this.#dispatchCtx({ collection: this.name, id: "resolve-on-read" }));
     }
     await this.ensureHydrated();
@@ -6417,7 +6420,8 @@ var VaultPeriods = class {
       if (tp) targetPurges.set(tp.period, tp);
     }
     const scoped = options === void 0 ? all : all.filter((p) => samePartition(p.partition, options.partition));
-    return scoped.map((p) => {
+    const withReopen = await this.mergeReopenState(scoped);
+    return withReopen.map((p) => {
       const f = freezes.get(p.name);
       let merged = f ? this.mergeFreeze(p, f) : p;
       const a = archives.get(p.name);
@@ -6447,8 +6451,119 @@ var VaultPeriods = class {
     if (archive) merged = this.mergeArchive(merged, archive);
     const targetPurge = await this.readReserved(PERIOD_TARGET_PURGES_COLLECTION, key);
     if (targetPurge) merged = this.mergeTargetPurge(merged, targetPurge);
+    const reopenLog = await this.readReserved(PERIOD_REOPENS_COLLECTION, key);
+    if (reopenLog) merged = { ...merged, ...resolveReopenState(reopenLog.events) };
     return merged;
   }
+  /**
+   * The full append-only reopen/reclose log for one period (#1022) — the record
+   * an audit actually asks for, in order. `[]` when never reopened.
+   */
+  async listPeriodReopens(name, options) {
+    const key = resolvePeriodKey(name, options?.partition);
+    const log = await this.readReserved(PERIOD_REOPENS_COLLECTION, key);
+    return log?.events ?? [];
+  }
+  /**
+   * Return a closed period to a writable state (#1022).
+   *
+   * Close is a three-state lifecycle in practice — open / closed / reopened —
+   * because a month gets closed and then a missing invoice arrives, or a filing
+   * is rejected and must be amended. That is routine, and it is supposed to
+   * leave a trail.
+   *
+   * The `_periods/<key>` record is NOT touched: the reopen is appended to a
+   * companion log, so the inter-period hash chain that proves the close
+   * happened survives the reopen intact. The chain reads *closed at T1,
+   * reopened at T2 by U, reclosed at T3*.
+   *
+   * A reopen withdraws the PERIOD's veto and nothing else. Record-level rules —
+   * an `immutableGuard` on a sent receipt, a frozen field — are separate gate
+   * handlers registered ahead of the period gate, so a reopened month cannot
+   * resurrect a document that is independently locked. Period state can only
+   * ever widen what the record-level rule already permits.
+   *
+   * Reopening an already-open window is allowed and appends another event: that
+   * is how a window gets extended, and the log keeps both.
+   */
+  async reopenPeriod(name, options) {
+    const existing = await this.loadPeriodsCache();
+    const period = this.findPeriod(existing, name, options);
+    if (!period) throw new ValidationError(`reopenPeriod: no period named "${name}"${scopeSuffix(options)}.`);
+    if (period.kind !== "closed") {
+      throw new ValidationError(
+        `reopenPeriod: period "${name}" is "${period.kind}"; only a closed period can be reopened.`
+      );
+    }
+    if (options?.until !== void 0 && Number.isNaN(Date.parse(options.until))) {
+      throw new ValidationError(`reopenPeriod: unparseable \`until\` "${options.until}".`);
+    }
+    return this.appendReopenEvent(period, options, {
+      op: "reopen",
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      by: this.deps.userId(),
+      ...options?.until !== void 0 && { until: options.until },
+      ...options?.reason !== void 0 && { reason: options.reason }
+    });
+  }
+  /**
+   * Seal a reopened period again (#1022), ending the window explicitly rather
+   * than waiting for an `until` to lapse. Appends to the same log, so the
+   * close → reopen → reclose sequence is recoverable in order.
+   */
+  async reclosePeriod(name, options) {
+    const existing = await this.loadPeriodsCache();
+    const period = this.findPeriod(existing, name, options);
+    if (!period) throw new ValidationError(`reclosePeriod: no period named "${name}"${scopeSuffix(options)}.`);
+    const merged = await this.mergeReopenState([period]);
+    if (!isEffectivelyReopened(merged[0], (/* @__PURE__ */ new Date()).toISOString())) {
+      throw new ValidationError(
+        `reclosePeriod: period "${name}"${scopeSuffix(options)} is not currently reopened \u2014 nothing to reclose. A period whose \`until\` has already lapsed re-sealed on its own.`
+      );
+    }
+    return this.appendReopenEvent(period, options, {
+      op: "reclose",
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      by: this.deps.userId(),
+      ...options?.reason !== void 0 && { reason: options.reason }
+    });
+  }
+  /** Append one entry to a period's reopen log, ledger it, and invalidate the guard's view. */
+  async appendReopenEvent(period, scope, event) {
+    const key = resolvePeriodKey(period.name, period.partition);
+    const prior = await this.readReserved(PERIOD_REOPENS_COLLECTION, key);
+    const record = {
+      period: period.name,
+      ...hasPartition(period.partition) && { partition: period.partition },
+      events: [...prior?.events ?? [], event]
+    };
+    const envelope = await this.writeReserved(PERIOD_REOPENS_COLLECTION, key, record);
+    await this.deps.strategy.appendPeriodLedgerEntry(
+      this.deps.getLedgerOrNull(),
+      this.deps.userId(),
+      envelope,
+      key,
+      PERIOD_REOPENS_COLLECTION
+    );
+    this.periodCache = null;
+    void scope;
+    return { ...period, ...resolveReopenState(record.events) };
+  }
+  /** Merge each period's reopen log onto it. One adapter listing, not one per period. */
+  async mergeReopenState(periods) {
+    if (periods.length === 0) return [];
+    const ids = await this.deps.adapter.list(this.deps.vault, PERIOD_REOPENS_COLLECTION);
+    if (ids.length === 0) return [...periods];
+    const byKey = /* @__PURE__ */ new Map();
+    for (const id of ids) {
+      const r = await this.readReserved(PERIOD_REOPENS_COLLECTION, id);
+      if (r) byKey.set(id, r);
+    }
+    return periods.map((p) => {
+      const log = byKey.get(resolvePeriodKey(p.name, p.partition));
+      return log ? { ...p, ...resolveReopenState(log.events) } : p;
+    });
+  }
   /** 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));
@@ -6457,11 +6572,12 @@ var VaultPeriods = class {
   async assertTsWritable(existing, incoming, collection) {
     if (existing === null && incoming === null) return;
     if (this.periodCache === null) {
-      this.periodCache = await this.deps.strategy.loadPeriods(
+      const loaded = await this.deps.strategy.loadPeriods(
         this.deps.adapter,
         this.deps.vault,
         (env) => this.decryptPeriodRecord(env)
       );
+      this.periodCache = await this.mergeReopenState(loaded);
     }
     if (this.periodCache.length === 0) return;
     this.deps.strategy.assertTsWritable(
@@ -10184,14 +10300,14 @@ var Vault = class {
     if (!reg) {
       throw new Error(`refreshView: no MV registered with name "${name}"`);
     }
-    const { MaterializedViewExecutor } = await import("./executor-HYQBNG6J.js");
+    const { MaterializedViewExecutor } = await import("./executor-YIQB2S6N.js");
     const result = await MaterializedViewExecutor.refresh(reg, {
       getCollection: (n) => this.collection(n),
       getActiveTxContext: () => this.noydb._activeTxContextOrNull,
       getQueryContext: () => this,
       dispatchCtx: this._dispatchCtx({ collection: name, id: "refreshView" })
     });
-    const { clearMVStaleFully } = await import("./stale-C27ICSB4.js");
+    const { clearMVStaleFully } = await import("./stale-ARHFVL5U.js");
     await clearMVStaleFully(this.adapter, this.name, registry, name);
     return result;
   }
@@ -10699,6 +10815,18 @@ var Vault = class {
   async purgePeriodTargets(name, options) {
     return this.periods.purgePeriodTargets(name, options);
   }
+  /** Return a closed period to writable (#1022); logged append-only, close chain untouched. */
+  async reopenPeriod(name, options) {
+    return this.periods.reopenPeriod(name, options);
+  }
+  /** Seal a reopened period again (#1022) rather than waiting for its `until` to lapse. */
+  async reclosePeriod(name, options) {
+    return this.periods.reclosePeriod(name, options);
+  }
+  /** The append-only reopen/reclose log for one period (#1022), in order. */
+  async listPeriodReopens(name, options) {
+    return this.periods.listPeriodReopens(name, options);
+  }
   /** @internal — called by the gate bus before put/delete. */
   async _assertTsWritable(existing, incoming, collection) {
     return this.periods.assertTsWritable(existing, incoming, collection);
@@ -14414,4 +14542,4 @@ export {
   Noydb,
   createNoydb
 };
-//# sourceMappingURL=chunk-YM75S6N6.js.map
+//# sourceMappingURL=chunk-2GAJGUNM.js.map