amalgm 0.1.245 → 0.1.246

package/runtime/scripts/amalgm-mcp/workspace/provenance.js

@@ -1,240 +0,0 @@
-'use strict';
-
-/**
- * The complete provenance transition relation for managed repo bytes.
- *
- * This is deliberately data, not a second reconciler. Runtime code may name
- * one of these transitions, and tests exhaust the whole relation.
- */
-
-const CLASS = Object.freeze({
-  OFFICIAL: 'officially-applied',
-  INTENT: 'journaled-local-intent',
-  UNKNOWN: 'unknown-provenance',
-});
-
-const STATE = Object.freeze({
-  OFFICIAL: CLASS.OFFICIAL,
-  UNKNOWN: CLASS.UNKNOWN,
-  CAPTURED: `${CLASS.INTENT}:captured`,
-  RESERVED: `${CLASS.INTENT}:reserved`,
-  NUMBERED: `${CLASS.INTENT}:numbered`,
-  FOLDED: `${CLASS.INTENT}:folded`,
-});
-
-const ACTION = Object.freeze({
-  SAVE: 'save',
-  VERIFY: 'verify',
-  CAPTURE: 'capture',
-  RESERVE: 'reserve',
-  RETRY: 'retry',
-  NUMBER: 'number',
-  FOLD: 'fold',
-  APPLY: 'apply',
-  SNAPSHOT: 'snapshot',
-  COMPACT: 'compact',
-  PRUNE: 'prune',
-  RECOVER: 'recover',
-  OBSERVE_UNKNOWN: 'observe-unknown',
-});
-
-const allStates = Object.freeze(Object.values(STATE));
-
-function transition(from, action, to, facts) {
-  return Object.freeze({
-    from,
-    action,
-    to,
-    facts: Object.freeze(facts),
-  });
-}
-
-const transitions = [
-  transition(STATE.OFFICIAL, ACTION.SAVE, STATE.UNKNOWN, [
-    'previous-provenance-preserved',
-  ]),
-  ...[
-    STATE.CAPTURED,
-    STATE.RESERVED,
-    STATE.NUMBERED,
-    STATE.FOLDED,
-  ].map((from) => transition(from, ACTION.SAVE, STATE.UNKNOWN, [
-    'previous-provenance-preserved',
-  ])),
-  transition(STATE.UNKNOWN, ACTION.OBSERVE_UNKNOWN, STATE.UNKNOWN, [
-    'exact-physical-observation',
-  ]),
-  transition(STATE.UNKNOWN, ACTION.VERIFY, STATE.OFFICIAL, [
-    'official-target',
-    'physical-verification',
-    'applied-cursor',
-  ]),
-  transition(STATE.UNKNOWN, ACTION.CAPTURE, STATE.CAPTURED, [
-    'verified-base',
-    'exact-local-state',
-    'physical-digest',
-    'intent-record',
-  ]),
-  transition(STATE.CAPTURED, ACTION.RESERVE, STATE.RESERVED, [
-    'intent-record',
-    'publication-id',
-  ]),
-  transition(STATE.RESERVED, ACTION.RESERVE, STATE.RESERVED, [
-    'same-publication-id',
-    'same-envelope',
-  ]),
-  transition(STATE.RESERVED, ACTION.RETRY, STATE.RESERVED, [
-    'same-publication-id',
-    'same-envelope',
-  ]),
-  transition(STATE.RESERVED, ACTION.NUMBER, STATE.NUMBERED, [
-    'publication-id',
-    'official-version',
-    'server-receipt',
-  ]),
-  transition(STATE.NUMBERED, ACTION.NUMBER, STATE.NUMBERED, [
-    'same-publication-id',
-    'same-official-version',
-  ]),
-  transition(STATE.NUMBERED, ACTION.FOLD, STATE.FOLDED, [
-    'predecessor-folded',
-    'official-event',
-    'official-snapshot',
-  ]),
-  transition(STATE.FOLDED, ACTION.FOLD, STATE.FOLDED, [
-    'same-official-version',
-    'official-snapshot',
-  ]),
-  transition(STATE.FOLDED, ACTION.APPLY, STATE.OFFICIAL, [
-    'official-target',
-    'apply-wal',
-    'physical-verification',
-    'applied-cursor',
-    'intent-retired',
-  ]),
-  transition(STATE.OFFICIAL, ACTION.APPLY, STATE.OFFICIAL, [
-    'contiguous-official-target',
-    'apply-wal',
-    'physical-verification',
-    'applied-cursor',
-  ]),
-  ...[
-    STATE.CAPTURED,
-    STATE.RESERVED,
-    STATE.NUMBERED,
-  ].map((state) => transition(state, ACTION.APPLY, state, [
-    'contiguous-official-target',
-    'apply-wal',
-    'pending-intent-preserved',
-    'physical-verification',
-    'applied-cursor',
-  ])),
-  transition(STATE.OFFICIAL, ACTION.SNAPSHOT, STATE.OFFICIAL, [
-    'verified-snapshot',
-    'apply-wal',
-    'physical-verification',
-    'applied-cursor',
-  ]),
-  transition(STATE.UNKNOWN, ACTION.SNAPSHOT, STATE.OFFICIAL, [
-    'empty-path',
-    'verified-snapshot',
-    'apply-wal',
-    'physical-verification',
-    'applied-cursor',
-  ]),
-  transition(STATE.UNKNOWN, ACTION.SNAPSHOT, STATE.UNKNOWN, [
-    'unknown-bytes-preserved',
-  ]),
-  ...[
-    STATE.CAPTURED,
-    STATE.RESERVED,
-  ].map((state) => transition(state, ACTION.SNAPSHOT, state, [
-    'verified-snapshot',
-    'apply-wal',
-    'pending-intent-preserved',
-    'physical-verification',
-    'applied-cursor',
-  ])),
-  ...[
-    STATE.NUMBERED,
-    STATE.FOLDED,
-  ].map((state) => transition(state, ACTION.SNAPSHOT, STATE.OFFICIAL, [
-    'numbered-event-in-snapshot',
-    'verified-snapshot',
-    'apply-wal',
-    'physical-verification',
-    'applied-cursor',
-    'intent-retired',
-  ])),
-  transition(STATE.OFFICIAL, ACTION.COMPACT, STATE.OFFICIAL, [
-    'retained-server-receipt',
-    'verified-server-snapshot',
-  ]),
-  transition(STATE.FOLDED, ACTION.PRUNE, STATE.FOLDED, [
-    'official-fold',
-    'durable-folded-intent',
-  ]),
-  transition(STATE.OFFICIAL, ACTION.PRUNE, STATE.OFFICIAL, [
-    'official-fold',
-    'physical-verification',
-    'applied-cursor',
-  ]),
-  ...allStates.map((state) => transition(state, ACTION.RECOVER, state, [
-    'durable-provenance-record',
-    'apply-wal-before-destructive-write',
-  ])),
-  ...[
-    STATE.OFFICIAL,
-    STATE.CAPTURED,
-    STATE.RESERVED,
-    STATE.NUMBERED,
-    STATE.FOLDED,
-  ].map((state) => transition(state, ACTION.RECOVER, STATE.UNKNOWN, [
-    'apply-wal',
-    'exact-third-value-observation',
-    'previous-provenance-preserved',
-  ])),
-];
-
-const TRANSITIONS = Object.freeze(transitions);
-const transitionByKey = new Map(
-  TRANSITIONS.map((entry) => [`${entry.from}\u0000${entry.action}\u0000${entry.to}`, entry]),
-);
-
-function provenanceClass(state) {
-  if (state === STATE.OFFICIAL) return CLASS.OFFICIAL;
-  if (state === STATE.UNKNOWN) return CLASS.UNKNOWN;
-  if (typeof state === 'string' && state.startsWith(`${CLASS.INTENT}:`)) {
-    return CLASS.INTENT;
-  }
-  return null;
-}
-
-function publicationState(publication) {
-  if (!publication) return STATE.CAPTURED;
-  if (publication.foldedAt != null) return STATE.FOLDED;
-  if (publication.numberedVersion != null) return STATE.NUMBERED;
-  return STATE.RESERVED;
-}
-
-function requireTransition(from, action, to, availableFacts = []) {
-  const entry = transitionByKey.get(`${from}\u0000${action}\u0000${to}`);
-  if (!entry) throw new Error(`illegal provenance transition: ${from} --${action}--> ${to}`);
-  const available = new Set(availableFacts);
-  const missing = entry.facts.filter((fact) => !available.has(fact));
-  if (missing.length > 0) {
-    throw new Error(`provenance transition ${action} is missing: ${missing.join(', ')}`);
-  }
-  return entry;
-}
-
-module.exports = {
-  ACTION,
-  CLASS,
-  STATE,
-  TRANSITIONS,
-  allStates,
-  provenanceClass,
-  publicationState,
-  requireTransition,
-};

