@noy-db/hub 0.3.0-pre.8 → 0.3.0

package/dist/chunk-QABECTNN.js

@@ -1,255 +0,0 @@
-import {
-  hasExportCapability,
-  hasImportCapability
-} from "./chunk-TUL5YQWF.js";
-import {
-  ExportCapabilityError,
-  ImportCapabilityError
-} from "./chunk-OJ64XMPJ.js";
-
-// src/port/with/capabilities.ts
-function assertCanExport(keyring, tier, format) {
-  if (tier === "plaintext") {
-    if (format === void 0) {
-      throw new Error("vault.assertCanExport: plaintext tier requires a format");
-    }
-    if (!hasExportCapability(keyring, "plaintext", format)) {
-      throw new ExportCapabilityError({
-        tier: "plaintext",
-        userId: keyring.userId,
-        format
-      });
-    }
-    return;
-  }
-  if (!hasExportCapability(keyring, "bundle")) {
-    throw new ExportCapabilityError({
-      tier: "bundle",
-      userId: keyring.userId
-    });
-  }
-}
-function assertCanImport(keyring, tier, format) {
-  if (tier === "plaintext") {
-    if (format === void 0) {
-      throw new Error("vault.assertCanImport: plaintext tier requires a format");
-    }
-    if (!hasImportCapability(keyring, "plaintext", format)) {
-      throw new ImportCapabilityError({
-        tier: "plaintext",
-        userId: keyring.userId,
-        format
-      });
-    }
-    return;
-  }
-  if (!hasImportCapability(keyring, "bundle")) {
-    throw new ImportCapabilityError({
-      tier: "bundle",
-      userId: keyring.userId
-    });
-  }
-}
-function canExport(keyring, tier, format) {
-  if (tier === "plaintext") {
-    if (format === void 0) return false;
-    return hasExportCapability(keyring, "plaintext", format);
-  }
-  return hasExportCapability(keyring, "bundle");
-}
-function canImport(keyring, tier, format) {
-  if (tier === "plaintext") {
-    if (format === void 0) return false;
-    return hasImportCapability(keyring, "plaintext", format);
-  }
-  return hasImportCapability(keyring, "bundle");
-}
-
-// src/port/with/write-hooks.ts
-var WriteHookRegistry = class {
-  #before = [];
-  #after = [];
-  #suppressed = false;
-  /** True while handlers are running — used by the write path to skip nested firing. */
-  get suppressed() {
-    return this.#suppressed;
-  }
-  /** True when any hook is registered (cheap gate for the write path). */
-  get hasHandlers() {
-    return this.#before.length > 0 || this.#after.length > 0;
-  }
-  onBeforeWrite(handler) {
-    this.#before.push(handler);
-    return () => {
-      const i = this.#before.indexOf(handler);
-      if (i >= 0) this.#before.splice(i, 1);
-    };
-  }
-  onAfterWrite(handler) {
-    this.#after.push(handler);
-    return () => {
-      const i = this.#after.indexOf(handler);
-      if (i >= 0) this.#after.splice(i, 1);
-    };
-  }
-  /** Run before-hooks (awaited, in order). A throw propagates and aborts the write. */
-  async runBefore(event) {
-    if (this.#before.length === 0) return;
-    this.#suppressed = true;
-    try {
-      for (const h of this.#before.slice()) await h(event);
-    } finally {
-      this.#suppressed = false;
-    }
-  }
-  /** Run after-hooks (awaited, in order). Per-handler errors are warned, not thrown. */
-  async runAfter(event) {
-    if (this.#after.length === 0) return;
-    this.#suppressed = true;
-    try {
-      for (const h of this.#after.slice()) {
-        try {
-          await h(event);
-        } catch (err) {
-          console.warn(
-            `[noy-db] onAfterWrite handler failed for ${event.collection}/${event.docId}: ` + (err instanceof Error ? err.message : String(err))
-          );
-        }
-      }
-    } finally {
-      this.#suppressed = false;
-    }
-  }
-};
-
-// src/port/with/service-bus.ts
-var ServiceBus = class {
-  #handlers = /* @__PURE__ */ new Map();
-  #gateHandlers = /* @__PURE__ */ new Map();
-  #depth = 0;
-  /** Register a handler for an observe point. Returns an unsubscribe fn. */
-  register(point, handler) {
-    let arr = this.#handlers.get(point);
-    if (!arr) {
-      arr = [];
-      this.#handlers.set(point, arr);
-    }
-    arr.push(handler);
-    return () => {
-      const a = this.#handlers.get(point);
-      if (!a) return;
-      const i = a.indexOf(handler);
-      if (i >= 0) a.splice(i, 1);
-    };
-  }
-  /** Cheap gate for the write path — true when any handler is registered for the point. */
-  hasHandlers(point) {
-    const a = this.#handlers.get(point);
-    return a !== void 0 && a.length > 0;
-  }
-  /**
-   * True while one or more dispatches are in flight. Backed by a depth counter
-   * so that two concurrent async dispatches (`Promise.all([put('a'), put('b')])`
-   * each captured `busAfterPut=true` at their respective put() tops while depth
-   * was 0) both proceed independently — the counter stays > 0 until BOTH finish,
-   * so any nested write attempted by a handler still sees `dispatching === true`
-   * and is suppressed by the write-path gate in `collection.ts`
-   * (`busAfterPut = hasHandlers('afterPut') && !dispatching`). Re-entrancy
-   * suppression lives exclusively on that write-path gate; concurrent independent
-   * dispatches must not drop each other's events.
-   */
-  get dispatching() {
-    return this.#depth > 0;
-  }
-  /**
-   * Dispatch in registration order, awaited. Per-handler errors are warned, not
-   * thrown — an observe handler must never abort a completed write. A
-   * re-entrancy guard suppresses nested firing so a handler that itself writes
-   * cannot loop (same rationale as WriteHookRegistry.#suppressed).
-   */
-  async dispatch(point, event) {
-    const a = this.#handlers.get(point);
-    if (!a || a.length === 0) return;
-    this.#depth++;
-    try {
-      for (const h of a.slice()) {
-        try {
-          await h(event);
-        } catch (err) {
-          console.warn(
-            `[noy-db] service observe handler failed at ${point}: ` + (err instanceof Error ? err.message : String(err))
-          );
-        }
-      }
-    } finally {
-      this.#depth--;
-    }
-  }
-  /**
-   * Register a write-gating handler. A throw from the handler ABORTS the
-   * write. Returns an unsubscribe fn. See {@link GateRegisterOptions} for
-   * the `needsPrior` prior-read declaration (#267).
-   */
-  registerGate(point, handler, opts) {
-    let arr = this.#gateHandlers.get(point);
-    if (!arr) {
-      arr = [];
-      this.#gateHandlers.set(point, arr);
-    }
-    const entry = { fn: handler, needsPrior: opts?.needsPrior !== false };
-    arr.push(entry);
-    return () => {
-      const a = this.#gateHandlers.get(point);
-      if (!a) return;
-      const i = a.indexOf(entry);
-      if (i >= 0) a.splice(i, 1);
-    };
-  }
-  /** Cheap gate for the write path — true when any gate handler is registered for the point. */
-  hasGateHandlers(point) {
-    const a = this.#gateHandlers.get(point);
-    return a !== void 0 && a.length > 0;
-  }
-  /**
-   * True when at least one gate handler at `point` needs the prior record
-   * (the default). False when the point has no handlers or every handler
-   * registered with `needsPrior: false` — the write path then skips the
-   * prior-read before dispatching (#267 prior-read elision).
-   */
-  gateNeedsPrior(point) {
-    const a = this.#gateHandlers.get(point);
-    if (!a) return false;
-    return a.some((e) => e.needsPrior);
-  }
-  /**
-   * Run gate handlers in registration order, awaited. Unlike `dispatch`
-   * (observe), a handler throw is NOT swallowed — it PROPAGATES, aborting the
-   * write before it reaches the store. The first throw stops the remaining
-   * handlers (fail-fast). This is the seam guards/periods migrate onto.
-   *
-   * Note: gate handlers are validators that read, not write. A gate handler
-   * that writes back into the same collection would re-enter the write path
-   * and re-dispatch this point; loop-suppression for that case is deferred to
-   * the migration slice (contract: gate handlers must not perform writes that
-   * re-trigger their own point).
-   */
-  async dispatchGate(point, event) {
-    const a = this.#gateHandlers.get(point);
-    if (!a || a.length === 0) return;
-    for (const e of a.slice()) {
-      await e.fn(event);
-    }
-  }
-};
-var SubsystemBus = ServiceBus;
-
-export {
-  assertCanExport,
-  assertCanImport,
-  canExport,
-  canImport,
-  WriteHookRegistry,
-  ServiceBus,
-  SubsystemBus
-};
-//# sourceMappingURL=chunk-QABECTNN.js.map

package/dist/chunk-QYMMMKOO.js

@@ -1,164 +0,0 @@
-import {
-  freezeAndDeleteClosure,
-  randomId
-} from "./chunk-3KBK5LU4.js";
-import {
-  buildAccessibleBundle,
-  resolveAccessibleCollections
-} from "./chunk-DCVVCJVB.js";
-import {
-  NOYDB_FORMAT_VERSION
-} from "./chunk-REWTMYSF.js";
-import {
-  NoydbError
-} from "./chunk-OJ64XMPJ.js";
-
-// src/with-audit/portability/request-withdrawal.ts
-var WITHDRAWAL_REQUESTS_COLLECTION = "_user_withdrawal_requests";
-var WithdrawalRequestError = class extends NoydbError {
-  constructor(message) {
-    super("WITHDRAWAL_REQUEST", message);
-    this.name = "WithdrawalRequestError";
-  }
-};
-function writeRequest(vault, req, expectedVersion) {
-  const { name: vaultName, adapter } = vault._introspectState();
-  const body = JSON.stringify(req);
-  const env = {
-    _noydb: NOYDB_FORMAT_VERSION,
-    _v: expectedVersion + 1,
-    _ts: req.decidedAt ?? req.requestedAt,
-    _iv: "",
-    _data: body,
-    _by: req.decidedBy ?? req.requester
-  };
-  return adapter.put(vaultName, WITHDRAWAL_REQUESTS_COLLECTION, req.requestId, env, expectedVersion);
-}
-async function readRequest(vault, requestId) {
-  const { name: vaultName, adapter } = vault._introspectState();
-  const env = await adapter.get(vaultName, WITHDRAWAL_REQUESTS_COLLECTION, requestId);
-  if (!env) throw new WithdrawalRequestError(`withdrawal request "${requestId}" not found`);
-  return { req: JSON.parse(env._data), version: env._v };
-}
-async function requestWithdrawal(vault, opts = {}) {
-  const { keyring } = vault._introspectState();
-  const collections = resolveAccessibleCollections(keyring, opts.scope, false);
-  if (!collections || collections.length === 0) {
-    throw new WithdrawalRequestError(
-      "requestWithdrawal needs a concrete scope.collections (the caller has all-collection access \u2014 name the collections to withdraw)"
-    );
-  }
-  const requestId = `wr-${randomId()}`;
-  const requestedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const req = {
-    requestId,
-    requester: keyring.userId,
-    collections,
-    disposition: opts.disposition ?? "delete",
-    status: "pending",
-    requestedAt,
-    ...opts.legalBasis ? { legalBasis: opts.legalBasis } : {},
-    ...opts.expiresInMs ? { expiresAt: new Date(Date.parse(requestedAt) + opts.expiresInMs).toISOString() } : {}
-  };
-  await writeRequest(vault, req, 0);
-  await vault._getLedgerOrNull()?.append({
-    op: "lifecycle",
-    collection: "",
-    id: "",
-    version: 0,
-    actor: keyring.userId,
-    payloadHash: "",
-    reason: `user-withdrawal-request:${requestId}:${keyring.userId}`
-  });
-  return { requestId, status: "pending", ...req.expiresAt ? { expiresAt: req.expiresAt } : {} };
-}
-async function listWithdrawalRequests(vault, opts = {}) {
-  const { name: vaultName, adapter } = vault._introspectState();
-  const ids = await adapter.list(vaultName, WITHDRAWAL_REQUESTS_COLLECTION);
-  const out = [];
-  for (const id of ids) {
-    const env = await adapter.get(vaultName, WITHDRAWAL_REQUESTS_COLLECTION, id);
-    if (!env) continue;
-    const req = JSON.parse(env._data);
-    if (!opts.status || req.status === opts.status) out.push(req);
-  }
-  return out;
-}
-function assertApprover(vault) {
-  const { keyring } = vault._introspectState();
-  if (keyring.role !== "owner" && keyring.role !== "admin") {
-    throw new WithdrawalRequestError("approveWithdrawal / rejectWithdrawal require an owner or admin");
-  }
-  return keyring.userId;
-}
-function assertPending(req) {
-  if (req.status !== "pending") {
-    throw new WithdrawalRequestError(`withdrawal request "${req.requestId}" is already ${req.status}`);
-  }
-  if (req.expiresAt && Date.now() > Date.parse(req.expiresAt)) {
-    throw new WithdrawalRequestError(`withdrawal request "${req.requestId}" expired at ${req.expiresAt}`);
-  }
-}
-async function approveWithdrawal(vault, requestId, opts = {}) {
-  const approver = assertApprover(vault);
-  const { req, version } = await readRequest(vault, requestId);
-  assertPending(req);
-  const bundle = await buildAccessibleBundle(vault, [...req.collections], opts.reKey);
-  const snapshot = await freezeAndDeleteClosure(vault, req.collections, {
-    disposition: req.disposition,
-    actorUserId: approver,
-    withdrawalId: `wd-${requestId}`
-  });
-  const decidedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeRequest(vault, {
-    ...req,
-    status: "approved",
-    decidedAt,
-    decidedBy: approver,
-    ...snapshot ? { snapshotSha256: snapshot.sha256 } : {}
-  }, version);
-  await vault._getLedgerOrNull()?.append({
-    op: "lifecycle",
-    collection: "",
-    id: "",
-    version: 0,
-    actor: approver,
-    payloadHash: "",
-    reason: `user-withdrawal-approved:${requestId}:${req.requester}:${req.disposition}`
-  });
-  return snapshot ? { bundle, snapshot } : { bundle };
-}
-async function rejectWithdrawal(vault, requestId, opts = {}) {
-  const approver = assertApprover(vault);
-  const { req, version } = await readRequest(vault, requestId);
-  assertPending(req);
-  const decidedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const updated = {
-    ...req,
-    status: "rejected",
-    decidedAt,
-    decidedBy: approver,
-    ...opts.reason ? { rejectReason: opts.reason } : {}
-  };
-  await writeRequest(vault, updated, version);
-  await vault._getLedgerOrNull()?.append({
-    op: "lifecycle",
-    collection: "",
-    id: "",
-    version: 0,
-    actor: approver,
-    payloadHash: "",
-    reason: `user-withdrawal-rejected:${requestId}:${req.requester}`
-  });
-  return updated;
-}
-
-export {
-  WITHDRAWAL_REQUESTS_COLLECTION,
-  WithdrawalRequestError,
-  requestWithdrawal,
-  listWithdrawalRequests,
-  approveWithdrawal,
-  rejectWithdrawal
-};
-//# sourceMappingURL=chunk-QYMMMKOO.js.map

package/dist/chunk-R4IVPJHN.js

@@ -1,130 +0,0 @@
-import {
-  linkCollectionName,
-  linkRowKey
-} from "./chunk-V76PHWLE.js";
-import {
-  openEnvelopeJson
-} from "./chunk-7TAV3BFQ.js";
-import {
-  NOYDB_FORMAT_VERSION
-} from "./chunk-REWTMYSF.js";
-import {
-  encrypt
-} from "./chunk-5HZULLHE.js";
-import {
-  NoydbError
-} from "./chunk-OJ64XMPJ.js";
-
-// src/with-shape/links/link-set.ts
-var LinkSet = class {
-  constructor(adapter, vault, name, spec, encrypted, getDEK, actor, emitter, endpointExists) {
-    this.adapter = adapter;
-    this.vault = vault;
-    this.name = name;
-    this.spec = spec;
-    this.encrypted = encrypted;
-    this.getDEK = getDEK;
-    this.actor = actor;
-    this.emitter = emitter;
-    this.endpointExists = endpointExists;
-    this.collName = linkCollectionName(name);
-  }
-  adapter;
-  vault;
-  name;
-  spec;
-  encrypted;
-  getDEK;
-  actor;
-  emitter;
-  endpointExists;
-  collName;
-  dekPromise = null;
-  dek() {
-    if (!this.dekPromise) this.dekPromise = this.getDEK(this.collName);
-    return this.dekPromise;
-  }
-  async encryptEntry(entry, version) {
-    const json = JSON.stringify(entry);
-    const base = { _noydb: NOYDB_FORMAT_VERSION, _v: version, _ts: (/* @__PURE__ */ new Date()).toISOString(), _by: this.actor };
-    if (!this.encrypted) return { ...base, _iv: "", _data: json };
-    const { iv, data } = await encrypt(json, await this.dek());
-    return { ...base, _iv: iv, _data: data };
-  }
-  async decryptEntry(env) {
-    const json = this.encrypted ? await openEnvelopeJson(env, await this.dek()) : env._data;
-    return JSON.parse(json);
-  }
-  async connect(aId, bId, meta) {
-    if (!await this.endpointExists(this.spec.a, aId)) {
-      throw new LinkEndpointError(this.name, this.spec.a, aId);
-    }
-    if (!await this.endpointExists(this.spec.b, bId)) {
-      throw new LinkEndpointError(this.name, this.spec.b, bId);
-    }
-    const key = linkRowKey(aId, bId);
-    const entry = meta !== void 0 ? { a: aId, b: bId, meta } : { a: aId, b: bId };
-    const existing = await this.adapter.get(this.vault, this.collName, key);
-    const env = await this.encryptEntry(entry, (existing?._v ?? 0) + 1);
-    await this.adapter.put(this.vault, this.collName, key, env, existing?._v);
-    this.emitter.emit("change", { vault: this.vault, collection: this.collName, id: key, action: "put" });
-  }
-  async disconnect(aId, bId) {
-    const key = linkRowKey(aId, bId);
-    const existing = await this.adapter.get(this.vault, this.collName, key);
-    if (!existing) return;
-    await this.adapter.delete(this.vault, this.collName, key);
-    this.emitter.emit("change", { vault: this.vault, collection: this.collName, id: key, action: "delete" });
-  }
-  async has(aId, bId) {
-    return await this.adapter.get(this.vault, this.collName, linkRowKey(aId, bId)) !== null;
-  }
-  async of(id) {
-    const rows = await this.list();
-    return rows.filter((r) => r.a === id || r.b === id);
-  }
-  async list() {
-    const keys = await this.adapter.list(this.vault, this.collName);
-    const out = [];
-    for (const key of keys) {
-      const env = await this.adapter.get(this.vault, this.collName, key);
-      if (!env) continue;
-      const e = await this.decryptEntry(env);
-      out.push(e.meta !== void 0 ? { a: e.a, b: e.b, meta: e.meta } : { a: e.a, b: e.b });
-    }
-    return out;
-  }
-  // ── Vault-internal cascade helpers ──────────────────────────────────
-  /** @internal — rows where the deleted endpoint id matches the relevant slot. */
-  async _rowsTouchingEndpoint(collection, id) {
-    const rows = await this.list();
-    return rows.filter(
-      (r) => this.spec.a === collection && r.a === id || this.spec.b === collection && r.b === id
-    );
-  }
-  /** @internal — the storage collection name (for tx pre-image capture). */
-  get _collectionName() {
-    return this.collName;
-  }
-};
-var LinkEndpointError = class extends NoydbError {
-  link;
-  endpoint;
-  missingId;
-  constructor(link, endpoint, missingId) {
-    super(
-      "LINK_ENDPOINT",
-      `link("${link}").connect: endpoint "${endpoint}" has no record "${missingId}".`
-    );
-    this.name = "LinkEndpointError";
-    this.link = link;
-    this.endpoint = endpoint;
-    this.missingId = missingId;
-  }
-};
-
-export {
-  LinkSet,
-  LinkEndpointError
-};
-//# sourceMappingURL=chunk-R4IVPJHN.js.map

package/dist/chunk-REWTMYSF.js

@@ -1,32 +0,0 @@
-// src/kernel/types.ts
-var NOYDB_FORMAT_VERSION = 1;
-var NOYDB_KEYRING_VERSION = 1;
-var NOYDB_BACKUP_VERSION = 1;
-var NOYDB_SYNC_VERSION = 1;
-var SealedHandle = class {
-  sealed = true;
-  #reveal;
-  constructor(reveal) {
-    this.#reveal = reveal;
-  }
-  reveal() {
-    return this.#reveal();
-  }
-  /** Non-leaking serialisation marker — never the underlying value. */
-  toJSON() {
-    return "[sealed]";
-  }
-};
-function createStore(factory) {
-  return factory;
-}
-
-export {
-  NOYDB_FORMAT_VERSION,
-  NOYDB_KEYRING_VERSION,
-  NOYDB_BACKUP_VERSION,
-  NOYDB_SYNC_VERSION,
-  SealedHandle,
-  createStore
-};
-//# sourceMappingURL=chunk-REWTMYSF.js.map