@nicia-ai/typegraph 0.34.0 → 0.35.0

package/dist/chunk-SHLY4MCM.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/indexes/ddl.ts"],"names":[],"mappings":"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","file":"chunk-SHLY4MCM.js","sourcesContent":["import { type SQL, sql } from \"drizzle-orm\";\nimport { CasingCache } from \"drizzle-orm/casing\";\n\nimport { getDialect } from \"../query/dialect\";\nimport { type SqlDialect } from \"../query/dialect/types\";\nimport {\n  compileEdgeIndexKeys,\n  compileIndexWhere,\n  compileNodeIndexKeys,\n  type IndexCompilationContext,\n} from \"./compiler\";\nimport {\n  type EdgeIndexDeclaration,\n  type NodeIndexDeclaration,\n  type RelationalIndexDeclaration,\n  type SystemColumnName,\n} from \"./types\";\n\nexport type GenerateIndexDdlOptions = Readonly<{\n  nodesTableName?: string | undefined;\n  edgesTableName?: string | undefined;\n  ifNotExists?: boolean | undefined;\n  /**\n   * Emit `CREATE INDEX CONCURRENTLY` (Postgres only). Required for\n   * `store.materializeIndexes()` so live tables don't take an\n   * `AccessExclusiveLock`. Ignored on SQLite (no equivalent; SQLite is\n   * single-writer regardless). When true on Postgres, the resulting\n   * statement cannot be executed inside a transaction.\n   */\n  concurrent?: boolean | undefined;\n}>;\n\n/**\n * Generate `CREATE INDEX` DDL for a single relational index declaration.\n *\n * Vector index declarations (`entity: \"vector\"`) are NOT handled here —\n * they go through `backend.createVectorIndex` instead because the DDL\n * is dialect-specific (`USING hnsw (...) WITH (m=..., ef_construction=...)`\n * on Postgres) and operates on the strategy's per-`(kind, field)` embedding\n * tables, not `typegraph_nodes` / `typegraph_edges`. Callers narrow to the\n * relational subset before calling this function.\n */\nexport function generateIndexDDL(\n  index: RelationalIndexDeclaration,\n  dialect: SqlDialect,\n  options: GenerateIndexDdlOptions = {},\n): string {\n  if (index.entity === \"node\") {\n    return generateNodeIndexDDL(index, dialect, options);\n  }\n  return generateEdgeIndexDDL(index, dialect, options);\n}\n\nexport function generateNodeIndexDDL(\n  index: NodeIndexDeclaration,\n  dialect: SqlDialect,\n  options: GenerateIndexDdlOptions = {},\n): string {\n  const tableName = options.nodesTableName ?? \"typegraph_nodes\";\n  return generateTableIndexDDL(index, dialect, tableName, options);\n}\n\nexport function generateEdgeIndexDDL(\n  index: EdgeIndexDeclaration,\n  dialect: SqlDialect,\n  options: GenerateIndexDdlOptions = {},\n): string {\n  const tableName = options.edgesTableName ?? \"typegraph_edges\";\n  return generateTableIndexDDL(index, dialect, tableName, options);\n}\n\nfunction generateTableIndexDDL(\n  index: RelationalIndexDeclaration,\n  dialect: SqlDialect,\n  tableName: string,\n  options: GenerateIndexDdlOptions,\n): string {\n  const ifNotExists = options.ifNotExists ?? true;\n  const propsColumn = sql.raw('\"props\"');\n  const systemColumn = (column: SystemColumnName): SQL =>\n    sql.raw(quoteIdentifier(column));\n\n  const keys =\n    index.entity === \"node\" ?\n      compileNodeIndexKeys(index, dialect, propsColumn, systemColumn).keys\n    : compileEdgeIndexKeys(index, dialect, propsColumn, systemColumn).keys;\n\n  const whereSql =\n    index.where ?\n      sqlToInlineString(\n        compileIndexWhere(\n          {\n            dialect,\n            propsColumn,\n            systemColumn,\n          } satisfies IndexCompilationContext,\n          index.where,\n        ),\n        dialect,\n      )\n    : undefined;\n\n  const keySql = keys.map((k) => sqlToInlineString(k, dialect)).join(\", \");\n  const unique = index.unique ? \"UNIQUE \" : \"\";\n  const concurrent =\n    options.concurrent === true && dialect === \"postgres\" ?\n      \"CONCURRENTLY \"\n    : \"\";\n  const ifNotExistsSql = ifNotExists ? \"IF NOT EXISTS \" : \"\";\n\n  const whereClause = whereSql ? ` WHERE ${whereSql}` : \"\";\n\n  return `CREATE ${unique}INDEX ${concurrent}${ifNotExistsSql}${quoteIdentifier(index.name)} ON ${quoteIdentifier(tableName)} (${keySql})${whereClause};`;\n}\n\nfunction quoteIdentifier(identifier: string): string {\n  return `\"${identifier.replaceAll('\"', '\"\"')}\"`;\n}\n\nfunction sqlToInlineString(object: SQL, dialect: SqlDialect): string {\n  const query = object.toQuery({\n    casing: new CasingCache(),\n    escapeName: (name) => name,\n    escapeParam: (_number, value) => inlineParam(value, dialect),\n    escapeString: (value) => escapeStringLiteral(value),\n    inlineParams: true,\n    invokeSource: \"indexes\",\n  });\n\n  if (query.params.length > 0) {\n    throw new Error(\n      \"Index DDL generation produced parameters; expected fully inlined SQL\",\n    );\n  }\n\n  return query.sql;\n}\n\nfunction inlineParam(value: unknown, dialect: SqlDialect): string {\n  if (value === null || value === undefined) {\n    return \"NULL\";\n  }\n  if (value instanceof Date) {\n    return escapeStringLiteral(value.toISOString());\n  }\n\n  if (typeof value === \"string\") {\n    return escapeStringLiteral(value);\n  }\n  if (typeof value === \"number\") {\n    return value.toString();\n  }\n  if (typeof value === \"boolean\") {\n    return getDialect(dialect).booleanLiteralString(value);\n  }\n  if (typeof value === \"bigint\") {\n    return value.toString();\n  }\n\n  throw new TypeError(\n    \"Index DDL generation received an unsupported SQL parameter value\",\n  );\n}\n\nfunction escapeStringLiteral(value: string): string {\n  return `'${value.replaceAll(\"'\", \"''\")}'`;\n}\n"]}

