@jungjaehoon/mama-core 1.4.2 → 1.6.0

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

@@ -0,0 +1,275 @@
+"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;
+    }
+    const edges = (0, ref_validation_js_1.listVisibleTwinEdgesForRefs)(adapter, contextRefs, {
+        scopes: visibility.scopes,
+        connectors: visibility.connectors,
+        projectRefs: visibility.projectRefs,
+        tenantId: visibility.tenantId,
+        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,
+    };
+    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

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

package/dist/agent-graph/errors.js

@@ -0,0 +1,11 @@
+"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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,359 @@
+"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) {
+    return (0, ref_validation_js_1.listVisibleTwinEdgesForRefs)(adapter, refs, {
+        scopes: input.visibility.scopes,
+        connectors: input.visibility.connectors,
+        projectRefs: input.visibility.projectRefs,
+        tenantId: input.visibility.tenantId,
+        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,
+    };
+}
+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

@@ -0,0 +1,6 @@
+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-graph/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./errors.js"), exports);
+__exportStar(require("./entity-resolve.js"), exports);
+__exportStar(require("./graph-query.js"), exports);
+__exportStar(require("./alias-write.js"), exports);
+//# sourceMappingURL=index.js.map