@anvia/neo4j 1.0.1 → 1.0.3

package/dist/index.js

@@ -1,1459 +1,17 @@
-// src/client.ts
-import { auth, driver as createDriver } from "neo4j-driver";
-
-// src/graph.ts
 import {
-  isInt as isInt2
-} from "neo4j-driver";
-
-// src/helpers.ts
-import { isInt } from "neo4j-driver";
-
-// 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
-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
-var Neo4jKnowledgeGraphBase = class {
-  constructor(owner, schema) {
-    this.owner = owner;
-    this.schema = schema;
-    if (schema.kind !== "neo4j-graph-schema") {
-      throw new TypeError("Neo4j knowledge graphs require 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)
-    );
-  }
-  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([
-            ...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 properties2 = resources.indexes.entities.fulltext.properties ?? [];
-    if (properties2.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 properties2 = requiredStringArray(
-    record.get("properties"),
-    `Neo4j index ${expected.name} properties`
-  );
-  if (entityType !== "NODE" || type !== expected.kind.toUpperCase() || !sameStrings(labels, expected.labels) || !sameStrings(properties2, 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 properties2 = requiredStringArray(
-    record.get("properties"),
-    `Neo4j constraint ${expected.name} properties`
-  );
-  if (entityType !== "NODE" || type !== "UNIQUENESS" || !sameStrings(labels, [expected.label]) || !sameStrings(properties2, 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, properties2) {
-  const expression = properties2.length === 1 ? `n.${quoteIdentifier(properties2[0])}` : `(${properties2.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, properties2) {
-  if (properties2.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 [${properties2.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 properties2 = parseExactSchemaProperties(
-      definition.properties,
-      entity.document.properties,
-      `entity ${entity.id} properties`
-    );
-    const identity = parseIdentity(entity.document.identity, definition.identity, properties2, 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 properties2 = parseExactSchemaProperties(
-      definition.properties,
-      relationship.properties,
-      `relationship ${relationship.key} properties`
-    );
-    const identity = identityFromProperties(
-      definition.identity ?? [],
-      properties2,
-      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 = [...entitySourceChunks.get(entityId) ?? []];
-    const mentions = [...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, properties2, 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] !== properties2[key]) {
-      throw new TypeError(`Entity ${type} identity property ${key} does not match its properties.`);
-    }
-  }
-  return identity;
-}
-function identityFromProperties(keys, properties2, type) {
-  const identity = {};
-  for (const key of keys) {
-    const value = properties2[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 properties2 = 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: properties2 }));
-  }
-  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, entityKey2) {
-  return `${chunkId}\0${entityKey2}`;
-}
-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 = conflict === "keep-existing" ? `ON CREATE SET e += row.properties
-WITH e, row,
-     coalesce(e.${quoteIdentifier("__anvia_source_document_ids")}, []) AS existingDocumentIds,
-     coalesce(e.${quoteIdentifier("__anvia_source_chunk_ids")}, []) AS existingChunkIds` : `WITH e, row,
-     coalesce(e.${quoteIdentifier("__anvia_source_document_ids")}, []) AS existingDocumentIds,
-     coalesce(e.${quoteIdentifier("__anvia_source_chunk_ids")}, []) AS existingChunkIds
-${conflict === "overwrite" ? "SET e = row.properties" : "SET e += row.properties"}`;
-    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")} = ${conflict === "keep-existing" ? `coalesce(e.${quoteIdentifier("__anvia_embedding")}, row.embedding)` : "row.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 = conflict === "keep-existing" ? `ON CREATE SET r += row.properties
-WITH r, row,
-     coalesce(r.${quoteIdentifier("__anvia_source_document_ids")}, []) AS existingDocumentIds,
-     coalesce(r.${quoteIdentifier("__anvia_source_chunk_ids")}, []) AS existingChunkIds` : `WITH r, row,
-     coalesce(r.${quoteIdentifier("__anvia_source_document_ids")}, []) AS existingDocumentIds,
-     coalesce(r.${quoteIdentifier("__anvia_source_chunk_ids")}, []) AS existingChunkIds
-${conflict === "overwrite" ? "SET r = row.properties" : "SET r += row.properties"}`;
-    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 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;
-}
+  retrieveGraphContext
+} from "./chunk-YLW4LCKJ.js";
+import {
+  exploreGraph
+} from "./chunk-PWE3ETSF.js";
+import {
+  ManagedNeo4jKnowledgeGraph,
+  Neo4jKnowledgeGraph,
+  defineNeo4jGraphSchema
+} from "./chunk-QNHOT7P2.js";
 
 // src/client.ts
+import { auth, driver as createDriver } from "neo4j-driver";
 var Neo4jClient = class {
   driver;
   ownsDriver;
@@ -1504,768 +62,17 @@ var Neo4jClient = class {
 };
 
 // src/extract.ts
-import { Usage } from "@anvia/core";
-import { extract } from "@anvia/core/extractor";
-import { z as z2 } from "zod";
+import { extractGraphFacts as extractSharedGraphFacts, GraphFactConflictError } from "@anvia/graph";
 async function extractGraphFacts(options) {
-  assertConcurrency(options.concurrency);
-  throwIfAborted(options.abortSignal);
-  const ids = /* @__PURE__ */ new Set();
-  for (const chunk of options.chunks) {
-    if (ids.has(chunk.id)) throw new TypeError(`Duplicate graph chunk id: ${chunk.id}`);
-    ids.add(chunk.id);
-    if (typeof chunk.text !== "string")
-      throw new TypeError(`Graph chunk ${chunk.id} text must be a string.`);
-  }
-  const outputSchema = extractionSchema(options.schema);
-  const instructions = graphInstructions(options.schema, options.instructions);
-  const extractions = await mapConcurrent(
-    options.chunks,
-    options.concurrency ?? 1,
-    async (chunk) => {
-      throwIfAborted(options.abortSignal);
-      const result = await extract({
-        model: options.model,
-        text: chunk.text,
-        outputSchema,
-        instructions,
-        retries: options.retries,
-        abortSignal: options.abortSignal
-      });
-      return { chunkId: chunk.id, output: result.output, usage: result.usage };
-    }
-  );
-  return {
-    output: normalizeFacts(options.schema, extractions),
-    usage: extractions.reduce((usage, item) => Usage.add(usage, item.usage), Usage.empty())
-  };
-}
-function extractionSchema(schema) {
-  const entityVariants = Object.entries(schema.nodes).map(
-    ([type, definition]) => z2.object({
-      ref: z2.string().min(1),
-      type: z2.literal(type),
-      properties: definition.properties
-    })
-  );
-  const relationshipVariants = Object.entries(schema.relationships).map(
-    ([type, definition]) => z2.object({
-      type: z2.literal(type),
-      from: z2.string().min(1),
-      to: z2.string().min(1),
-      properties: definition.properties
-    })
-  );
-  const entity = union(entityVariants, z2.never());
-  const relationship = union(relationshipVariants, z2.never());
-  return z2.object({
-    entities: z2.array(entity),
-    relationships: z2.array(relationship)
-  });
-}
-function union(items, empty) {
-  if (items.length === 0) return empty;
-  if (items.length === 1) return items[0];
-  return z2.union(items);
-}
-function graphInstructions(schema, instructions) {
-  const nodes = Object.entries(schema.nodes).map(([type, definition]) => `- ${type}: ${definition.description}`).join("\n");
-  const relationships = Object.entries(schema.relationships).map(
-    ([type, definition]) => `- ${type}: ${definition.from} -> ${definition.to}. ${definition.description}`
-  ).join("\n");
-  return [
-    "Extract only facts directly supported by the source text.",
-    "Give every extracted entity a unique local ref and use those refs as relationship endpoints.",
-    "Do not invent entity or relationship types outside the declared schema.",
-    `Node types:
-${nodes}`,
-    relationships.length === 0 ? "No relationship types are allowed." : `Relationship types:
-${relationships}`,
-    instructions
-  ].filter((part) => part !== void 0 && part.length > 0).join("\n\n");
-}
-function normalizeFacts(schema, extractions) {
-  const entities = /* @__PURE__ */ new Map();
-  const relationships = /* @__PURE__ */ new Map();
-  const mentions = /* @__PURE__ */ new Map();
-  for (const extraction of extractions) {
-    const refs = /* @__PURE__ */ new Map();
-    for (const raw of extraction.output.entities) {
-      if (refs.has(raw.ref))
-        throw new TypeError(`Duplicate entity ref ${raw.ref} in chunk ${extraction.chunkId}.`);
-      const definition = schema.nodes[raw.type];
-      if (definition === void 0) throw new TypeError(`Unknown graph entity type: ${raw.type}`);
-      const properties2 = parseNeo4jProperties(
-        definition.properties.parse(raw.properties),
-        `entity ${raw.type}`
-      );
-      const identity = identityFromProperties2(definition.identity, properties2, raw.type);
-      const key = entityKey(raw.type, identity);
-      const current = entities.get(key);
-      const next = {
-        key,
-        type: raw.type,
-        identity,
-        properties: properties2,
-        sourceChunkIds: [extraction.chunkId]
-      };
-      if (current === void 0) {
-        entities.set(key, next);
-        refs.set(raw.ref, next);
-      } else {
-        assertSameProperties(
-          current.properties,
-          properties2,
-          key,
-          current.sourceChunkIds,
-          extraction.chunkId
-        );
-        const merged = {
-          ...current,
-          sourceChunkIds: [...current.sourceChunkIds, extraction.chunkId]
-        };
-        entities.set(key, merged);
-        refs.set(raw.ref, merged);
-      }
-      mentions.set(`${extraction.chunkId}\0${key}`, {
-        chunkId: extraction.chunkId,
-        entityKey: key
-      });
-    }
-    for (const raw of extraction.output.relationships) {
-      const definition = schema.relationships[raw.type];
-      if (definition === void 0)
-        throw new TypeError(`Unknown graph relationship type: ${raw.type}`);
-      const from = refs.get(raw.from);
-      const to = refs.get(raw.to);
-      if (from === void 0 || to === void 0) {
-        throw new TypeError(
-          `Relationship ${raw.type} in chunk ${extraction.chunkId} references an unknown entity ref.`
-        );
-      }
-      if (from.type !== definition.from || to.type !== definition.to) {
-        throw new TypeError(
-          `Relationship ${raw.type} has invalid endpoint types ${from.type} -> ${to.type}.`
-        );
-      }
-      const properties2 = parseNeo4jProperties(
-        definition.properties.parse(raw.properties),
-        `relationship ${raw.type}`
-      );
-      const identity = identityFromProperties2(definition.identity ?? [], properties2, raw.type);
-      const key = relationshipKey(raw.type, from.key, to.key, identity);
-      const current = relationships.get(key);
-      const next = {
-        key,
-        type: raw.type,
-        from: from.key,
-        to: to.key,
-        properties: properties2,
-        sourceChunkIds: [extraction.chunkId]
-      };
-      if (current === void 0) relationships.set(key, next);
-      else {
-        assertSameProperties(
-          current.properties,
-          properties2,
-          key,
-          current.sourceChunkIds,
-          extraction.chunkId
-        );
-        relationships.set(key, {
-          ...current,
-          sourceChunkIds: [...current.sourceChunkIds, extraction.chunkId]
-        });
-      }
-    }
-  }
-  return {
-    entities: [...entities.values()],
-    relationships: [...relationships.values()],
-    mentions: [...mentions.values()]
-  };
-}
-function identityFromProperties2(keys, properties2, type) {
-  const identity = {};
-  for (const key of keys) {
-    const value = properties2[key];
-    if (value === void 0 || !(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 entityKey(type, identity) {
-  return `${type}:${stableObject2(identity)}`;
-}
-function relationshipKey(type, from, to, identity) {
-  return `${type}:${from}->${to}:${stableObject2(identity)}`;
-}
-function stableObject2(value) {
-  return JSON.stringify(
-    Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)))
-  );
-}
-function assertSameProperties(left, right, key, sourceChunkIds, nextChunkId) {
-  if (stableObject2(left) !== stableObject2(right)) {
-    throw new GraphFactConflictError(key, [...sourceChunkIds, nextChunkId]);
-  }
-}
-var GraphFactConflictError = class extends Error {
-  constructor(factKey, sourceChunkIds) {
-    super(
-      `Conflicting graph fact ${factKey} was extracted from chunks ${sourceChunkIds.join(", ")}.`
-    );
-    this.factKey = factKey;
-    this.sourceChunkIds = sourceChunkIds;
-    this.name = "GraphFactConflictError";
-  }
-  factKey;
-  sourceChunkIds;
-};
-function assertConcurrency(value) {
-  if (value !== void 0 && (!Number.isSafeInteger(value) || value < 1)) {
-    throw new RangeError("Graph extraction concurrency must be a positive safe integer.");
-  }
-}
-async function mapConcurrent(values, concurrency, run) {
-  const output = Array(values.length);
-  let cursor = 0;
-  await Promise.all(
-    Array.from({ length: Math.min(concurrency, values.length) }, async () => {
-      for (; ; ) {
-        const index = cursor;
-        cursor += 1;
-        if (index >= values.length) return;
-        output[index] = await run(values[index]);
-      }
-    })
-  );
-  return output;
-}
-
-// src/retrieve.ts
-import { embedText } from "@anvia/core/embeddings";
-import { int, isInt as isInt3 } from "neo4j-driver";
-async function retrieveGraphContext(options) {
-  if (!(options.graph instanceof Neo4jKnowledgeGraphBase)) {
-    throw new TypeError("retrieveGraphContext requires a Neo4j knowledge graph registration.");
-  }
-  if (typeof options.query !== "string" || options.query.trim().length === 0) {
-    throw new TypeError("Graph retrieval query must be a non-empty string.");
-  }
-  validateSearch(options.search);
-  validateTraversal(options.graph.schema, options.traversal);
-  validateEvidence(options.graph.evidenceCapability, options.evidence);
-  throwIfAborted(options.abortSignal);
-  const graph = options.graph;
-  const selectedSeeds = options.search.seeds.map((name) => ({ name, seed: graph.seed(name) }));
-  const expectedDimensions = selectedSeeds[0]?.seed.vectorIndex.dimensions;
-  if (expectedDimensions === void 0 || selectedSeeds.some((item) => item.seed.vectorIndex.dimensions !== expectedDimensions)) {
-    throw new TypeError("Selected Neo4j graph seeds must use the same vector dimensions.");
-  }
-  if (options.model.dimensions !== void 0 && options.model.dimensions !== expectedDimensions) {
-    throw new TypeError(
-      `Embedding model dimensions ${options.model.dimensions} do not match Neo4j graph dimensions ${expectedDimensions}.`
-    );
-  }
-  if (options.search.type === "hybrid") {
-    for (const { name, seed } of selectedSeeds) {
-      if (seed.fulltextIndex === void 0) {
-        throw new TypeError(`Neo4j graph seed ${name} does not declare a full-text index.`);
-      }
-    }
-  }
-  const { embedding } = await embedText({
-    model: options.model,
-    text: options.query,
-    retries: options.retries,
-    abortSignal: options.abortSignal
-  });
-  if (embedding.vector.length !== expectedDimensions) {
-    throw new TypeError(
-      `Query embedding dimensions ${embedding.vector.length} do not match Neo4j graph dimensions ${expectedDimensions}.`
-    );
-  }
-  const resultLists = [];
-  for (const { seed } of selectedSeeds) {
-    const limit = options.search.type === "hybrid" ? options.search.candidatesPerSeed : options.search.topK;
-    resultLists.push(
-      await vectorSearch(
-        graph,
-        seed.labels,
-        seed.vectorIndex.name,
-        embedding.vector,
-        limit,
-        seed.entryRelationshipType,
-        options.abortSignal
-      )
-    );
-    if (options.search.type === "hybrid") {
-      const fulltextIndex2 = seed.fulltextIndex;
-      if (fulltextIndex2 === void 0) {
-        throw new TypeError("Hybrid Neo4j graph retrieval requires a full-text index.");
-      }
-      resultLists.push(
-        await fulltextSearch(
-          graph,
-          fulltextIndex2.name,
-          options.query,
-          limit,
-          seed.entryRelationshipType,
-          options.abortSignal
-        )
-      );
-    }
-  }
-  const hits = options.search.type === "hybrid" ? fuseResults(resultLists, options.search.topK, options.search.rrfK) : vectorResults(resultLists[0] ?? [], options.search.topK, options.search.minScore);
-  throwIfAborted(options.abortSignal);
-  const seeds = hits.map((hit) => seedFromHit(hit, options.graph.schema));
-  const traversed = hits.length === 0 ? { nodes: [], relationships: [] } : await traverse(graph, hits, options.traversal, options.abortSignal);
-  const context = { seeds, ...traversed };
-  const evidence = await hydrateEvidence(graph, context, options.evidence, options.abortSignal);
-  return { ...context, evidence };
-}
-async function vectorSearch(graph, labels, indexName, vector, limit, entryRelationshipType, abortSignal) {
-  const labelExpression = labels.map(quoteIdentifier).join("|");
-  const result = await graph.query(
-    `CYPHER 25
-MATCH (seed:${labelExpression})
-SEARCH seed IN (VECTOR INDEX ${quoteIdentifier(indexName)} FOR $vector LIMIT $limit) SCORE AS score
-RETURN elementId(seed) AS elementId, labels(seed) AS labels, properties(seed) AS properties, score`,
-    { vector, limit: int(limit) },
-    abortSignal
-  );
-  return result.records.map((record) => ({ ...parseSearchHit(record), entryRelationshipType }));
-}
-async function fulltextSearch(graph, indexName, query, limit, entryRelationshipType, abortSignal) {
-  const result = await graph.query(
-    `CALL db.index.fulltext.queryNodes($indexName, $query, {limit: $limit}) YIELD node AS seed, score
-RETURN elementId(seed) AS elementId, labels(seed) AS labels, properties(seed) AS properties, score`,
-    { indexName, query: escapeLucene(query), limit: int(limit) },
-    abortSignal
-  );
-  return result.records.map((record) => ({ ...parseSearchHit(record), entryRelationshipType }));
-}
-function parseSearchHit(record) {
-  const elementId = record.get("elementId");
-  const labels = record.get("labels");
-  const properties2 = record.get("properties");
-  const score = record.get("score");
-  if (typeof elementId !== "string" || !Array.isArray(labels) || !labels.every((label) => typeof label === "string") || typeof properties2 !== "object" || properties2 === null || typeof score !== "number" || !Number.isFinite(score)) {
-    throw new TypeError("Neo4j search returned a malformed result.");
-  }
-  return { elementId, labels, properties: properties2, score };
-}
-function seedFromHit(hit, schema) {
-  const application = applicationProperties2(hit.properties, "Neo4j search seed");
-  const key = stringProperty(hit.properties, "__anvia_key") ?? stringProperty(hit.properties, "__anvia_id") ?? hit.elementId;
-  const type = hit.labels.find((label) => label in schema.nodes) ?? hit.labels[0] ?? "Node";
-  return {
-    key,
-    type,
-    score: hit.score,
-    properties: application,
-    sourceChunkIds: hit.entryRelationshipType === "ANVIA_MENTIONS" ? [key] : stringArrayProperty(hit.properties, "__anvia_source_chunk_ids")
-  };
-}
-async function hydrateEvidence(graph, context, options, abortSignal) {
-  if (options.type === "none") return [];
-  if (!(graph instanceof ManagedNeo4jKnowledgeGraph)) {
-    throw new TypeError("Chunk evidence requires a managed Neo4j knowledge graph.");
-  }
-  const chunkIds = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const sourceChunkIds of [
-    ...context.seeds.map((seed) => seed.sourceChunkIds),
-    ...context.nodes.map((node) => node.sourceChunkIds),
-    ...context.relationships.map((relationship) => relationship.sourceChunkIds)
-  ]) {
-    for (const chunkId of sourceChunkIds) {
-      if (seen.has(chunkId)) continue;
-      seen.add(chunkId);
-      chunkIds.push(chunkId);
-      if (chunkIds.length === options.maxChunks) break;
-    }
-    if (chunkIds.length === options.maxChunks) break;
-  }
-  if (chunkIds.length === 0) return [];
-  throwIfAborted(abortSignal);
-  const result = await graph.query(
-    `MATCH (d:${quoteIdentifier(graph.resources.labels.document)})-[:${quoteIdentifier("ANVIA_HAS_CHUNK")}]->(c:${quoteIdentifier(graph.resources.labels.chunk)})
-WHERE c.${quoteIdentifier("__anvia_id")} IN $chunkIds
-RETURN c.${quoteIdentifier("__anvia_id")} AS chunkId,
-       d.${quoteIdentifier("__anvia_id")} AS documentId,
-       c.${quoteIdentifier("__anvia_index")} AS index,
-       c.${quoteIdentifier("__anvia_text")} AS text,
-       properties(c) AS properties`,
-    { chunkIds },
-    abortSignal
-  );
-  const byId = /* @__PURE__ */ new Map();
-  for (const record of result.records) {
-    const evidence = evidenceFromRecord(record);
-    if (byId.has(evidence.chunkId)) {
-      throw new TypeError(`Neo4j evidence returned duplicate chunk ${evidence.chunkId}.`);
-    }
-    byId.set(evidence.chunkId, evidence);
-  }
-  return chunkIds.map((chunkId) => {
-    const evidence = byId.get(chunkId);
-    if (evidence === void 0) {
-      throw new Error(`Neo4j graph evidence references missing chunk ${chunkId}.`);
-    }
-    return evidence;
-  });
-}
-function evidenceFromRecord(record) {
-  const chunkId = stringValue(record.get("chunkId"), "Neo4j evidence chunk id");
-  const documentId = stringValue(record.get("documentId"), "Neo4j evidence document id");
-  const index = safeIntegerValue(record.get("index"), "Neo4j evidence chunk index");
-  const text = stringValue(record.get("text"), "Neo4j evidence text");
-  const raw = record.get("properties");
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    throw new TypeError("Neo4j evidence properties must be an object.");
-  }
-  return {
-    chunkId,
-    documentId,
-    index,
-    text,
-    metadata: applicationProperties2(raw, "Neo4j evidence metadata")
-  };
-}
-function safeIntegerValue(value, label) {
-  const number = isInt3(value) ? value.inSafeRange() ? value.toNumber() : void 0 : value;
-  if (typeof number !== "number" || !Number.isSafeInteger(number)) {
-    throw new TypeError(`${label} must be a safe integer.`);
-  }
-  return number;
-}
-function vectorResults(results, topK, minScore) {
-  return results.filter((item) => minScore === void 0 || item.score >= minScore).slice(0, topK);
-}
-async function traverse(graph, seeds, options, abortSignal) {
-  const traversalSeedIds = new Set(
-    seeds.filter((seed) => seed.entryRelationshipType === void 0).map((seed) => seed.elementId)
-  );
-  const entryGroups = groupBy2(
-    seeds.filter(
-      (seed) => seed.entryRelationshipType !== void 0
-    ),
-    (seed) => seed.entryRelationshipType
-  );
-  for (const [relationshipType, group] of entryGroups) {
-    const entries = await graph.query(
-      `MATCH (seed) WHERE elementId(seed) IN $seedIds
-MATCH (seed)-[:${quoteIdentifier(relationshipType)}]->(entry)
-RETURN DISTINCT elementId(entry) AS elementId`,
-      { seedIds: group.map((seed) => seed.elementId) },
-      abortSignal
-    );
-    for (const record of entries.records) {
-      traversalSeedIds.add(stringValue(record.get("elementId"), "Neo4j entry elementId"));
-    }
-  }
-  if (traversalSeedIds.size === 0) return { nodes: [], relationships: [] };
-  const limitedSeedIds = [...traversalSeedIds].slice(0, options.maxNodes);
-  const pattern = options.direction === "outgoing" ? `(seed)-[*1..${options.maxDepth}]->(node)` : options.direction === "incoming" ? `(seed)<-[*1..${options.maxDepth}]-(node)` : `(seed)-[*1..${options.maxDepth}]-(node)`;
-  const pathLimit = Math.max(options.maxNodes, options.maxRelationships);
-  const seedNodes = await graph.query(
-    `MATCH (node) WHERE elementId(node) IN $seedIds
-RETURN {elementId: elementId(node), labels: labels(node), properties: properties(node)} AS node`,
-    { seedIds: limitedSeedIds },
-    abortSignal
-  );
-  const result = await graph.query(
-    `MATCH (seed) WHERE elementId(seed) IN $seedIds
-MATCH path = ${pattern}
-WHERE all(rel IN relationships(path) WHERE type(rel) IN $relationshipTypes)
-RETURN [item IN nodes(path) | {elementId: elementId(item), labels: labels(item), properties: properties(item)}] AS nodes,
-       [item IN relationships(path) | {elementId: elementId(item), type: type(item), properties: properties(item), from: elementId(startNode(item)), to: elementId(endNode(item))}] AS relationships
-LIMIT $pathLimit`,
-    {
-      seedIds: limitedSeedIds,
-      relationshipTypes: options.relationships,
-      pathLimit: int(pathLimit)
-    },
-    abortSignal
-  );
-  const nodes = /* @__PURE__ */ new Map();
-  const nodeKeysByElementId = /* @__PURE__ */ new Map();
-  const relationships = /* @__PURE__ */ new Map();
-  const seedNodesByElementId = /* @__PURE__ */ new Map();
-  for (const record of seedNodes.records) {
-    const value = record.get("node");
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-      throw new TypeError("Neo4j traversal returned a malformed seed node.");
-    }
-    const map = value;
-    seedNodesByElementId.set(stringValue(map.elementId, "Neo4j seed node elementId"), map);
-  }
-  const addNode = (value) => {
-    const parsed = contextNode(value, graph.schema);
-    const existing = nodes.get(parsed.node.key);
-    if (existing === void 0 && nodes.size >= options.maxNodes) return;
-    if (existing === void 0) nodes.set(parsed.node.key, parsed.node);
-    nodeKeysByElementId.set(parsed.elementId, parsed.node.key);
-  };
-  for (const elementId of limitedSeedIds) {
-    const value = seedNodesByElementId.get(elementId);
-    if (value !== void 0) addNode(value);
-  }
-  for (const record of result.records) {
-    for (const value of listOfMaps(record.get("nodes"), "Neo4j traversal nodes")) {
-      addNode(value);
-    }
-  }
-  for (const record of result.records) {
-    for (const value of listOfMaps(record.get("relationships"), "Neo4j traversal relationships")) {
-      const relationship = contextRelationship(value, nodeKeysByElementId);
-      if (relationship !== void 0 && !relationships.has(relationship.key) && relationships.size < options.maxRelationships) {
-        relationships.set(relationship.key, relationship);
-      }
-    }
-  }
-  return { nodes: [...nodes.values()], relationships: [...relationships.values()] };
-}
-function contextNode(value, schema) {
-  const labels = value.labels;
-  const raw = value.properties;
-  if (!Array.isArray(labels) || !labels.every((label) => typeof label === "string")) {
-    throw new TypeError("Neo4j traversal returned malformed node labels.");
-  }
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    throw new TypeError("Neo4j traversal returned malformed node properties.");
-  }
-  const properties2 = applicationProperties2(raw, "Neo4j graph node");
-  const type = labels.find((label) => label in schema.nodes) ?? labels[0] ?? "Node";
-  const definition = schema.nodes[type];
-  const identity = {};
-  if (definition !== void 0) {
-    for (const property of definition.identity) {
-      const item = properties2[property];
-      if (typeof item === "string" || typeof item === "number" || typeof item === "boolean") {
-        identity[property] = item;
-      }
-    }
-  }
-  const elementId = stringValue(value.elementId, "Neo4j node elementId");
-  return {
-    elementId,
-    node: {
-      key: stringProperty(raw, "__anvia_key") ?? elementId,
-      type,
-      identity,
-      properties: properties2,
-      sourceChunkIds: stringArrayProperty(
-        raw,
-        "__anvia_source_chunk_ids"
-      )
-    }
-  };
-}
-function contextRelationship(value, nodeKeysByElementId) {
-  const raw = value.properties;
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    throw new TypeError("Neo4j traversal returned malformed relationship properties.");
-  }
-  const elementId = stringValue(value.elementId, "Neo4j relationship elementId");
-  const fromElementId = stringValue(value.from, "Neo4j relationship source");
-  const toElementId = stringValue(value.to, "Neo4j relationship target");
-  const from = nodeKeysByElementId.get(fromElementId);
-  const to = nodeKeysByElementId.get(toElementId);
-  if (from === void 0 || to === void 0) return void 0;
-  return {
-    key: stringProperty(raw, "__anvia_key") ?? elementId,
-    type: stringValue(value.type, "Neo4j relationship type"),
-    from,
-    to,
-    properties: applicationProperties2(raw, "Neo4j graph relationship"),
-    sourceChunkIds: stringArrayProperty(raw, "__anvia_source_chunk_ids")
-  };
-}
-function fuseResults(lists, topK, rrfK) {
-  const fused = /* @__PURE__ */ new Map();
-  for (const list of lists) {
-    list.forEach((item, index) => {
-      const score = 1 / (rrfK + index + 1);
-      const current = fused.get(item.elementId);
-      fused.set(item.elementId, { ...item, score: (current?.score ?? 0) + score });
-    });
-  }
-  return [...fused.values()].sort((left, right) => right.score - left.score).slice(0, topK);
-}
-function validateSearch(search) {
-  positiveInteger(search.topK, "Neo4j graph search topK");
-  if (search.seeds.length === 0 || new Set(search.seeds).size !== search.seeds.length) {
-    throw new TypeError("Neo4j graph search requires unique seed names.");
-  }
-  if (search.type === "vector") {
-    if (search.seeds.length !== 1)
-      throw new TypeError(
-        "Vector graph search accepts exactly one seed; use hybrid search to fuse multiple seeds."
-      );
-    finiteScore(search.minScore, "Neo4j graph search minScore");
-  } else {
-    positiveInteger(search.candidatesPerSeed, "Neo4j hybrid candidatesPerSeed");
-    positiveInteger(search.rrfK, "Neo4j hybrid rrfK");
-  }
-}
-function validateEvidence(capability, evidence) {
-  if (typeof evidence !== "object" || evidence === null) {
-    throw new TypeError("Neo4j graph retrieval requires an explicit evidence mode.");
-  }
-  if (evidence.type === "none") return;
-  if (evidence.type !== "chunks") {
-    throw new TypeError("Unknown Neo4j graph evidence mode.");
-  }
-  positiveInteger(evidence.maxChunks, "Neo4j graph evidence maxChunks");
-  if (capability !== "chunks") {
-    throw new TypeError("Chunk evidence requires a managed Neo4j knowledge graph.");
-  }
-}
-function validateTraversal(schema, traversal) {
-  if (traversal.direction !== "outgoing" && traversal.direction !== "incoming" && traversal.direction !== "both") {
-    throw new TypeError("Neo4j traversal direction must be outgoing, incoming, or both.");
-  }
-  positiveInteger(traversal.maxDepth, "Neo4j traversal maxDepth", 8);
-  positiveInteger(traversal.maxNodes, "Neo4j traversal maxNodes");
-  positiveInteger(traversal.maxRelationships, "Neo4j traversal maxRelationships");
-  if (traversal.relationships.length === 0 || new Set(traversal.relationships).size !== traversal.relationships.length) {
-    throw new TypeError("Neo4j traversal requires unique relationship types.");
-  }
-  for (const type of traversal.relationships) {
-    if (!(type in schema.relationships))
-      throw new TypeError(`Neo4j traversal references unknown relationship type ${type}.`);
-  }
-}
-function applicationProperties2(value, label) {
-  return strictProperties(
-    Object.fromEntries(Object.entries(value).filter(([key]) => !key.startsWith("__anvia_"))),
-    label
-  );
-}
-function stringProperty(value, property) {
-  const item = value[property];
-  if (item === void 0) return void 0;
-  return stringValue(item, `Neo4j property ${property}`);
-}
-function stringArrayProperty(value, property) {
-  const item = value[property];
-  if (item === void 0) return [];
-  if (!Array.isArray(item) || !item.every((entry) => typeof entry === "string")) {
-    throw new TypeError(`Neo4j property ${property} must be a string array.`);
-  }
-  return [...item];
-}
-function stringValue(value, label) {
-  if (typeof value !== "string") throw new TypeError(`${label} must be a string.`);
-  return value;
-}
-function listOfMaps(value, label) {
-  if (!Array.isArray(value) || !value.every((item) => typeof item === "object" && item !== null && !Array.isArray(item))) {
-    throw new TypeError(`${label} must be an array of objects.`);
-  }
-  return value;
-}
-function escapeLucene(value) {
-  const specialCharacters = new Set('+-&|!(){}[]^"~*?:\\/');
-  let escaped = "";
-  for (const character of value) {
-    escaped += specialCharacters.has(character) ? `\\${character}` : character;
-  }
-  return escaped;
-}
-function groupBy2(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;
-}
-
-// src/tool.ts
-import { createTool } from "@anvia/core/tool";
-import { z as z3 } from "zod";
-var primitive = z3.union([z3.string(), z3.number().finite(), z3.boolean()]);
-var propertyValue = z3.union([
-  primitive,
-  z3.array(z3.string()),
-  z3.array(z3.number().finite()),
-  z3.array(z3.boolean())
-]);
-var properties = z3.record(z3.string(), propertyValue);
-var contextSchema = z3.object({
-  seeds: z3.array(
-    z3.object({
-      key: z3.string(),
-      type: z3.string(),
-      score: z3.number().finite(),
-      properties,
-      sourceChunkIds: z3.array(z3.string())
-    })
-  ),
-  nodes: z3.array(
-    z3.object({
-      key: z3.string(),
-      type: z3.string(),
-      identity: z3.record(z3.string(), primitive),
-      properties,
-      sourceChunkIds: z3.array(z3.string())
-    })
-  ),
-  relationships: z3.array(
-    z3.object({
-      key: z3.string(),
-      type: z3.string(),
-      from: z3.string(),
-      to: z3.string(),
-      properties,
-      sourceChunkIds: z3.array(z3.string())
-    })
-  ),
-  evidence: z3.array(
-    z3.object({
-      chunkId: z3.string(),
-      documentId: z3.string(),
-      index: z3.number().int(),
-      text: z3.string(),
-      metadata: properties
-    })
-  )
-});
-function createNeo4jGraphSearchTool(options) {
-  return createTool({
-    name: options.name,
-    description: options.description,
-    inputSchema: z3.object({
-      query: z3.string().min(1).describe("The question or concept to search for in the graph.")
-    }),
-    outputSchema: contextSchema,
-    execute: async ({ query }, context) => await retrieveGraphContext({
-      graph: options.graph,
-      model: options.model,
-      query,
-      search: options.search,
-      traversal: options.traversal,
-      evidence: options.evidence,
-      retries: options.retries,
-      abortSignal: context.abortSignal
-    })
-  });
+  return extractSharedGraphFacts(options);
 }
 export {
   GraphFactConflictError,
   ManagedNeo4jKnowledgeGraph,
   Neo4jClient,
   Neo4jKnowledgeGraph,
-  createNeo4jGraphSearchTool,
   defineNeo4jGraphSchema,
+  exploreGraph,
   extractGraphFacts,
   retrieveGraphContext
 };