@omiron33/omi-neuron-web 0.1.0

package/dist/chunk-RTSFO7BW.cjs

@@ -0,0 +1,592 @@
+'use strict';
+
+var chunkCOO66N7H_cjs = require('./chunk-COO66N7H.cjs');
+var slugify = require('slugify');
+var zod = require('zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var slugify__default = /*#__PURE__*/_interopDefault(slugify);
+
+// src/core/types/settings.ts
+var DEFAULT_VISUALIZATION_SETTINGS = {
+  domainColors: {},
+  defaultDomainColor: "#c0c5ff",
+  edgeColor: "#4d4d55",
+  edgeActiveColor: "#c6d4ff",
+  backgroundColor: "#020314",
+  defaultCameraPosition: [4, 8, 20],
+  defaultCameraTarget: [0, 0, 0],
+  minZoomDistance: 4,
+  maxZoomDistance: 42,
+  enableStarfield: true,
+  starfieldCount: 1200,
+  labelDistance: 26,
+  maxVisibleLabels: 50,
+  performanceMode: "auto",
+  nodeCountThreshold: 120,
+  pixelRatioCap: 2,
+  enableAnimations: true,
+  focusTweenDuration: 800,
+  filterTransitionDuration: 650,
+  enableHover: true,
+  enableClick: true,
+  enableDoubleClick: true,
+  enablePan: true,
+  enableZoom: true,
+  enableRotate: true
+};
+var DEFAULT_ANALYSIS_SETTINGS = {
+  embeddingModel: "text-embedding-3-small",
+  embeddingDimensions: 1536,
+  embeddingBatchSize: 20,
+  embeddingCacheTTL: 86400,
+  clusteringAlgorithm: "kmeans",
+  defaultClusterCount: 8,
+  minClusterSize: 3,
+  clusterSimilarityThreshold: 0.75,
+  relationshipInferenceModel: "gpt-4o-mini",
+  relationshipMinConfidence: 0.7,
+  relationshipMaxPerNode: 10,
+  openaiRateLimit: 60,
+  maxConcurrentAnalysis: 5
+};
+var slugTransform = (label) => slugify__default.default(label, { lower: true, strict: true, trim: true }).slice(0, 255);
+var nodeTierSchema = zod.z.enum(["primary", "secondary", "tertiary", "insight"]);
+var nodeCreateSchema = zod.z.object({
+  slug: zod.z.string().min(1).max(255).optional(),
+  label: zod.z.string().min(1).max(500),
+  nodeType: zod.z.string().min(1).max(100).optional(),
+  domain: zod.z.string().min(1).max(100).optional(),
+  summary: zod.z.string().max(1e3).optional(),
+  description: zod.z.string().optional(),
+  content: zod.z.string().optional(),
+  metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  tier: nodeTierSchema.optional()
+}).transform((data) => ({
+  ...data,
+  slug: data.slug ?? slugTransform(data.label)
+}));
+var nodeUpdateSchema = zod.z.object({
+  label: zod.z.string().min(1).max(500).optional(),
+  summary: zod.z.string().max(1e3).optional(),
+  description: zod.z.string().optional(),
+  content: zod.z.string().optional(),
+  metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  domain: zod.z.string().min(1).max(100).optional(),
+  tier: nodeTierSchema.optional(),
+  positionOverride: zod.z.tuple([zod.z.number(), zod.z.number(), zod.z.number()]).nullable().optional()
+});
+var nodeBatchCreateSchema = zod.z.object({
+  nodes: zod.z.array(nodeCreateSchema),
+  options: zod.z.object({
+    skipDuplicates: zod.z.boolean().optional(),
+    updateOnConflict: zod.z.boolean().optional(),
+    autoAnalyze: zod.z.boolean().optional(),
+    analysisDepth: zod.z.enum(["embeddings", "cluster", "full"]).optional()
+  }).optional()
+});
+var nodeFilterSchema = zod.z.object({
+  page: zod.z.coerce.number().int().min(1).optional(),
+  limit: zod.z.coerce.number().int().min(1).max(1e3).optional(),
+  nodeType: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
+  domain: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
+  clusterId: zod.z.string().uuid().optional(),
+  analysisStatus: zod.z.string().optional(),
+  search: zod.z.string().optional(),
+  sortBy: zod.z.enum(["createdAt", "updatedAt", "label", "connectionCount"]).optional(),
+  sortOrder: zod.z.enum(["asc", "desc"]).optional(),
+  includeEmbeddings: zod.z.coerce.boolean().optional(),
+  includeStats: zod.z.coerce.boolean().optional()
+});
+var edgeEvidenceSchema = zod.z.object({
+  type: zod.z.enum(["text", "url", "citation", "ai_inference"]),
+  content: zod.z.string().min(1),
+  confidence: zod.z.number().min(0).max(1).optional(),
+  sourceId: zod.z.string().optional(),
+  metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var edgeCreateSchema = zod.z.object({
+  fromNodeId: zod.z.string().uuid(),
+  toNodeId: zod.z.string().uuid(),
+  relationshipType: zod.z.string().optional(),
+  strength: zod.z.number().min(0).max(1).optional(),
+  confidence: zod.z.number().min(0).max(1).optional(),
+  evidence: zod.z.array(edgeEvidenceSchema).optional(),
+  label: zod.z.string().max(255).optional(),
+  description: zod.z.string().optional(),
+  metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  bidirectional: zod.z.boolean().optional()
+});
+var edgeUpdateSchema = zod.z.object({
+  strength: zod.z.number().min(0).max(1).optional(),
+  confidence: zod.z.number().min(0).max(1).optional(),
+  relationshipType: zod.z.string().optional(),
+  label: zod.z.string().max(255).optional(),
+  description: zod.z.string().optional(),
+  evidence: zod.z.array(edgeEvidenceSchema).optional(),
+  metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var edgeFilterSchema = zod.z.object({
+  page: zod.z.coerce.number().int().min(1).optional(),
+  limit: zod.z.coerce.number().int().min(1).max(1e3).optional(),
+  fromNodeId: zod.z.string().uuid().optional(),
+  toNodeId: zod.z.string().uuid().optional(),
+  nodeId: zod.z.string().uuid().optional(),
+  relationshipType: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
+  source: zod.z.enum(["manual", "ai_inferred", "imported"]).optional(),
+  minStrength: zod.z.coerce.number().min(0).max(1).optional(),
+  minConfidence: zod.z.coerce.number().min(0).max(1).optional()
+});
+var analysisOptionsSchema = zod.z.object({
+  nodeIds: zod.z.array(zod.z.string().uuid()).optional(),
+  forceRecompute: zod.z.boolean().optional(),
+  skipEmbeddings: zod.z.boolean().optional(),
+  embeddingModel: zod.z.string().optional(),
+  skipClustering: zod.z.boolean().optional(),
+  clusterCount: zod.z.coerce.number().int().min(1).optional(),
+  clusteringAlgorithm: zod.z.enum(["kmeans", "dbscan", "hierarchical"]).optional(),
+  skipRelationships: zod.z.boolean().optional(),
+  relationshipThreshold: zod.z.coerce.number().min(0).max(1).optional(),
+  maxRelationshipsPerNode: zod.z.coerce.number().int().min(1).optional()
+});
+var analysisRequestSchema = zod.z.object({
+  action: zod.z.enum(["embeddings", "cluster", "infer_relationships", "full"]),
+  options: analysisOptionsSchema.optional()
+});
+var colorSchema = zod.z.string().min(1);
+var nodeTypeConfigSchema = zod.z.object({
+  type: zod.z.string().min(1),
+  label: zod.z.string().min(1),
+  description: zod.z.string().optional(),
+  defaultDomain: zod.z.string().min(1),
+  icon: zod.z.string().optional(),
+  color: colorSchema.optional(),
+  analysisPrompt: zod.z.string().optional()
+});
+var domainConfigSchema = zod.z.object({
+  key: zod.z.string().min(1),
+  label: zod.z.string().min(1),
+  color: colorSchema,
+  description: zod.z.string().optional()
+});
+var relationshipTypeConfigSchema = zod.z.object({
+  type: zod.z.string().min(1),
+  label: zod.z.string().min(1),
+  description: zod.z.string().optional(),
+  bidirectional: zod.z.boolean(),
+  color: colorSchema.optional()
+});
+var visualizationSettingsSchema = zod.z.object({
+  domainColors: zod.z.record(zod.z.string(), colorSchema),
+  defaultDomainColor: colorSchema,
+  edgeColor: colorSchema,
+  edgeActiveColor: colorSchema,
+  backgroundColor: colorSchema,
+  defaultCameraPosition: zod.z.tuple([zod.z.number(), zod.z.number(), zod.z.number()]),
+  defaultCameraTarget: zod.z.tuple([zod.z.number(), zod.z.number(), zod.z.number()]),
+  minZoomDistance: zod.z.number(),
+  maxZoomDistance: zod.z.number(),
+  enableStarfield: zod.z.boolean(),
+  starfieldCount: zod.z.number().int().min(0),
+  labelDistance: zod.z.number().min(0),
+  maxVisibleLabels: zod.z.number().int().min(0),
+  performanceMode: zod.z.enum(["auto", "normal", "degraded", "fallback"]),
+  nodeCountThreshold: zod.z.number().int().min(0),
+  pixelRatioCap: zod.z.number().min(0.5),
+  enableAnimations: zod.z.boolean(),
+  focusTweenDuration: zod.z.number().int().min(0),
+  filterTransitionDuration: zod.z.number().int().min(0),
+  enableHover: zod.z.boolean(),
+  enableClick: zod.z.boolean(),
+  enableDoubleClick: zod.z.boolean(),
+  enablePan: zod.z.boolean(),
+  enableZoom: zod.z.boolean(),
+  enableRotate: zod.z.boolean()
+});
+var analysisSettingsSchema = zod.z.object({
+  embeddingModel: zod.z.enum(["text-embedding-ada-002", "text-embedding-3-small", "text-embedding-3-large"]),
+  embeddingDimensions: zod.z.number().int().min(1),
+  embeddingBatchSize: zod.z.number().int().min(1),
+  embeddingCacheTTL: zod.z.number().int().min(0),
+  clusteringAlgorithm: zod.z.enum(["kmeans", "dbscan", "hierarchical"]),
+  defaultClusterCount: zod.z.number().int().min(1),
+  minClusterSize: zod.z.number().int().min(1),
+  clusterSimilarityThreshold: zod.z.number().min(0).max(1),
+  relationshipInferenceModel: zod.z.string().min(1),
+  relationshipMinConfidence: zod.z.number().min(0).max(1),
+  relationshipMaxPerNode: zod.z.number().int().min(1),
+  openaiRateLimit: zod.z.number().int().min(1),
+  maxConcurrentAnalysis: zod.z.number().int().min(1)
+});
+var instanceSettingsSchema = zod.z.object({
+  name: zod.z.string().min(1),
+  version: zod.z.string().min(1),
+  repoName: zod.z.string().min(1)
+});
+var databaseSettingsSchema = zod.z.object({
+  mode: zod.z.enum(["docker", "external"]),
+  port: zod.z.number().int().min(1).max(65535),
+  containerName: zod.z.string().optional(),
+  image: zod.z.string().optional(),
+  user: zod.z.string().optional(),
+  password: zod.z.string().optional(),
+  database: zod.z.string().optional(),
+  url: zod.z.string().optional(),
+  pool: zod.z.object({
+    min: zod.z.number().int().min(0),
+    max: zod.z.number().int().min(1),
+    idleTimeoutMs: zod.z.number().int().min(0),
+    connectionTimeoutMs: zod.z.number().int().min(0)
+  }).optional(),
+  resources: zod.z.object({
+    memoryLimit: zod.z.string().min(1),
+    cpuLimit: zod.z.string().optional()
+  }).optional()
+});
+var apiSettingsSchema = zod.z.object({
+  basePath: zod.z.string().min(1),
+  enableCors: zod.z.boolean(),
+  rateLimit: zod.z.object({
+    windowMs: zod.z.number().int().min(1),
+    max: zod.z.number().int().min(1)
+  }).optional()
+});
+var loggingSettingsSchema = zod.z.object({
+  level: zod.z.enum(["debug", "info", "warn", "error"]),
+  prettyPrint: zod.z.boolean()
+});
+var neuronSettingsSchema = zod.z.object({
+  instance: instanceSettingsSchema,
+  visualization: visualizationSettingsSchema,
+  analysis: analysisSettingsSchema,
+  nodeTypes: zod.z.array(nodeTypeConfigSchema),
+  domains: zod.z.array(domainConfigSchema),
+  relationshipTypes: zod.z.array(relationshipTypeConfigSchema)
+});
+var neuronSettingsUpdateSchema = zod.z.object({
+  visualization: visualizationSettingsSchema.partial().optional(),
+  analysis: analysisSettingsSchema.partial().optional(),
+  nodeTypes: zod.z.array(nodeTypeConfigSchema).optional(),
+  domains: zod.z.array(domainConfigSchema).optional(),
+  relationshipTypes: zod.z.array(relationshipTypeConfigSchema).optional()
+});
+var neuronConfigSchema = neuronSettingsSchema.extend({
+  openai: zod.z.object({
+    apiKey: zod.z.string().min(1),
+    organization: zod.z.string().optional(),
+    requestsPerMinute: zod.z.number().int().min(1).optional(),
+    maxRetries: zod.z.number().int().min(0).optional()
+  }),
+  database: databaseSettingsSchema,
+  api: apiSettingsSchema,
+  logging: loggingSettingsSchema
+});
+var paginationSchema = zod.z.object({
+  page: zod.z.coerce.number().int().min(1).optional(),
+  limit: zod.z.coerce.number().int().min(1).max(1e3).optional()
+});
+var listNodesParamsSchema = paginationSchema.extend({
+  nodeType: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
+  domain: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
+  clusterId: zod.z.string().uuid().optional(),
+  analysisStatus: zod.z.string().optional(),
+  search: zod.z.string().optional(),
+  sortBy: zod.z.enum(["createdAt", "updatedAt", "label", "connectionCount"]).optional(),
+  sortOrder: zod.z.enum(["asc", "desc"]).optional(),
+  includeEmbeddings: zod.z.coerce.boolean().optional(),
+  includeStats: zod.z.coerce.boolean().optional()
+});
+var listEdgesParamsSchema = paginationSchema.extend({
+  fromNodeId: zod.z.string().uuid().optional(),
+  toNodeId: zod.z.string().uuid().optional(),
+  nodeId: zod.z.string().uuid().optional(),
+  relationshipType: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
+  source: zod.z.enum(["manual", "ai_inferred", "imported"]).optional(),
+  minStrength: zod.z.coerce.number().min(0).max(1).optional(),
+  minConfidence: zod.z.coerce.number().min(0).max(1).optional()
+});
+var getGraphParamsSchema = zod.z.object({
+  nodeTypes: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
+  domains: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
+  clusterIds: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
+  nodeIds: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
+  depth: zod.z.coerce.number().int().min(1).optional(),
+  minEdgeStrength: zod.z.coerce.number().min(0).max(1).optional(),
+  relationshipTypes: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
+  maxNodes: zod.z.coerce.number().int().min(1).optional(),
+  includeOrphanNodes: zod.z.coerce.boolean().optional()
+});
+var expandGraphRequestSchema = zod.z.object({
+  fromNodeIds: zod.z.array(zod.z.string().uuid()),
+  depth: zod.z.coerce.number().int().min(1),
+  direction: zod.z.enum(["outbound", "inbound", "both"]),
+  maxNodes: zod.z.coerce.number().int().min(1).optional()
+});
+var findPathRequestSchema = zod.z.object({
+  fromNodeId: zod.z.string().uuid(),
+  toNodeId: zod.z.string().uuid(),
+  maxDepth: zod.z.coerce.number().int().min(1).optional(),
+  algorithm: zod.z.enum(["shortest", "all"]).optional()
+});
+var semanticSearchRequestSchema = zod.z.object({
+  query: zod.z.string().min(1),
+  nodeTypes: zod.z.array(zod.z.string()).optional(),
+  domains: zod.z.array(zod.z.string()).optional(),
+  limit: zod.z.coerce.number().int().min(1).optional()
+});
+var findSimilarRequestSchema = zod.z.object({
+  nodeId: zod.z.string().uuid(),
+  limit: zod.z.coerce.number().int().min(1).optional(),
+  excludeConnected: zod.z.coerce.boolean().optional()
+});
+
+// src/core/analysis/scoring-engine.ts
+var DEFAULT_CONFIG = {
+  similarityWeight: 0.6,
+  connectionWeight: 0.2,
+  recencyWeight: 0.1,
+  domainBoost: 0.1
+};
+var ScoringEngine = class {
+  constructor(db, config) {
+    this.db = db;
+    this.config = { ...DEFAULT_CONFIG, ...config ?? {} };
+  }
+  config;
+  cosineSimilarity(a, b) {
+    let dot = 0;
+    let magA = 0;
+    let magB = 0;
+    for (let i = 0; i < a.length; i += 1) {
+      dot += a[i] * b[i];
+      magA += a[i] * a[i];
+      magB += b[i] * b[i];
+    }
+    if (magA === 0 || magB === 0) return 0;
+    return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+  }
+  async semanticSimilarity(nodeA, nodeB) {
+    const rows = await this.db.query(
+      "SELECT 1 - (a.embedding <=> b.embedding) as similarity FROM nodes a JOIN nodes b ON b.id = $2 WHERE a.id = $1",
+      [nodeA, nodeB]
+    );
+    return rows[0]?.similarity ?? 0;
+  }
+  async scoreForQuery(queryEmbedding, nodeIds) {
+    const filterClause = nodeIds?.length ? "AND id = ANY($2)" : "";
+    const values = nodeIds?.length ? [queryEmbedding, nodeIds] : [queryEmbedding];
+    const nodes = await this.db.query(
+      `SELECT *, 1 - (embedding <=> $1) as similarity FROM nodes WHERE embedding IS NOT NULL ${filterClause} ORDER BY embedding <=> $1`,
+      values
+    );
+    return nodes.map((node) => this.applyScoring(node, node.similarity ?? 0));
+  }
+  async findSimilar(nodeId, limit = 10, excludeConnected = false) {
+    const base = excludeConnected ? `SELECT id FROM nodes WHERE id NOT IN (SELECT to_node_id FROM edges WHERE from_node_id = $1)` : `SELECT id FROM nodes WHERE id != $1`;
+    const nodes = await this.db.query(
+      `SELECT n.*, 1 - (n.embedding <=> (SELECT embedding FROM nodes WHERE id = $1)) as similarity
+       FROM nodes n
+       WHERE n.embedding IS NOT NULL AND n.id IN (${base})
+       ORDER BY n.embedding <=> (SELECT embedding FROM nodes WHERE id = $1)
+       LIMIT $2`,
+      [nodeId, limit]
+    );
+    return nodes.map((node) => this.applyScoring(node, node.similarity ?? 0));
+  }
+  async calculateNodeImportance(nodeId) {
+    const row = await this.db.queryOne(
+      `WITH edge_weights AS (
+        SELECT to_node_id, SUM(strength) as total_inbound
+        FROM edges
+        GROUP BY to_node_id
+      )
+      SELECT COALESCE(ew.total_inbound, 0) + (n.connection_count * 0.1) as importance
+      FROM nodes n
+      LEFT JOIN edge_weights ew ON n.id = ew.to_node_id
+      WHERE n.id = $1`,
+      [nodeId]
+    );
+    return row?.importance ?? 0;
+  }
+  async rankAllNodes() {
+    const rows = await this.db.query(
+      `WITH edge_weights AS (
+        SELECT to_node_id, SUM(strength) as total_inbound
+        FROM edges
+        GROUP BY to_node_id
+      )
+      SELECT n.id, COALESCE(ew.total_inbound, 0) + (n.connection_count * 0.1) as importance
+      FROM nodes n
+      LEFT JOIN edge_weights ew ON n.id = ew.to_node_id
+      ORDER BY importance DESC`
+    );
+    return rows.map((row) => ({ nodeId: row.id, importance: row.importance }));
+  }
+  async scoreRelevance(sourceNodeId, candidateNodeIds, context) {
+    const nodes = await this.db.query(
+      `SELECT *, 1 - (embedding <=> (SELECT embedding FROM nodes WHERE id = $1)) as similarity
+       FROM nodes
+       WHERE embedding IS NOT NULL AND id = ANY($2)
+       ORDER BY embedding <=> (SELECT embedding FROM nodes WHERE id = $1)`,
+      [sourceNodeId, candidateNodeIds]
+    );
+    return nodes.map((node) => {
+      const base = this.applyScoring(node, node.similarity ?? 0);
+      if (context) {
+        base.score += this.config.domainBoost * 0.1;
+      }
+      return base;
+    });
+  }
+  applyScoring(node, similarity) {
+    const connections = node.connectionCount ?? 0;
+    const recency = node.updatedAt ? Math.max(0, 1 - (Date.now() - new Date(node.updatedAt).getTime()) / (1e3 * 60 * 60 * 24 * 30)) : 0;
+    const domainMatch = 0;
+    const score = similarity * this.config.similarityWeight + connections * this.config.connectionWeight + recency * this.config.recencyWeight + domainMatch * this.config.domainBoost;
+    return {
+      node,
+      score,
+      breakdown: {
+        similarity,
+        connections,
+        recency,
+        domainMatch
+      }
+    };
+  }
+};
+
+// src/storage/factory.ts
+var singleton = null;
+function createDatabase(config) {
+  const dbConfig = {
+    connectionString: config.database.url,
+    host: config.database.mode === "docker" ? "localhost" : void 0,
+    port: config.database.port,
+    user: config.database.user,
+    password: config.database.password,
+    database: config.database.database,
+    pool: config.database.pool
+  };
+  return new chunkCOO66N7H_cjs.Database(dbConfig);
+}
+function createDatabaseFromEnv() {
+  const dbConfig = {
+    connectionString: process.env.DATABASE_URL,
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT ? Number(process.env.DB_PORT) : void 0,
+    user: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    database: process.env.DB_NAME
+  };
+  return new chunkCOO66N7H_cjs.Database(dbConfig);
+}
+function getDatabase(config) {
+  if (!singleton) {
+    singleton = new chunkCOO66N7H_cjs.Database(config ?? {});
+  }
+  return singleton;
+}
+function resetDatabaseSingleton() {
+  singleton = null;
+}
+
+// src/storage/query-helpers.ts
+var buildWhereClause = (where, startIndex = 1) => {
+  if (!where || Object.keys(where).length === 0) {
+    return { clause: "", values: [], nextIndex: startIndex };
+  }
+  const keys = Object.keys(where);
+  const values = [];
+  const conditions = keys.map((key, idx) => {
+    values.push(where[key]);
+    return `${key} = $${startIndex + idx}`;
+  });
+  return {
+    clause: `WHERE ${conditions.join(" AND ")}`,
+    values,
+    nextIndex: startIndex + keys.length
+  };
+};
+var buildInsert = (table, data) => {
+  const keys = Object.keys(data);
+  const values = Object.values(data);
+  const columns = keys.map((key) => `"${key}"`).join(", ");
+  const placeholders = keys.map((_, idx) => `$${idx + 1}`).join(", ");
+  return {
+    sql: `INSERT INTO ${table} (${columns}) VALUES (${placeholders}) RETURNING *`,
+    values
+  };
+};
+var buildUpdate = (table, data, where) => {
+  const keys = Object.keys(data);
+  const values = Object.values(data);
+  const setClause = keys.map((key, idx) => `"${key}" = $${idx + 1}`).join(", ");
+  const whereResult = buildWhereClause(where, keys.length + 1);
+  return {
+    sql: `UPDATE ${table} SET ${setClause} ${whereResult.clause} RETURNING *`,
+    values: [...values, ...whereResult.values]
+  };
+};
+var buildSelect = (table, columns, where, options) => {
+  const columnList = columns === "*" ? "*" : columns.map((col) => `"${col}"`).join(", ");
+  const whereResult = buildWhereClause(where);
+  const orderClause = options?.orderBy ? `ORDER BY ${options.orderBy} ${options.orderDirection ?? "asc"}` : "";
+  const limitClause = options?.limit ? `LIMIT ${options.limit}` : "";
+  const offsetClause = options?.offset ? `OFFSET ${options.offset}` : "";
+  return {
+    sql: `SELECT ${columnList} FROM ${table} ${whereResult.clause} ${orderClause} ${limitClause} ${offsetClause}`.trim(),
+    values: whereResult.values
+  };
+};
+var buildDelete = (table, where) => {
+  const whereResult = buildWhereClause(where);
+  return {
+    sql: `DELETE FROM ${table} ${whereResult.clause}`,
+    values: whereResult.values
+  };
+};
+
+exports.DEFAULT_ANALYSIS_SETTINGS = DEFAULT_ANALYSIS_SETTINGS;
+exports.DEFAULT_VISUALIZATION_SETTINGS = DEFAULT_VISUALIZATION_SETTINGS;
+exports.ScoringEngine = ScoringEngine;
+exports.analysisOptionsSchema = analysisOptionsSchema;
+exports.analysisRequestSchema = analysisRequestSchema;
+exports.analysisSettingsSchema = analysisSettingsSchema;
+exports.buildDelete = buildDelete;
+exports.buildInsert = buildInsert;
+exports.buildSelect = buildSelect;
+exports.buildUpdate = buildUpdate;
+exports.buildWhereClause = buildWhereClause;
+exports.createDatabase = createDatabase;
+exports.createDatabaseFromEnv = createDatabaseFromEnv;
+exports.databaseSettingsSchema = databaseSettingsSchema;
+exports.domainConfigSchema = domainConfigSchema;
+exports.edgeCreateSchema = edgeCreateSchema;
+exports.edgeEvidenceSchema = edgeEvidenceSchema;
+exports.edgeFilterSchema = edgeFilterSchema;
+exports.edgeUpdateSchema = edgeUpdateSchema;
+exports.expandGraphRequestSchema = expandGraphRequestSchema;
+exports.findPathRequestSchema = findPathRequestSchema;
+exports.findSimilarRequestSchema = findSimilarRequestSchema;
+exports.getDatabase = getDatabase;
+exports.getGraphParamsSchema = getGraphParamsSchema;
+exports.listEdgesParamsSchema = listEdgesParamsSchema;
+exports.listNodesParamsSchema = listNodesParamsSchema;
+exports.neuronConfigSchema = neuronConfigSchema;
+exports.neuronSettingsSchema = neuronSettingsSchema;
+exports.neuronSettingsUpdateSchema = neuronSettingsUpdateSchema;
+exports.nodeBatchCreateSchema = nodeBatchCreateSchema;
+exports.nodeCreateSchema = nodeCreateSchema;
+exports.nodeFilterSchema = nodeFilterSchema;
+exports.nodeTierSchema = nodeTierSchema;
+exports.nodeTypeConfigSchema = nodeTypeConfigSchema;
+exports.nodeUpdateSchema = nodeUpdateSchema;
+exports.paginationSchema = paginationSchema;
+exports.relationshipTypeConfigSchema = relationshipTypeConfigSchema;
+exports.resetDatabaseSingleton = resetDatabaseSingleton;
+exports.semanticSearchRequestSchema = semanticSearchRequestSchema;
+exports.visualizationSettingsSchema = visualizationSettingsSchema;
+//# sourceMappingURL=chunk-RTSFO7BW.cjs.map
+//# sourceMappingURL=chunk-RTSFO7BW.cjs.map