package/runtime/scripts/amalgm-mcp/workspace/sync-stats.js

@@ -1,240 +0,0 @@
-'use strict';
-
-/**
- * Referee projection for the floor, physical verification, and local overlay.
- *
- * Referee axiom: a gate must see every active or successor intent. Proven by
- * workspace-sync-stats.test.js and workspace-sync-harness-core.test.mjs.
- */
-
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-const { listRepoCards, repoCardServiceStats } = require('./cards');
-const { repoKeyOfCard } = require('./checkpoint');
-const { machineId, userId } = require('./identity');
-const projectStream = require('./project-stream');
-const reducer = require('./reducer');
-const { listWorkspaces } = require('./store');
-const wall = require('./wall');
-const runtimeVersion = require('../../../../package.json').version;
-const PACKAGE_ROOT = path.resolve(__dirname, '..', '..', '..', '..');
-const RUNTIME_ROOT = path.resolve(__dirname, '..');
-
-function filesUnder(root) {
-  return fs.readdirSync(root, { withFileTypes: true })
-    .flatMap((entry) => {
-      const file = path.join(root, entry.name);
-      if (entry.isDirectory()) return filesUnder(file);
-      return entry.isFile() ? [file] : [];
-    })
-    .sort();
-}
-
-// The sync identity follows the architecture tree, not a hand-maintained
-// dependency list. New state/materialization modules and native workspace
-// helpers therefore enter the release identity automatically.
-const SYNC_FILES = [
-  path.join(RUNTIME_ROOT, 'state'),
-  path.join(RUNTIME_ROOT, 'workspace'),
-].flatMap(filesUnder);
-
-function fileFingerprint(files) {
-  const hash = crypto.createHash('sha256');
-  for (const file of files.filter((candidate) => fs.existsSync(candidate)).sort()) {
-    hash.update(path.relative(PACKAGE_ROOT, file));
-    hash.update('\0');
-    hash.update(fs.readFileSync(file));
-    hash.update('\0');
-  }
-  return `sha256:${hash.digest('hex')}`;
-}
-
-function sharedTunnelFiles() {
-  return [
-    path.join(PACKAGE_ROOT, 'lib', 'shared-realtime-tunnel.js'),
-    path.join(PACKAGE_ROOT, 'packages', 'amalgm', 'lib', 'shared-realtime-tunnel.js'),
-  ].filter((file) => fs.existsSync(file));
-}
-
-const runtimeBuildFingerprint = fileFingerprint([
-  path.join(PACKAGE_ROOT, 'package.json'),
-  ...filesUnder(RUNTIME_ROOT),
-  ...sharedTunnelFiles(),
-]);
-const runtimeSyncFingerprint = fileFingerprint([
-  ...SYNC_FILES,
-  ...sharedTunnelFiles(),
-]);
-
-function canonical(value) {
-  if (Array.isArray(value)) return value.map(canonical);
-  if (!value || typeof value !== 'object') return value;
-  return Object.fromEntries(
-    Object.keys(value).sort().map((key) => [key, canonical(value[key])]),
-  );
-}
-
-function digest(value) {
-  return crypto.createHash('sha256')
-    .update(JSON.stringify(canonical(value)))
-    .digest('hex');
-}
-
-function samePath(left, right) {
-  return Boolean(left && right && path.resolve(left) === path.resolve(right));
-}
-
-function folderFor(project, cards, workspaces) {
-  const card = cards.find((entry) => (
-    entry.kind === 'primary'
-    && repoKeyOfCard(entry) === project.repoKey
-  ));
-  const folderPath = project.path || card?.path || null;
-  const workspace = workspaces.find((entry) => samePath(entry.path, folderPath));
-  return {
-    card,
-    folderPath,
-    folderUuid: workspace?.id || null,
-  };
-}
-
-function waitingFor(state, outcome) {
-  const waiting = [];
-  if (outcome?.state === 'waiting' || outcome?.state === 'error') {
-    waiting.push({
-      state: outcome.state,
-      reason: outcome.reason || null,
-    });
-  }
-  return waiting;
-}
-
-function verificationFor(state, outcome, pendingIntent = null) {
-  return {
-    contract: state?.verificationContract || null,
-    appliedThrough: Number.isSafeInteger(state?.appliedThrough)
-      ? state.appliedThrough
-      : null,
-    materialized: state?.materialized === true,
-    targetDigest: state?.targetDigest || null,
-    expectedPhysicalDigest: state?.expectedPhysicalDigest || null,
-    observedPhysicalDigest: state?.observedPhysicalDigest || null,
-    pendingIntent,
-    waiting: waitingFor(state, outcome),
-  };
-}
-
-function pendingIntentValue(value, owned) {
-  const successor = value?.successor || null;
-  if (!owned && !successor) return null;
-  const result = {
-    baseThrough: value.base.through,
-    semanticDigest: value.semanticDigest,
-    mutationId: value.birthMutationId || value.publication?.mutationId || null,
-    terminalCode: value.terminal?.code || null,
-  };
-  if (successor) {
-    result.successor = {
-      predecessorSemanticDigest: successor.predecessorSemanticDigest,
-      semanticDigest: successor.semanticDigest,
-      mutationId: successor.birthMutationId || null,
-      terminalCode: successor.terminal?.code || null,
-    };
-  }
-  return result;
-}
-
-function pendingIntentFor(project) {
-  const intents = require('./intent');
-  const value = intents.readIntent(project);
-  return pendingIntentValue(
-    value,
-    Boolean(value && !intents.officialAcknowledgement(project, value)),
-  );
-}
-
-function autoUpdateDisabled(env = process.env) {
-  const disabled = String(env.AMALGM_DISABLE_AUTO_UPDATE || '').trim().toLowerCase();
-  if (['1', 'true', 'yes', 'on'].includes(disabled)) return true;
-  const enabled = String(env.AMALGM_AUTO_UPDATE || '').trim().toLowerCase();
-  return ['0', 'false', 'no', 'off'].includes(enabled);
-}
-
-function projectObservation({
-  project,
-  cards,
-  workspaces,
-  reducerRepos,
-}) {
-  const folder = folderFor(project, cards, workspaces);
-  const state = reducer.readRepoState(project.repoKey, project.resourceId);
-  const exactState = (
-    state
-    && folder.folderPath
-    && samePath(state.path, folder.folderPath)
-    && (!folder.card || state.replica === folder.card.replica)
-  ) ? state : null;
-  const snapshot = projectStream.readSnapshot(project.file, project.resourceId);
-  const publication = wall.publicationStatus(project.repoKey, exactState);
-  const outcome = reducerRepos.find((entry) => (
-    entry.repoKey === project.repoKey
-    && (!folder.folderPath || !entry.path || samePath(entry.path, folder.folderPath))
-  )) || null;
-  return {
-    resourceId: project.resourceId,
-    repoKey: project.repoKey,
-    folderPath: folder.folderPath,
-    folderUuid: folder.folderUuid,
-    receivedThrough: publication.receivedThrough,
-    snapshotThrough: snapshot.version,
-    snapshotDigest: digest(snapshot),
-    pendingOutbound: publication.pending,
-    verification: verificationFor(exactState, outcome, pendingIntentFor(project)),
-  };
-}
-
-function workspaceSyncStats() {
-  const cards = listRepoCards();
-  const wallState = wall.wallStats();
-  const reducerState = reducer.reducerStats();
-  const workspaces = listWorkspaces();
-  const projects = wallState.projects.map((entry) => projectObservation({
-    project: wall.projectForRepo(entry.repoKey),
-    cards,
-    workspaces,
-    reducerRepos: reducerState.repos,
-  }));
-  const health = { healthy: 0, missing: 0, broken: 0, inaccessible: 0 };
-  for (const card of cards) health[card.health] = (health[card.health] || 0) + 1;
-  return {
-    machine: machineId(),
-    user: userId(),
-    runtimeVersion,
-    runtime: {
-      buildFingerprint: runtimeBuildFingerprint,
-      syncFingerprint: runtimeSyncFingerprint,
-      autoUpdateDisabled: autoUpdateDisabled(),
-    },
-    projects,
-    cards: { total: cards.length, ...health },
-    service: repoCardServiceStats(),
-    wall: wallState,
-    checkpoints: require('./checkpoint').checkpointStats(),
-    reducer: reducerState,
-  };
-}
-
-module.exports = {
-  _test: {
-    digest,
-    folderFor,
-    autoUpdateDisabled,
-    fileFingerprint,
-    syncFingerprintFiles: SYNC_FILES.map((file) => path.relative(RUNTIME_ROOT, file)),
-    pendingIntentFor,
-    pendingIntentValue,
-    verificationFor,
-  },
-  workspaceSyncStats,
-};

