@jungjaehoon/mama-core 2.4.1 → 4.1.0

package/dist/registry/corrections.js

@@ -0,0 +1,332 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendIdentityCorrection = appendIdentityCorrection;
+exports.readIdentityAssignments = readIdentityAssignments;
+exports.newCorrectionCommandId = newCorrectionCommandId;
+const node_crypto_1 = require("node:crypto");
+const observations_js_1 = require("../knowledge/observations.js");
+const access_js_1 = require("../knowledge/access.js");
+const store_js_1 = require("./store.js");
+function stable(value) {
+    if (Array.isArray(value)) {
+        return value.map(stable);
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+            .map(([key, item]) => [key, stable(item)]));
+    }
+    return value;
+}
+function canonicalJson(value) {
+    return JSON.stringify(stable(value));
+}
+function scopeKey(scope) {
+    return `${scope.kind}\0${scope.id}`;
+}
+function requireTrustedContext(trusted) {
+    if (!trusted.principalId.trim()) {
+        throw new store_js_1.RegistryError('invalid_principal', 'A trusted principal is required');
+    }
+    if (!trusted.agentId.trim()) {
+        throw new store_js_1.RegistryError('invalid_agent', 'A trusted agent is required');
+    }
+    if (trusted.scopes.length === 0) {
+        throw new store_js_1.RegistryError('invalid_scope', 'At least one signed scope is required');
+    }
+    for (const scope of trusted.scopes) {
+        if (!scope.id.trim()) {
+            throw new store_js_1.RegistryError('invalid_scope', 'Signed scope ids must be nonblank');
+        }
+    }
+}
+function effectiveScopes(correction, trusted) {
+    requireTrustedContext(trusted);
+    const requested = correction.scopes ?? trusted.scopes;
+    if (requested.length === 0) {
+        throw new store_js_1.RegistryError('invalid_scope', 'At least one effective scope is required');
+    }
+    const allowed = new Set(trusted.scopes.map(scopeKey));
+    for (const scope of requested) {
+        if (!scope.id.trim() || !allowed.has(scopeKey(scope))) {
+            throw new store_js_1.RegistryError('scope_denied', 'Requested registry scope is unavailable');
+        }
+    }
+    return [...new Map(requested.map((scope) => [scopeKey(scope), scope])).values()];
+}
+function genericTargetUnavailable() {
+    throw new store_js_1.RegistryError('registry_target_unavailable', 'Registry target is unavailable');
+}
+function nodeBindings(db, nodeId) {
+    return db
+        .prepare('SELECT scope_kind AS kind, scope_id AS id FROM registry_scope_bindings WHERE node_id = ?')
+        .all(nodeId);
+}
+function requireVisibleNode(db, nodeId, scopes) {
+    const node = (0, store_js_1.resolveNodeById)(db, nodeId);
+    if (!node) {
+        genericTargetUnavailable();
+    }
+    const allowed = new Set(scopes.map(scopeKey));
+    if (!nodeBindings(db, nodeId).some((scope) => allowed.has(scopeKey(scope)))) {
+        genericTargetUnavailable();
+    }
+}
+function requireFullNodeAuthority(db, nodeId, scopes) {
+    requireVisibleNode(db, nodeId, scopes);
+    const allowed = new Set(scopes.map(scopeKey));
+    const bindings = nodeBindings(db, nodeId);
+    if (bindings.length === 0 || bindings.some((scope) => !allowed.has(scopeKey(scope)))) {
+        genericTargetUnavailable();
+    }
+}
+function requireVisibleEdge(db, edgeId, trusted, scopes) {
+    try {
+        (0, access_js_1.assertTwinRefsVisible)(db, [{ kind: 'edge', id: edgeId }], {
+            scopes: [...scopes],
+            connectors: [...trusted.connectors],
+            principalId: trusted.principalId,
+            agentId: trusted.agentId,
+            ...(trusted.channels ? { channels: trusted.channels } : {}),
+        });
+    }
+    catch (error) {
+        if (error instanceof access_js_1.TwinRefNotVisibleError) {
+            genericTargetUnavailable();
+        }
+        throw error;
+    }
+}
+function edgeSlot(db, edgeId, endpoint) {
+    const row = db
+        .prepare('SELECT subject_kind, subject_id, object_kind, object_id FROM twin_edges WHERE edge_id = ?')
+        .get(edgeId);
+    if (!row) {
+        genericTargetUnavailable();
+    }
+    return endpoint === 'from'
+        ? { kind: row.subject_kind, id: row.subject_id }
+        : { kind: row.object_kind, id: row.object_id };
+}
+function validateEvidence(db, correction, scopes, trusted) {
+    if ((correction.evidence?.length ?? 0) > 0) {
+        const table = db
+            .prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'observation_versions'")
+            .get();
+        if (!table) {
+            throw new store_js_1.RegistryError('missing_observation_schema', 'observation_versions is required to validate supplied evidence');
+        }
+    }
+    for (const ref of correction.evidence ?? []) {
+        if (ref.kind !== 'observation' ||
+            !(0, observations_js_1.isObservationVersionVisible)(db, ref.id, {
+                principalId: trusted.principalId,
+                agentId: trusted.agentId,
+                scopes,
+                connectors: trusted.connectors,
+                channels: trusted.channels,
+            })) {
+            throw new store_js_1.RegistryError('correction_evidence_unavailable', 'Correction evidence is unavailable');
+        }
+    }
+}
+function validateAccess(db, correction, scopes, trusted) {
+    if (correction.operation === 'add_alias') {
+        requireVisibleNode(db, correction.nodeId, scopes);
+    }
+    if (correction.operation === 'merge') {
+        requireFullNodeAuthority(db, correction.survivorId, scopes);
+        for (const memberId of correction.memberIds) {
+            requireFullNodeAuthority(db, memberId, scopes);
+        }
+    }
+    if (correction.operation === 'split' || correction.operation === 'assign_refs') {
+        requireFullNodeAuthority(db, correction.parentId, scopes);
+        for (const assignment of correction.assignments) {
+            requireVisibleEdge(db, assignment.edgeId, trusted, scopes);
+            if (assignment.targetNodeId !== undefined && assignment.targetNodeId !== null) {
+                requireVisibleNode(db, assignment.targetNodeId, scopes);
+            }
+        }
+    }
+    validateEvidence(db, correction, scopes, trusted);
+}
+function parseScopes(value) {
+    if (typeof value !== 'string') {
+        throw new Error('registry_corrections.scope_json must be JSON text');
+    }
+    const parsed = JSON.parse(value);
+    if (!Array.isArray(parsed) ||
+        parsed.some((scope) => !scope ||
+            typeof scope !== 'object' ||
+            typeof scope.kind !== 'string' ||
+            typeof scope.id !== 'string')) {
+        throw new Error('registry_corrections.scope_json must contain scope references');
+    }
+    return parsed;
+}
+function validateCommon(correction) {
+    if (!correction.commandId.trim()) {
+        throw new store_js_1.RegistryError('invalid_command', 'Correction command id must be nonblank');
+    }
+    if (!Number.isSafeInteger(correction.expectedRevision) || correction.expectedRevision < 0) {
+        throw new store_js_1.RegistryError('invalid_revision', 'Correction revision must be a nonnegative integer');
+    }
+    if (!correction.reason.trim()) {
+        throw new store_js_1.RegistryError('missing_reason', 'A correction reason is required');
+    }
+    if (correction.operation === 'split' || correction.operation === 'assign_refs') {
+        const slots = correction.assignments.map((assignment) => `${assignment.edgeId}\0${assignment.endpoint}`);
+        if (new Set(slots).size !== slots.length) {
+            throw new store_js_1.RegistryError('invalid_assignment', 'A correction cannot assign the same edge endpoint more than once');
+        }
+    }
+    if (correction.operation === 'merge' && correction.memberIds.length === 0) {
+        throw new store_js_1.RegistryError('invalid_merge', 'A merge requires at least one member');
+    }
+    if (correction.operation === 'split') {
+        if (correction.children.length < 2) {
+            throw new store_js_1.RegistryError('split_too_small', 'A split requires at least two children');
+        }
+        const keys = correction.children.map((child, index) => child.clientKey ?? String(index));
+        if (keys.some((key) => !key.trim()) || new Set(keys).size !== keys.length) {
+            throw new store_js_1.RegistryError('invalid_client_key', 'Split child client keys must be unique');
+        }
+        const knownKeys = new Set(keys);
+        for (const assignment of correction.assignments) {
+            if (assignment.targetClientKey !== undefined && !knownKeys.has(assignment.targetClientKey)) {
+                throw new store_js_1.RegistryError('invalid_client_key', 'Split assignment client key is unknown');
+            }
+        }
+    }
+    if (correction.operation === 'assign_refs' &&
+        correction.assignments.some((assignment) => assignment.targetClientKey !== undefined)) {
+        throw new store_js_1.RegistryError('invalid_client_key', 'Client keys are valid only during split');
+    }
+}
+function appendIdentityCorrection(adapter, correction, trusted) {
+    validateCommon(correction);
+    const db = adapter;
+    const requestedScopes = effectiveScopes(correction, trusted);
+    const payloadJson = canonicalJson(correction);
+    return db.transaction(() => {
+        const replay = db
+            .prepare(`SELECT principal_id, agent_id, payload_json, scope_json, receipt_json
+           FROM registry_corrections WHERE command_id = ?`)
+            .get(correction.commandId);
+        if (replay) {
+            if (replay.principal_id !== trusted.principalId ||
+                replay.agent_id !== trusted.agentId ||
+                replay.payload_json !== payloadJson ||
+                replay.scope_json !== canonicalJson(requestedScopes)) {
+                throw new store_js_1.RegistryError('COMMAND_CONFLICT', 'Correction command has different authority or payload');
+            }
+            const persistedScopes = parseScopes(replay.scope_json);
+            validateAccess(db, correction, persistedScopes, trusted);
+            return JSON.parse(replay.receipt_json);
+        }
+        const current = (0, store_js_1.currentIdentityRevision)(db);
+        if (current !== correction.expectedRevision) {
+            throw new store_js_1.RegistryError('REVISION_CONFLICT', `Expected identity revision ${correction.expectedRevision}, current revision is ${current}`);
+        }
+        validateAccess(db, correction, requestedScopes, trusted);
+        const committedRevision = current + 1;
+        const now = Date.now();
+        const children = [];
+        if (correction.operation === 'add_alias') {
+            (0, store_js_1.addAliases)(db, correction.nodeId, [correction.alias], requestedScopes);
+        }
+        else if (correction.operation === 'merge') {
+            for (const memberId of correction.memberIds) {
+                (0, store_js_1.mergeNodes)(db, {
+                    loser: memberId,
+                    survivor: correction.survivorId,
+                    reason: correction.reason,
+                });
+            }
+        }
+        else if (correction.operation === 'split') {
+            for (const [index, child] of correction.children.entries()) {
+                const childId = (0, store_js_1.createNode)(db, {
+                    kind: (0, store_js_1.resolveNodeById)(db, correction.parentId)?.kind ?? '',
+                    name: child.name,
+                    aliases: child.aliases,
+                    parentId: correction.parentId,
+                    note: correction.reason,
+                    scopes: requestedScopes,
+                });
+                children.push({
+                    clientKey: child.clientKey ?? String(index),
+                    ref: { kind: 'registry', id: childId },
+                });
+            }
+        }
+        const childIds = new Map(children.map((child) => [child.clientKey, child.ref.id]));
+        const resolvedAssignments = correction.operation === 'split' || correction.operation === 'assign_refs'
+            ? correction.assignments.map((assignment) => ({
+                edgeId: assignment.edgeId,
+                endpoint: assignment.endpoint,
+                targetNodeId: assignment.targetClientKey !== undefined
+                    ? (childIds.get(assignment.targetClientKey) ?? genericTargetUnavailable())
+                    : assignment.targetNodeId === undefined
+                        ? genericTargetUnavailable()
+                        : assignment.targetNodeId,
+            }))
+            : [];
+        const receipt = {
+            commandId: correction.commandId,
+            identityRevision: committedRevision,
+            children,
+            changedSlots: correction.operation === 'split' || correction.operation === 'assign_refs'
+                ? resolvedAssignments.map(({ edgeId, endpoint }) => ({ edgeId, endpoint }))
+                : [],
+            unresolved: correction.operation === 'split' || correction.operation === 'assign_refs'
+                ? resolvedAssignments
+                    .filter((assignment) => assignment.targetNodeId === null)
+                    .map(({ edgeId, endpoint }) => ({ edgeId, endpoint }))
+                : [],
+        };
+        db.prepare(`INSERT INTO registry_corrections
+       (command_id, operation, expected_revision, committed_revision, principal_id, agent_id,
+        origin, payload_json, reason, evidence_json, scope_json, receipt_json, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, 'trusted', ?, ?, ?, ?, ?, ?)`).run(correction.commandId, correction.operation, correction.expectedRevision, committedRevision, trusted.principalId, trusted.agentId, payloadJson, correction.reason.trim(), canonicalJson(correction.evidence ?? []), canonicalJson(requestedScopes), canonicalJson(receipt), now);
+        if (correction.operation === 'split' || correction.operation === 'assign_refs') {
+            for (const assignment of resolvedAssignments) {
+                const original = edgeSlot(db, assignment.edgeId, assignment.endpoint);
+                db.prepare(`INSERT INTO registry_ref_assignments
+           (command_id, edge_id, endpoint, original_kind, original_id, resolved_node_id,
+            committed_revision, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(correction.commandId, assignment.edgeId, assignment.endpoint, original.kind, original.id, assignment.targetNodeId, committedRevision, now);
+            }
+        }
+        db.prepare('UPDATE registry_identity_state SET revision = ? WHERE singleton = 1').run(committedRevision);
+        return receipt;
+    });
+}
+function readIdentityAssignments(adapter, edgeId) {
+    const rows = adapter
+        .prepare(`SELECT command_id, edge_id, endpoint, original_kind, original_id, resolved_node_id,
+              committed_revision
+         FROM registry_ref_assignments
+        WHERE edge_id = ?
+          AND committed_revision = (
+            SELECT MAX(current_assignment.committed_revision)
+              FROM registry_ref_assignments current_assignment
+             WHERE current_assignment.edge_id = registry_ref_assignments.edge_id
+               AND current_assignment.endpoint = registry_ref_assignments.endpoint
+          )
+        ORDER BY endpoint`)
+        .all(edgeId);
+    return rows.map((row) => ({
+        edgeId: row.edge_id,
+        endpoint: row.endpoint,
+        originalRef: { kind: row.original_kind, id: row.original_id },
+        resolvedRef: row.resolved_node_id === null ? null : { kind: 'registry', id: row.resolved_node_id },
+        identityRevision: row.committed_revision,
+        commandId: row.command_id,
+    }));
+}
+function newCorrectionCommandId() {
+    return `correction_${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}`;
+}
+//# sourceMappingURL=corrections.js.map

package/dist/registry/record-identity.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Binding a record to what it is about and who was involved.
+ *
+ * The subject of a record used to be the text in `topic`, leaving alternate spellings
+ * unjoinable. Here the subject is a
+ * registry node id, and the people are rows with their roles.
+ *
+ * Everything this module refuses, it refuses loudly. An unknown node, a person id in the item
+ * slot, an empty role: all raise. A dangling reference stored quietly would surface later as a
+ * timeline that is missing history, which is the failure mode this whole design exists to remove.
+ *
+ * The binding is written only inside the transaction that appends the record it belongs to, so
+ * this module offers no separate entry point that rewrites the identity of a record already
+ * stored. Changing what a stored record is about is a correction, not an overwrite.
+ */
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { RecordActor, RecordIdentity, RegistryScopeRef } from './types.js';
+export type { RecordActor, RecordIdentity };
+export declare class RecordIdentityError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+type RecordIdentityAdapter = Pick<DatabaseAdapter, 'prepare'>;
+/** Resolve every supplied identity reference before a record write begins. */
+export declare function validateRecordIdentityReferences(adapter: RecordIdentityAdapter, input: {
+    itemId?: string | null;
+    actors?: readonly RecordActor[];
+    scopes?: readonly RegistryScopeRef[];
+}): void;
+export declare function writeRecordIdentity(db: RecordIdentityAdapter, input: {
+    recordId: string;
+    itemId?: string | null;
+    actors?: readonly RecordActor[];
+    scopes?: readonly RegistryScopeRef[];
+}): void;
+export declare function readRecordIdentity(adapter: RecordIdentityAdapter, recordId: string): RecordIdentity | null;
+export declare function listActors(adapter: RecordIdentityAdapter, recordId: string): RecordActor[];
+/** Records bound to one item, newest first. The read `item_timeline` is built on. */
+export declare function listRecordIdsForItem(adapter: RecordIdentityAdapter, itemId: string, options?: {
+    limit?: number;
+    before?: {
+        timestamp: number;
+        id: string;
+    };
+}): Array<{
+    id: string;
+    timestamp: number;
+}>;
+//# sourceMappingURL=record-identity.d.ts.map

package/dist/registry/record-identity.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * Binding a record to what it is about and who was involved.
+ *
+ * The subject of a record used to be the text in `topic`, leaving alternate spellings
+ * unjoinable. Here the subject is a
+ * registry node id, and the people are rows with their roles.
+ *
+ * Everything this module refuses, it refuses loudly. An unknown node, a person id in the item
+ * slot, an empty role: all raise. A dangling reference stored quietly would surface later as a
+ * timeline that is missing history, which is the failure mode this whole design exists to remove.
+ *
+ * The binding is written only inside the transaction that appends the record it belongs to, so
+ * this module offers no separate entry point that rewrites the identity of a record already
+ * stored. Changing what a stored record is about is a correction, not an overwrite.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordIdentityError = void 0;
+exports.validateRecordIdentityReferences = validateRecordIdentityReferences;
+exports.writeRecordIdentity = writeRecordIdentity;
+exports.readRecordIdentity = readRecordIdentity;
+exports.listActors = listActors;
+exports.listRecordIdsForItem = listRecordIdsForItem;
+const store_js_1 = require("./store.js");
+class RecordIdentityError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'RecordIdentityError';
+    }
+}
+exports.RecordIdentityError = RecordIdentityError;
+/** The live node for an id, following merges. Raises when it is absent or the wrong kind. */
+function requireNode(adapter, id, kind, slot, scopes) {
+    const node = (0, store_js_1.resolveNodeById)(adapter, id);
+    if (!node) {
+        throw new RecordIdentityError('unknown_node', `${slot} references ${id}, which is not a registry node. Register it before binding.`);
+    }
+    if (node.kind !== kind) {
+        throw new RecordIdentityError('wrong_kind', `${slot} expects a ${kind} node; ${id} is a ${node.kind}.`);
+    }
+    const bindings = adapter
+        .prepare('SELECT scope_kind, scope_id FROM registry_scope_bindings WHERE node_id = ?')
+        .all(node.id);
+    const visible = bindings.length === 0
+        ? true
+        : scopes !== undefined &&
+            scopes.some((scope) => bindings.some((binding) => binding.scope_kind === scope.kind && binding.scope_id === scope.id));
+    if (!visible) {
+        throw new RecordIdentityError('hidden_node', `${slot} references a node outside save scope`);
+    }
+    return node.id;
+}
+/** Resolve every supplied identity reference before a record write begins. */
+function validateRecordIdentityReferences(adapter, input) {
+    if (input.itemId !== undefined && input.itemId !== null) {
+        requireNode(adapter, input.itemId, 'item', 'item_id', input.scopes);
+    }
+    for (const actor of input.actors ?? []) {
+        if (!actor.role.trim()) {
+            throw new RecordIdentityError('empty_role', 'An actor needs a role.');
+        }
+        requireNode(adapter, actor.personId, 'person', 'actor', input.scopes);
+    }
+}
+function writeRecordIdentity(db, input) {
+    const itemId = input.itemId === undefined || input.itemId === null
+        ? null
+        : requireNode(db, input.itemId, 'item', 'item_id', input.scopes);
+    const actors = (input.actors ?? []).map((actor, position) => ({
+        personId: requireNode(db, actor.personId, 'person', 'actor', input.scopes),
+        role: actor.role.trim(),
+        position,
+    }));
+    for (const actor of actors) {
+        if (!actor.role) {
+            throw new RecordIdentityError('empty_role', 'An actor needs a role.');
+        }
+    }
+    db.prepare('UPDATE decisions SET item_id = ? WHERE id = ?').run(itemId, input.recordId);
+    db.prepare('DELETE FROM record_actors WHERE record_id = ?').run(input.recordId);
+    const now = Date.now();
+    for (const actor of actors) {
+        db.prepare(`INSERT INTO record_actors (record_id, person_id, role, position, created_at)
+       VALUES (?, ?, ?, ?, ?)`).run(input.recordId, actor.personId, actor.role, actor.position, now);
+    }
+}
+function readRecordIdentity(adapter, recordId) {
+    const row = adapter.prepare('SELECT item_id FROM decisions WHERE id = ?').get(recordId);
+    if (!row) {
+        return null;
+    }
+    // Canonicalise on read: a merge moves aliases but rewrites no consumer, so an id stored
+    // before the merge still has to answer with the surviving node.
+    const itemId = row.item_id ? ((0, store_js_1.resolveNodeById)(adapter, row.item_id)?.id ?? null) : null;
+    return { itemId };
+}
+function listActors(adapter, recordId) {
+    const rows = adapter
+        .prepare('SELECT person_id, role FROM record_actors WHERE record_id = ? ORDER BY position, rowid')
+        .all(recordId);
+    return rows.map((row) => ({
+        personId: (0, store_js_1.resolveNodeById)(adapter, row.person_id)?.id ?? row.person_id,
+        role: row.role,
+    }));
+}
+/** Records bound to one item, newest first. The read `item_timeline` is built on. */
+function listRecordIdsForItem(adapter, itemId, options) {
+    const node = (0, store_js_1.resolveNodeById)(adapter, itemId);
+    if (!node) {
+        throw new RecordIdentityError('unknown_node', `No registry node ${itemId}.`);
+    }
+    const limit = Math.min(Math.max(options?.limit ?? 20, 1), 100);
+    const before = options?.before;
+    const rows = adapter
+        .prepare(`WITH RECURSIVE item_ids(id) AS (
+         SELECT ?
+         UNION
+         SELECT registry_nodes.id FROM registry_nodes
+         JOIN item_ids ON registry_nodes.merged_into = item_ids.id
+       )
+       SELECT id, COALESCE(event_datetime, created_at) AS ts FROM decisions
+        WHERE item_id IN (SELECT id FROM item_ids)
+          ${before ? 'AND (COALESCE(event_datetime, created_at) < ? OR (COALESCE(event_datetime, created_at) = ? AND id < ?))' : ''}
+        ORDER BY ts DESC, id DESC
+        LIMIT ?`)
+        .all(...(before
+        ? [node.id, before.timestamp, before.timestamp, before.id, limit]
+        : [node.id, limit]));
+    return rows.map((row) => ({ id: row.id, timestamp: row.ts }));
+}
+//# sourceMappingURL=record-identity.js.map

package/dist/registry/store.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Registry store: work items, people and clients as nodes with the names they go by.
+ *
+ * Identity used to live in strings such as task titles and decision topics, so alternate
+ * spellings could not join without an explicit durable identity.
+ *
+ * A node here is cheap: an id, a kind, a display name, and the aliases it answers to.
+ * What it buys is that a record can point at identity instead of spelling it.
+ *
+ * Two decisions this module refuses to make on its own:
+ * - It never merges by similarity. `mergeNodes` happens because a caller decided, and the
+ *   reason is stored with it.
+ * - It never reassigns a contested alias. Claiming an alias another node holds raises, so
+ *   the caller resolves it (merge, or pick a different alias) rather than the store
+ *   silently moving identity from under existing records.
+ */
+import type { DatabaseAdapter } from '../db-manager.js';
+import { REGISTRY_KINDS, type RegistryKind, type RegistryNode, type RegistryScopeRef } from './types.js';
+export { REGISTRY_KINDS };
+export type { RegistryKind, RegistryNode };
+export type { RegistryScopeRef };
+export declare class RegistryError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+type RegistryReadAdapter = Pick<DatabaseAdapter, 'prepare'>;
+type RegistryStoreAdapter = Pick<DatabaseAdapter, 'prepare' | 'transaction'>;
+export declare function currentIdentityRevision(adapter: RegistryReadAdapter): number;
+export declare function rebuildRegistryProjections(adapter: RegistryReadAdapter): void;
+/**
+ * The lookup key for an alias: case-folded, inner runs of whitespace collapsed, trimmed.
+ *
+ * Deliberately conservative - it folds the differences that are the same string typed
+ * twice, and nothing else. Hyphens, underscores and script differences stay significant,
+ * because "a-0001" and "a_0001" being the same thing is a judgement about the work, not
+ * about text, and belongs in an alias row someone added.
+ */
+export declare function normalizeAlias(value: string): string;
+export declare function createNode(adapter: RegistryStoreAdapter, input: {
+    kind: RegistryKind | string;
+    name: string;
+    aliases?: readonly string[];
+    parentId?: string | null;
+    note?: string | null;
+    scopes?: readonly RegistryScopeRef[];
+}): string;
+export declare function addAliases(adapter: RegistryStoreAdapter, nodeId: string, aliases: readonly string[], scopes?: readonly RegistryScopeRef[]): void;
+export declare function upsertNode(adapter: RegistryStoreAdapter, input: {
+    kind: RegistryKind | string;
+    name: string;
+    aliases?: readonly string[];
+    note?: string | null;
+    scopes?: readonly RegistryScopeRef[];
+    children?: ReadonlyArray<{
+        name: string;
+        aliases?: readonly string[];
+    }>;
+}): {
+    id: string;
+    created: boolean;
+    children: string[];
+};
+export declare function addAlias(adapter: RegistryReadAdapter, nodeId: string, alias: string): void;
+/** The live node behind an id, following merges. Null when the id is unknown. */
+export declare function resolveNodeById(adapter: RegistryReadAdapter, id: string): RegistryNode | null;
+/** The node an alias names, following merges. `kind` narrows when the same word is both. */
+export declare function resolveAlias(adapter: RegistryReadAdapter, alias: string, kind?: RegistryKind | string, scopes?: readonly RegistryScopeRef[]): RegistryNode | null;
+export declare function resolveAliasCandidates(adapter: RegistryReadAdapter, alias: string, options?: {
+    kind?: RegistryKind | string;
+    scopes?: readonly RegistryScopeRef[];
+}): RegistryNode[];
+export declare function listNodes(adapter: RegistryReadAdapter, filter?: {
+    kind?: RegistryKind | string;
+    parentId?: string | null;
+    includeMerged?: boolean;
+    scopes?: readonly RegistryScopeRef[];
+}): RegistryNode[];
+/**
+ * Point one node's identity at another. The loser keeps its row as a tombstone so records
+ * that still reference it resolve forward instead of dangling.
+ */
+export declare function mergeNodes(adapter: RegistryStoreAdapter, input: {
+    loser: string;
+    survivor: string;
+    reason: string;
+}): void;
+/**
+ * Split one item into the children it really covers, keeping the parent as the umbrella.
+ *
+ * Nothing is deleted: the parent stays resolvable by its own aliases, and existing records
+ * keep pointing at it until someone decides which child they belong to.
+ */
+export declare function splitNode(adapter: RegistryStoreAdapter, input: {
+    parent: string;
+    children: ReadonlyArray<{
+        name: string;
+        aliases?: readonly string[];
+    }>;
+    reason: string;
+}): string[];
+//# sourceMappingURL=store.d.ts.map