conftree 0.1.0

package/dist/index.mjs

@@ -0,0 +1,895 @@
+// src/core/types.ts
+var DEFAULT_SCOPE = { kind: "default", refId: null };
+
+// src/core/errors.ts
+var ConfTreeError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = new.target.name;
+    Error.captureStackTrace?.(this, new.target);
+  }
+  code;
+};
+var NotFoundError = class extends ConfTreeError {
+  constructor(key) {
+    super(`Unknown setting definition: "${key}"`, "NOT_FOUND");
+  }
+};
+var ScopeError = class extends ConfTreeError {
+  constructor(key, scopeKind) {
+    super(
+      `Setting "${key}" cannot be set or read at scope kind "${scopeKind}"`,
+      "SCOPE"
+    );
+  }
+};
+var RequiredError = class extends ConfTreeError {
+  constructor(key, scopeKind, scopeRefId) {
+    super(
+      `Required setting "${key}" has no resolvable value for scope ${scopeKind}:${scopeRefId ?? "null"} and no default is defined`,
+      "REQUIRED"
+    );
+  }
+};
+var ValueError = class extends ConfTreeError {
+  constructor(message) {
+    super(message, "VALUE");
+  }
+};
+var ConflictError = class extends ConfTreeError {
+  constructor(key, scopeKind, scopeRefId) {
+    super(
+      `Setting "${key}" at scope ${scopeKind}:${scopeRefId ?? "null"} was modified concurrently. Reload the current value and retry.`,
+      "CONFLICT"
+    );
+  }
+};
+var CorruptError = class extends ConfTreeError {
+  constructor(valueId) {
+    super(
+      `setting value row ${valueId} has no typed value set: data corruption`,
+      "CORRUPT"
+    );
+  }
+};
+var CycleError = class extends ConfTreeError {
+  constructor(id, newParentId) {
+    super(
+      `Cannot attach/move scope "${id}" under "${newParentId}": would create a cycle`,
+      "CYCLE"
+    );
+  }
+};
+
+// src/cache/change-bus.ts
+var LocalBus = class {
+  listeners = /* @__PURE__ */ new Set();
+  async publish(event) {
+    await Promise.all(
+      [...this.listeners].map(
+        (listener) => Promise.resolve(listener(event))
+      )
+    );
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+  }
+};
+
+// src/cache/cache.ts
+var DEFAULT_TTL_MS = 3e4;
+var DEFAULT_MAX_ENTRIES = 5e4;
+var Cache = class {
+  constructor(bus, options = {}, hierarchy) {
+    this.bus = bus;
+    this.options = options;
+    this.hierarchy = hierarchy;
+    this.bus.subscribe((event) => this.onChange(event));
+  }
+  bus;
+  options;
+  hierarchy;
+  store = /* @__PURE__ */ new Map();
+  get(key, scope) {
+    if (this.options.enabled === false) return void 0;
+    const cacheKey = this.keyFor(key, scope);
+    const entry = this.store.get(cacheKey);
+    if (!entry) return void 0;
+    if (entry.expiresAt <= Date.now()) {
+      this.store.delete(cacheKey);
+      return void 0;
+    }
+    return entry.value;
+  }
+  set(key, scope, value) {
+    if (this.options.enabled === false) return;
+    const cacheKey = this.keyFor(key, scope);
+    if (!this.store.has(cacheKey) && this.store.size >= (this.options.maxEntries ?? DEFAULT_MAX_ENTRIES)) {
+      const oldest = this.store.keys().next().value;
+      if (oldest !== void 0) this.store.delete(oldest);
+    }
+    const ttlMs = this.options.ttlMs ?? DEFAULT_TTL_MS;
+    this.store.set(cacheKey, {
+      key,
+      scopeKind: scope.kind,
+      scopeRefId: scope.refId,
+      value,
+      expiresAt: Date.now() + ttlMs
+    });
+  }
+  drop(key) {
+    for (const [cacheKey, entry] of this.store) {
+      if (entry.key === key) this.store.delete(cacheKey);
+    }
+  }
+  dropAll() {
+    this.store.clear();
+  }
+  dropForScopes(scopeRefIds) {
+    const targets = new Set(scopeRefIds);
+    if (targets.size === 0) return;
+    for (const [cacheKey, entry] of this.store) {
+      if (entry.scopeRefId !== null && targets.has(entry.scopeRefId)) {
+        this.store.delete(cacheKey);
+      }
+    }
+  }
+  dropScoped(key, scopeRefIds) {
+    const targets = new Set(scopeRefIds);
+    for (const [cacheKey, entry] of this.store) {
+      if (entry.key === key && entry.scopeRefId !== null && targets.has(entry.scopeRefId)) {
+        this.store.delete(cacheKey);
+      }
+    }
+  }
+  async onChange(event) {
+    if (this.hierarchy && event.scopeRefId !== null) {
+      const descendants = await this.hierarchy.descendants(event.scopeRefId).catch(() => null);
+      if (descendants !== null) {
+        this.dropScoped(event.key, descendants);
+        return;
+      }
+    }
+    this.drop(event.key);
+  }
+  keyFor(key, scope) {
+    return JSON.stringify([key, scope.kind, scope.refId]);
+  }
+};
+
+// src/hierarchy/scope-hierarchy.ts
+var LocalScopeHierarchy = class {
+  parentOf = /* @__PURE__ */ new Map();
+  childrenOf = /* @__PURE__ */ new Map();
+  async chain(id) {
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    let current = id;
+    while (current !== null) {
+      if (seen.has(current)) break;
+      seen.add(current);
+      result.push(current);
+      current = this.parentOf.get(current) ?? null;
+    }
+    return result;
+  }
+  async descendants(id) {
+    const result = [];
+    const stack = [id];
+    const seen = /* @__PURE__ */ new Set();
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (seen.has(current)) continue;
+      seen.add(current);
+      result.push(current);
+      const kids = this.childrenOf.get(current);
+      if (kids) stack.push(...kids);
+    }
+    return result;
+  }
+  async children(id) {
+    return [...this.childrenOf.get(id) ?? []];
+  }
+  async parent(id) {
+    return this.parentOf.get(id) ?? null;
+  }
+  async attach(id, parentId) {
+    if (parentId !== null) await this.assertNoCycle(id, parentId);
+    this.parentOf.set(id, parentId);
+    if (parentId !== null) this.addChild(parentId, id);
+    if (!this.childrenOf.has(id)) this.childrenOf.set(id, /* @__PURE__ */ new Set());
+  }
+  async move(id, newParentId) {
+    if (newParentId !== null) await this.assertNoCycle(id, newParentId);
+    const oldParent = this.parentOf.get(id) ?? null;
+    if (oldParent !== null) this.childrenOf.get(oldParent)?.delete(id);
+    this.parentOf.set(id, newParentId);
+    if (newParentId !== null) this.addChild(newParentId, id);
+  }
+  async detach(id) {
+    const parentId = this.parentOf.get(id) ?? null;
+    const kids = [...this.childrenOf.get(id) ?? []];
+    for (const kid of kids) {
+      await this.move(kid, parentId);
+    }
+    if (parentId !== null) this.childrenOf.get(parentId)?.delete(id);
+    this.parentOf.delete(id);
+    this.childrenOf.delete(id);
+  }
+  addChild(parentId, id) {
+    if (!this.childrenOf.has(parentId))
+      this.childrenOf.set(parentId, /* @__PURE__ */ new Set());
+    this.childrenOf.get(parentId).add(id);
+  }
+  async assertNoCycle(id, newParentId) {
+    if (id === newParentId || (await this.chain(newParentId)).includes(id)) {
+      throw new CycleError(id, newParentId);
+    }
+  }
+};
+
+// src/storage/memory-storage.ts
+function toTypedColumns(type, value) {
+  return {
+    bool: type === "BOOLEAN" ? value : null,
+    num: type === "NUMERIC" ? value : null,
+    text: type === "TEXT" || type === "ENUM" ? value : null,
+    json: type === "JSON" ? value : null,
+    jsonSet: type === "JSON",
+    date: type === "DATE" ? value : null
+  };
+}
+var MemoryStorageAdapter = class {
+  defs = [];
+  values = [];
+  auditLog = [];
+  nextId = 1;
+  txQueue = Promise.resolve();
+  newId(prefix) {
+    return `${prefix}-${this.nextId++}`;
+  }
+  async findDefs(keys) {
+    const result = [];
+    for (const key of keys) {
+      const found = this.latestByStatus(key, ["STABLE", "DEPRECATED"]);
+      if (found) result.push(found);
+    }
+    return result;
+  }
+  async findValues(query) {
+    const asOf = query.asOf ?? /* @__PURE__ */ new Date();
+    const ids = new Set(query.definitionIds);
+    return this.values.filter(
+      (v) => ids.has(v.definitionId) && v.scopeKind === query.scopeKind && v.scopeRefId === query.scopeRefId && v.validFrom <= asOf && (v.validTo === null || v.validTo > asOf)
+    );
+  }
+  async findChainValues(query) {
+    const asOf = query.asOf ?? /* @__PURE__ */ new Date();
+    const defIds = new Set(query.definitionIds);
+    const refIds = new Set(query.chain);
+    return this.values.filter(
+      (v) => defIds.has(v.definitionId) && v.scopeRefId !== null && refIds.has(v.scopeRefId) && v.validFrom <= asOf && (v.validTo === null || v.validTo > asOf)
+    );
+  }
+  async findDefsByIds(ids) {
+    const idSet = new Set(ids);
+    return this.defs.filter((d) => idSet.has(d.id));
+  }
+  async findAnyDef(key) {
+    return this.latestVersion(key) ?? null;
+  }
+  async listValues(query) {
+    const now = /* @__PURE__ */ new Date();
+    const active = this.values.filter(
+      (v) => v.scopeKind === query.scopeKind && v.scopeRefId === query.scopeRefId && v.validFrom <= now && (v.validTo === null || v.validTo > now)
+    ).sort((a, b) => a.id.localeCompare(b.id));
+    const startIndex = query.cursor ? active.findIndex((v) => v.id === query.cursor) + 1 : 0;
+    const limit = query.limit ?? active.length - startIndex;
+    const page = active.slice(startIndex, startIndex + limit);
+    const nextCursor = startIndex + page.length < active.length ? page[page.length - 1]?.id ?? null : null;
+    return { values: page, nextCursor };
+  }
+  async findAudit(query) {
+    return this.auditLog.filter(
+      (a) => a.definitionId === query.definitionId && (query.scopeKind === void 0 || a.scopeKind === query.scopeKind) && (query.scopeRefId === void 0 || a.scopeRefId === query.scopeRefId)
+    ).sort((a, b) => a.at.getTime() - b.at.getTime());
+  }
+  async createDef(input) {
+    const existingVersions = this.defs.filter((d) => d.key === input.key);
+    const version = existingVersions.length > 0 ? Math.max(...existingVersions.map((d) => d.version)) + 1 : 1;
+    const record = {
+      id: this.newId("def"),
+      key: input.key,
+      version,
+      label: input.label,
+      description: input.description ?? null,
+      type: input.type,
+      options: input.options ?? [],
+      min: input.min ?? null,
+      max: input.max ?? null,
+      scopes: input.scopes,
+      inherit: input.inherit,
+      required: input.required,
+      secret: input.secret ?? false,
+      status: input.status ?? "DRAFT",
+      category: input.category ?? null
+    };
+    this.defs.push(record);
+    return record;
+  }
+  async updateDefStatus(key, status) {
+    const current = this.latestVersion(key);
+    if (!current) throw new NotFoundError(key);
+    current.status = status;
+    return current;
+  }
+  async listDefs(status) {
+    const rows = status ? this.defs.filter((d) => d.status === status) : this.defs;
+    return [...rows].sort(
+      (a, b) => (a.category ?? "").localeCompare(b.category ?? "") || a.key.localeCompare(b.key)
+    );
+  }
+  async transact(fn) {
+    const run = this.txQueue.then(() => fn(this.tx()));
+    this.txQueue = run.catch(() => {
+    });
+    return run;
+  }
+  latestByStatus(key, statuses) {
+    const latest = this.latestVersion(key);
+    return latest && statuses.includes(latest.status) ? latest : void 0;
+  }
+  latestVersion(key) {
+    return this.defs.filter((d) => d.key === key).sort((a, b) => b.version - a.version)[0];
+  }
+  tx() {
+    return {
+      findDef: async (key) => this.latestByStatus(key, ["STABLE"]) ?? null,
+      findValue: async (definitionId, scopeKind, scopeRefId) => this.values.find(
+        (v) => v.definitionId === definitionId && v.scopeKind === scopeKind && v.scopeRefId === scopeRefId && v.validTo === null
+      ) ?? null,
+      closeValue: async (id) => {
+        const row = this.values.find((v) => v.id === id);
+        if (row) row.validTo = /* @__PURE__ */ new Date();
+      },
+      createValue: async (input) => {
+        const record = {
+          id: this.newId("val"),
+          definitionId: input.definitionId,
+          scopeKind: input.scopeKind,
+          scopeRefId: input.scopeRefId,
+          version: input.version,
+          validFrom: /* @__PURE__ */ new Date(),
+          validTo: null,
+          ...toTypedColumns(input.type, input.value)
+        };
+        this.values.push(record);
+        return record;
+      },
+      createAudit: async (input) => {
+        this.auditLog.push({
+          ...input,
+          id: this.newId("audit"),
+          at: /* @__PURE__ */ new Date()
+        });
+      }
+    };
+  }
+};
+
+// src/engine/resolver.ts
+var Resolver = class {
+  constructor(storage, hierarchy, cache) {
+    this.storage = storage;
+    this.hierarchy = hierarchy;
+    this.cache = cache;
+  }
+  storage;
+  hierarchy;
+  cache;
+  async get(key, scope, asOf) {
+    const result = await this.getMany([key], scope, asOf);
+    return result[key];
+  }
+  async listAt(scope, opts = {}) {
+    const { values, nextCursor } = await this.storage.listValues({
+      scopeKind: scope.kind,
+      scopeRefId: scope.refId,
+      limit: opts.limit,
+      cursor: opts.cursor
+    });
+    if (values.length === 0) return { entries: {}, nextCursor };
+    const defs = await this.storage.findDefsByIds([
+      ...new Set(values.map((v) => v.definitionId))
+    ]);
+    const defById = new Map(defs.map((d) => [d.id, d]));
+    const entries = {};
+    for (const row of values) {
+      const def = defById.get(row.definitionId);
+      if (!def) continue;
+      entries[def.key] = this.unwrap(def, row);
+    }
+    return { entries, nextCursor };
+  }
+  async getMany(keys, scope, asOf) {
+    const uniqueKeys = [...new Set(keys)];
+    const result = {};
+    const uncached = [];
+    if (asOf === void 0) {
+      for (const key of uniqueKeys) {
+        const cached = this.cache?.get(key, scope);
+        if (cached !== void 0) result[key] = cached;
+        else uncached.push(key);
+      }
+    } else {
+      uncached.push(...uniqueKeys);
+    }
+    if (uncached.length === 0) return result;
+    const defByKey = await this.getDefs(uncached);
+    for (const key of uncached) {
+      this.checkScope(defByKey.get(key), scope);
+    }
+    const exactDefs = [];
+    const chainDefs = [];
+    for (const key of uncached) {
+      const def = defByKey.get(key);
+      const climbsHierarchy = def.inherit !== "INDEPENDENT" && scope.refId !== null && this.hierarchy;
+      (climbsHierarchy ? chainDefs : exactDefs).push(def);
+    }
+    const chain = chainDefs.length > 0 && scope.refId !== null && this.hierarchy ? await this.hierarchy.chain(scope.refId) : [];
+    const [exactRows, chainRows] = await Promise.all([
+      exactDefs.length > 0 ? this.storage.findValues({
+        definitionIds: exactDefs.map((d) => d.id),
+        scopeKind: scope.kind,
+        scopeRefId: scope.refId,
+        asOf
+      }) : Promise.resolve([]),
+      chainDefs.length > 0 && chain.length > 0 ? this.storage.findChainValues({
+        definitionIds: chainDefs.map((d) => d.id),
+        chain,
+        asOf
+      }) : Promise.resolve([])
+    ]);
+    const exactByDef = new Map(exactRows.map((r) => [r.definitionId, r]));
+    const chainByDef = /* @__PURE__ */ new Map();
+    for (const row of chainRows) {
+      const list = chainByDef.get(row.definitionId) ?? [];
+      list.push(row);
+      chainByDef.set(row.definitionId, list);
+    }
+    const chainDefIds = new Set(chainDefs.map((d) => d.id));
+    const missing = [];
+    for (const key of uncached) {
+      const def = defByKey.get(key);
+      let row;
+      if (chainDefIds.has(def.id)) {
+        const byRef = new Map(
+          (chainByDef.get(def.id) ?? []).map((v) => [
+            v.scopeRefId,
+            v
+          ])
+        );
+        for (const ref of chain) {
+          row = byRef.get(ref);
+          if (row) break;
+        }
+      } else {
+        row = exactByDef.get(def.id);
+      }
+      if (row) {
+        result[key] = this.unwrap(def, row);
+        if (asOf === void 0)
+          this.cache?.set(key, scope, result[key]);
+      } else {
+        missing.push(def);
+      }
+    }
+    if (missing.length > 0)
+      await this.resolveMissing(
+        missing,
+        scope,
+        uncached,
+        defByKey,
+        result,
+        asOf
+      );
+    return result;
+  }
+  async resolveMissing(missing, scope, keysInOrder, defByKey, result, asOf) {
+    const defaultRows = await this.storage.findValues({
+      definitionIds: missing.map((d) => d.id),
+      scopeKind: DEFAULT_SCOPE.kind,
+      scopeRefId: DEFAULT_SCOPE.refId
+    });
+    const defaultByDef = new Map(
+      defaultRows.map((r) => [r.definitionId, r])
+    );
+    const missingIds = new Set(missing.map((d) => d.id));
+    for (const key of keysInOrder) {
+      const def = defByKey.get(key);
+      if (!missingIds.has(def.id)) continue;
+      const row = defaultByDef.get(def.id);
+      if (!row) {
+        throw new RequiredError(def.key, scope.kind, scope.refId);
+      }
+      result[key] = this.unwrap(def, row);
+      if (asOf === void 0) this.cache?.set(key, scope, result[key]);
+    }
+  }
+  async getDefs(keys) {
+    const defs = await this.storage.findDefs(keys);
+    const byKey = new Map(defs.map((d) => [d.key, d]));
+    for (const key of keys) {
+      if (!byKey.has(key)) throw new NotFoundError(key);
+    }
+    return byKey;
+  }
+  checkScope(def, scope) {
+    if (scope.kind === "default") return;
+    if (!def.scopes.includes(scope.kind)) {
+      throw new ScopeError(def.key, scope.kind);
+    }
+  }
+  unwrap(def, row) {
+    switch (def.type) {
+      case "BOOLEAN":
+        if (row.bool === null) throw new CorruptError(row.id);
+        return row.bool;
+      case "NUMERIC":
+        if (row.num === null) throw new CorruptError(row.id);
+        return row.num;
+      case "TEXT":
+      case "ENUM":
+        if (row.text === null) throw new CorruptError(row.id);
+        return row.text;
+      case "JSON":
+        if (!row.jsonSet) throw new CorruptError(row.id);
+        return row.json;
+      case "DATE":
+        if (row.date === null) throw new CorruptError(row.id);
+        return row.date;
+    }
+  }
+};
+
+// src/engine/writer.ts
+var REDACTED = "[redacted]";
+var Writer = class {
+  constructor(storage, bus) {
+    this.storage = storage;
+    this.bus = bus;
+  }
+  storage;
+  bus;
+  async set(params) {
+    const created = await this.storage.transact(
+      (tx) => this.setInTx(tx, params)
+    );
+    await this.emit(created, params.key);
+    return created;
+  }
+  async setMany(paramsList) {
+    const created = await this.storage.transact(async (tx) => {
+      const results = [];
+      for (const params of paramsList) {
+        results.push(await this.setInTx(tx, params));
+      }
+      return results;
+    });
+    await Promise.all(
+      created.map((row, i) => this.emit(row, paramsList[i].key))
+    );
+    return created;
+  }
+  async setInTx(tx, params) {
+    const def = await tx.findDef(params.key);
+    if (!def) throw new NotFoundError(params.key);
+    if (params.scope.kind !== "default" && !def.scopes.includes(params.scope.kind)) {
+      throw new ScopeError(def.key, params.scope.kind);
+    }
+    this.validate(def, params.value);
+    const current = await tx.findValue(
+      def.id,
+      params.scope.kind,
+      params.scope.refId
+    );
+    const currentVersion = current?.version ?? 0;
+    const expected = params.expectedVersion ?? 0;
+    if (currentVersion !== expected) {
+      throw new ConflictError(
+        def.key,
+        params.scope.kind,
+        params.scope.refId
+      );
+    }
+    if (current) {
+      await tx.closeValue(current.id);
+    }
+    const created = await tx.createValue({
+      definitionId: def.id,
+      scopeKind: params.scope.kind,
+      scopeRefId: params.scope.refId,
+      version: currentVersion + 1,
+      authorId: params.authorId,
+      reason: params.reason,
+      type: def.type,
+      value: params.value
+    });
+    await tx.createAudit({
+      valueId: created.id,
+      definitionId: def.id,
+      scopeKind: created.scopeKind,
+      scopeRefId: created.scopeRefId,
+      action: current ? "superseded" : "created",
+      authorId: params.authorId,
+      before: current ? this.snapshotOf(def, current) : void 0,
+      after: this.snapshotOf(def, created),
+      reason: params.reason
+    });
+    return created;
+  }
+  async unset(params) {
+    const closed = await this.storage.transact(
+      (tx) => this.unsetInTx(tx, params)
+    );
+    if (closed) await this.emit(closed, params.key);
+  }
+  async unsetInTx(tx, params) {
+    const def = await tx.findDef(params.key);
+    if (!def) throw new NotFoundError(params.key);
+    if (params.scope.kind !== "default" && !def.scopes.includes(params.scope.kind)) {
+      throw new ScopeError(def.key, params.scope.kind);
+    }
+    const current = await tx.findValue(
+      def.id,
+      params.scope.kind,
+      params.scope.refId
+    );
+    const currentVersion = current?.version ?? 0;
+    const expected = params.expectedVersion ?? 0;
+    if (currentVersion !== expected) {
+      throw new ConflictError(
+        def.key,
+        params.scope.kind,
+        params.scope.refId
+      );
+    }
+    if (!current) return null;
+    await tx.closeValue(current.id);
+    await tx.createAudit({
+      valueId: current.id,
+      definitionId: def.id,
+      scopeKind: current.scopeKind,
+      scopeRefId: current.scopeRefId,
+      action: "unset",
+      authorId: params.authorId,
+      before: this.snapshotOf(def, current),
+      reason: params.reason
+    });
+    return current;
+  }
+  async emit(created, key) {
+    await this.bus?.publish({
+      definitionId: created.definitionId,
+      key,
+      scopeKind: created.scopeKind,
+      scopeRefId: created.scopeRefId
+    });
+  }
+  validate(def, value) {
+    switch (def.type) {
+      case "BOOLEAN":
+        if (typeof value !== "boolean") {
+          throw new ValueError(
+            `Setting "${def.key}" expects a boolean`
+          );
+        }
+        break;
+      case "NUMERIC": {
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+          throw new ValueError(
+            `Setting "${def.key}" expects a finite number`
+          );
+        }
+        if (def.min !== null && value < def.min) {
+          throw new ValueError(
+            `Setting "${def.key}" must be >= ${def.min}, got ${value}`
+          );
+        }
+        if (def.max !== null && value > def.max) {
+          throw new ValueError(
+            `Setting "${def.key}" must be <= ${def.max}, got ${value}`
+          );
+        }
+        break;
+      }
+      case "TEXT":
+        if (typeof value !== "string") {
+          throw new ValueError(
+            `Setting "${def.key}" expects a string`
+          );
+        }
+        break;
+      case "ENUM":
+        if (typeof value !== "string" || !def.options.includes(value)) {
+          throw new ValueError(
+            `Setting "${def.key}" must be one of: ${def.options.join(", ")}`
+          );
+        }
+        break;
+      case "JSON":
+        try {
+          JSON.stringify(value);
+        } catch {
+          throw new ValueError(
+            `Setting "${def.key}" expects a JSON-serializable value`
+          );
+        }
+        break;
+      case "DATE":
+        if (!(value instanceof Date) || Number.isNaN(value.getTime())) {
+          throw new ValueError(
+            `Setting "${def.key}" expects a valid Date`
+          );
+        }
+        break;
+    }
+  }
+  snapshotOf(def, row) {
+    if (def.secret) {
+      return {
+        scopeKind: row.scopeKind,
+        scopeRefId: row.scopeRefId,
+        version: row.version,
+        value: REDACTED
+      };
+    }
+    return {
+      scopeKind: row.scopeKind,
+      scopeRefId: row.scopeRefId,
+      version: row.version,
+      bool: row.bool,
+      num: row.num,
+      text: row.text,
+      json: row.jsonSet ? row.json : void 0,
+      date: row.date
+    };
+  }
+};
+
+// src/engine/auditor.ts
+var Auditor = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  storage;
+  async history(key, scope) {
+    const def = await this.storage.findAnyDef(key);
+    if (!def) throw new NotFoundError(key);
+    return this.storage.findAudit({
+      definitionId: def.id,
+      scopeKind: scope?.kind,
+      scopeRefId: scope?.refId
+    });
+  }
+};
+
+// src/engine/hierarchy-cache-sync.ts
+function withHierarchyInvalidation(hierarchy, cache) {
+  return {
+    chain: (id) => hierarchy.chain(id),
+    descendants: (id) => hierarchy.descendants(id),
+    children: (id) => hierarchy.children(id),
+    parent: (id) => hierarchy.parent(id),
+    attach: async (id, parentId) => {
+      await hierarchy.attach(id, parentId);
+      cache.dropForScopes(await hierarchy.descendants(id));
+    },
+    move: async (id, newParentId) => {
+      const descendants = await hierarchy.descendants(id);
+      await hierarchy.move(id, newParentId);
+      cache.dropForScopes(descendants);
+    },
+    detach: async (id) => {
+      const descendants = await hierarchy.descendants(id);
+      await hierarchy.detach(id);
+      cache.dropForScopes(descendants);
+    }
+  };
+}
+
+// src/engine/engine.ts
+function createEngine(options = {}) {
+  const storage = options.storage ?? new MemoryStorageAdapter();
+  const rawHierarchy = options.hierarchy ?? new LocalScopeHierarchy();
+  const bus = options.bus ?? new LocalBus();
+  const cacheOptions = options.cache === false ? { enabled: false } : options.cache ?? {};
+  const cache = new Cache(bus, cacheOptions, rawHierarchy);
+  const hierarchy = withHierarchyInvalidation(rawHierarchy, cache);
+  const resolver = new Resolver(storage, hierarchy, cache);
+  const writer = new Writer(storage, bus);
+  const auditor = new Auditor(storage);
+  return { storage, hierarchy, bus, cache, resolver, writer, auditor };
+}
+
+// src/typed/typed-resolver.ts
+var TypedResolver = class {
+  constructor(resolver) {
+    this.resolver = resolver;
+  }
+  resolver;
+  get(key, scope, asOf) {
+    return this.resolver.get(key, scope, asOf);
+  }
+  async getMany(keys, scope, asOf) {
+    const result = await this.resolver.getMany([...keys], scope, asOf);
+    return result;
+  }
+  async listAt(scope, opts = {}) {
+    const page = await this.resolver.listAt(scope, opts);
+    return page;
+  }
+};
+
+// src/typed/typed-writer.ts
+var TypedWriter = class {
+  constructor(writer) {
+    this.writer = writer;
+  }
+  writer;
+  set(params) {
+    return this.writer.set(params);
+  }
+  setMany(paramsList) {
+    return this.writer.setMany(paramsList);
+  }
+  unset(params) {
+    return this.writer.unset(params);
+  }
+};
+
+// src/typed/typed-auditor.ts
+var TypedAuditor = class {
+  constructor(auditor) {
+    this.auditor = auditor;
+  }
+  auditor;
+  history(key, scope) {
+    return this.auditor.history(key, scope);
+  }
+};
+
+// src/typed/typed-engine.ts
+function createTypedEngine(engine) {
+  return {
+    resolver: new TypedResolver(engine.resolver),
+    writer: new TypedWriter(engine.writer),
+    auditor: new TypedAuditor(engine.auditor)
+  };
+}
+export {
+  Auditor,
+  Cache,
+  ConfTreeError,
+  ConflictError,
+  CorruptError,
+  CycleError,
+  DEFAULT_SCOPE,
+  LocalBus,
+  LocalScopeHierarchy,
+  MemoryStorageAdapter,
+  NotFoundError,
+  RequiredError,
+  Resolver,
+  ScopeError,
+  TypedAuditor,
+  TypedResolver,
+  TypedWriter,
+  ValueError,
+  Writer,
+  createEngine,
+  createTypedEngine,
+  withHierarchyInvalidation
+};
+//# sourceMappingURL=index.mjs.map