package/runtime/scripts/amalgm-mcp/workspace/tree/floor.js

@@ -1,100 +0,0 @@
-'use strict';
-
-/**
- * The official workspace-tree floor.
- *
- * `workspace_nodes` is the physical view (official floor plus durable local
- * overlay), so it cannot also answer what an incoming official operation is
- * allowed to reduce against. This table keeps that one separate fact.
- */
-
-const { openLocalDb } = require('../../state/db');
-const { normalizeTreeSnapshot } = require('./snapshot');
-
-function ensureSchema(database = openLocalDb()) {
-  database.exec(`
-    CREATE TABLE IF NOT EXISTS workspace_tree_floors (
-      resource_id TEXT PRIMARY KEY,
-      rail_version INTEGER NOT NULL CHECK (rail_version >= 0),
-      authority_epoch INTEGER NOT NULL CHECK (authority_epoch > 0),
-      snapshot_json TEXT NOT NULL,
-      updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-    );
-  `);
-}
-
-function snapshotRecord(snapshot) {
-  return {
-    schemaVersion: 1,
-    workspaceId: snapshot.workspaceId,
-    version: snapshot.version,
-    nodes: Array.from(snapshot.nodes.values()),
-  };
-}
-
-function normalize(row) {
-  if (!row) return null;
-  const snapshot = normalizeTreeSnapshot(JSON.parse(row.snapshot_json));
-  if (
-    snapshot.workspaceId !== row.resource_id
-    || snapshot.version !== Number(row.rail_version)
-  ) {
-    throw new Error(`workspace tree floor ${row.resource_id} is inconsistent`);
-  }
-  return {
-    resourceId: row.resource_id,
-    version: Number(row.rail_version),
-    authorityEpoch: Number(row.authority_epoch),
-    snapshot,
-    updatedAt: row.updated_at,
-  };
-}
-
-function read(resourceId, options = {}) {
-  const database = options.database || openLocalDb();
-  ensureSchema(database);
-  return normalize(database.prepare(`
-    SELECT * FROM workspace_tree_floors WHERE resource_id = ?
-  `).get(resourceId));
-}
-
-function write(snapshotInput, authorityEpochInput, options = {}) {
-  const database = options.database || openLocalDb();
-  ensureSchema(database);
-  const snapshot = normalizeTreeSnapshot(snapshotRecord(snapshotInput));
-  const authorityEpoch = Number(authorityEpochInput);
-  if (!Number.isSafeInteger(authorityEpoch) || authorityEpoch < 1) {
-    throw new Error('workspace tree floor authority epoch is invalid');
-  }
-  database.prepare(`
-    INSERT INTO workspace_tree_floors (
-      resource_id, rail_version, authority_epoch, snapshot_json, updated_at
-    ) VALUES (?, ?, ?, ?, ?)
-    ON CONFLICT(resource_id) DO UPDATE SET
-      rail_version = excluded.rail_version,
-      authority_epoch = excluded.authority_epoch,
-      snapshot_json = excluded.snapshot_json,
-      updated_at = excluded.updated_at
-  `).run(
-    snapshot.workspaceId,
-    snapshot.version,
-    authorityEpoch,
-    JSON.stringify(snapshotRecord(snapshot)),
-    new Date().toISOString(),
-  );
-  return read(snapshot.workspaceId, { database });
-}
-
-function ensure(snapshot, authorityEpoch, options = {}) {
-  const database = options.database || openLocalDb();
-  const existing = read(snapshot.workspaceId, { database });
-  if (existing) return existing;
-  return write(snapshot, authorityEpoch, { database });
-}
-
-module.exports = {
-  ensure,
-  read,
-  snapshotRecord,
-  write,
-};