package/dist/chunk-T2DWPQNE.js

@@ -1,649 +0,0 @@
-import { runInWriteTransaction } from './chunk-6SCVW4AS.js';
-import { getNodeKinds, getEdgeKinds } from './chunk-CHXTTSC6.js';
-import { applyNodeInsertSideEffects, validateEdgeEndpoints, applyNodeUpdate, checkUniquenessConstraints } from './chunk-A7SZZFAG.js';
-import { isLiveNodeRow } from './chunk-V3QNTB7Z.js';
-import { isCanonicalIsoDate, nowIso, validateOptionalCanonicalIsoDate } from './chunk-XXVEULWX.js';
-import { UniquenessError } from './chunk-TQOYM4LN.js';
-import { z } from 'zod';
-
-var FORMAT_VERSION = "1.0";
-var ValidityTimestampSchema = z.iso.datetime().refine((value) => isCanonicalIsoDate(value), {
-  message: "Expected canonical UTC ISO 8601 (YYYY-MM-DDTHH:mm:ss.sssZ); convert with new Date(value).toISOString()."
-});
-var InterchangeNodeSchema = z.object({
-  kind: z.string().min(1),
-  id: z.string().min(1),
-  properties: z.record(z.string(), z.unknown()),
-  validFrom: ValidityTimestampSchema.optional(),
-  validTo: ValidityTimestampSchema.optional(),
-  meta: z.object({
-    version: z.number().int().positive().optional(),
-    createdAt: z.iso.datetime().optional(),
-    updatedAt: z.iso.datetime().optional()
-  }).optional()
-});
-var InterchangeEdgeSchema = z.object({
-  kind: z.string().min(1),
-  id: z.string().min(1),
-  from: z.object({
-    kind: z.string().min(1),
-    id: z.string().min(1)
-  }),
-  to: z.object({
-    kind: z.string().min(1),
-    id: z.string().min(1)
-  }),
-  properties: z.record(z.string(), z.unknown()).default({}),
-  validFrom: ValidityTimestampSchema.optional(),
-  validTo: ValidityTimestampSchema.optional(),
-  meta: z.object({
-    createdAt: z.iso.datetime().optional(),
-    updatedAt: z.iso.datetime().optional()
-  }).optional()
-});
-var ConflictStrategySchema = z.enum(["skip", "update", "error"]);
-var UnknownPropertyStrategySchema = z.enum([
-  "error",
-  "strip",
-  "allow"
-]);
-var ImportOptionsSchema = z.object({
-  /** How to handle existing nodes/edges with the same ID */
-  onConflict: ConflictStrategySchema,
-  /** How to handle properties not in the schema */
-  onUnknownProperty: UnknownPropertyStrategySchema.default("error"),
-  /** Whether to validate that edge endpoints exist */
-  validateReferences: z.boolean().default(true),
-  /** Number of items to process in each batch */
-  batchSize: z.number().int().positive().default(100)
-});
-var GraphDataSourceSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("typegraph-export"),
-    graphId: z.string(),
-    schemaVersion: z.number().int().positive()
-  }),
-  z.object({
-    type: z.literal("external"),
-    description: z.string().optional()
-  })
-]);
-var GraphDataSchema = z.object({
-  formatVersion: z.literal(FORMAT_VERSION),
-  exportedAt: z.iso.datetime(),
-  source: GraphDataSourceSchema,
-  nodes: z.array(InterchangeNodeSchema),
-  edges: z.array(InterchangeEdgeSchema)
-});
-var ImportErrorSchema = z.object({
-  entityType: z.enum(["node", "edge"]),
-  kind: z.string(),
-  id: z.string(),
-  error: z.string()
-});
-var ImportResultSchema = z.object({
-  success: z.boolean(),
-  nodes: z.object({
-    created: z.number().int().nonnegative(),
-    updated: z.number().int().nonnegative(),
-    skipped: z.number().int().nonnegative()
-  }),
-  edges: z.object({
-    created: z.number().int().nonnegative(),
-    updated: z.number().int().nonnegative(),
-    skipped: z.number().int().nonnegative()
-  }),
-  errors: z.array(ImportErrorSchema)
-});
-var ExportOptionsSchema = z.object({
-  /** Filter to specific node kinds (undefined = all) */
-  nodeKinds: z.array(z.string()).optional(),
-  /** Filter to specific edge kinds (undefined = all) */
-  edgeKinds: z.array(z.string()).optional(),
-  /** Include temporal fields (validFrom, validTo) */
-  includeTemporal: z.boolean().default(false),
-  /** Include metadata (version, timestamps) */
-  includeMeta: z.boolean().default(false),
-  /** Include soft-deleted records */
-  includeDeleted: z.boolean().default(false)
-});
-
-// src/interchange/export.ts
-async function exportGraph(store, options) {
-  const options_ = {
-    nodeKinds: options?.nodeKinds,
-    edgeKinds: options?.edgeKinds,
-    includeTemporal: options?.includeTemporal ?? false,
-    includeMeta: options?.includeMeta ?? false,
-    includeDeleted: options?.includeDeleted ?? false
-  };
-  const graph = store.graph;
-  const graphId = store.graphId;
-  const backend = store.backend;
-  const nodeKindsToExport = options_.nodeKinds ?? getNodeKinds(graph);
-  const edgeKindsToExport = options_.edgeKinds ?? getEdgeKinds(graph);
-  const nodes = [];
-  for (const kind of nodeKindsToExport) {
-    const kindNodes = await exportNodesOfKind(backend, graphId, kind, options_);
-    nodes.push(...kindNodes);
-  }
-  const edges = [];
-  for (const kind of edgeKindsToExport) {
-    const kindEdges = await exportEdgesOfKind(backend, graphId, kind, options_);
-    edges.push(...kindEdges);
-  }
-  const schemaVersion = await backend.getActiveSchema(graphId);
-  return {
-    formatVersion: FORMAT_VERSION,
-    exportedAt: nowIso(),
-    source: {
-      type: "typegraph-export",
-      graphId,
-      schemaVersion: schemaVersion?.version ?? 1
-    },
-    nodes,
-    edges
-  };
-}
-async function exportNodesOfKind(backend, graphId, kind, options) {
-  const rows = await backend.findNodesByKind({
-    graphId,
-    kind,
-    excludeDeleted: !options.includeDeleted
-  });
-  return rows.map((row) => {
-    const node = {
-      kind: row.kind,
-      id: row.id,
-      properties: JSON.parse(row.props)
-    };
-    if (options.includeTemporal) {
-      if (row.valid_from) {
-        node.validFrom = row.valid_from;
-      }
-      if (row.valid_to) {
-        node.validTo = row.valid_to;
-      }
-    }
-    if (options.includeMeta) {
-      node.meta = {
-        version: row.version,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at
-      };
-    }
-    return node;
-  });
-}
-async function exportEdgesOfKind(backend, graphId, kind, options) {
-  const rows = await backend.findEdgesByKind({
-    graphId,
-    kind,
-    excludeDeleted: !options.includeDeleted
-  });
-  return rows.map((row) => {
-    const edge = {
-      kind: row.kind,
-      id: row.id,
-      from: {
-        kind: row.from_kind,
-        id: row.from_id
-      },
-      to: {
-        kind: row.to_kind,
-        id: row.to_id
-      },
-      properties: JSON.parse(row.props)
-    };
-    if (options.includeTemporal) {
-      if (row.valid_from) {
-        edge.validFrom = row.valid_from;
-      }
-      if (row.valid_to) {
-        edge.validTo = row.valid_to;
-      }
-    }
-    if (options.includeMeta) {
-      edge.meta = {
-        createdAt: row.created_at,
-        updatedAt: row.updated_at
-      };
-    }
-    return edge;
-  });
-}
-
-// src/interchange/import.ts
-async function importGraph(store, data, options) {
-  const result = {
-    success: true,
-    nodes: { created: 0, updated: 0, skipped: 0 },
-    edges: { created: 0, updated: 0, skipped: 0 },
-    errors: []
-  };
-  const errors = [];
-  const graph = store.graph;
-  const graphId = store.graphId;
-  const backend = store.backend;
-  const registry = store.registry;
-  const nodeSchemas = buildNodeSchemaMap(graph);
-  const edgeSchemas = buildEdgeSchemaMap(graph);
-  const importedNodeIds = /* @__PURE__ */ new Set();
-  await runInWriteTransaction(store, backend, async (target, lock) => {
-    await processNodes(
-      target,
-      graphId,
-      registry,
-      data.nodes,
-      nodeSchemas,
-      options,
-      result,
-      errors,
-      importedNodeIds,
-      lock
-    );
-    await processEdges(
-      target,
-      graphId,
-      registry,
-      data.edges,
-      edgeSchemas,
-      nodeSchemas,
-      options,
-      result,
-      errors,
-      importedNodeIds
-    );
-  });
-  return {
-    ...result,
-    success: errors.length === 0,
-    errors
-  };
-}
-function buildNodeSchemaMap(graph) {
-  const map = /* @__PURE__ */ new Map();
-  for (const kindName of getNodeKinds(graph)) {
-    const registration = graph.nodes[kindName];
-    map.set(kindName, {
-      registration,
-      schema: registration.type.schema
-    });
-  }
-  return map;
-}
-function buildEdgeSchemaMap(graph) {
-  const map = /* @__PURE__ */ new Map();
-  for (const kindName of getEdgeKinds(graph)) {
-    const registration = graph.edges[kindName];
-    map.set(kindName, {
-      registration,
-      schema: registration.type.schema
-    });
-  }
-  return map;
-}
-async function processNodes(backend, graphId, registry, nodes, schemas, options, result, errors, importedNodeIds, lock) {
-  const batchSize = options.batchSize;
-  for (let index = 0; index < nodes.length; index += batchSize) {
-    const batch = nodes.slice(index, index + batchSize);
-    for (const node of batch) {
-      const importResult = await processNode(
-        backend,
-        graphId,
-        registry,
-        node,
-        schemas,
-        options,
-        lock
-      );
-      switch (importResult.status) {
-        case "created": {
-          result.nodes.created++;
-          importedNodeIds.add(makeNodeKey(node.kind, node.id));
-          break;
-        }
-        case "updated": {
-          result.nodes.updated++;
-          importedNodeIds.add(makeNodeKey(node.kind, node.id));
-          break;
-        }
-        case "skipped": {
-          result.nodes.skipped++;
-          if (importResult.liveTarget) {
-            importedNodeIds.add(makeNodeKey(node.kind, node.id));
-          }
-          break;
-        }
-        case "error": {
-          errors.push({
-            entityType: "node",
-            kind: node.kind,
-            id: node.id,
-            error: importResult.error
-          });
-          break;
-        }
-      }
-    }
-  }
-}
-async function catchUniquenessError(fn) {
-  try {
-    return { ok: true, value: await fn() };
-  } catch (error) {
-    if (error instanceof UniquenessError) {
-      return { ok: false, error: error.message };
-    }
-    throw error;
-  }
-}
-function validateValidityWindow(entity) {
-  try {
-    validateOptionalCanonicalIsoDate(entity.validFrom, "validFrom");
-    validateOptionalCanonicalIsoDate(entity.validTo, "validTo");
-    return void 0;
-  } catch (error) {
-    return error instanceof Error ? error.message : String(error);
-  }
-}
-async function processNode(backend, graphId, registry, node, schemas, options, lock) {
-  const schemaEntry = schemas.get(node.kind);
-  if (!schemaEntry) {
-    return { status: "error", error: `Unknown node kind: ${node.kind}` };
-  }
-  const propsResult = validateProperties(
-    node.properties,
-    schemaEntry.schema,
-    options.onUnknownProperty
-  );
-  if (!propsResult.success) {
-    return { status: "error", error: propsResult.error };
-  }
-  const validityError = validateValidityWindow(node);
-  if (validityError !== void 0) {
-    return { status: "error", error: validityError };
-  }
-  const { registration } = schemaEntry;
-  const uniqueConstraints = registration.unique ?? [];
-  const writeContext = { graphId, registry, lock };
-  const existing = await backend.getNode(graphId, node.kind, node.id);
-  if (existing) {
-    switch (options.onConflict) {
-      case "skip": {
-        return { status: "skipped", liveTarget: isLiveNodeRow(existing) };
-      }
-      case "error": {
-        return {
-          status: "error",
-          error: `Node already exists: ${node.kind}:${node.id}`
-        };
-      }
-      case "update": {
-        if (!isLiveNodeRow(existing)) {
-          return { status: "skipped", liveTarget: false };
-        }
-        const updateResult = await catchUniquenessError(
-          () => applyNodeUpdate(
-            writeContext,
-            {
-              existing,
-              schema: registration.type.schema,
-              validatedProps: propsResult.data,
-              uniqueConstraints,
-              ...node.validTo !== void 0 && { validTo: node.validTo }
-            },
-            backend
-          )
-        );
-        if (!updateResult.ok) {
-          return { status: "error", error: updateResult.error };
-        }
-        return { status: "updated" };
-      }
-    }
-  }
-  const uniquenessResult = await catchUniquenessError(
-    () => checkUniquenessConstraints(
-      { graphId, registry, backend },
-      node.kind,
-      node.id,
-      propsResult.data,
-      uniqueConstraints
-    )
-  );
-  if (!uniquenessResult.ok) {
-    return { status: "error", error: uniquenessResult.error };
-  }
-  await backend.insertNode({
-    graphId,
-    kind: node.kind,
-    id: node.id,
-    props: propsResult.data,
-    ...node.validFrom !== void 0 && { validFrom: node.validFrom },
-    ...node.validTo !== void 0 && { validTo: node.validTo }
-  });
-  await applyNodeInsertSideEffects(
-    writeContext,
-    {
-      kind: node.kind,
-      id: node.id,
-      schema: registration.type.schema,
-      props: propsResult.data,
-      uniqueConstraints
-    },
-    backend
-  );
-  return { status: "created" };
-}
-async function processEdges(backend, graphId, registry, edges, edgeSchemas, nodeSchemas, options, result, errors, importedNodeIds) {
-  const batchSize = options.batchSize;
-  for (let index = 0; index < edges.length; index += batchSize) {
-    const batch = edges.slice(index, index + batchSize);
-    for (const edge of batch) {
-      const importResult = await processEdge(
-        backend,
-        graphId,
-        registry,
-        edge,
-        edgeSchemas,
-        nodeSchemas,
-        options,
-        importedNodeIds
-      );
-      switch (importResult.status) {
-        case "created": {
-          result.edges.created++;
-          break;
-        }
-        case "updated": {
-          result.edges.updated++;
-          break;
-        }
-        case "skipped": {
-          result.edges.skipped++;
-          break;
-        }
-        case "error": {
-          errors.push({
-            entityType: "edge",
-            kind: edge.kind,
-            id: edge.id,
-            error: importResult.error
-          });
-          break;
-        }
-      }
-    }
-  }
-}
-async function processEdge(backend, graphId, registry, edge, edgeSchemas, nodeSchemas, options, importedNodeIds) {
-  const schemaEntry = edgeSchemas.get(edge.kind);
-  if (!schemaEntry) {
-    return { status: "error", error: `Unknown edge kind: ${edge.kind}` };
-  }
-  if (!nodeSchemas.has(edge.from.kind)) {
-    return {
-      status: "error",
-      error: `Unknown from node kind: ${edge.from.kind}`
-    };
-  }
-  if (!nodeSchemas.has(edge.to.kind)) {
-    return { status: "error", error: `Unknown to node kind: ${edge.to.kind}` };
-  }
-  const endpointError = validateEdgeEndpoints(
-    edge.kind,
-    edge.from.kind,
-    edge.to.kind,
-    schemaEntry.registration,
-    registry
-  );
-  if (endpointError !== void 0) {
-    return { status: "error", error: endpointError.message };
-  }
-  if (options.validateReferences) {
-    const fromKey = makeNodeKey(edge.from.kind, edge.from.id);
-    const toKey = makeNodeKey(edge.to.kind, edge.to.id);
-    if (!importedNodeIds.has(fromKey)) {
-      const fromExists = await backend.getNode(
-        graphId,
-        edge.from.kind,
-        edge.from.id
-      );
-      if (fromExists === void 0 || !isLiveNodeRow(fromExists)) {
-        return {
-          status: "error",
-          error: `From node not found: ${edge.from.kind}:${edge.from.id}`
-        };
-      }
-    }
-    if (!importedNodeIds.has(toKey)) {
-      const toExists = await backend.getNode(graphId, edge.to.kind, edge.to.id);
-      if (toExists === void 0 || !isLiveNodeRow(toExists)) {
-        return {
-          status: "error",
-          error: `To node not found: ${edge.to.kind}:${edge.to.id}`
-        };
-      }
-    }
-  }
-  const propsResult = validateProperties(
-    edge.properties,
-    schemaEntry.schema,
-    options.onUnknownProperty
-  );
-  if (!propsResult.success) {
-    return { status: "error", error: propsResult.error };
-  }
-  const validityError = validateValidityWindow(edge);
-  if (validityError !== void 0) {
-    return { status: "error", error: validityError };
-  }
-  const existing = await backend.getEdge(graphId, edge.id);
-  if (existing) {
-    switch (options.onConflict) {
-      case "skip": {
-        return {
-          status: "skipped",
-          liveTarget: existing.deleted_at === void 0
-        };
-      }
-      case "error": {
-        return { status: "error", error: `Edge already exists: ${edge.id}` };
-      }
-      case "update": {
-        if (existing.deleted_at !== void 0) {
-          return { status: "skipped", liveTarget: false };
-        }
-        await backend.updateEdge({
-          graphId,
-          id: edge.id,
-          props: propsResult.data,
-          ...edge.validTo !== void 0 && { validTo: edge.validTo }
-        });
-        return { status: "updated" };
-      }
-    }
-  }
-  await backend.insertEdge({
-    graphId,
-    id: edge.id,
-    kind: edge.kind,
-    fromKind: edge.from.kind,
-    fromId: edge.from.id,
-    toKind: edge.to.kind,
-    toId: edge.to.id,
-    props: propsResult.data,
-    ...edge.validFrom !== void 0 && { validFrom: edge.validFrom },
-    ...edge.validTo !== void 0 && { validTo: edge.validTo }
-  });
-  return { status: "created" };
-}
-function validateProperties(properties, schema, unknownStrategy) {
-  try {
-    const knownKeys = new Set(Object.keys(schema.shape));
-    const unknownKeys = Object.keys(properties).filter(
-      (key) => !knownKeys.has(key)
-    );
-    if (unknownKeys.length > 0) {
-      switch (unknownStrategy) {
-        case "error": {
-          return {
-            success: false,
-            error: `Unknown properties: ${unknownKeys.join(", ")}`
-          };
-        }
-        case "strip": {
-          const stripped = {};
-          for (const key of knownKeys) {
-            if (key in properties) {
-              stripped[key] = properties[key];
-            }
-          }
-          const result2 = schema.safeParse(stripped);
-          if (!result2.success) {
-            return {
-              success: false,
-              error: formatZodError(result2.error)
-            };
-          }
-          return {
-            success: true,
-            data: result2.data
-          };
-        }
-        case "allow": {
-          const result2 = schema.safeParse(properties);
-          if (!result2.success) {
-            return {
-              success: false,
-              error: formatZodError(result2.error)
-            };
-          }
-          return { success: true, data: properties };
-        }
-      }
-    }
-    const result = schema.safeParse(properties);
-    if (!result.success) {
-      return { success: false, error: formatZodError(result.error) };
-    }
-    return { success: true, data: result.data };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { success: false, error: `Validation error: ${message}` };
-  }
-}
-function formatZodError(error) {
-  return error.issues.map((issue) => {
-    const path = issue.path.join(".");
-    return path ? `${path}: ${issue.message}` : issue.message;
-  }).join("; ");
-}
-function makeNodeKey(kind, id) {
-  return `${kind}:${id}`;
-}
-
-export { ConflictStrategySchema, ExportOptionsSchema, FORMAT_VERSION, GraphDataSchema, GraphDataSourceSchema, ImportErrorSchema, ImportOptionsSchema, ImportResultSchema, InterchangeEdgeSchema, InterchangeNodeSchema, UnknownPropertyStrategySchema, exportGraph, importGraph };
-//# sourceMappingURL=chunk-T2DWPQNE.js.map
-//# sourceMappingURL=chunk-T2DWPQNE.js.map