@anvia/neo4j 1.0.2 → 1.0.4

package/dist/chunk-QNHOT7P2.js

@@ -0,0 +1,1486 @@
+// src/schema.ts
+import { z } from "zod";
+var reservedPrefix = "__anvia_";
+function defineNeo4jGraphSchema(options) {
+  if (Object.keys(options.nodes).length === 0) {
+    throw new TypeError("A Neo4j graph schema requires at least one node type.");
+  }
+  for (const [type, definition] of Object.entries(options.nodes)) {
+    assertName(type, "node type");
+    assertDescription(definition.description, `node ${type}`);
+    if (!(definition.properties instanceof z.ZodObject)) {
+      throw new TypeError(`Properties for node ${type} must be a Zod object schema.`);
+    }
+    assertExactPropertySchema(definition.properties, `node ${type}`);
+    if (definition.identity.length === 0 || new Set(definition.identity).size !== definition.identity.length) {
+      throw new TypeError(`Node ${type} must declare unique identity properties.`);
+    }
+    const shape = definition.properties.shape;
+    for (const property of definition.identity) {
+      assertPropertyName(property);
+      if (!(property in shape)) {
+        throw new TypeError(`Identity property ${property} is not declared by node ${type}.`);
+      }
+    }
+    for (const property of Object.keys(shape)) assertPropertyName(property);
+  }
+  for (const [type, definition] of Object.entries(options.relationships)) {
+    assertName(type, "relationship type");
+    assertDescription(definition.description, `relationship ${type}`);
+    if (!(definition.from in options.nodes) || !(definition.to in options.nodes)) {
+      throw new TypeError(`Relationship ${type} references an unknown endpoint type.`);
+    }
+    if (!(definition.properties instanceof z.ZodObject)) {
+      throw new TypeError(`Properties for relationship ${type} must be a Zod object schema.`);
+    }
+    assertExactPropertySchema(definition.properties, `relationship ${type}`);
+    const identity = definition.identity ?? [];
+    if (new Set(identity).size !== identity.length) {
+      throw new TypeError(`Relationship ${type} contains duplicate identity properties.`);
+    }
+    for (const property of Object.keys(definition.properties.shape)) assertPropertyName(property);
+    for (const property of identity) {
+      if (!(property in definition.properties.shape)) {
+        throw new TypeError(
+          `Identity property ${property} is not declared by relationship ${type}.`
+        );
+      }
+    }
+  }
+  const nodes = Object.fromEntries(
+    Object.entries(options.nodes).map(([type, definition]) => [
+      type,
+      Object.freeze({ ...definition, identity: Object.freeze([...definition.identity]) })
+    ])
+  );
+  const relationships = Object.fromEntries(
+    Object.entries(options.relationships).map(([type, definition]) => {
+      const copy = { ...definition };
+      if (definition.identity !== void 0) {
+        Object.assign(copy, { identity: Object.freeze([...definition.identity]) });
+      }
+      return [type, Object.freeze(copy)];
+    })
+  );
+  return Object.freeze({
+    nodes: Object.freeze(nodes),
+    relationships: Object.freeze(relationships),
+    kind: "neo4j-graph-schema"
+  });
+}
+function parseNeo4jProperties(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`${label} must be an object of Neo4j property values.`);
+  }
+  const output = {};
+  for (const [key, item] of Object.entries(value)) {
+    assertPropertyName(key);
+    output[key] = parseNeo4jPropertyValue(item, `${label}.${key}`);
+  }
+  return output;
+}
+function parseNeo4jPropertyValue(value, label) {
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError(`${label} must be finite.`);
+    if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+      throw new TypeError(`${label} must be a safe integer.`);
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return [];
+    const parsed = value.map((item, index) => parsePrimitive(item, `${label}[${index}]`));
+    const type = typeof parsed[0];
+    if (!parsed.every((item) => typeof item === type)) {
+      throw new TypeError(`${label} must be a homogeneous array.`);
+    }
+    return parsed;
+  }
+  throw new TypeError(`${label} is not a supported Neo4j property value.`);
+}
+function parsePrimitive(value, label) {
+  const parsed = parseNeo4jPropertyValue(value, label);
+  if (typeof parsed === "string" || typeof parsed === "number" || typeof parsed === "boolean") {
+    return parsed;
+  }
+  throw new TypeError(`${label} must be a primitive property value.`);
+}
+function assertName(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string.`);
+  }
+}
+function assertPropertyName(value) {
+  assertName(value, "Neo4j property name");
+  if (value.startsWith(reservedPrefix)) {
+    throw new TypeError(`Neo4j property names beginning with ${reservedPrefix} are reserved.`);
+  }
+}
+function assertDescription(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TypeError(`${label} requires a non-empty description.`);
+  }
+}
+function assertExactPropertySchema(schema, label) {
+  const definition = schema._zod.def;
+  if (!(definition.catchall instanceof z.ZodNever)) {
+    throw new TypeError(`${label} properties must use a strict Zod object schema.`);
+  }
+  for (const [property, propertySchema] of Object.entries(schema.shape)) {
+    assertNonEffectfulSchema(propertySchema, `${label} property ${property}`, /* @__PURE__ */ new Set());
+  }
+}
+function assertNonEffectfulSchema(value, label, visited) {
+  if (!(value instanceof z.ZodType)) {
+    throw new TypeError(`${label} must be a Zod schema.`);
+  }
+  const schema = value;
+  if (visited.has(schema)) return;
+  visited.add(schema);
+  const definition = schema._zod.def;
+  const type = definition.type;
+  if (definition.coerce === true || type === "default" || type === "prefault" || type === "catch" || type === "transform" || type === "pipe") {
+    throw new TypeError(
+      `${label} must not coerce, default, transform, preprocess, or catch values.`
+    );
+  }
+  const checks = definition.checks;
+  if (Array.isArray(checks) && checks.some((check) => {
+    if (typeof check !== "object" || check === null) return false;
+    const internals = check._zod;
+    return internals?.def?.check === "overwrite";
+  })) {
+    throw new TypeError(`${label} must not normalize or overwrite values.`);
+  }
+  for (const child of schemaChildren(definition)) {
+    assertNonEffectfulSchema(child, label, visited);
+  }
+}
+function schemaChildren(definition) {
+  const children = [];
+  for (const key of ["innerType", "element", "left", "right", "rest", "keyType", "valueType"]) {
+    const value = definition[key];
+    if (value instanceof z.ZodType) children.push(value);
+  }
+  for (const key of ["options", "items"]) {
+    const value = definition[key];
+    if (Array.isArray(value)) {
+      for (const item of value) if (item instanceof z.ZodType) children.push(item);
+    }
+  }
+  return children;
+}
+
+// src/helpers.ts
+import { isInt } from "neo4j-driver";
+function quoteIdentifier(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError("Neo4j identifiers must be non-empty strings.");
+  }
+  if (value.includes("\0")) throw new TypeError("Neo4j identifiers must not contain NUL.");
+  return `\`${value.replaceAll("`", "``")}\``;
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw abortError();
+  }
+}
+function abortError() {
+  const error = new Error("The operation was aborted.");
+  error.name = "AbortError";
+  return error;
+}
+function positiveInteger(value, label, maximum) {
+  if (!Number.isSafeInteger(value) || value < 1 || maximum !== void 0 && value > maximum) {
+    throw new RangeError(
+      `${label} must be a positive safe integer${maximum === void 0 ? "" : ` no greater than ${maximum}`}.`
+    );
+  }
+  return value;
+}
+function finiteScore(value, label) {
+  if (value !== void 0 && !Number.isFinite(value))
+    throw new RangeError(`${label} must be finite.`);
+}
+function strictProperties(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`${label} must be an object.`);
+  }
+  const normalized = {};
+  for (const [key, item] of Object.entries(value))
+    normalized[key] = normalizeDriverValue(item, `${label}.${key}`);
+  return parseNeo4jProperties(normalized, label);
+}
+function normalizeDriverValue(value, label) {
+  if (isInt(value)) {
+    if (!value.inSafeRange()) throw new TypeError(`${label} contains an unsafe Neo4j integer.`);
+    return value.toNumber();
+  }
+  if (Array.isArray(value))
+    return value.map((item, index) => normalizeDriverValue(item, `${label}[${index}]`));
+  return value;
+}
+function stableObject(value) {
+  return JSON.stringify(
+    Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)))
+  );
+}
+
+// src/graph.ts
+import {
+  isInt as isInt2
+} from "neo4j-driver";
+var Neo4jKnowledgeGraphBase = class {
+  constructor(owner, schema) {
+    this.owner = owner;
+    this.schema = schema;
+    if (schema.kind !== "neo4j-graph-schema" && schema.kind !== "graph-schema") {
+      throw new TypeError(
+        "Neo4j knowledge graphs require defineGraphSchema() or defineNeo4jGraphSchema()."
+      );
+    }
+  }
+  owner;
+  schema;
+  async validate(options = {}) {
+    throwIfAborted(options.abortSignal);
+    await this.assertSupportedVersion(options.abortSignal);
+    const expected = expectedIndexes(this.seeds);
+    const names = [...expected.keys()];
+    const result = await this.query(
+      "SHOW INDEXES YIELD name, state, type, entityType, labelsOrTypes, properties, options WHERE name IN $names RETURN name, state, type, entityType, labelsOrTypes, properties, options",
+      { names },
+      options.abortSignal
+    );
+    const actual = new Map(
+      result.records.map((record) => [
+        requiredString(record.get("name"), "Neo4j index name"),
+        record
+      ])
+    );
+    for (const [name, definition] of expected) {
+      const record = actual.get(name);
+      if (record === void 0) throw new Error(`Neo4j index ${name} does not exist.`);
+      validateIndexRecord(record, definition);
+    }
+  }
+  async query(text, parameters, abortSignal, access = "read") {
+    return this.runTransaction(
+      access,
+      abortSignal,
+      async (transaction) => await transaction.run(text, parameters)
+    );
+  }
+  async retrieve(options) {
+    const { retrieveGraphContext } = await import("./retrieve-QRQHIVRO.js");
+    return retrieveGraphContext({
+      ...options,
+      graph: this
+    });
+  }
+  async explore(options) {
+    const { exploreGraph } = await import("./explore-RA53GFX2.js");
+    return exploreGraph(this, options);
+  }
+  seed(name) {
+    const seed = this.seeds[name];
+    if (seed === void 0) throw new TypeError(`Unknown Neo4j graph seed: ${name}`);
+    return seed;
+  }
+  async transaction(abortSignal, run) {
+    return this.runTransaction("write", abortSignal, run);
+  }
+  async runTransaction(access, abortSignal, run) {
+    throwIfAborted(abortSignal);
+    const sessionOptions = {
+      defaultAccessMode: access === "read" ? "READ" : "WRITE"
+    };
+    if (this.owner.database !== void 0) {
+      Object.assign(sessionOptions, { database: this.owner.database });
+    }
+    const session = this.owner.nativeDriver().session(sessionOptions);
+    const transaction = session.beginTransaction();
+    let rejectAbort;
+    const aborted = new Promise((_resolve, reject) => {
+      rejectAbort = reject;
+    });
+    const onAbort = () => {
+      rejectAbort?.(abortError());
+    };
+    abortSignal?.addEventListener("abort", onAbort, { once: true });
+    let committing = false;
+    try {
+      const value = await Promise.race([run(transaction), aborted]);
+      throwIfAborted(abortSignal);
+      committing = true;
+      await transaction.commit();
+      return value;
+    } catch (error) {
+      if (transaction.isOpen()) await transaction.rollback();
+      if (!committing && abortSignal?.aborted) throw abortError();
+      throw error;
+    } finally {
+      abortSignal?.removeEventListener("abort", onAbort);
+      if (transaction.isOpen()) await transaction.rollback();
+      await session.close();
+    }
+  }
+  async assertSupportedVersion(abortSignal) {
+    const result = await this.query(
+      "CALL dbms.components() YIELD versions RETURN versions[0] AS version LIMIT 1",
+      {},
+      abortSignal
+    );
+    const version = result.records[0]?.get("version");
+    if (typeof version !== "string") {
+      throw new TypeError("Neo4j returned a non-string server version.");
+    }
+    if (!supportedVersion(version)) {
+      throw new Error(`@anvia/neo4j requires Neo4j 2026.01 or newer; received ${version}.`);
+    }
+  }
+};
+var Neo4jKnowledgeGraph = class extends Neo4jKnowledgeGraphBase {
+  evidenceCapability = "none";
+  seeds;
+  constructor(owner, options) {
+    super(owner, options.schema);
+    if (Object.keys(options.seeds).length === 0) {
+      throw new TypeError("An existing Neo4j knowledge graph requires at least one seed.");
+    }
+    const seeds = {};
+    for (const [name, seed] of Object.entries(options.seeds)) {
+      assertName(name, "Neo4j seed name");
+      seeds[name] = validateExistingSeed(options.schema, seed);
+    }
+    this.seeds = Object.freeze(seeds);
+  }
+};
+var ManagedNeo4jKnowledgeGraph = class extends Neo4jKnowledgeGraphBase {
+  evidenceCapability = "chunks";
+  seeds;
+  resources;
+  name;
+  constructor(owner, options) {
+    super(owner, options.schema);
+    assertName(options.name, "Managed Neo4j graph name");
+    this.name = options.name;
+    this.resources = validateManagedResources(options.resources);
+    let chunks = {
+      labels: Object.freeze([this.resources.labels.chunk]),
+      vectorIndex: Object.freeze({
+        ...this.resources.indexes.chunks.vector,
+        property: "__anvia_embedding"
+      }),
+      entryRelationshipType: "ANVIA_MENTIONS"
+    };
+    if (this.resources.indexes.chunks.fulltext !== void 0) {
+      chunks = {
+        ...chunks,
+        fulltextIndex: Object.freeze({
+          ...this.resources.indexes.chunks.fulltext,
+          properties: Object.freeze(["__anvia_text"])
+        })
+      };
+    }
+    let entities = {
+      labels: Object.freeze([this.resources.labels.entity]),
+      vectorIndex: Object.freeze({
+        ...this.resources.indexes.entities.vector,
+        property: "__anvia_embedding"
+      })
+    };
+    if (this.resources.indexes.entities.fulltext !== void 0) {
+      entities = {
+        ...entities,
+        fulltextIndex: Object.freeze({
+          ...this.resources.indexes.entities.fulltext,
+          properties: Object.freeze(
+            Array.from(this.resources.indexes.entities.fulltext.properties ?? [])
+          )
+        })
+      };
+    }
+    this.seeds = Object.freeze({
+      chunks: Object.freeze(chunks),
+      entities: Object.freeze(entities)
+    });
+  }
+  async ensure(options) {
+    positiveInteger(options.indexTimeoutMs, "Neo4j index timeout");
+    throwIfAborted(options.abortSignal);
+    const { labels, indexes } = this.resources;
+    const statements = [
+      uniquenessConstraint(constraintName(this.name, "document"), labels.document, ["__anvia_id"]),
+      uniquenessConstraint(constraintName(this.name, "chunk"), labels.chunk, ["__anvia_id"]),
+      uniquenessConstraint(constraintName(this.name, "entity"), labels.entity, ["__anvia_key"]),
+      ...Object.entries(this.schema.nodes).map(
+        ([type, definition]) => uniquenessConstraint(
+          constraintName(this.name, `entity_${type}`),
+          type,
+          definition.identity
+        )
+      ),
+      vectorIndex(indexes.chunks.vector, labels.chunk),
+      vectorIndex(indexes.entities.vector, labels.entity)
+    ];
+    if (indexes.chunks.fulltext !== void 0) {
+      statements.push(fulltextIndex(indexes.chunks.fulltext.name, labels.chunk, ["__anvia_text"]));
+    }
+    if (indexes.entities.fulltext !== void 0) {
+      statements.push(
+        fulltextIndex(
+          indexes.entities.fulltext.name,
+          labels.entity,
+          indexes.entities.fulltext.properties ?? []
+        )
+      );
+    }
+    for (const statement of statements)
+      await this.query(statement, {}, options.abortSignal, "write");
+    await this.query(
+      "CALL db.awaitIndexes($timeoutSeconds)",
+      { timeoutSeconds: Math.ceil(options.indexTimeoutMs / 1e3) },
+      options.abortSignal
+    );
+    await this.validate({ abortSignal: options.abortSignal });
+  }
+  async validate(options = {}) {
+    await super.validate(options);
+    const expected = this.expectedConstraints();
+    const names = expected.map((constraint) => constraint.name);
+    const result = await this.query(
+      "SHOW CONSTRAINTS YIELD name, type, entityType, labelsOrTypes, properties WHERE name IN $names RETURN name, type, entityType, labelsOrTypes, properties",
+      { names },
+      options.abortSignal
+    );
+    const actual = new Map(
+      result.records.map((record) => [
+        requiredString(record.get("name"), "Neo4j constraint name"),
+        record
+      ])
+    );
+    for (const constraint of expected) {
+      const record = actual.get(constraint.name);
+      if (record === void 0) {
+        throw new Error(`Neo4j constraint ${constraint.name} does not exist.`);
+      }
+      validateConstraintRecord(record, constraint);
+    }
+  }
+  async replaceDocuments(options) {
+    validateReplacement(options, this.resources.indexes, this.schema);
+    if (options.documents.length === 0) return emptyWriteResult();
+    const documentIds = options.documents.map((document) => document.id);
+    const chunksById = new Map(options.chunks.map((chunk) => [chunk.id, chunk.document]));
+    const sourceDocuments = (sourceChunkIds) => [
+      ...new Set(
+        sourceChunkIds.map((chunkId) => {
+          const chunk = chunksById.get(chunkId);
+          if (chunk === void 0)
+            throw new TypeError(`Graph fact references unknown chunk ${chunkId}.`);
+          return chunk.documentId;
+        })
+      )
+    ];
+    return await this.transaction(options.abortSignal, async (transaction) => {
+      const targets = replacementSnapshotTargets(options);
+      const before = await snapshotGraphState(
+        transaction,
+        this.name,
+        this.resources.labels,
+        targets
+      );
+      await removeDocuments(
+        transaction,
+        this.name,
+        this.resources.labels,
+        documentIds,
+        options.orphanEntities
+      );
+      await writeDocuments(transaction, this.resources.labels, options.documents);
+      await writeChunks(transaction, this.resources.labels, options.chunks);
+      await writeEntities(
+        transaction,
+        this.name,
+        this.resources.labels.entity,
+        options.entities,
+        options.conflict,
+        sourceDocuments
+      );
+      await writeMentions(transaction, this.resources.labels, options.mentions);
+      await writeRelationships(
+        transaction,
+        this.name,
+        this.resources.labels.entity,
+        options.relationships,
+        options.conflict,
+        sourceDocuments
+      );
+      const after = await snapshotGraphState(
+        transaction,
+        this.name,
+        this.resources.labels,
+        expandSnapshotTargets(targets, before)
+      );
+      return diffGraphSnapshots(before, after);
+    });
+  }
+  async deleteDocuments(options) {
+    validateOrphanPolicy(options.orphanEntities);
+    const ids = uniqueIds(options.documentIds, "document");
+    if (ids.length === 0) return emptyWriteResult();
+    return await this.transaction(options.abortSignal, async (transaction) => {
+      const targets = emptySnapshotTargets(ids);
+      const before = await snapshotGraphState(
+        transaction,
+        this.name,
+        this.resources.labels,
+        targets
+      );
+      await removeDocuments(
+        transaction,
+        this.name,
+        this.resources.labels,
+        ids,
+        options.orphanEntities
+      );
+      const after = await snapshotGraphState(
+        transaction,
+        this.name,
+        this.resources.labels,
+        expandSnapshotTargets(targets, before)
+      );
+      return diffGraphSnapshots(before, after);
+    });
+  }
+  expectedConstraints() {
+    return [
+      {
+        name: constraintName(this.name, "document"),
+        label: this.resources.labels.document,
+        properties: ["__anvia_id"]
+      },
+      {
+        name: constraintName(this.name, "chunk"),
+        label: this.resources.labels.chunk,
+        properties: ["__anvia_id"]
+      },
+      {
+        name: constraintName(this.name, "entity"),
+        label: this.resources.labels.entity,
+        properties: ["__anvia_key"]
+      },
+      ...Object.entries(this.schema.nodes).map(([type, definition]) => ({
+        name: constraintName(this.name, `entity_${type}`),
+        label: type,
+        properties: definition.identity
+      }))
+    ];
+  }
+};
+function validateExistingSeed(schema, seed) {
+  if (seed.nodeTypes.length !== 1) {
+    throw new TypeError(
+      "Each existing Neo4j seed requires exactly one indexed node type; register additional indexes as separate seeds."
+    );
+  }
+  for (const type of seed.nodeTypes) {
+    if (!(type in schema.nodes))
+      throw new TypeError(`Neo4j seed references unknown node type ${type}.`);
+  }
+  validateVectorIndex(seed.vectorIndex);
+  assertPropertyName(seed.vectorIndex.property);
+  if (seed.fulltextIndex !== void 0) {
+    validateFulltextIndex(seed.fulltextIndex, "Existing Neo4j full-text index");
+  }
+  let registration = {
+    labels: Object.freeze([...seed.nodeTypes]),
+    vectorIndex: Object.freeze({ ...seed.vectorIndex })
+  };
+  if (seed.fulltextIndex !== void 0) {
+    registration = {
+      ...registration,
+      fulltextIndex: Object.freeze({
+        ...seed.fulltextIndex,
+        properties: Object.freeze([...seed.fulltextIndex.properties])
+      })
+    };
+  }
+  return Object.freeze(registration);
+}
+function validateManagedResources(resources) {
+  const labels = Object.values(resources.labels);
+  for (const label of labels) assertName(label, "Neo4j managed label");
+  if (new Set(labels).size !== labels.length)
+    throw new TypeError("Managed Neo4j graph labels must be distinct.");
+  const indexes = [resources.indexes.chunks.vector, resources.indexes.entities.vector];
+  for (const index of indexes) validateVectorIndex(index);
+  const names = [
+    ...indexes.map((index) => index.name),
+    resources.indexes.chunks.fulltext?.name,
+    resources.indexes.entities.fulltext?.name
+  ].filter((name) => name !== void 0);
+  if (new Set(names).size !== names.length)
+    throw new TypeError("Managed Neo4j index names must be unique.");
+  if (resources.indexes.entities.fulltext !== void 0) {
+    const properties = resources.indexes.entities.fulltext.properties ?? [];
+    if (properties.length === 0)
+      throw new TypeError("Entity full-text indexes require explicit properties.");
+  }
+  if (resources.indexes.chunks.fulltext !== void 0) {
+    validateFulltextIndex(
+      { ...resources.indexes.chunks.fulltext, properties: ["__anvia_text"] },
+      "Chunk full-text index",
+      true
+    );
+  }
+  if (resources.indexes.entities.fulltext !== void 0) {
+    validateFulltextIndex(
+      {
+        ...resources.indexes.entities.fulltext,
+        properties: resources.indexes.entities.fulltext.properties ?? []
+      },
+      "Entity full-text index"
+    );
+  }
+  const copyFulltext = (fulltext) => {
+    let copy = { ...fulltext };
+    if (fulltext.properties !== void 0) {
+      copy = { ...copy, properties: Object.freeze([...fulltext.properties]) };
+    }
+    return Object.freeze(copy);
+  };
+  let chunks = Object.freeze({
+    vector: Object.freeze({ ...resources.indexes.chunks.vector })
+  });
+  if (resources.indexes.chunks.fulltext !== void 0) {
+    chunks = Object.freeze({
+      ...chunks,
+      fulltext: copyFulltext(resources.indexes.chunks.fulltext)
+    });
+  }
+  let entities = Object.freeze({
+    vector: Object.freeze({ ...resources.indexes.entities.vector })
+  });
+  if (resources.indexes.entities.fulltext !== void 0) {
+    entities = Object.freeze({
+      ...entities,
+      fulltext: copyFulltext(resources.indexes.entities.fulltext)
+    });
+  }
+  return Object.freeze({
+    labels: Object.freeze({ ...resources.labels }),
+    indexes: Object.freeze({
+      chunks,
+      entities
+    })
+  });
+}
+function validateVectorIndex(index) {
+  assertName(index.name, "Neo4j vector index name");
+  positiveInteger(index.dimensions, "Neo4j vector dimensions", 4096);
+  if (index.similarity !== "cosine" && index.similarity !== "euclidean") {
+    throw new TypeError("Neo4j vector similarity must be cosine or euclidean.");
+  }
+}
+function validateFulltextIndex(index, label, allowReservedProperties = false) {
+  assertName(index.name, `${label} name`);
+  if (index.properties.length === 0 || new Set(index.properties).size !== index.properties.length) {
+    throw new TypeError(`${label} requires unique properties.`);
+  }
+  for (const property of index.properties) {
+    if (allowReservedProperties) assertName(property, `${label} property`);
+    else assertPropertyName(property);
+  }
+}
+function expectedIndexes(seeds) {
+  const expected = /* @__PURE__ */ new Map();
+  const register = (index) => {
+    const previous = expected.get(index.name);
+    if (previous !== void 0 && stableObject(previous) !== stableObject(index)) {
+      throw new TypeError(`Neo4j index ${index.name} has conflicting registrations.`);
+    }
+    expected.set(index.name, index);
+  };
+  for (const seed of Object.values(seeds)) {
+    register({
+      kind: "vector",
+      name: seed.vectorIndex.name,
+      labels: seed.labels,
+      properties: [seed.vectorIndex.property],
+      dimensions: seed.vectorIndex.dimensions,
+      similarity: seed.vectorIndex.similarity
+    });
+    if (seed.fulltextIndex !== void 0) {
+      register({
+        kind: "fulltext",
+        name: seed.fulltextIndex.name,
+        labels: seed.labels,
+        properties: seed.fulltextIndex.properties
+      });
+    }
+  }
+  return expected;
+}
+function validateIndexRecord(record, expected) {
+  const state = requiredString(record.get("state"), `Neo4j index ${expected.name} state`);
+  if (state !== "ONLINE") throw new Error(`Neo4j index ${expected.name} is ${state}, not ONLINE.`);
+  const type = requiredString(record.get("type"), `Neo4j index ${expected.name} type`);
+  const entityType = requiredString(
+    record.get("entityType"),
+    `Neo4j index ${expected.name} entity type`
+  );
+  const labels = requiredStringArray(
+    record.get("labelsOrTypes"),
+    `Neo4j index ${expected.name} labels`
+  );
+  const properties = requiredStringArray(
+    record.get("properties"),
+    `Neo4j index ${expected.name} properties`
+  );
+  if (entityType !== "NODE" || type !== expected.kind.toUpperCase() || !sameStrings(labels, expected.labels) || !sameStrings(properties, expected.properties)) {
+    throw new Error(`Neo4j index ${expected.name} does not match its registration.`);
+  }
+  if (expected.kind === "vector") {
+    const options = requiredObject(record.get("options"), `Neo4j index ${expected.name} options`);
+    const config = requiredObject(
+      options.indexConfig,
+      `Neo4j index ${expected.name} vector configuration`
+    );
+    const dimensions = requiredSafeInteger(
+      config["vector.dimensions"],
+      `Neo4j index ${expected.name} dimensions`
+    );
+    const similarity = requiredString(
+      config["vector.similarity_function"],
+      `Neo4j index ${expected.name} similarity`
+    ).toLowerCase();
+    if (dimensions !== expected.dimensions || similarity !== expected.similarity) {
+      throw new Error(`Neo4j index ${expected.name} has incompatible vector configuration.`);
+    }
+  }
+}
+function validateConstraintRecord(record, expected) {
+  const type = requiredString(record.get("type"), `Neo4j constraint ${expected.name} type`);
+  const entityType = requiredString(
+    record.get("entityType"),
+    `Neo4j constraint ${expected.name} entity type`
+  );
+  const labels = requiredStringArray(
+    record.get("labelsOrTypes"),
+    `Neo4j constraint ${expected.name} labels`
+  );
+  const properties = requiredStringArray(
+    record.get("properties"),
+    `Neo4j constraint ${expected.name} properties`
+  );
+  if (entityType !== "NODE" || type !== "UNIQUENESS" || !sameStrings(labels, [expected.label]) || !sameStrings(properties, expected.properties)) {
+    throw new Error(`Neo4j constraint ${expected.name} does not match its registration.`);
+  }
+}
+function requiredObject(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`${label} must be an object.`);
+  }
+  return value;
+}
+function requiredStringArray(value, label) {
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+    throw new TypeError(`${label} must be a string array.`);
+  }
+  return [...value];
+}
+function requiredSafeInteger(value, label) {
+  if (isInt2(value)) {
+    if (!value.inSafeRange()) throw new TypeError(`${label} must be a safe integer.`);
+    return value.toNumber();
+  }
+  if (!Number.isSafeInteger(value)) throw new TypeError(`${label} must be a safe integer.`);
+  return value;
+}
+function sameStrings(left, right) {
+  if (left.length !== right.length) return false;
+  const sortedLeft = [...left].sort();
+  const sortedRight = [...right].sort();
+  return sortedLeft.every((value, index) => value === sortedRight[index]);
+}
+function supportedVersion(value) {
+  const match = /^(\d{4})\.(\d+)/.exec(value);
+  if (match === null) return false;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  return year > 2026 || year === 2026 && month >= 1;
+}
+function constraintName(graph, resource) {
+  return `anvia_${graph}_${resource}_identity`;
+}
+function uniquenessConstraint(name, label, properties) {
+  const expression = properties.length === 1 ? `n.${quoteIdentifier(properties[0])}` : `(${properties.map((property) => `n.${quoteIdentifier(property)}`).join(", ")})`;
+  return `CREATE CONSTRAINT ${quoteIdentifier(name)} IF NOT EXISTS FOR (n:${quoteIdentifier(label)}) REQUIRE ${expression} IS UNIQUE`;
+}
+function vectorIndex(index, label) {
+  return `CREATE VECTOR INDEX ${quoteIdentifier(index.name)} IF NOT EXISTS FOR (n:${quoteIdentifier(label)}) ON (n.${quoteIdentifier("__anvia_embedding")}) OPTIONS {indexConfig: {\`vector.dimensions\`: ${index.dimensions}, \`vector.similarity_function\`: '${index.similarity}'}}`;
+}
+function fulltextIndex(name, label, properties) {
+  if (properties.length === 0) throw new TypeError(`Full-text index ${name} requires properties.`);
+  return `CREATE FULLTEXT INDEX ${quoteIdentifier(name)} IF NOT EXISTS FOR (n:${quoteIdentifier(label)}) ON EACH [${properties.map((property) => `n.${quoteIdentifier(property)}`).join(", ")}]`;
+}
+function validateReplacement(options, indexes, schema) {
+  if (!Array.isArray(options.documents) || !Array.isArray(options.chunks) || !Array.isArray(options.entities) || !Array.isArray(options.relationships) || !Array.isArray(options.mentions)) {
+    throw new TypeError("Neo4j replacement collections must be arrays.");
+  }
+  if (options.conflict !== "error" && options.conflict !== "overwrite" && options.conflict !== "keep-existing") {
+    throw new TypeError("Neo4j conflict policy must be error, overwrite, or keep-existing.");
+  }
+  validateOrphanPolicy(options.orphanEntities);
+  const documentIds = uniqueIds(
+    options.documents.map((document, index) => {
+      requiredObject(document, `Neo4j document at index ${index}`);
+      return document.id;
+    }),
+    "document"
+  );
+  const documentSet = new Set(documentIds);
+  const chunkIds = uniqueIds(
+    options.chunks.map((chunk, index) => {
+      requiredObject(chunk, `Neo4j chunk at index ${index}`);
+      requiredObject(chunk.document, `Neo4j chunk document at index ${index}`);
+      return chunk.id;
+    }),
+    "chunk"
+  );
+  const chunkSet = new Set(chunkIds);
+  const entityIds = uniqueIds(
+    options.entities.map((entity, index) => {
+      requiredObject(entity, `Neo4j entity at index ${index}`);
+      requiredObject(entity.document, `Neo4j entity document at index ${index}`);
+      return entity.id;
+    }),
+    "entity"
+  );
+  const entitySet = new Set(entityIds);
+  for (const document of options.documents)
+    parseNeo4jProperties(document.properties ?? {}, `document ${document.id}`);
+  const chunkPositions = /* @__PURE__ */ new Set();
+  for (const chunk of options.chunks) {
+    if (!documentSet.has(chunk.document.documentId))
+      throw new TypeError(`Chunk ${chunk.id} references an unknown document.`);
+    if (chunk.document.id !== chunk.id)
+      throw new TypeError(`Embedded chunk ${chunk.id} has a mismatched document id.`);
+    if (!Number.isSafeInteger(chunk.document.index) || chunk.document.index < 0) {
+      throw new TypeError(`Chunk ${chunk.id} index must be a non-negative safe integer.`);
+    }
+    if (typeof chunk.document.text !== "string") {
+      throw new TypeError(`Chunk ${chunk.id} text must be a string.`);
+    }
+    const position = `${chunk.document.documentId}\0${chunk.document.index}`;
+    if (chunkPositions.has(position)) {
+      throw new TypeError(
+        `Document ${chunk.document.documentId} contains duplicate chunk index ${chunk.document.index}.`
+      );
+    }
+    chunkPositions.add(position);
+    singleEmbedding(chunk.embeddings, indexes.chunks.vector.dimensions, `chunk ${chunk.id}`);
+    parseNeo4jProperties(chunk.document.metadata ?? {}, `chunk ${chunk.id} metadata`);
+  }
+  const entityTypes = /* @__PURE__ */ new Map();
+  const entitySourceChunks = /* @__PURE__ */ new Map();
+  for (const entity of options.entities) {
+    if (entity.document.key !== entity.id)
+      throw new TypeError(`Embedded entity ${entity.id} has a mismatched key.`);
+    singleEmbedding(entity.embeddings, indexes.entities.vector.dimensions, `entity ${entity.id}`);
+    const type = entity.document.type;
+    if (typeof type !== "string") throw new TypeError(`Entity ${entity.id} type must be a string.`);
+    const definition = schema.nodes[type];
+    if (definition === void 0)
+      throw new TypeError(`Entity ${entity.id} has unknown type ${type}.`);
+    const properties = parseExactSchemaProperties(
+      definition.properties,
+      entity.document.properties,
+      `entity ${entity.id} properties`
+    );
+    const identity = parseIdentity(entity.document.identity, definition.identity, properties, type);
+    const expectedKey = `${type}:${stableObject(identity)}`;
+    if (entity.id !== expectedKey) {
+      throw new TypeError(`Entity ${entity.id} does not match its canonical identity key.`);
+    }
+    const sourceChunkIds = validateSourceChunkIds(
+      entity.document.sourceChunkIds,
+      chunkSet,
+      `entity ${entity.id}`
+    );
+    entityTypes.set(entity.id, type);
+    entitySourceChunks.set(entity.id, new Set(sourceChunkIds));
+  }
+  uniqueIds(
+    options.relationships.map((relationship, index) => {
+      requiredObject(relationship, `Neo4j relationship at index ${index}`);
+      return relationship.key;
+    }),
+    "relationship"
+  );
+  for (const relationship of options.relationships) {
+    const definition = schema.relationships[relationship.type];
+    if (definition === void 0) {
+      throw new TypeError(
+        `Relationship ${relationship.key} has unknown type ${relationship.type}.`
+      );
+    }
+    if (!entitySet.has(relationship.from) || !entitySet.has(relationship.to)) {
+      throw new TypeError(`Relationship ${relationship.key} references an unknown entity.`);
+    }
+    if (entityTypes.get(relationship.from) !== definition.from || entityTypes.get(relationship.to) !== definition.to) {
+      throw new TypeError(`Relationship ${relationship.key} has incompatible endpoint types.`);
+    }
+    const properties = parseExactSchemaProperties(
+      definition.properties,
+      relationship.properties,
+      `relationship ${relationship.key} properties`
+    );
+    const identity = identityFromProperties(
+      definition.identity ?? [],
+      properties,
+      relationship.type
+    );
+    const expectedKey = `${relationship.type}:${relationship.from}->${relationship.to}:${stableObject(identity)}`;
+    if (relationship.key !== expectedKey) {
+      throw new TypeError(`Relationship ${relationship.key} does not match its canonical key.`);
+    }
+    const sourceChunkIds = validateSourceChunkIds(
+      relationship.sourceChunkIds,
+      chunkSet,
+      `relationship ${relationship.key}`
+    );
+    const fromSources = entitySourceChunks.get(relationship.from);
+    const toSources = entitySourceChunks.get(relationship.to);
+    if (fromSources === void 0 || toSources === void 0 || sourceChunkIds.some((chunkId) => !fromSources.has(chunkId) || !toSources.has(chunkId))) {
+      throw new TypeError(
+        `Relationship ${relationship.key} source chunks must support both endpoint entities.`
+      );
+    }
+  }
+  const mentionKeys = /* @__PURE__ */ new Set();
+  const mentionChunksByEntity = /* @__PURE__ */ new Map();
+  for (const [index, mention] of options.mentions.entries()) {
+    requiredObject(mention, `Neo4j mention at index ${index}`);
+    if (!chunkSet.has(mention.chunkId) || !entitySet.has(mention.entityKey)) {
+      throw new TypeError(`Mention at index ${index} references an unknown chunk or entity.`);
+    }
+    const key = `${mention.chunkId}\0${mention.entityKey}`;
+    if (mentionKeys.has(key)) throw new TypeError(`Duplicate Neo4j mention at index ${index}.`);
+    mentionKeys.add(key);
+    const chunks = mentionChunksByEntity.get(mention.entityKey);
+    if (chunks === void 0)
+      mentionChunksByEntity.set(mention.entityKey, /* @__PURE__ */ new Set([mention.chunkId]));
+    else chunks.add(mention.chunkId);
+  }
+  for (const entityId of entityIds) {
+    const sources = Array.from(entitySourceChunks.get(entityId) ?? []);
+    const mentions = Array.from(mentionChunksByEntity.get(entityId) ?? []);
+    if (!sameStrings(sources, mentions)) {
+      throw new TypeError(`Entity ${entityId} source chunks must exactly match its mentions.`);
+    }
+  }
+}
+function parseExactSchemaProperties(schema, value, label) {
+  const input = parseNeo4jProperties(value, label);
+  const result = schema.safeParse(value);
+  if (!result.success) throw new TypeError(`${label} does not match the graph schema.`);
+  const output = parseNeo4jProperties(result.data, `${label} output`);
+  if (stableObject(input) !== stableObject(output)) {
+    throw new TypeError(`${label} must not be coerced, defaulted, transformed, or stripped.`);
+  }
+  return input;
+}
+function parseIdentity(value, keys, properties, type) {
+  const identity = identityFromProperties(
+    keys,
+    parseNeo4jProperties(value, `${type} identity`),
+    type
+  );
+  if (!sameStrings(Object.keys(identity), keys)) {
+    throw new TypeError(`Entity ${type} identity must contain exactly its declared properties.`);
+  }
+  for (const key of keys) {
+    if (identity[key] !== properties[key]) {
+      throw new TypeError(`Entity ${type} identity property ${key} does not match its properties.`);
+    }
+  }
+  return identity;
+}
+function identityFromProperties(keys, properties, type) {
+  const identity = {};
+  for (const key of keys) {
+    const value = properties[key];
+    if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+      throw new TypeError(`Identity property ${key} for ${type} must be a primitive value.`);
+    }
+    identity[key] = value;
+  }
+  return identity;
+}
+function validateSourceChunkIds(value, chunkIds, label) {
+  const ids = uniqueIds(value, `${label} source chunk`);
+  if (ids.length === 0) throw new TypeError(`${label} requires source chunk provenance.`);
+  for (const id of ids) {
+    if (!chunkIds.has(id)) throw new TypeError(`${label} references unknown source chunk ${id}.`);
+  }
+  return ids;
+}
+function validateOrphanPolicy(value) {
+  if (value !== "delete" && value !== "keep") {
+    throw new TypeError("Neo4j orphan entity policy must be delete or keep.");
+  }
+}
+function singleEmbedding(embeddings, dimensions, label) {
+  if (!Array.isArray(embeddings)) throw new TypeError(`${label} embeddings must be an array.`);
+  if (embeddings.length !== 1) throw new TypeError(`${label} requires exactly one embedding.`);
+  const vector = embeddings[0]?.vector;
+  if (vector === void 0 || vector.length !== dimensions || !vector.every(Number.isFinite)) {
+    throw new TypeError(`${label} has an invalid ${dimensions}-dimension embedding.`);
+  }
+  return vector;
+}
+function uniqueIds(ids, label) {
+  if (!Array.isArray(ids)) throw new TypeError(`Neo4j ${label} ids must be an array.`);
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (typeof id !== "string" || id.length === 0)
+      throw new TypeError(`Neo4j ${label} ids must be non-empty strings.`);
+    if (seen.has(id)) throw new TypeError(`Duplicate Neo4j ${label} id: ${id}`);
+    seen.add(id);
+  }
+  return [...seen];
+}
+function replacementSnapshotTargets(options) {
+  return {
+    documentIds: options.documents.map((document) => document.id),
+    chunkIds: options.chunks.map((chunk) => chunk.id),
+    entityKeys: options.entities.map((entity) => entity.id),
+    relationshipKeys: options.relationships.map((relationship) => relationship.key),
+    mentions: options.mentions
+  };
+}
+function emptySnapshotTargets(documentIds) {
+  return {
+    documentIds,
+    chunkIds: [],
+    entityKeys: [],
+    relationshipKeys: [],
+    mentions: []
+  };
+}
+function expandSnapshotTargets(targets, snapshot) {
+  const mentions = new Map(
+    targets.mentions.map((mention) => [mentionKey(mention.chunkId, mention.entityKey), mention])
+  );
+  for (const key of snapshot.mentions.keys()) {
+    const separator = key.indexOf("\0");
+    if (separator < 0) throw new TypeError("Stored Neo4j mention has an invalid identity.");
+    mentions.set(key, { chunkId: key.slice(0, separator), entityKey: key.slice(separator + 1) });
+  }
+  return {
+    documentIds: targets.documentIds,
+    chunkIds: [.../* @__PURE__ */ new Set([...targets.chunkIds, ...snapshot.chunks.keys()])],
+    entityKeys: [.../* @__PURE__ */ new Set([...targets.entityKeys, ...snapshot.entities.keys()])],
+    relationshipKeys: [.../* @__PURE__ */ new Set([...targets.relationshipKeys, ...snapshot.relationships.keys()])],
+    mentions: [...mentions.values()]
+  };
+}
+async function snapshotGraphState(transaction, graphName, labels, targets) {
+  const documentsResult = await transaction.run(
+    `MATCH (d:${quoteIdentifier(labels.document)})
+WHERE d.${quoteIdentifier("__anvia_id")} IN $documentIds
+RETURN d.${quoteIdentifier("__anvia_id")} AS key, properties(d) AS properties`,
+    { documentIds: targets.documentIds }
+  );
+  const chunksResult = await transaction.run(
+    `MATCH (c:${quoteIdentifier(labels.chunk)})
+OPTIONAL MATCH (d:${quoteIdentifier(labels.document)})-[:${quoteIdentifier("ANVIA_HAS_CHUNK")}]->(c)
+WITH c, d WHERE c.${quoteIdentifier("__anvia_id")} IN $chunkIds OR d.${quoteIdentifier("__anvia_id")} IN $documentIds
+RETURN c.${quoteIdentifier("__anvia_id")} AS key, properties(c) AS properties`,
+    { chunkIds: targets.chunkIds, documentIds: targets.documentIds }
+  );
+  const entitiesResult = await transaction.run(
+    `MATCH (e:${quoteIdentifier(labels.entity)})
+WHERE e.${quoteIdentifier("__anvia_graph")} = $graph AND (
+  e.${quoteIdentifier("__anvia_key")} IN $entityKeys OR
+  any(id IN coalesce(e.${quoteIdentifier("__anvia_source_document_ids")}, []) WHERE id IN $documentIds)
+)
+RETURN e.${quoteIdentifier("__anvia_key")} AS key, labels(e) AS labels, properties(e) AS properties`,
+    { graph: graphName, entityKeys: targets.entityKeys, documentIds: targets.documentIds }
+  );
+  const relationshipsResult = await transaction.run(
+    `MATCH ()-[r]->()
+WHERE r.${quoteIdentifier("__anvia_graph")} = $graph AND (
+  r.${quoteIdentifier("__anvia_key")} IN $relationshipKeys OR
+  any(id IN coalesce(r.${quoteIdentifier("__anvia_source_document_ids")}, []) WHERE id IN $documentIds)
+)
+RETURN r.${quoteIdentifier("__anvia_key")} AS key,
+       type(r) AS type,
+       startNode(r).${quoteIdentifier("__anvia_key")} AS source,
+       endNode(r).${quoteIdentifier("__anvia_key")} AS target,
+       properties(r) AS properties`,
+    {
+      graph: graphName,
+      relationshipKeys: targets.relationshipKeys,
+      documentIds: targets.documentIds
+    }
+  );
+  const mentionsResult = await transaction.run(
+    `MATCH (c:${quoteIdentifier(labels.chunk)})-[:${quoteIdentifier("ANVIA_MENTIONS")}]->(e:${quoteIdentifier(labels.entity)})
+OPTIONAL MATCH (d:${quoteIdentifier(labels.document)})-[:${quoteIdentifier("ANVIA_HAS_CHUNK")}]->(c)
+WITH c, e, d WHERE d.${quoteIdentifier("__anvia_id")} IN $documentIds OR
+  any(item IN $mentions WHERE item.chunkId = c.${quoteIdentifier("__anvia_id")} AND item.entityKey = e.${quoteIdentifier("__anvia_key")})
+RETURN c.${quoteIdentifier("__anvia_id")} AS chunkId, e.${quoteIdentifier("__anvia_key")} AS entityKey`,
+    { documentIds: targets.documentIds, mentions: targets.mentions }
+  );
+  return {
+    documents: snapshotProperties(documentsResult.records, "document"),
+    chunks: snapshotProperties(chunksResult.records, "chunk"),
+    entities: snapshotProperties(entitiesResult.records, "entity", true),
+    relationships: snapshotRelationships(relationshipsResult.records),
+    mentions: snapshotMentions(mentionsResult.records)
+  };
+}
+function snapshotProperties(records, resource, includeLabels = false) {
+  const output = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const key = requiredString(record.get("key"), `Neo4j ${resource} snapshot key`);
+    if (output.has(key))
+      throw new TypeError(`Neo4j ${resource} snapshot contains duplicate ${key}.`);
+    const properties = normalizedSnapshotProperties(
+      record.get("properties"),
+      `Neo4j ${resource} snapshot`
+    );
+    const labels = includeLabels ? requiredStringArray(record.get("labels"), `Neo4j ${resource} snapshot labels`).sort() : [];
+    output.set(key, stableObject({ labels: labels.join("\0"), properties }));
+  }
+  return output;
+}
+function snapshotRelationships(records) {
+  const output = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const key = requiredString(record.get("key"), "Neo4j relationship snapshot key");
+    if (output.has(key))
+      throw new TypeError(`Neo4j relationship snapshot contains duplicate ${key}.`);
+    output.set(
+      key,
+      stableObject({
+        source: requiredString(record.get("source"), "Neo4j relationship snapshot source"),
+        target: requiredString(record.get("target"), "Neo4j relationship snapshot target"),
+        type: requiredString(record.get("type"), "Neo4j relationship snapshot type"),
+        properties: normalizedSnapshotProperties(
+          record.get("properties"),
+          "Neo4j relationship snapshot"
+        )
+      })
+    );
+  }
+  return output;
+}
+function snapshotMentions(records) {
+  const output = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const key = mentionKey(
+      requiredString(record.get("chunkId"), "Neo4j mention chunk id"),
+      requiredString(record.get("entityKey"), "Neo4j mention entity key")
+    );
+    if (output.has(key)) throw new TypeError(`Neo4j mention snapshot contains duplicate ${key}.`);
+    output.set(key, key);
+  }
+  return output;
+}
+function normalizedSnapshotProperties(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`${label} properties must be an object.`);
+  }
+  const normalized = {};
+  for (const [key, item] of Object.entries(value)) {
+    normalized[key] = parseNeo4jPropertyValue(
+      normalizeSnapshotDriverValue(item, `${label}.${key}`),
+      `${label}.${key}`
+    );
+  }
+  for (const property of ["__anvia_source_document_ids", "__anvia_source_chunk_ids"]) {
+    const items = normalized[property];
+    if (items !== void 0) {
+      if (!Array.isArray(items) || !items.every((item) => typeof item === "string")) {
+        throw new TypeError(`${label}.${property} must be a string array.`);
+      }
+      normalized[property] = [...new Set(items)].sort();
+    }
+  }
+  return stableObject(normalized);
+}
+function normalizeSnapshotDriverValue(value, label) {
+  if (isInt2(value)) {
+    if (!value.inSafeRange()) throw new TypeError(`${label} contains an unsafe Neo4j integer.`);
+    return value.toNumber();
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => normalizeSnapshotDriverValue(item, `${label}[${index}]`));
+  }
+  return value;
+}
+function mentionKey(chunkId, entityKey) {
+  return `${chunkId}\0${entityKey}`;
+}
+function diffGraphSnapshots(before, after) {
+  return {
+    documents: diffSnapshotMaps(before.documents, after.documents),
+    chunks: diffSnapshotMaps(before.chunks, after.chunks),
+    entities: diffSnapshotMaps(before.entities, after.entities),
+    relationships: diffSnapshotMaps(before.relationships, after.relationships),
+    mentions: diffSnapshotMaps(before.mentions, after.mentions)
+  };
+}
+function diffSnapshotMaps(before, after) {
+  let created = 0;
+  let updated = 0;
+  let deleted = 0;
+  let unchanged = 0;
+  for (const key of /* @__PURE__ */ new Set([...before.keys(), ...after.keys()])) {
+    const previous = before.get(key);
+    const next = after.get(key);
+    if (previous === void 0) created += 1;
+    else if (next === void 0) deleted += 1;
+    else if (previous === next) unchanged += 1;
+    else updated += 1;
+  }
+  return { created, updated, deleted, unchanged };
+}
+function emptyWriteResult() {
+  const empty = () => ({ created: 0, updated: 0, deleted: 0, unchanged: 0 });
+  return {
+    documents: empty(),
+    chunks: empty(),
+    entities: empty(),
+    relationships: empty(),
+    mentions: empty()
+  };
+}
+async function removeDocuments(transaction, graphName, labels, documentIds, orphanEntities) {
+  const chunks = await transaction.run(
+    `MATCH (d:${quoteIdentifier(labels.document)})-[:${quoteIdentifier("ANVIA_HAS_CHUNK")}]->(c:${quoteIdentifier(labels.chunk)}) WHERE d.${quoteIdentifier("__anvia_id")} IN $documentIds RETURN collect(c.${quoteIdentifier("__anvia_id")}) AS chunkIds`,
+    { documentIds }
+  );
+  const chunkIdsValue = chunks.records[0]?.get("chunkIds");
+  const chunkIds = requiredStringArray(chunkIdsValue, "Neo4j replacement chunk ids");
+  await transaction.run(
+    `MATCH ()-[r]->() WHERE r.${quoteIdentifier("__anvia_graph")} = $graph AND any(id IN r.${quoteIdentifier("__anvia_source_document_ids")} WHERE id IN $documentIds)
+SET r.${quoteIdentifier("__anvia_source_document_ids")} = [id IN r.${quoteIdentifier("__anvia_source_document_ids")} WHERE NOT id IN $documentIds]
+SET r.${quoteIdentifier("__anvia_source_chunk_ids")} = [id IN coalesce(r.${quoteIdentifier("__anvia_source_chunk_ids")}, []) WHERE NOT id IN $chunkIds]
+WITH r WHERE size(r.${quoteIdentifier("__anvia_source_document_ids")}) = 0 DELETE r`,
+    { graph: graphName, documentIds, chunkIds }
+  );
+  await transaction.run(
+    `MATCH (d:${quoteIdentifier(labels.document)}) WHERE d.${quoteIdentifier("__anvia_id")} IN $documentIds
+OPTIONAL MATCH (d)-[:${quoteIdentifier("ANVIA_HAS_CHUNK")}]->(c:${quoteIdentifier(labels.chunk)})
+DETACH DELETE c, d`,
+    { documentIds }
+  );
+  await transaction.run(
+    `MATCH (e:${quoteIdentifier(labels.entity)})
+WHERE e.${quoteIdentifier("__anvia_graph")} = $graph AND
+      any(id IN coalesce(e.${quoteIdentifier("__anvia_source_document_ids")}, []) WHERE id IN $documentIds)
+SET e.${quoteIdentifier("__anvia_source_document_ids")} = [id IN e.${quoteIdentifier("__anvia_source_document_ids")} WHERE NOT id IN $documentIds],
+    e.${quoteIdentifier("__anvia_source_chunk_ids")} = [id IN coalesce(e.${quoteIdentifier("__anvia_source_chunk_ids")}, []) WHERE NOT id IN $chunkIds]
+WITH e WHERE $deleteOrphans AND size(e.${quoteIdentifier("__anvia_source_document_ids")}) = 0
+DETACH DELETE e`,
+    {
+      graph: graphName,
+      documentIds,
+      chunkIds,
+      deleteOrphans: orphanEntities === "delete"
+    }
+  );
+}
+async function writeDocuments(transaction, labels, documents) {
+  await transaction.run(
+    `UNWIND $rows AS row MERGE (d:${quoteIdentifier(labels.document)} {${quoteIdentifier("__anvia_id")}: row.id}) SET d += row.properties`,
+    {
+      rows: documents.map((document) => ({
+        id: document.id,
+        properties: document.properties ?? {}
+      }))
+    }
+  );
+}
+async function writeChunks(transaction, labels, chunks) {
+  const rows = chunks.map((chunk) => ({
+    id: chunk.id,
+    documentId: chunk.document.documentId,
+    index: chunk.document.index,
+    text: chunk.document.text,
+    metadata: chunk.document.metadata ?? {},
+    embedding: chunk.embeddings[0]?.vector
+  }));
+  await transaction.run(
+    `UNWIND $rows AS row
+MATCH (d:${quoteIdentifier(labels.document)} {${quoteIdentifier("__anvia_id")}: row.documentId})
+CREATE (c:${quoteIdentifier(labels.chunk)} {${quoteIdentifier("__anvia_id")}: row.id, ${quoteIdentifier("__anvia_document_id")}: row.documentId, ${quoteIdentifier("__anvia_index")}: row.index, ${quoteIdentifier("__anvia_text")}: row.text, ${quoteIdentifier("__anvia_embedding")}: row.embedding})
+SET c += row.metadata
+CREATE (d)-[:${quoteIdentifier("ANVIA_HAS_CHUNK")}]->(c)`,
+    { rows }
+  );
+  const pairs = [...rows].sort(
+    (left, right) => left.documentId.localeCompare(right.documentId) || left.index - right.index
+  ).flatMap((row, index, all) => {
+    const next = all[index + 1];
+    return next !== void 0 && next.documentId === row.documentId ? [{ from: row.id, to: next.id }] : [];
+  });
+  if (pairs.length > 0) {
+    await transaction.run(
+      `UNWIND $rows AS row MATCH (a:${quoteIdentifier(labels.chunk)} {${quoteIdentifier("__anvia_id")}: row.from}), (b:${quoteIdentifier(labels.chunk)} {${quoteIdentifier("__anvia_id")}: row.to}) CREATE (a)-[:${quoteIdentifier("ANVIA_NEXT_CHUNK")}]->(b)`,
+      { rows: pairs }
+    );
+  }
+}
+async function writeEntities(transaction, graphName, entityLabel, entities, conflict, sourceDocuments) {
+  const grouped = groupBy(entities, (entity) => entity.document.type);
+  for (const [type, values] of grouped) {
+    const rows = values.map((entity) => ({
+      key: entity.id,
+      properties: entity.document.properties,
+      embedding: entity.embeddings[0]?.vector,
+      sourceDocumentIds: sourceDocuments(entity.document.sourceChunkIds),
+      sourceChunkIds: entity.document.sourceChunkIds
+    }));
+    if (conflict === "error") await assertEntityConflicts(transaction, entityLabel, rows);
+    const propertySet = conflictPropertySet("e", conflict);
+    const embedding = entityEmbeddingExpression(conflict);
+    await transaction.run(
+      `UNWIND $rows AS row
+MERGE (e:${quoteIdentifier(entityLabel)}:${quoteIdentifier(type)} {${quoteIdentifier("__anvia_key")}: row.key})
+${propertySet}
+SET e.${quoteIdentifier("__anvia_key")} = row.key,
+    e.${quoteIdentifier("__anvia_graph")} = $graph,
+    e.${quoteIdentifier("__anvia_embedding")} = ${embedding},
+    e.${quoteIdentifier("__anvia_source_document_ids")} = reduce(all = existingDocumentIds, id IN row.sourceDocumentIds | CASE WHEN id IN all THEN all ELSE all + id END),
+    e.${quoteIdentifier("__anvia_source_chunk_ids")} = reduce(all = existingChunkIds, id IN row.sourceChunkIds | CASE WHEN id IN all THEN all ELSE all + id END)`,
+      { rows, graph: graphName }
+    );
+  }
+}
+async function assertEntityConflicts(transaction, entityLabel, rows) {
+  const result = await transaction.run(
+    `UNWIND $keys AS key MATCH (e:${quoteIdentifier(entityLabel)} {${quoteIdentifier("__anvia_key")}: key}) RETURN key, properties(e) AS properties`,
+    { keys: rows.map((row) => row.key) }
+  );
+  const incoming = new Map(rows.map((row) => [row.key, row.properties]));
+  for (const record of result.records) {
+    const key = requiredString(record.get("key"), "Neo4j entity key");
+    const existing = applicationProperties(record.get("properties"));
+    if (stableObject(existing) !== stableObject(incoming.get(key) ?? {})) {
+      throw new Error(`Neo4j entity ${key} conflicts with existing properties.`);
+    }
+  }
+}
+async function writeMentions(transaction, labels, mentions) {
+  if (mentions.length === 0) return;
+  await transaction.run(
+    `UNWIND $rows AS row
+MATCH (c:${quoteIdentifier(labels.chunk)} {${quoteIdentifier("__anvia_id")}: row.chunkId}), (e:${quoteIdentifier(labels.entity)} {${quoteIdentifier("__anvia_key")}: row.entityKey})
+MERGE (c)-[:${quoteIdentifier("ANVIA_MENTIONS")}]->(e)`,
+    { rows: mentions }
+  );
+}
+async function writeRelationships(transaction, graphName, entityLabel, relationships, conflict, sourceDocuments) {
+  const grouped = groupBy(relationships, (relationship) => relationship.type);
+  for (const [type, values] of grouped) {
+    const rows = values.map((relationship) => ({
+      key: relationship.key,
+      from: relationship.from,
+      to: relationship.to,
+      properties: relationship.properties,
+      sourceDocumentIds: sourceDocuments(relationship.sourceChunkIds),
+      sourceChunkIds: relationship.sourceChunkIds
+    }));
+    if (conflict === "error") {
+      const existing = await transaction.run(
+        `UNWIND $keys AS key MATCH ()-[r:${quoteIdentifier(type)} {${quoteIdentifier("__anvia_key")}: key}]->() RETURN key, properties(r) AS properties`,
+        { keys: rows.map((row) => row.key) }
+      );
+      const incoming = new Map(rows.map((row) => [row.key, row.properties]));
+      for (const record of existing.records) {
+        const key = requiredString(record.get("key"), "Neo4j relationship key");
+        if (stableObject(applicationProperties(record.get("properties"))) !== stableObject(incoming.get(key) ?? {})) {
+          throw new Error(`Neo4j relationship ${key} conflicts with existing properties.`);
+        }
+      }
+    }
+    const propertySet = conflictPropertySet("r", conflict);
+    await transaction.run(
+      `UNWIND $rows AS row
+MATCH (a:${quoteIdentifier(entityLabel)} {${quoteIdentifier("__anvia_key")}: row.from}), (b:${quoteIdentifier(entityLabel)} {${quoteIdentifier("__anvia_key")}: row.to})
+MERGE (a)-[r:${quoteIdentifier(type)} {${quoteIdentifier("__anvia_key")}: row.key}]->(b)
+${propertySet}
+SET r.${quoteIdentifier("__anvia_key")} = row.key,
+    r.${quoteIdentifier("__anvia_graph")} = $graph,
+    r.${quoteIdentifier("__anvia_source_document_ids")} = reduce(all = existingDocumentIds, id IN row.sourceDocumentIds | CASE WHEN id IN all THEN all ELSE all + id END),
+    r.${quoteIdentifier("__anvia_source_chunk_ids")} = reduce(all = existingChunkIds, id IN row.sourceChunkIds | CASE WHEN id IN all THEN all ELSE all + id END)`,
+      { rows, graph: graphName }
+    );
+  }
+}
+function conflictPropertySet(variable, conflict) {
+  const sourceDocuments = quoteIdentifier("__anvia_source_document_ids");
+  const sourceChunks = quoteIdentifier("__anvia_source_chunk_ids");
+  const existingSources = `WITH ${variable}, row,
+     coalesce(${variable}.${sourceDocuments}, []) AS existingDocumentIds,
+     coalesce(${variable}.${sourceChunks}, []) AS existingChunkIds`;
+  if (conflict === "keep-existing") {
+    return `ON CREATE SET ${variable} += row.properties
+${existingSources}`;
+  }
+  if (conflict === "overwrite") {
+    return `${existingSources}
+SET ${variable} = row.properties`;
+  }
+  return `${existingSources}
+SET ${variable} += row.properties`;
+}
+function entityEmbeddingExpression(conflict) {
+  if (conflict === "keep-existing") {
+    return `coalesce(e.${quoteIdentifier("__anvia_embedding")}, row.embedding)`;
+  }
+  return "row.embedding";
+}
+function requiredString(value, label) {
+  if (typeof value !== "string") throw new TypeError(`${label} must be a string.`);
+  return value;
+}
+function applicationProperties(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+  return parseNeo4jProperties(
+    Object.fromEntries(Object.entries(value).filter(([key]) => !key.startsWith("__anvia_"))),
+    "stored Neo4j properties"
+  );
+}
+function groupBy(values, keyFor) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const key = keyFor(value);
+    const group = groups.get(key);
+    if (group === void 0) groups.set(key, [value]);
+    else group.push(value);
+  }
+  return groups;
+}
+
+export {
+  defineNeo4jGraphSchema,
+  parseNeo4jProperties,
+  quoteIdentifier,
+  throwIfAborted,
+  positiveInteger,
+  finiteScore,
+  strictProperties,
+  Neo4jKnowledgeGraphBase,
+  Neo4jKnowledgeGraph,
+  ManagedNeo4jKnowledgeGraph
+};
+//# sourceMappingURL=chunk-QNHOT7P2.js.map