package/runtime/scripts/amalgm-mcp/workspace/tree/observation-holds.js

@@ -1,127 +0,0 @@
-'use strict';
-
-const crypto = require('crypto');
-
-function stableHold(input) {
-  const operation = input?.operation || null;
-  const operationKind = typeof operation?.kind === 'string' ? operation.kind : null;
-  const explicitNodeId = typeof input?.nodeId === 'string' ? input.nodeId : null;
-  const operationNodeId = (
-    operationKind !== 'tree.create'
-    && typeof operation?.nodeId === 'string'
-  ) ? operation.nodeId : null;
-  return {
-    reason: typeof input?.reason === 'string' && input.reason
-      ? input.reason
-      : 'observation-pending',
-    nodeId: explicitNodeId || operationNodeId,
-    operationKind,
-    paths: Array.from(new Set(
-      Array.isArray(input?.paths)
-        ? input.paths.filter((value) => typeof value === 'string' && value)
-        : [],
-    )).sort(),
-  };
-}
-
-function ownerScope(options = {}) {
-  return {
-    ownerKind: typeof options.ownerKind === 'string' && options.ownerKind
-      ? options.ownerKind
-      : 'observer',
-    ownerId: typeof options.ownerId === 'string' && options.ownerId
-      ? options.ownerId
-      : 'workspace-tree-observer',
-  };
-}
-
-function holdKey(owner, hold) {
-  return crypto.createHash('sha256')
-    .update(JSON.stringify({ ...owner, hold }))
-    .digest('hex');
-}
-
-function normalize(rows) {
-  return rows.map((row) => ({
-    id: row.hold_key,
-    ownerKind: row.owner_kind,
-    ownerId: row.owner_id,
-    reason: row.reason,
-    nodeId: row.node_id || null,
-    operationKind: row.operation_kind || null,
-    paths: JSON.parse(row.paths_json),
-    firstObservedAt: row.first_observed_at,
-  }));
-}
-
-function list(workspaceId, database) {
-  return normalize(database.prepare(`
-    SELECT *
-    FROM workspace_tree_observation_holds
-    WHERE workspace_id = ?
-    ORDER BY owner_kind, owner_id, reason, hold_key
-  `).all(workspaceId));
-}
-
-function replace(workspaceId, inputs, database, options = {}) {
-  const owner = ownerScope(options);
-  const next = (Array.isArray(inputs) ? inputs : [])
-    .map(stableHold)
-    .map((hold) => ({ ...hold, key: holdKey(owner, hold) }))
-    .sort((left, right) => left.key.localeCompare(right.key));
-  const current = database.prepare(`
-    SELECT *
-    FROM workspace_tree_observation_holds
-    WHERE workspace_id = ? AND owner_kind = ? AND owner_id = ?
-    ORDER BY hold_key
-  `).all(workspaceId, owner.ownerKind, owner.ownerId);
-  const currentShape = current.map((row) => ({
-    key: row.hold_key,
-    reason: row.reason,
-    nodeId: row.node_id || null,
-    operationKind: row.operation_kind || null,
-    paths: JSON.parse(row.paths_json),
-  }));
-  const nextShape = next.map((hold) => ({
-    key: hold.key,
-    reason: hold.reason,
-    nodeId: hold.nodeId,
-    operationKind: hold.operationKind,
-    paths: hold.paths,
-  }));
-  if (JSON.stringify(currentShape) === JSON.stringify(nextShape)) return false;
-
-  const firstObservedByKey = new Map(
-    current.map((row) => [row.hold_key, row.first_observed_at]),
-  );
-  const now = new Date().toISOString();
-  database.prepare(`
-    DELETE FROM workspace_tree_observation_holds
-    WHERE workspace_id = ? AND owner_kind = ? AND owner_id = ?
-  `).run(workspaceId, owner.ownerKind, owner.ownerId);
-  const insert = database.prepare(`
-    INSERT INTO workspace_tree_observation_holds (
-      workspace_id, hold_key, owner_kind, owner_id, reason, node_id,
-      operation_kind, paths_json, first_observed_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-  for (const hold of next) {
-    insert.run(
-      workspaceId,
-      hold.key,
-      owner.ownerKind,
-      owner.ownerId,
-      hold.reason,
-      hold.nodeId,
-      hold.operationKind,
-      JSON.stringify(hold.paths),
-      firstObservedByKey.get(hold.key) || now,
-    );
-  }
-  return true;
-}
-
-module.exports = {
-  list,
-  replace,
-};