@jungjaehoon/mama-core 2.4.0 → 4.0.0

package/dist/agent-graph/entity-resolve.js

@@ -1,271 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveEntity = resolveEntity;
-const ref_validation_js_1 = require("../edges/ref-validation.js");
-const normalization_js_1 = require("../entities/normalization.js");
-const store_js_1 = require("../entities/store.js");
-const types_js_1 = require("../edges/types.js");
-const errors_js_1 = require("./errors.js");
-const TWIN_REF_KIND_SET = new Set(types_js_1.TWIN_REF_KINDS);
-function hasScopes(scopes) {
-    return Array.isArray(scopes) && scopes.length > 0;
-}
-function normalizeLabel(value) {
-    try {
-        return (0, normalization_js_1.normalizeEntityLabel)(value).normalized;
-    }
-    catch (error) {
-        throw new errors_js_1.AgentGraphValidationError(error instanceof Error ? error.message : String(error));
-    }
-}
-function entityVisible(entity, scopes) {
-    if (!hasScopes(scopes)) {
-        return true;
-    }
-    return scopes.some((scope) => entity.scope_kind === scope.kind && entity.scope_id === scope.id);
-}
-function isAtOrBeforeAsOf(value, asOfMs) {
-    return typeof asOfMs !== 'number' || value <= asOfMs;
-}
-function scopeVisible(scopeKind, scopeId, scopes) {
-    if (!hasScopes(scopes)) {
-        return true;
-    }
-    return scopes.some((scope) => scope.kind === scopeKind && scope.id === scopeId);
-}
-function connectorVisible(connector, connectors) {
-    return !connectors || connectors.length === 0 || connectors.includes(connector);
-}
-function hasProjectOrTenantFilter(visibility) {
-    return ((Array.isArray(visibility.projectRefs) && visibility.projectRefs.length > 0) ||
-        (typeof visibility.tenantId === 'string' && visibility.tenantId.length > 0));
-}
-function refsVisible(adapter, refs, visibility) {
-    if (refs.length === 0) {
-        return true;
-    }
-    try {
-        (0, ref_validation_js_1.assertTwinRefsVisible)(adapter, refs, visibility);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function parseSourceRefs(value, context) {
-    if (value === undefined || value === null) {
-        return [];
-    }
-    if (!Array.isArray(value)) {
-        throw new Error(`${context}.source_refs must be an array.`);
-    }
-    const refs = [];
-    for (const item of value) {
-        if (item === null ||
-            typeof item !== 'object' ||
-            typeof item.kind !== 'string' ||
-            typeof item.id !== 'string') {
-            throw new Error(`${context}.source_refs entries must be TwinRef objects.`);
-        }
-        const kind = item.kind;
-        const id = item.id.trim();
-        if (!TWIN_REF_KIND_SET.has(kind) || id.length === 0) {
-            throw new Error(`${context}.source_refs contains an invalid TwinRef.`);
-        }
-        refs.push({ kind, id });
-    }
-    return refs;
-}
-function aliasSourceRefs(adapter, aliasId, entityId) {
-    const rows = adapter
-        .prepare(`
-        SELECT relation_attrs_json
-        FROM twin_edges
-        WHERE edge_type = 'alias_of'
-          AND subject_kind = 'entity'
-          AND subject_id = ?
-          AND object_kind = 'entity'
-          AND object_id = ?
-          AND relation_attrs_json IS NOT NULL
-        ORDER BY created_at DESC, edge_id ASC
-      `)
-        .all(entityId, entityId);
-    const refs = [];
-    const seen = new Set();
-    for (const row of rows) {
-        if (!row.relation_attrs_json) {
-            continue;
-        }
-        const parsed = JSON.parse(row.relation_attrs_json);
-        if (parsed === null ||
-            typeof parsed !== 'object' ||
-            parsed.alias_id !== aliasId) {
-            continue;
-        }
-        for (const ref of parseSourceRefs(parsed.source_refs, `alias ${aliasId}`)) {
-            const key = `${ref.kind}:${ref.id}`;
-            if (!seen.has(key)) {
-                seen.add(key);
-                refs.push(ref);
-            }
-        }
-    }
-    return refs;
-}
-function aliasVisible(adapter, row, visibility, asOfMs) {
-    if (!isAtOrBeforeAsOf(row.created_at, asOfMs)) {
-        return false;
-    }
-    const sourceRefs = aliasSourceRefs(adapter, row.id, row.entity_id);
-    if (row.source_type === 'agent' && sourceRefs.length === 0) {
-        return false;
-    }
-    return refsVisible(adapter, sourceRefs, visibility);
-}
-function rawRefForObservation(adapter, row) {
-    const raw = adapter
-        .prepare(`
-        SELECT event_index_id
-        FROM connector_event_index
-        WHERE event_index_id = ?
-           OR (source_connector = ? AND source_id = ?)
-        ORDER BY CASE WHEN event_index_id = ? THEN 0 ELSE 1 END
-        LIMIT 1
-      `)
-        .get(row.source_raw_record_id, row.source_connector, row.source_raw_record_id, row.source_raw_record_id);
-    return raw ? { kind: 'raw', id: raw.event_index_id } : null;
-}
-function observationVisible(adapter, row, visibility, asOfMs) {
-    if (!isAtOrBeforeAsOf(row.timestamp_observed ?? row.created_at, asOfMs)) {
-        return false;
-    }
-    if (!scopeVisible(row.scope_kind, row.scope_id, visibility.scopes)) {
-        return false;
-    }
-    if (!connectorVisible(row.source_connector, visibility.connectors)) {
-        return false;
-    }
-    const rawRef = rawRefForObservation(adapter, row);
-    if (!rawRef) {
-        return !hasProjectOrTenantFilter(visibility);
-    }
-    return refsVisible(adapter, [rawRef], visibility);
-}
-function canonicalEntity(adapter, entityId) {
-    try {
-        const canonicalId = (0, store_js_1.resolveCanonicalEntityId)(adapter, entityId);
-        const entity = (0, store_js_1.getEntityNode)(canonicalId, adapter);
-        return entity && entity.status === 'active' ? entity : null;
-    }
-    catch (error) {
-        if (error instanceof store_js_1.EntityMergeError) {
-            throw new errors_js_1.AgentGraphValidationError(`${error.code}: ${error.message}`);
-        }
-        throw error;
-    }
-}
-function contextBoost(adapter, entityId, contextRefs, visibility, asOfMs) {
-    if (!contextRefs || contextRefs.length === 0) {
-        return 0;
-    }
-    // Spread rather than re-list: see graph-query's listFilteredEdges.
-    const edges = (0, ref_validation_js_1.listVisibleTwinEdgesForRefs)(adapter, contextRefs, { ...visibility, asOfMs });
-    return edges.some((edge) => (edge.subject_ref.kind === 'entity' && edge.subject_ref.id === entityId) ||
-        (edge.object_ref.kind === 'entity' && edge.object_ref.id === entityId))
-        ? 0.2
-        : 0;
-}
-function resolveEntity(adapter, input) {
-    const normalized = normalizeLabel(input.label);
-    const limit = Math.max(1, Math.floor(input.limit ?? 5));
-    const visibility = {
-        scopes: input.scopes,
-        connectors: input.connectors,
-        projectRefs: input.project_refs,
-        tenantId: input.tenant_id,
-        asOfMs: input.as_of_ms,
-        ...(input.channels ? { channels: input.channels } : {}),
-    };
-    if (input.context_refs && input.context_refs.length > 0) {
-        try {
-            (0, ref_validation_js_1.assertTwinRefsVisible)(adapter, input.context_refs, visibility);
-        }
-        catch (error) {
-            throw new errors_js_1.AgentGraphValidationError(error instanceof Error ? error.message : String(error));
-        }
-    }
-    const candidates = new Map();
-    const recordCandidate = (entityId, matchedLabel, matchSource, baseScore) => {
-        const entity = canonicalEntity(adapter, entityId);
-        if (!entity ||
-            !entityVisible(entity, input.scopes) ||
-            !isAtOrBeforeAsOf(entity.created_at, input.as_of_ms)) {
-            return;
-        }
-        const score = baseScore + contextBoost(adapter, entity.id, input.context_refs, visibility, input.as_of_ms);
-        const existing = candidates.get(entity.id);
-        if (!existing || score > existing.score) {
-            candidates.set(entity.id, {
-                entity,
-                matched_label: matchedLabel,
-                match_source: matchSource,
-                score,
-            });
-        }
-    };
-    const nodeRows = adapter
-        .prepare(`
-        SELECT id, preferred_label
-        FROM entity_nodes
-        WHERE status = 'active'
-      `)
-        .all();
-    for (const row of nodeRows) {
-        if (normalizeLabel(row.preferred_label) === normalized) {
-            recordCandidate(row.id, row.preferred_label, 'preferred_label', 1);
-        }
-    }
-    const aliasRows = adapter
-        .prepare(`
-        SELECT id, entity_id, label, normalized_label, source_type, created_at
-        FROM entity_aliases
-        WHERE status = 'active'
-      `)
-        .all();
-    for (const row of aliasRows) {
-        if (aliasVisible(adapter, row, visibility, input.as_of_ms) &&
-            (row.normalized_label === normalized || normalizeLabel(row.label) === normalized)) {
-            recordCandidate(row.entity_id, row.label, 'alias', 0.95);
-        }
-    }
-    const observationRows = adapter
-        .prepare(`
-        SELECT
-          l.canonical_entity_id, o.surface_form, o.normalized_form,
-          o.scope_kind, o.scope_id, o.source_connector, o.source_raw_record_id,
-          o.timestamp_observed, o.created_at
-        FROM entity_lineage_links l
-        JOIN entity_observations o ON o.id = l.entity_observation_id
-        WHERE l.status = 'active'
-      `)
-        .all();
-    for (const row of observationRows) {
-        if (observationVisible(adapter, row, visibility, input.as_of_ms) &&
-            (row.normalized_form === normalized || normalizeLabel(row.surface_form) === normalized)) {
-            recordCandidate(row.canonical_entity_id, row.surface_form, 'observation', 0.85);
-        }
-    }
-    const sorted = Array.from(candidates.values())
-        .sort((left, right) => {
-        if (right.score !== left.score) {
-            return right.score - left.score;
-        }
-        return left.entity.id.localeCompare(right.entity.id);
-    })
-        .slice(0, limit);
-    return {
-        entity: sorted[0]?.entity ?? null,
-        candidates: sorted,
-    };
-}
-//# sourceMappingURL=entity-resolve.js.map

package/dist/agent-graph/errors.d.ts

@@ -1,4 +0,0 @@
-export declare class AgentGraphValidationError extends Error {
-    constructor(message: string);
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/agent-graph/errors.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentGraphValidationError = void 0;
-class AgentGraphValidationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'AgentGraphValidationError';
-    }
-}
-exports.AgentGraphValidationError = AgentGraphValidationError;
-//# sourceMappingURL=errors.js.map

package/dist/agent-graph/graph-query.d.ts

@@ -1,5 +0,0 @@
-import type { AgentGraphAdapter, AgentGraphResult, GraphNeighborhoodInput, GraphPathsInput, GraphPathsResult, GraphTimelineInput, GraphTimelineResult } from './types.js';
-export declare function getGraphNeighborhood(adapter: AgentGraphAdapter, input: GraphNeighborhoodInput): AgentGraphResult;
-export declare function getGraphPaths(adapter: AgentGraphAdapter, input: GraphPathsInput): GraphPathsResult;
-export declare function getGraphTimeline(adapter: AgentGraphAdapter, input: GraphTimelineInput): GraphTimelineResult;
-//# sourceMappingURL=graph-query.d.ts.map

package/dist/agent-graph/graph-query.js

@@ -1,360 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGraphNeighborhood = getGraphNeighborhood;
-exports.getGraphPaths = getGraphPaths;
-exports.getGraphTimeline = getGraphTimeline;
-const ref_validation_js_1 = require("../edges/ref-validation.js");
-const store_js_1 = require("../entities/store.js");
-const errors_js_1 = require("./errors.js");
-const DEFAULT_GRAPH_LIMIT = 100;
-const DEFAULT_PATH_LIMIT = 10;
-const MAX_DEPTH = 5;
-function refKey(ref) {
-    return `${ref.kind}:${ref.id}`;
-}
-function edgeKey(edge) {
-    return edge.edge_id;
-}
-function eventKey(event) {
-    if (event.kind === 'edge') {
-        return event.edge.edge_id;
-    }
-    return `${event.ref.kind}:${event.ref.id}`;
-}
-function eventKindRank(kind) {
-    if (kind === 'entity') {
-        return 0;
-    }
-    if (kind === 'memory') {
-        return 1;
-    }
-    if (kind === 'raw') {
-        return 2;
-    }
-    if (kind === 'case') {
-        return 3;
-    }
-    return 4;
-}
-function normalizeDepth(value, fallback) {
-    if (typeof value !== 'number' || !Number.isFinite(value)) {
-        return fallback;
-    }
-    return Math.max(0, Math.min(MAX_DEPTH, Math.floor(value)));
-}
-function normalizeLimit(value, fallback) {
-    if (typeof value !== 'number' || !Number.isFinite(value)) {
-        return fallback;
-    }
-    return Math.max(1, Math.floor(value));
-}
-function addNode(nodes, seen, ref) {
-    const key = refKey(ref);
-    if (!seen.has(key)) {
-        seen.add(key);
-        nodes.push(ref);
-    }
-}
-function addRef(refs, seen, ref) {
-    if (ref.kind === 'edge' || ref.kind === 'report') {
-        return;
-    }
-    const key = refKey(ref);
-    if (!seen.has(key)) {
-        seen.add(key);
-        refs.push(ref);
-    }
-}
-function oppositeRef(edge, current) {
-    const currentKey = refKey(current);
-    const refs = [];
-    if (refKey(edge.subject_ref) !== currentKey) {
-        refs.push(edge.subject_ref);
-    }
-    if (refKey(edge.object_ref) !== currentKey) {
-        refs.push(edge.object_ref);
-    }
-    if (refs.length === 0) {
-        refs.push(edge.object_ref);
-    }
-    return refs;
-}
-function listFilteredEdges(adapter, refs, input) {
-    // Spread, not a field-by-field re-listing. Re-listing is how the channel grant was
-    // silently dropped here while every other path enforced it: a new field on the
-    // visibility type simply never arrived, and nothing failed to say so.
-    return (0, ref_validation_js_1.listVisibleTwinEdgesForRefs)(adapter, refs, {
-        ...input.visibility,
-        edgeTypes: input.edge_filters?.edge_types,
-        asOfMs: input.as_of_ms,
-        limit: input.limit,
-    });
-}
-function assertRefsVisible(adapter, refs, visibility, asOfMs) {
-    try {
-        (0, ref_validation_js_1.assertTwinRefsVisible)(adapter, refs, { ...visibility, asOfMs });
-    }
-    catch (error) {
-        throw new errors_js_1.AgentGraphValidationError(error instanceof Error ? error.message : String(error));
-    }
-}
-function graphVisibility(input) {
-    return {
-        scopes: input.scopes,
-        connectors: input.connectors,
-        projectRefs: input.project_refs,
-        tenantId: input.tenant_id,
-        ...(input.channels ? { channels: input.channels } : {}),
-    };
-}
-function numberMs(value, field, refId) {
-    if (typeof value === 'number' && Number.isFinite(value)) {
-        return Math.floor(value);
-    }
-    throw new Error(`Invalid ${field} timestamp for graph timeline ref ${refId}.`);
-}
-function nullableNumberMs(value, field, refId) {
-    if (value === null || value === undefined) {
-        return null;
-    }
-    return numberMs(value, field, refId);
-}
-function parseTimestampMs(value, field, refId) {
-    if (typeof value === 'number' && Number.isFinite(value)) {
-        return Math.floor(value);
-    }
-    if (typeof value === 'string') {
-        const parsed = Date.parse(value);
-        if (Number.isFinite(parsed)) {
-            return parsed;
-        }
-    }
-    throw new Error(`Invalid ${field} timestamp for graph timeline ref ${refId}.`);
-}
-function timelineWindow(input) {
-    const upperBounds = [input.to_ms, input.as_of_ms].filter((value) => typeof value === 'number');
-    return {
-        fromMs: input.from_ms,
-        toMs: upperBounds.length > 0 ? Math.min(...upperBounds) : undefined,
-    };
-}
-function isInTimelineWindow(atMs, window) {
-    return ((window.fromMs === undefined || atMs >= window.fromMs) &&
-        (window.toMs === undefined || atMs <= window.toMs));
-}
-function loadTimelineRecordEvent(adapter, ref) {
-    if (ref.kind === 'entity') {
-        const entity = (0, store_js_1.getEntityNode)(ref.id, adapter);
-        if (!entity || entity.status !== 'active') {
-            return null;
-        }
-        return { kind: 'entity', at_ms: entity.created_at, ref, entity };
-    }
-    if (ref.kind === 'memory') {
-        const row = adapter
-            .prepare(`
-          SELECT id, topic, decision, created_at, event_datetime
-          FROM decisions
-          WHERE id = ?
-          LIMIT 1
-        `)
-            .get(ref.id);
-        if (!row) {
-            return null;
-        }
-        const eventDatetime = nullableNumberMs(row.event_datetime, 'decisions.event_datetime', ref.id);
-        const createdAt = numberMs(row.created_at, 'decisions.created_at', ref.id);
-        return {
-            kind: 'memory',
-            at_ms: eventDatetime ?? createdAt,
-            ref,
-            memory: {
-                id: row.id,
-                topic: row.topic,
-                decision: row.decision,
-                created_at: createdAt,
-                event_datetime: eventDatetime,
-            },
-        };
-    }
-    if (ref.kind === 'raw') {
-        const row = adapter
-            .prepare(`
-          SELECT
-            event_index_id, source_connector, source_type, source_id, source_locator,
-            title, event_datetime, source_timestamp_ms
-          FROM connector_event_index
-          WHERE event_index_id = ?
-          LIMIT 1
-        `)
-            .get(ref.id);
-        if (!row) {
-            return null;
-        }
-        const eventDatetime = nullableNumberMs(row.event_datetime, 'connector_event_index.event_datetime', ref.id);
-        const sourceTimestampMs = numberMs(row.source_timestamp_ms, 'connector_event_index.source_timestamp_ms', ref.id);
-        return {
-            kind: 'raw',
-            at_ms: eventDatetime ?? sourceTimestampMs,
-            ref,
-            raw: {
-                event_index_id: row.event_index_id,
-                source_connector: row.source_connector,
-                source_type: row.source_type,
-                source_id: row.source_id,
-                source_locator: row.source_locator,
-                title: row.title,
-                event_datetime: eventDatetime,
-                source_timestamp_ms: sourceTimestampMs,
-            },
-        };
-    }
-    if (ref.kind === 'case') {
-        const row = adapter
-            .prepare(`
-          SELECT case_id, title, status, last_activity_at, created_at, updated_at
-          FROM case_truth
-          WHERE case_id = ?
-          LIMIT 1
-        `)
-            .get(ref.id);
-        if (!row) {
-            return null;
-        }
-        return {
-            kind: 'case',
-            at_ms: parseTimestampMs(row.last_activity_at ?? row.updated_at, 'case_truth.updated_at', ref.id),
-            ref,
-            case: {
-                case_id: row.case_id,
-                title: row.title,
-                status: row.status,
-                created_at: row.created_at,
-                updated_at: row.updated_at,
-                last_activity_at: row.last_activity_at,
-            },
-        };
-    }
-    return null;
-}
-function getGraphNeighborhood(adapter, input) {
-    const depth = normalizeDepth(input.depth, 1);
-    const limit = normalizeLimit(input.limit, DEFAULT_GRAPH_LIMIT);
-    const visibility = graphVisibility(input);
-    assertRefsVisible(adapter, [input.ref], visibility, input.as_of_ms);
-    const nodes = [];
-    const edges = [];
-    const seenNodes = new Set();
-    const seenEdges = new Set();
-    addNode(nodes, seenNodes, input.ref);
-    let frontier = [input.ref];
-    for (let currentDepth = 0; currentDepth < depth && frontier.length > 0; currentDepth++) {
-        const found = listFilteredEdges(adapter, frontier, {
-            visibility,
-            edge_filters: input.edge_filters,
-            as_of_ms: input.as_of_ms,
-            limit,
-        });
-        const nextFrontier = [];
-        const nextKeys = new Set();
-        for (const edge of found) {
-            if (seenEdges.size >= limit) {
-                break;
-            }
-            if (!seenEdges.has(edgeKey(edge))) {
-                seenEdges.add(edgeKey(edge));
-                edges.push(edge);
-            }
-            for (const endpoint of [edge.subject_ref, edge.object_ref]) {
-                const before = seenNodes.size;
-                addNode(nodes, seenNodes, endpoint);
-                if (seenNodes.size > before && !nextKeys.has(refKey(endpoint))) {
-                    nextKeys.add(refKey(endpoint));
-                    nextFrontier.push(endpoint);
-                }
-            }
-        }
-        frontier = nextFrontier;
-    }
-    return { nodes, edges };
-}
-function getGraphPaths(adapter, input) {
-    const maxDepth = normalizeDepth(input.max_depth, 3);
-    const limit = normalizeLimit(input.limit, DEFAULT_PATH_LIMIT);
-    const visibility = graphVisibility(input);
-    assertRefsVisible(adapter, [input.from_ref, input.to_ref], visibility, input.as_of_ms);
-    const targetKey = refKey(input.to_ref);
-    const queue = [{ refs: [input.from_ref], edges: [] }];
-    const paths = [];
-    while (queue.length > 0 && paths.length < limit) {
-        const path = queue.shift();
-        if (!path) {
-            break;
-        }
-        const current = path.refs[path.refs.length - 1];
-        if (!current || path.edges.length >= maxDepth) {
-            continue;
-        }
-        const edges = listFilteredEdges(adapter, [current], {
-            visibility,
-            edge_filters: input.edge_filters,
-            as_of_ms: input.as_of_ms,
-        });
-        for (const edge of edges) {
-            for (const next of oppositeRef(edge, current)) {
-                if (path.refs.some((ref) => refKey(ref) === refKey(next))) {
-                    continue;
-                }
-                const nextPath = { refs: [...path.refs, next], edges: [...path.edges, edge] };
-                if (refKey(next) === targetKey) {
-                    paths.push(nextPath);
-                    if (paths.length >= limit) {
-                        break;
-                    }
-                }
-                else {
-                    queue.push(nextPath);
-                }
-            }
-            if (paths.length >= limit) {
-                break;
-            }
-        }
-    }
-    return { paths };
-}
-function getGraphTimeline(adapter, input) {
-    const visibility = graphVisibility(input);
-    assertRefsVisible(adapter, [input.ref], visibility, input.as_of_ms);
-    const limit = normalizeLimit(input.limit, DEFAULT_GRAPH_LIMIT);
-    const window = timelineWindow(input);
-    const edges = listFilteredEdges(adapter, [input.ref], {
-        visibility,
-        edge_filters: input.edge_filters,
-        as_of_ms: input.as_of_ms,
-    }).filter((edge) => isInTimelineWindow(edge.created_at, window));
-    const refs = [];
-    const seenRefs = new Set();
-    addRef(refs, seenRefs, input.ref);
-    for (const edge of edges) {
-        addRef(refs, seenRefs, edge.subject_ref);
-        addRef(refs, seenRefs, edge.object_ref);
-    }
-    const events = [];
-    for (const ref of refs) {
-        const event = loadTimelineRecordEvent(adapter, ref);
-        if (event && isInTimelineWindow(event.at_ms, window)) {
-            events.push(event);
-        }
-    }
-    events.push(...edges.map((edge) => ({ kind: 'edge', at_ms: edge.created_at, edge })));
-    return {
-        ref: input.ref,
-        events: events
-            .sort((left, right) => left.at_ms - right.at_ms ||
-            eventKindRank(left.kind) - eventKindRank(right.kind) ||
-            eventKey(left).localeCompare(eventKey(right)))
-            .slice(0, limit),
-    };
-}
-//# sourceMappingURL=graph-query.js.map

package/dist/agent-graph/index.d.ts

@@ -1,6 +0,0 @@
-export * from './types.js';
-export * from './errors.js';
-export * from './entity-resolve.js';
-export * from './graph-query.js';
-export * from './alias-write.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/agent-situation/builder.d.ts

@@ -1,8 +0,0 @@
-import type { DatabaseAdapter } from '../db-manager.js';
-import { type AgentSituationSourceReadInput, type VisibleAgentSituationSources } from './source-readers.js';
-import type { AgentSituationInput, AgentSituationPacketRecord } from './types.js';
-type SituationBuilderAdapter = Pick<DatabaseAdapter, 'prepare'>;
-export declare function listVisibleAgentSituationSources(adapter: SituationBuilderAdapter, input: AgentSituationSourceReadInput): VisibleAgentSituationSources;
-export declare function buildAgentSituationPacketRecord(adapter: SituationBuilderAdapter, input: AgentSituationInput): AgentSituationPacketRecord;
-export {};
-//# sourceMappingURL=builder.d.ts.map