principles-disciple 1.197.2 → 1.197.3

package/dist/core/principle-tree-ledger.js

@@ -1,658 +0,0 @@
-// ../principles-core/dist/principle-tree-ledger.js
-import * as fs from "fs";
-import * as path from "path";
-
-// ../principles-core/dist/runtime-v2/types/ledger-store.js
-var TREE_NAMESPACE = "_tree";
-
-// ../principles-core/dist/runtime-v2/principle-tree/ledger-codec.js
-var VALID_EVALUABILITIES = ["deterministic", "weak_heuristic", "manual_only"];
-var VALID_INTERNALIZATION_STATUSES = [
-  "prompt_only",
-  "needs_training",
-  "in_training",
-  "deployed_pending_eval",
-  "internalized",
-  "regressed"
-];
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function stringArray(value) {
-  return Array.isArray(value) ? value.filter((e) => typeof e === "string") : [];
-}
-function clampFloat(value, opts) {
-  if (typeof value !== "number" || !Number.isFinite(value))
-    return opts.fallback;
-  return Math.max(opts.min, Math.min(opts.max, value));
-}
-function clampInt(value, opts) {
-  if (typeof value !== "number" || !Number.isFinite(value))
-    return opts.fallback;
-  return Math.max(opts.min, Math.min(opts.max, Math.round(value)));
-}
-function uniqueStrings(values) {
-  return Array.from(new Set(values));
-}
-function parseLegacyTrainingStore(raw) {
-  if (!isRecord(raw))
-    return {};
-  const result = {};
-  for (const [principleId, candidate] of Object.entries(raw)) {
-    if (principleId === TREE_NAMESPACE || !isRecord(candidate))
-      continue;
-    if (candidate.principleId !== principleId)
-      continue;
-    result[principleId] = {
-      principleId,
-      evaluability: VALID_EVALUABILITIES.includes(candidate.evaluability) ? candidate.evaluability : "manual_only",
-      applicableOpportunityCount: clampInt(candidate.applicableOpportunityCount, { min: 0, max: Infinity, fallback: 0 }),
-      observedViolationCount: clampInt(candidate.observedViolationCount, { min: 0, max: Infinity, fallback: 0 }),
-      complianceRate: clampFloat(candidate.complianceRate, { min: 0, max: 1, fallback: 0 }),
-      violationTrend: clampFloat(candidate.violationTrend, { min: -1, max: 1, fallback: 0 }),
-      generatedSampleCount: clampInt(candidate.generatedSampleCount, { min: 0, max: Infinity, fallback: 0 }),
-      approvedSampleCount: clampInt(candidate.approvedSampleCount, { min: 0, max: Infinity, fallback: 0 }),
-      includedTrainRunIds: stringArray(candidate.includedTrainRunIds),
-      deployedCheckpointIds: stringArray(candidate.deployedCheckpointIds),
-      lastEvalScore: typeof candidate.lastEvalScore === "number" && Number.isFinite(candidate.lastEvalScore) ? clampFloat(candidate.lastEvalScore, { min: 0, max: 1, fallback: 0 }) : void 0,
-      internalizationStatus: VALID_INTERNALIZATION_STATUSES.includes(candidate.internalizationStatus) ? candidate.internalizationStatus : "prompt_only"
-    };
-  }
-  return result;
-}
-function parsePrinciples(raw) {
-  if (!isRecord(raw))
-    return {};
-  const principles = {};
-  for (const [id, value] of Object.entries(raw)) {
-    if (!isRecord(value))
-      continue;
-    principles[id] = {
-      ...value,
-      id,
-      ruleIds: stringArray(value.ruleIds),
-      conflictsWithPrincipleIds: stringArray(value.conflictsWithPrincipleIds),
-      derivedFromPainIds: stringArray(value.derivedFromPainIds)
-    };
-  }
-  return principles;
-}
-function parseRules(raw) {
-  if (!isRecord(raw))
-    return {};
-  const rules = {};
-  for (const [id, value] of Object.entries(raw)) {
-    if (!isRecord(value))
-      continue;
-    rules[id] = {
-      ...value,
-      id,
-      principleId: typeof value.principleId === "string" ? value.principleId : "",
-      implementationIds: stringArray(value.implementationIds)
-    };
-  }
-  return rules;
-}
-function parseImplementations(raw) {
-  if (!isRecord(raw))
-    return {};
-  const implementations = {};
-  for (const [id, value] of Object.entries(raw)) {
-    if (!isRecord(value) || typeof value.ruleId !== "string")
-      continue;
-    implementations[id] = { ...value, id, ruleId: value.ruleId };
-  }
-  return implementations;
-}
-function parseMetrics(raw) {
-  if (!isRecord(raw))
-    return {};
-  const metrics = {};
-  for (const [id, value] of Object.entries(raw)) {
-    if (!isRecord(value))
-      continue;
-    metrics[id] = { ...value, principleId: typeof value.principleId === "string" ? value.principleId : id };
-  }
-  return metrics;
-}
-function createEmptyTree() {
-  return { principles: {}, rules: {}, implementations: {}, metrics: {}, lastUpdated: (/* @__PURE__ */ new Date(0)).toISOString() };
-}
-function parseTree(raw) {
-  if (!isRecord(raw))
-    return createEmptyTree();
-  return {
-    principles: parsePrinciples(raw.principles),
-    rules: parseRules(raw.rules),
-    implementations: parseImplementations(raw.implementations),
-    metrics: parseMetrics(raw.metrics),
-    lastUpdated: typeof raw.lastUpdated === "string" ? raw.lastUpdated : (/* @__PURE__ */ new Date(0)).toISOString()
-  };
-}
-function parseHybridLedger(raw) {
-  if (!isRecord(raw))
-    return { trainingStore: {}, tree: createEmptyTree() };
-  const trainingStoreRaw = raw.trainingStore ?? raw;
-  const treeRaw = raw[TREE_NAMESPACE] ?? raw.tree;
-  return {
-    trainingStore: parseLegacyTrainingStore(trainingStoreRaw),
-    tree: parseTree(treeRaw)
-  };
-}
-function serializeLedger(store) {
-  return JSON.stringify({
-    ...store.trainingStore,
-    [TREE_NAMESPACE]: { ...store.tree, lastUpdated: (/* @__PURE__ */ new Date()).toISOString() }
-  }, null, 2);
-}
-
-// ../principles-core/dist/principle-tree-ledger.js
-var PRINCIPLE_TRAINING_FILE = "principle_training_state.json";
-var RENAME_MAX_RETRIES = 3;
-var RENAME_BASE_DELAY_MS = 50;
-function atomicWriteFileSync(filePath, data) {
-  const targetDir = path.dirname(filePath);
-  const tmpDir = fs.mkdtempSync(path.join(targetDir, ".pd-write-"));
-  const tmpPath = path.join(tmpDir, "tmp");
-  try {
-    fs.writeFileSync(tmpPath, data, { encoding: "utf8", mode: 384 });
-    let lastError;
-    for (let attempt = 0; attempt < RENAME_MAX_RETRIES; attempt++) {
-      try {
-        fs.renameSync(tmpPath, filePath);
-        return;
-      } catch (err) {
-        lastError = err;
-        const { code } = err;
-        if (code === "EPERM" || code === "EBUSY" || code === "EACCES") {
-          if (attempt < RENAME_MAX_RETRIES - 1) {
-            const delay = RENAME_BASE_DELAY_MS * Math.pow(2, attempt);
-            const waitUntil = Date.now() + delay;
-            while (Date.now() < waitUntil) {
-              try {
-                fs.accessSync(tmpPath);
-              } catch {
-              }
-            }
-          }
-          continue;
-        }
-        break;
-      }
-    }
-    throw lastError ?? new Error("atomicWriteFileSync: rename failed");
-  } finally {
-    try {
-      fs.unlinkSync(tmpPath);
-    } catch {
-    }
-    try {
-      fs.rmdirSync(tmpDir);
-    } catch {
-    }
-  }
-}
-function getLedgerFilePath(stateDir) {
-  return path.join(stateDir, PRINCIPLE_TRAINING_FILE);
-}
-function readLedgerFromFile(filePath) {
-  if (!fs.existsSync(filePath)) {
-    return { trainingStore: {}, tree: createEmptyTree() };
-  }
-  try {
-    const content = fs.readFileSync(filePath, "utf-8");
-    if (!content || content.trim() === "") {
-      return { trainingStore: {}, tree: createEmptyTree() };
-    }
-    const parsed = JSON.parse(content);
-    return parseHybridLedger(parsed);
-  } catch {
-    return { trainingStore: {}, tree: createEmptyTree() };
-  }
-}
-var LockAcquisitionError = class extends Error {
-  filePath;
-  lockPath;
-  constructor(message, filePath, lockPath) {
-    super(message);
-    this.name = "LockAcquisitionError";
-    this.filePath = filePath;
-    this.lockPath = lockPath;
-  }
-};
-var DEFAULT_LOCK_OPTIONS = {
-  maxRetries: 50,
-  baseRetryDelayMs: 10,
-  maxRetryDelayMs: 500,
-  lockStaleMs: 1e4,
-  lockSuffix: ".lock"
-};
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isErrnoException(value) {
-  return typeof value === "object" && value !== null && Object.hasOwn(value, "code");
-}
-function tryAcquireLock(lockPath, pid) {
-  try {
-    const lockDir = path.dirname(lockPath);
-    if (!fs.existsSync(lockDir)) {
-      fs.mkdirSync(lockDir, { recursive: true });
-    }
-    const flags = fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL;
-    const fd = fs.openSync(lockPath, flags, 384);
-    fs.writeSync(fd, String(pid));
-    fs.fsyncSync(fd);
-    fs.closeSync(fd);
-    return true;
-  } catch (err) {
-    if (isErrnoException(err) && err.code === "EEXIST") {
-      return false;
-    }
-    throw err;
-  }
-}
-function readLockPid(lockPath) {
-  try {
-    const content = fs.readFileSync(lockPath, "utf8");
-    const pid = parseInt(content.trim(), 10);
-    return Number.isNaN(pid) ? null : pid;
-  } catch {
-    return null;
-  }
-}
-function safeReleaseLock(lockPath, expectedPid) {
-  try {
-    if (readLockPid(lockPath) === expectedPid) {
-      fs.unlinkSync(lockPath);
-    }
-  } catch {
-  }
-}
-function cleanupStaleLock(lockPath, _staleMs) {
-  try {
-    const pid = readLockPid(lockPath);
-    const isDead = pid === null || !isProcessAlive(pid);
-    if (isDead) {
-      try {
-        fs.unlinkSync(lockPath);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-function calculateBackoff(attempt, baseMs, maxMs) {
-  const exponentialDelay = Math.min(baseMs * Math.pow(2, attempt), maxMs);
-  const jitter = exponentialDelay * 0.2 * Math.random();
-  return Math.floor(exponentialDelay + jitter);
-}
-function sleepSync(ms) {
-  if (ms <= 0)
-    return;
-  const shared = new Int32Array(new SharedArrayBuffer(4));
-  Atomics.wait(shared, 0, 0, ms);
-}
-function tryAcquireWithStaleCleanup(filePath, opts, pid) {
-  const lockPath = filePath + opts.lockSuffix;
-  if (tryAcquireLock(lockPath, pid) && readLockPid(lockPath) === pid) {
-    return { lockPath, pid, acquiredAt: Date.now() };
-  }
-  cleanupStaleLock(lockPath, opts.lockStaleMs);
-  if (tryAcquireLock(lockPath, pid) && readLockPid(lockPath) === pid) {
-    return { lockPath, pid, acquiredAt: Date.now() };
-  }
-  return null;
-}
-function buildLockError(filePath, opts) {
-  const lockPath = filePath + opts.lockSuffix;
-  const holderPid = readLockPid(lockPath);
-  const holderStatus = holderPid !== null ? isProcessAlive(holderPid) ? `alive (PID ${holderPid})` : `dead (PID ${holderPid})` : "unknown";
-  return new LockAcquisitionError(`Failed to acquire lock for ${filePath}. Lock holder: ${holderStatus}.`, filePath, lockPath);
-}
-function acquireLock(filePath, options = {}) {
-  const opts = { ...DEFAULT_LOCK_OPTIONS, ...options };
-  const { pid } = process;
-  for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
-    const ctx = tryAcquireWithStaleCleanup(filePath, opts, pid);
-    if (ctx)
-      return ctx;
-    if (attempt < opts.maxRetries - 1) {
-      sleepSync(calculateBackoff(attempt, opts.baseRetryDelayMs, opts.maxRetryDelayMs));
-    }
-  }
-  throw buildLockError(filePath, opts);
-}
-async function acquireLockAsync(filePath, options = {}) {
-  const opts = { ...DEFAULT_LOCK_OPTIONS, ...options };
-  const { pid } = process;
-  for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
-    const ctx = tryAcquireWithStaleCleanup(filePath, opts, pid);
-    if (ctx)
-      return ctx;
-    if (attempt < opts.maxRetries - 1) {
-      await new Promise((resolve) => setTimeout(resolve, calculateBackoff(attempt, opts.baseRetryDelayMs, opts.maxRetryDelayMs)));
-    }
-  }
-  throw buildLockError(filePath, opts);
-}
-function releaseLock(ctx) {
-  safeReleaseLock(ctx.lockPath, ctx.pid);
-}
-function withLock(filePath, fn, options) {
-  const ctx = acquireLock(filePath, options);
-  try {
-    return fn();
-  } finally {
-    releaseLock(ctx);
-  }
-}
-async function withLockAsync(filePath, fn, options) {
-  const ctx = await acquireLockAsync(filePath, options);
-  try {
-    return await fn();
-  } finally {
-    releaseLock(ctx);
-  }
-}
-function mutateLedger(stateDir, mutate) {
-  const filePath = getLedgerFilePath(stateDir);
-  return withLock(filePath, () => {
-    const store = readLedgerFromFile(filePath);
-    const result = mutate(store);
-    const dir = path.dirname(filePath);
-    if (!fs.existsSync(dir))
-      fs.mkdirSync(dir, { recursive: true });
-    atomicWriteFileSync(filePath, serializeLedger(store));
-    return result;
-  });
-}
-async function mutateLedgerAsync(stateDir, mutate) {
-  const filePath = getLedgerFilePath(stateDir);
-  return withLockAsync(filePath, async () => {
-    const store = readLedgerFromFile(filePath);
-    const result = await mutate(store);
-    const dir = path.dirname(filePath);
-    if (!fs.existsSync(dir))
-      fs.mkdirSync(dir, { recursive: true });
-    atomicWriteFileSync(filePath, serializeLedger(store));
-    return result;
-  });
-}
-function loadLedger(stateDir) {
-  return readLedgerFromFile(getLedgerFilePath(stateDir));
-}
-function saveLedger(stateDir, store) {
-  mutateLedger(stateDir, (current) => {
-    current.trainingStore = store.trainingStore;
-    current.tree = store.tree;
-  });
-}
-function addPrincipleToLedger(stateDir, principle) {
-  return mutateLedger(stateDir, (store) => {
-    store.tree.principles[principle.id] = principle;
-    store.tree.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-    return principle;
-  });
-}
-function updatePrinciple(stateDir, principleId, updates) {
-  return mutateLedger(stateDir, (store) => {
-    const existing = store.tree.principles[principleId];
-    if (!existing)
-      throw new Error(`Cannot update missing principle "${principleId}".`);
-    const next = {
-      ...existing,
-      ...updates,
-      id: principleId,
-      ruleIds: updates.ruleIds ? uniqueStrings(updates.ruleIds) : existing.ruleIds,
-      conflictsWithPrincipleIds: updates.conflictsWithPrincipleIds ? uniqueStrings(updates.conflictsWithPrincipleIds) : existing.conflictsWithPrincipleIds,
-      derivedFromPainIds: updates.derivedFromPainIds ? uniqueStrings(updates.derivedFromPainIds) : existing.derivedFromPainIds
-    };
-    store.tree.principles[principleId] = next;
-    return next;
-  });
-}
-function updatePrincipleValueMetrics(stateDir, principleId, metrics) {
-  return mutateLedger(stateDir, (store) => {
-    const next = { ...metrics, principleId };
-    store.tree.metrics[principleId] = next;
-    return next;
-  });
-}
-function getLedgerFilePathPublic(stateDir) {
-  return getLedgerFilePath(stateDir);
-}
-function createRule(stateDir, rule) {
-  return mutateLedger(stateDir, (store) => {
-    const principle = store.tree.principles[rule.principleId];
-    if (!principle) {
-      throw new Error(`Cannot create rule "${rule.id}" for missing principle "${rule.principleId}".`);
-    }
-    if (Object.hasOwn(store.tree.rules, rule.id)) {
-      throw new Error(`Cannot create rule "${rule.id}": it already exists. Use updateRule instead.`);
-    }
-    const nextRule = {
-      ...rule,
-      implementationIds: uniqueStrings(rule.implementationIds)
-    };
-    store.tree.rules[nextRule.id] = nextRule;
-    principle.ruleIds = uniqueStrings([...principle.ruleIds, nextRule.id]);
-    return nextRule;
-  });
-}
-function createImplementation(stateDir, implementation) {
-  return mutateLedger(stateDir, (store) => {
-    const rule = store.tree.rules[implementation.ruleId];
-    if (!rule) {
-      throw new Error(`Cannot create implementation "${implementation.id}" for missing rule "${implementation.ruleId}".`);
-    }
-    if (Object.hasOwn(store.tree.implementations, implementation.id)) {
-      throw new Error(`Cannot create implementation "${implementation.id}": it already exists. Use updateImplementation instead.`);
-    }
-    store.tree.implementations[implementation.id] = implementation;
-    rule.implementationIds = uniqueStrings([...rule.implementationIds, implementation.id]);
-    return implementation;
-  });
-}
-function updateRule(stateDir, ruleId, updates) {
-  return mutateLedger(stateDir, (store) => {
-    const existingRule = store.tree.rules[ruleId];
-    if (!existingRule) {
-      throw new Error(`Cannot update missing rule "${ruleId}".`);
-    }
-    const nextPrincipleId = updates.principleId ?? existingRule.principleId;
-    const nextPrinciple = store.tree.principles[nextPrincipleId];
-    if (!nextPrinciple) {
-      throw new Error(`Cannot move rule "${ruleId}" to missing principle "${nextPrincipleId}".`);
-    }
-    const nextRule = {
-      ...existingRule,
-      ...updates,
-      id: ruleId,
-      principleId: nextPrincipleId,
-      implementationIds: updates.implementationIds ? uniqueStrings(updates.implementationIds) : existingRule.implementationIds
-    };
-    if (existingRule.principleId !== nextPrincipleId) {
-      const previousPrinciple = store.tree.principles[existingRule.principleId];
-      if (previousPrinciple) {
-        previousPrinciple.ruleIds = previousPrinciple.ruleIds.filter((candidateId) => candidateId !== ruleId);
-      }
-      nextPrinciple.ruleIds = uniqueStrings([...nextPrinciple.ruleIds, ruleId]);
-    }
-    store.tree.rules[ruleId] = nextRule;
-    return nextRule;
-  });
-}
-function deleteRule(stateDir, ruleId) {
-  return mutateLedger(stateDir, (store) => {
-    const existingRule = store.tree.rules[ruleId];
-    if (!existingRule) {
-      return void 0;
-    }
-    const parentPrinciple = store.tree.principles[existingRule.principleId];
-    if (parentPrinciple) {
-      parentPrinciple.ruleIds = parentPrinciple.ruleIds.filter((candidateId) => candidateId !== ruleId);
-    }
-    const implementationIds = uniqueStrings([
-      ...existingRule.implementationIds,
-      ...Object.values(store.tree.implementations).filter((implementation) => implementation.ruleId === ruleId).map((implementation) => implementation.id)
-    ]);
-    for (const implementationId of implementationIds) {
-      delete store.tree.implementations[implementationId];
-    }
-    delete store.tree.rules[ruleId];
-    return existingRule;
-  });
-}
-function updateImplementation(stateDir, implementationId, updates) {
-  return mutateLedger(stateDir, (store) => {
-    const existingImplementation = store.tree.implementations[implementationId];
-    if (!existingImplementation) {
-      throw new Error(`Cannot update missing implementation "${implementationId}".`);
-    }
-    const nextRuleId = updates.ruleId ?? existingImplementation.ruleId;
-    const nextRule = store.tree.rules[nextRuleId];
-    if (!nextRule) {
-      throw new Error(`Cannot move implementation "${implementationId}" to missing rule "${nextRuleId}".`);
-    }
-    const nextImplementation = {
-      ...existingImplementation,
-      ...updates,
-      id: implementationId,
-      ruleId: nextRuleId
-    };
-    if (existingImplementation.ruleId !== nextRuleId) {
-      const previousRule = store.tree.rules[existingImplementation.ruleId];
-      if (previousRule) {
-        previousRule.implementationIds = previousRule.implementationIds.filter((candidateId) => candidateId !== implementationId);
-      }
-      nextRule.implementationIds = uniqueStrings([...nextRule.implementationIds, implementationId]);
-    }
-    store.tree.implementations[implementationId] = nextImplementation;
-    return nextImplementation;
-  });
-}
-function deleteImplementation(stateDir, implementationId) {
-  return mutateLedger(stateDir, (store) => {
-    const existingImplementation = store.tree.implementations[implementationId];
-    if (!existingImplementation) {
-      return void 0;
-    }
-    const parentRule = store.tree.rules[existingImplementation.ruleId];
-    if (parentRule) {
-      parentRule.implementationIds = parentRule.implementationIds.filter((candidateId) => candidateId !== implementationId);
-    }
-    delete store.tree.implementations[implementationId];
-    return existingImplementation;
-  });
-}
-function listImplementationsForRule(stateDir, ruleId) {
-  const ledger = loadLedger(stateDir);
-  const rule = ledger.tree.rules[ruleId];
-  if (!rule) {
-    return [];
-  }
-  return rule.implementationIds.map((implementationId) => ledger.tree.implementations[implementationId]).filter((implementation) => implementation !== void 0);
-}
-function getPrincipleSubtree(stateDir, principleId) {
-  const ledger = loadLedger(stateDir);
-  const principle = ledger.tree.principles[principleId];
-  if (!principle) {
-    return void 0;
-  }
-  return {
-    principle,
-    rules: principle.ruleIds.map((ruleId) => ledger.tree.rules[ruleId]).filter((rule) => rule !== void 0).map((rule) => ({
-      rule,
-      implementations: rule.implementationIds.map((implementationId) => ledger.tree.implementations[implementationId]).filter((implementation) => implementation !== void 0)
-    }))
-  };
-}
-var VALID_LIFECYCLE_TRANSITIONS = {
-  candidate: ["active", "archived"],
-  active: ["disabled", "archived"],
-  disabled: ["active", "archived"],
-  archived: []
-};
-function isValidLifecycleTransition(from, to) {
-  return VALID_LIFECYCLE_TRANSITIONS[from]?.includes(to) ?? false;
-}
-function getAllowedTransitions(from) {
-  return VALID_LIFECYCLE_TRANSITIONS[from] ?? [];
-}
-function transitionImplementationState(stateDir, implementationId, newState) {
-  return mutateLedger(stateDir, (store) => {
-    const impl = store.tree.implementations[implementationId];
-    if (!impl) {
-      throw new Error(`Implementation not found: ${implementationId}`);
-    }
-    const currentState = impl.lifecycleState ?? "candidate";
-    if (!isValidLifecycleTransition(currentState, newState)) {
-      const allowed = getAllowedTransitions(currentState);
-      throw new Error(`Invalid lifecycle transition: ${currentState} -> ${newState}. Allowed: ${allowed.length > 0 ? allowed.join(", ") : "none (terminal state)"}`);
-    }
-    const updated = {
-      ...impl,
-      lifecycleState: newState,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    store.tree.implementations[implementationId] = updated;
-    return updated;
-  });
-}
-function listRuleImplementationsByState(stateDir, ruleId, state) {
-  const implementations = listImplementationsForRule(stateDir, ruleId);
-  return implementations.filter((impl) => (impl.lifecycleState ?? "candidate") === state);
-}
-function findActiveImplementation(stateDir, ruleId) {
-  const implementations = listImplementationsForRule(stateDir, ruleId);
-  return implementations.find((impl) => impl.lifecycleState === "active") ?? null;
-}
-async function saveLedgerAsync(stateDir, store) {
-  await mutateLedgerAsync(stateDir, async (current) => {
-    current.trainingStore = store.trainingStore;
-    current.tree = store.tree;
-  });
-}
-function updateTrainingStore(stateDir, mutate) {
-  mutateLedger(stateDir, (store) => {
-    mutate(store.trainingStore);
-  });
-}
-
-// src/core/principle-tree-ledger.ts
-var getLedgerFilePath2 = getLedgerFilePathPublic;
-export {
-  LockAcquisitionError,
-  TREE_NAMESPACE,
-  addPrincipleToLedger,
-  createImplementation,
-  createRule,
-  deleteImplementation,
-  deleteRule,
-  findActiveImplementation,
-  getAllowedTransitions,
-  getLedgerFilePath2 as getLedgerFilePath,
-  getPrincipleSubtree,
-  isValidLifecycleTransition,
-  listImplementationsForRule,
-  listRuleImplementationsByState,
-  loadLedger,
-  saveLedger,
-  saveLedgerAsync,
-  transitionImplementationState,
-  updateImplementation,
-  updatePrinciple,
-  updatePrincipleValueMetrics,
-  updateRule,
-  updateTrainingStore
-};