@graphty/graph-io 0.3.47 → 0.3.49

package/dist/sources-cypher.js

@@ -0,0 +1,1351 @@
+import { b as throwIfAborted } from "./chunks/input-CAxt_aV-.js";
+import { P as PRECISION_CODE, ah as ImportError } from "./chunks/report-CwMfYa9J.js";
+import { C as CYPHER_DESCRIPTOR, N as NEO4J_DESCRIPTOR, a as NEPTUNE_DESCRIPTOR, S as SOURCE_ISSUE } from "./chunks/codes-BE2xir2k.js";
+import { w as warnOn, f as failOn, p as SOURCE_DEGREE_ATTR, b as failAlone, o as originOf, u as unwrapCredential, d as defineSource, C as CYPHER_SOURCE_ID, h as NEO4J_SOURCE_ID, i as NEPTUNE_SOURCE_ID } from "./chunks/credentials-DXHx7nwR.js";
+import { sha256Hex } from "./chunks/sigv4-EokFic1V.js";
+import { INVALID_INDEX } from "@graphty/graph-format";
+import { t as transportOptions, i as isLoopback } from "./chunks/context-C3p0RQxR.js";
+class GraphNode {
+  /**
+   * Create one.
+   * @param id - the server's element id
+   * @param labels - its labels
+   * @param properties - its mapped properties
+   */
+  constructor(id, labels, properties) {
+    this.id = id;
+    this.labels = labels;
+    this.properties = properties;
+  }
+}
+class GraphRel {
+  /**
+   * Create one.
+   * @param id - the server's element id
+   * @param start - the start node's element id
+   * @param end - the end node's element id
+   * @param type - its type
+   * @param properties - its mapped properties
+   */
+  constructor(id, start, end, type, properties) {
+    this.id = id;
+    this.start = start;
+    this.end = end;
+    this.type = type;
+    this.properties = properties;
+  }
+}
+const SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+function integer(digits, column2, m) {
+  let big;
+  try {
+    big = BigInt(digits);
+  } catch {
+    return Number(digits);
+  }
+  if (big <= SAFE && big >= -SAFE) {
+    return Number(big);
+  }
+  if (m.long === "string") {
+    return big.toString();
+  }
+  m.report.warnOnce(
+    "precision",
+    PRECISION_CODE,
+    `column ${column2}: an integer beyond 2^53 was stored as the nearest 64-bit float; pass long: "string" to keep every digit`,
+    void 0,
+    `${PRECISION_CODE}:${column2}`
+  );
+  return Number(big);
+}
+function epoch(text, type, column2, m) {
+  const ms = Date.parse(withoutZoneName(text));
+  if (Number.isNaN(ms)) {
+    warnOn(m.report, "W_SOURCE_VALUE", `column ${column2}: a ${type} kept as text`, { type, column: column2, as: "string" });
+    return text;
+  }
+  return ms;
+}
+function dropped(type, column2, m) {
+  warnOn(m.report, "W_SOURCE_VALUE", `column ${column2}: a ${type} value was dropped`, {
+    type,
+    column: column2,
+    as: "dropped"
+  });
+}
+function mapEntries(value, each) {
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    const mapped = each(v, k);
+    if (mapped !== void 0) {
+      out[k] = mapped;
+    }
+  }
+  return out;
+}
+function wktPoint(text) {
+  const match = /^SRID=(\d+);POINT(?: Z)? ?\(([^)]*)\)$/i.exec(text.trim());
+  if (match === null) {
+    return text;
+  }
+  const [x = 0, y = 0, z] = match[2].trim().split(/\s+/).map(Number);
+  return z === void 0 ? { srid: Number(match[1]), x, y } : { srid: Number(match[1]), x, y, z };
+}
+function fromTypedJson(v, column2, m) {
+  if (v === null || typeof v !== "object" || !("$type" in v)) {
+    return v ?? null;
+  }
+  const { $type: type, _value: value } = v;
+  switch (type) {
+    case "Null":
+      return null;
+    case "Boolean":
+    case "String":
+      return value;
+    case "Integer":
+      return integer(String(value), column2, m);
+    case "Float":
+      return Number(value);
+    case "Date":
+      return epoch(`${String(value)}T00:00:00Z`, type, column2, m);
+    case "OffsetDateTime":
+    case "ZonedDateTime":
+      return epoch(String(value), type, column2, m);
+    case "LocalDateTime":
+    case "LocalTime":
+    case "Time":
+    case "Duration":
+      return String(value);
+    case "Point":
+      return wktPoint(String(value));
+    case "Base64":
+      dropped(type, column2, m);
+      return void 0;
+    case "List":
+      return value.map((x) => fromTypedJson(x, column2, m));
+    case "Map":
+      return mapEntries(value, (x) => fromTypedJson(x, column2, m));
+    case "Node": {
+      const n = value;
+      return new GraphNode(
+        n._element_id,
+        n._labels,
+        mapEntries(n._properties, (x, k) => fromTypedJson(x, k, m))
+      );
+    }
+    case "Relationship": {
+      const r = value;
+      return new GraphRel(
+        r._element_id,
+        r._start_node_element_id,
+        r._end_node_element_id,
+        r._type,
+        mapEntries(r._properties, (x, k) => fromTypedJson(x, k, m))
+      );
+    }
+    case "Path":
+      return value.map((x) => fromTypedJson(x, column2, m));
+    default:
+      warnOn(m.report, "W_SOURCE_VALUE", `column ${column2}: a ${type} kept as text`, {
+        type,
+        column: column2,
+        as: "string"
+      });
+      return typeof value === "string" ? value : JSON.stringify(value);
+  }
+}
+function withoutZoneName(text) {
+  const end = text.length - 1;
+  if (text[end] !== "]") {
+    return text;
+  }
+  const open2 = text.indexOf("[", text.lastIndexOf("]", end - 1) + 1);
+  return open2 === -1 || open2 >= end ? text : text.slice(0, open2);
+}
+function fromEntity(e, node, m, t) {
+  const props = mapEntries(e.properties, (x, k) => fromDriver(x, k, m, t));
+  const id = e.elementId ?? String(e.identity);
+  return node ? new GraphNode(id, [...e.labels ?? []], props) : new GraphRel(
+    id,
+    e.startNodeElementId ?? String(e.start),
+    e.endNodeElementId ?? String(e.end),
+    e.type ?? "",
+    props
+  );
+}
+function fromPoint(p) {
+  const srid = Number(String(p.srid));
+  return p.z === void 0 ? { srid, x: p.x, y: p.y } : { srid, x: p.x, y: p.y, z: p.z };
+}
+function fromDriver(v, column2, m, t) {
+  if (v === null || v === void 0) {
+    return null;
+  }
+  if (typeof v !== "object") {
+    return typeof v === "bigint" ? integer(v.toString(), column2, m) : v;
+  }
+  const text = () => v.toString();
+  if (t.isInt(v)) {
+    return integer(text(), column2, m);
+  }
+  if (t.isNode(v) || t.isRelationship(v)) {
+    return fromEntity(v, t.isNode(v), m, t);
+  }
+  if (t.isPath(v)) {
+    const p = v;
+    return [p.start, ...p.segments.flatMap((s) => [s.relationship, s.end])].map((x) => fromDriver(x, column2, m, t));
+  }
+  if (t.isDate(v)) {
+    return epoch(`${text()}T00:00:00Z`, "Date", column2, m);
+  }
+  if (t.isDateTime(v)) {
+    return epoch(text(), "DateTime", column2, m);
+  }
+  if (t.isLocalDateTime(v) || t.isLocalTime(v) || t.isTime(v) || t.isDuration(v)) {
+    return text();
+  }
+  if (t.isPoint(v)) {
+    return fromPoint(v);
+  }
+  if (v instanceof Uint8Array || v instanceof ArrayBuffer) {
+    dropped("ByteArray", column2, m);
+    return void 0;
+  }
+  if (Array.isArray(v)) {
+    return v.map((x) => fromDriver(x, column2, m, t));
+  }
+  return mapEntries(v, (x) => fromDriver(x, column2, m, t));
+}
+function fromNeptune(v, column2, m) {
+  if (typeof v === "number" && Number.isInteger(v) && !Number.isSafeInteger(v)) {
+    return integer(BigInt(v).toString(), column2, m);
+  }
+  if (v === null || typeof v !== "object") {
+    return v ?? null;
+  }
+  if (Array.isArray(v)) {
+    return v.map((x) => fromNeptune(x, column2, m));
+  }
+  const o = v;
+  const props = () => mapEntries(o["~properties"] ?? {}, (x, k) => fromNeptune(x, k, m));
+  switch (o["~entityType"]) {
+    case "node":
+      return new GraphNode(String(o["~id"]), o["~labels"] ?? [], props());
+    case "relationship":
+      return new GraphRel(String(o["~id"]), String(o["~start"]), String(o["~end"]), String(o["~type"]), props());
+    default:
+      return mapEntries(o, (x) => fromNeptune(x, column2, m));
+  }
+}
+const LABELS_COLUMN = "labels";
+const TYPE_COLUMN = "type";
+const LABELS_DECL = {
+  name: LABELS_COLUMN,
+  dtype: "list",
+  itemDtype: "dict",
+  nullable: true,
+  role: "labels"
+};
+const TYPE_DECL = { name: TYPE_COLUMN, dtype: "dict", nullable: true, role: "kind" };
+const EDGE_ID_DECL = { name: "id", dtype: "string", nullable: true, role: "id" };
+class Collector {
+  constructor() {
+    this.nodes = /* @__PURE__ */ new Map();
+    this.rels = /* @__PURE__ */ new Map();
+    this.degrees = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Collect a result.
+   * @param result - the result
+   * @param hints - whether its `key` / `degree` / `degrees` columns are the generated queries' hints
+   */
+  add(result, hints) {
+    const key = hints ? result.fields.indexOf("key") : -1;
+    const degree = hints ? result.fields.indexOf("degree") : -1;
+    const degrees = hints ? result.fields.indexOf("degrees") : -1;
+    for (const row of result.rows) {
+      row.forEach((value, i) => {
+        if (i === degrees && Array.isArray(value)) {
+          for (const pair of value) {
+            if (Array.isArray(pair) && typeof pair[1] === "number") {
+              this.degrees.set(String(pair[0]), pair[1]);
+            }
+          }
+        } else if (i !== key && i !== degree) {
+          this.visit(value);
+        }
+      });
+      if (key >= 0 && degree >= 0 && typeof row[degree] === "number") {
+        this.degrees.set(String(row[key]), row[degree]);
+      }
+    }
+  }
+  /**
+   * Collect every node and relationship inside a value.
+   * @param value - the value
+   */
+  visit(value) {
+    if (value instanceof GraphNode) {
+      this.nodes.set(value.id, value);
+    } else if (value instanceof GraphRel) {
+      this.rels.set(value.id, value);
+    } else if (Array.isArray(value)) {
+      value.forEach((v) => {
+        this.visit(v);
+      });
+    } else if (value !== null && typeof value === "object") {
+      Object.values(value).forEach((v) => {
+        this.visit(v);
+      });
+    }
+  }
+  /**
+   * Whether nothing was collected.
+   * @returns true when no node or relationship was found
+   */
+  get empty() {
+    return this.nodes.size === 0 && this.rels.size === 0;
+  }
+}
+function requireGraph(result, collector, report) {
+  if (result.rows.length > 0 && collector.empty) {
+    failOn(report, "E_SOURCE_NOT_A_GRAPH", "the query returned no node, relationship or path", {
+      columns: result.fields
+    });
+  }
+}
+function nodeIdOf(node, idProperty) {
+  const value = idProperty === null ? void 0 : node.properties[idProperty];
+  return typeof value === "string" || typeof value === "number" ? value : node.id;
+}
+function column(sink, decl, domain) {
+  const existing = domain === "node" ? sink.nodeColumn(decl.name) : sink.edgeColumn(decl.name);
+  if (existing !== INVALID_INDEX) {
+    return existing;
+  }
+  return domain === "node" ? sink.declareNodeColumn(decl) : sink.declareEdgeColumn(decl);
+}
+function writeCollected(c, sink, idProperty, report, signal) {
+  if (sink.edgeCount === 0 && !sink.directedLocked && !sink.directed) {
+    sink.setDirected(true);
+  }
+  const ids = writeNodes(c, sink, idProperty, report, signal);
+  writeRels(c, sink, ids, report, signal, c.nodes.size);
+}
+function writeNodes(c, sink, idProperty, report, signal) {
+  const ids = /* @__PURE__ */ new Map();
+  let n = 0;
+  for (const node of c.nodes.values()) {
+    if (n++ % 64 === 0) {
+      throwIfAborted(signal);
+    }
+    const id = nodeIdOf(node, idProperty);
+    ids.set(node.id, id);
+    const degree = c.degrees.get(String(idProperty === null ? node.id : id));
+    try {
+      const fresh = sink.indexOf(id) === INVALID_INDEX;
+      const index = sink.addNodeRecord(
+        id,
+        degree === void 0 ? node.properties : { ...node.properties, [SOURCE_DEGREE_ATTR]: degree }
+      );
+      sink.setNodeValue(column(sink, LABELS_DECL, "node"), index, node.labels);
+      if (fresh) {
+        report.counts.nodes++;
+      }
+    } catch (err) {
+      report.recordError(err, { element: String(id) });
+      report.counts.skippedNodes++;
+    }
+  }
+  return ids;
+}
+function writeRels(c, sink, ids, report, signal, written) {
+  let n = written;
+  for (const rel of c.rels.values()) {
+    if (n++ % 64 === 0) {
+      throwIfAborted(signal);
+    }
+    const s = ids.get(rel.start) ?? rel.start;
+    const t = ids.get(rel.end) ?? rel.end;
+    try {
+      for (const end of [s, t]) {
+        if (sink.indexOf(end) === INVALID_INDEX) {
+          sink.addNode(end);
+          report.counts.nodes++;
+        }
+      }
+      const e = sink.addEdgeRecord(s, t, rel.properties, null);
+      sink.setEdgeValue(column(sink, TYPE_DECL, "edge"), e, rel.type);
+      sink.setEdgeValue(column(sink, EDGE_ID_DECL, "edge"), e, rel.id);
+      report.counts.edges++;
+    } catch (err) {
+      report.recordError(err, { element: `${String(s)} -> ${String(t)}` });
+      report.counts.skippedEdges++;
+    }
+  }
+}
+function compareText(a, b) {
+  if (a === b) {
+    return 0;
+  }
+  return a < b ? -1 : 1;
+}
+function member(key, value) {
+  return `${JSON.stringify(key)}:${canonical(value)}`;
+}
+function canonical(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(canonical).join(",")}]`;
+  }
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value).sort(([a], [b]) => compareText(a, b));
+    const members = entries.map(([k, v]) => member(k, v));
+    return `{${members.join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function canonicalRows(c, idProperty) {
+  const ids = /* @__PURE__ */ new Map();
+  const lines = [];
+  for (const node of c.nodes.values()) {
+    const id = nodeIdOf(node, idProperty);
+    ids.set(node.id, id);
+    lines.push(canonical(["n", id, [...node.labels].sort(compareText), node.properties]));
+  }
+  for (const rel of c.rels.values()) {
+    lines.push(
+      canonical([
+        "r",
+        rel.id,
+        ids.get(rel.start) ?? rel.start,
+        ids.get(rel.end) ?? rel.end,
+        rel.type,
+        rel.properties
+      ])
+    );
+  }
+  return lines;
+}
+function neo4jProfile(version, product = "Neo4j") {
+  const major = version === null ? Number.NaN : Number.parseInt(version, 10);
+  return {
+    name: "neo4j",
+    elementIds: Number.isNaN(major) || major >= 5,
+    product,
+    version,
+    readOnly: "enforced"
+  };
+}
+function profileFromAgent(agent) {
+  const [product = "", version = ""] = agent.split("/");
+  if (product.toLowerCase() === "neo4j") {
+    return neo4jProfile(version === "" ? null : version);
+  }
+  return {
+    name: "neo4j",
+    elementIds: false,
+    product,
+    version: version === "" ? null : version,
+    readOnly: "enforced"
+  };
+}
+function neptuneProfile(version = null) {
+  return { name: "neptune", elementIds: false, product: "Neptune", version, readOnly: "not-enforced" };
+}
+function serverFacts(profile) {
+  return {
+    product: profile.product,
+    profile: profile.name,
+    readOnly: profile.readOnly,
+    ...profile.version === null ? {} : { version: profile.version }
+  };
+}
+const MAX_DEPTH = 10;
+const MAX_PAGE_SIZE = 1e5;
+const DEFAULT_PAGE_SIZE = 1e3;
+function identifierProblem(name) {
+  return typeof name !== "string" || name === "" || name.includes("\0") ? "identifier" : null;
+}
+function cypherIdentifier(name) {
+  if (identifierProblem(name) !== null) {
+    failAlone("E_SOURCE_PARAM", "a Cypher identifier must be a non-empty string without NUL", {
+      name: "identifier",
+      reason: "identifier"
+    });
+  }
+  return `\`${name.replaceAll("`", "``")}\``;
+}
+function quoted(name, param, report) {
+  if (identifierProblem(name) !== null) {
+    failOn(report, "E_SOURCE_PARAM", `parameter ${param}: not a Cypher identifier`, {
+      name: param,
+      reason: "identifier"
+    });
+  }
+  return cypherIdentifier(name);
+}
+function checkedInteger(value, name, min, max, report) {
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    failOn(report, "E_SOURCE_PARAM", `parameter ${name}: not an integer`, { name, reason: "type" });
+  }
+  if (value < min || value > max) {
+    failOn(report, "E_SOURCE_PARAM", `parameter ${name}: outside ${String(min)} to ${String(max)}`, {
+      name,
+      reason: "range"
+    });
+  }
+  return String(value);
+}
+function idExpression(v, profile, filters, node = true) {
+  if (node && filters.idProperty !== null) {
+    return `${v}.${filters.idProperty}`;
+  }
+  return profile.elementIds ? `elementId(${v})` : `id(${v})`;
+}
+function nodePredicate(v, filters) {
+  const parts = [];
+  if (filters.labels.length > 0) {
+    const prefix = `${v}:`;
+    parts.push(`(${filters.labels.map((l) => prefix + l).join(" OR ")})`);
+  }
+  if (filters.idProperty !== null) {
+    parts.push(`${v}.${filters.idProperty} IS NOT NULL`);
+  }
+  return parts.length === 0 ? null : parts.join(" AND ");
+}
+function typesPattern(filters) {
+  return filters.relationshipTypes.length === 0 ? "" : `:${filters.relationshipTypes.join("|")}`;
+}
+function degreeOf(v) {
+  return `size([(${v})--() | 1])`;
+}
+const ARROWS = { out: ["-", "->"], in: ["<-", "-"], both: ["-", "-"] };
+function nodePage(profile, filters, pageSize, after, degree) {
+  const where = nodePredicate("n", filters);
+  return [
+    "MATCH (n)",
+    where === null ? null : `WHERE ${where}`,
+    `WITH n, ${idExpression("n", profile, filters)} AS key`,
+    after ? "WHERE key > $after" : null,
+    degree ? `RETURN n, key, ${degreeOf("n")} AS degree` : "RETURN n, key",
+    `ORDER BY key LIMIT ${pageSize}`
+  ].filter((l) => l !== null).join(" ");
+}
+function edgePage(profile, filters, pageSize, after) {
+  const a = nodePredicate("a", filters);
+  const b = nodePredicate("b", filters);
+  const where = [a, b].filter((p) => p !== null);
+  return [
+    `MATCH (a)-[r${typesPattern(filters)}]->(b)`,
+    where.length === 0 ? null : `WHERE ${where.join(" AND ")}`,
+    `WITH a, r, b, ${idExpression("r", profile, filters, false)} AS key`,
+    after ? "WHERE key > $after" : null,
+    "RETURN a, r, b, key",
+    `ORDER BY key LIMIT ${pageSize}`
+  ].filter((l) => l !== null).join(" ");
+}
+function edgesAmong(profile, filters, after) {
+  const where = [nodePredicate("a", filters), nodePredicate("b", filters)].filter((p) => p !== null);
+  return [
+    `MATCH (a)-[r${typesPattern(filters)}]->(b)`,
+    where.length === 0 ? null : `WHERE ${where.join(" AND ")}`,
+    `WITH a, r, b, ${idExpression("a", profile, filters)} AS ka, ${idExpression("b", profile, filters)} AS kb`,
+    `WHERE ka <= $last AND kb <= $last${after ? " AND (ka > $after OR kb > $after)" : ""}`,
+    "RETURN a, r, b"
+  ].filter((l) => l !== null).join(" ");
+}
+function neighborhood(profile, filters, shape, degree) {
+  const rel = `[${typesPattern(filters)}*1..${shape.depth}]`;
+  const [left, right] = ARROWS[shape.direction];
+  const pattern = `${left}${rel}${right}`;
+  const x = nodePredicate("x", filters);
+  const degrees = degree ? `, [m IN CASE WHEN p IS NULL THEN [s] ELSE nodes(p) END | [${idExpression("m", profile, filters)}, ${degreeOf("m")}]] AS degrees` : "";
+  const head = [
+    `MATCH (s) WHERE ${idExpression("s", profile, filters)} IN $ids`,
+    `OPTIONAL MATCH p = (s)${pattern}(x)${whereClause(x)}`
+  ];
+  if (shape.limit === null) {
+    return [...head, "WITH s, p", `RETURN s, p${degrees}`].join(" ");
+  }
+  return [
+    ...head,
+    `WITH s, p, ${idExpression("x", profile, filters)} AS key`,
+    shape.after === true ? "WHERE key > $after" : null,
+    `WITH s, p, key ORDER BY key LIMIT ${shape.limit}`,
+    `RETURN s, p, key${degrees}`
+  ].filter((l) => l !== null).join(" ");
+}
+function whereClause(predicate) {
+  return predicate === null ? "" : ` WHERE ${predicate}`;
+}
+function counts(filters) {
+  const n = nodePredicate("n", filters);
+  const where = [nodePredicate("a", filters), nodePredicate("b", filters)].filter((p) => p !== null);
+  return [
+    `MATCH (n)${whereClause(n)} RETURN count(n) AS c`,
+    `MATCH (a)-[r${typesPattern(filters)}]->(b)${whereClause(where.length === 0 ? null : where.join(" AND "))} RETURN count(r) AS c`
+  ];
+}
+function storeCount(label) {
+  const pattern = label === void 0 ? "n" : `n:${label}`;
+  return `MATCH (${pattern}) RETURN count(n) AS c`;
+}
+const MAX_SERVER_MESSAGE = 500;
+function serverError(report, err, origin, database) {
+  const code = err.code ?? "";
+  if (/Security\.Unauthorized|AuthenticationRateLimit|UnauthorizedException/i.test(code)) {
+    return failOn(report, "E_SOURCE_AUTH", `${origin} refused the login`, {
+      origin,
+      status: err.status,
+      scheme: null,
+      serverCode: err.code
+    });
+  }
+  if (/Security\.Forbidden|AccessMode|AccessDenied/i.test(code)) {
+    return failOn(report, "E_SOURCE_FORBIDDEN", `${origin} refused the statement`, {
+      status: err.status,
+      serverCode: err.code
+    });
+  }
+  if (/TimedOut|Timeout|TimeLimitExceeded/i.test(code)) {
+    return failOn(report, "E_SOURCE_TIMEOUT", `${origin} timed the statement out`, {
+      timeoutMs: null,
+      serverSide: true
+    });
+  }
+  if (/DatabaseNotFound/i.test(code)) {
+    return failOn(report, "E_SOURCE_NOT_FOUND", `${origin} has no database ${String(database)}`, {
+      what: "database",
+      value: database ?? null
+    });
+  }
+  const where = /line (\d+), column (\d+)/i.exec(err.message);
+  return failOn(report, "E_SOURCE_QUERY", `${origin} refused the query: ${code}`, {
+    serverCode: err.code,
+    line: where === null ? null : Number(where[1]),
+    column: where === null ? null : Number(where[2]),
+    serverMessage: err.showable && err.message !== "" ? err.message.slice(0, MAX_SERVER_MESSAGE) : null
+  });
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function objectRows(results, map) {
+  const fields = [...new Set(results.flatMap((r) => Object.keys(r)))];
+  return { fields, rows: results.map((r) => fields.map((f) => map(r[f], f))) };
+}
+const DRIVER_PACKAGE = "neo4j-driver";
+const DIRECT_SCHEMES = /* @__PURE__ */ new Set(["bolt:", "bolt+s:", "bolt+ssc:"]);
+async function loadDriver(input) {
+  let mod;
+  try {
+    mod = await import("neo4j-driver");
+  } catch {
+    return failOn(input.ctx.report, "E_SOURCE_RUNTIME", `the bolt transport needs ${DRIVER_PACKAGE} installed`, {
+      runtime: input.ctx.runtime,
+      reason: "needs-peer-dependency",
+      package: DRIVER_PACKAGE
+    });
+  }
+  return mod.default ?? mod;
+}
+function refuseMixedContent(ctx, url) {
+  const page = globalThis.location;
+  if (ctx.runtime === "browser" && page?.protocol === "https:" && url.protocol === "bolt:" && !isLoopback(url.hostname)) {
+    failOn(ctx.report, "E_SOURCE_RUNTIME", "an https page cannot open a plain Bolt WebSocket", {
+      runtime: ctx.runtime,
+      reason: "insecure-endpoint"
+    });
+  }
+}
+async function connection(input, neo4j) {
+  const { ctx } = input;
+  const { report } = ctx;
+  const bad = (reason, message) => failOn(report, "E_SOURCE_PARAM", message, { name: "endpoint", reason });
+  const url = ctx.endpoint ?? bad("missing", "the bolt transport needs an endpoint");
+  if (!DIRECT_SCHEMES.has(url.protocol)) {
+    bad(url.protocol.startsWith("neo4j") ? "routing" : "scheme", `${url.protocol} is not a direct Bolt scheme`);
+  }
+  refuseMixedContent(ctx, url);
+  const { credential, allowInsecure } = transportOptions(ctx);
+  const origin = originOf(url);
+  const bound = credential !== void 0 && (credential.origins.length === 0 || credential.origins.includes(origin));
+  if (!bound || credential === void 0) {
+    return { url, auth: void 0 };
+  }
+  if (url.protocol === "bolt+ssc:") {
+    bad("unverified-tls", "bolt+ssc accepts any certificate, so no credential is sent over it");
+  }
+  if (url.protocol === "bolt:" && !isLoopback(url.hostname) && allowInsecure !== true) {
+    bad("insecure-endpoint", "a credential is never sent without TLS");
+  }
+  const secret = unwrapCredential(credential);
+  if (secret !== void 0 && "username" in secret) {
+    return { url, auth: neo4j.auth.basic(secret.username, secret.password) };
+  }
+  if (secret !== void 0 && "token" in secret) {
+    const token = typeof secret.token === "string" ? secret.token : await secret.token();
+    return { url, auth: neo4j.auth.bearer(token) };
+  }
+  return failOn(report, "E_SOURCE_PARAM", "the bolt transport takes a basic or bearer credential", {
+    name: "credential",
+    reason: "kind"
+  });
+}
+async function boltTransport(input) {
+  const { ctx, params, m } = input;
+  throwIfAborted(ctx.signal);
+  const neo4j = await loadDriver(input);
+  const { url, auth } = await connection(input, neo4j);
+  throwIfAborted(ctx.signal);
+  const origin = originOf(url);
+  const { userAgent } = transportOptions(ctx);
+  const driver = neo4j.driver(`${url.protocol}//${url.host}`, auth, userAgent === void 0 ? {} : { userAgent });
+  const session = driver.session({
+    defaultAccessMode: neo4j.session.READ,
+    ...params.database === void 0 ? {} : { database: params.database }
+  });
+  let closed = null;
+  const close = () => {
+    closed ??= session.close().catch(() => void 0).then(() => driver.close()).catch(() => void 0);
+    return closed;
+  };
+  const onAbort = () => {
+    void close();
+  };
+  ctx.signal.addEventListener("abort", onAbort, { once: true });
+  const fail = (err) => {
+    throwIfAborted(ctx.signal);
+    const e = err;
+    const code = typeof e.code === "string" ? e.code : null;
+    if (code === null || code === "ServiceUnavailable" || code === "SessionExpired") {
+      return ctx.runtime === "browser" ? failOn(ctx.report, "E_SOURCE_BLOCKED", `${origin} could not be reached over Bolt`, {
+        url: origin,
+        cause: "unknown"
+      }) : failOn(ctx.report, "E_FETCH", `${origin} could not be reached over Bolt`, {
+        url: origin,
+        status: null
+      });
+    }
+    return serverError(
+      ctx.report,
+      {
+        code,
+        message: typeof e.message === "string" ? e.message : "",
+        status: null,
+        showable: code.startsWith("Neo.ClientError.")
+      },
+      origin,
+      params.database
+    );
+  };
+  let detected = null;
+  const profile = async () => {
+    if (detected === null) {
+      const info = await driver.getServerInfo().catch(fail);
+      detected = profileFromAgent(info.agent ?? "");
+    }
+    return detected;
+  };
+  const timeout = ctx.limits.timeoutMs;
+  return {
+    async run(statement, parameters) {
+      throwIfAborted(ctx.signal);
+      const result = await session.run(statement, parameters, timeout === void 0 ? void 0 : { timeout }).catch(fail);
+      const fields = (result.records[0]?.keys ?? []).map(String);
+      return {
+        fields,
+        rows: result.records.map((r) => fields.map((k) => fromDriver(r.get(k), k, m, neo4j)))
+      };
+    },
+    profile,
+    probe: profile,
+    close: async () => {
+      ctx.signal.removeEventListener("abort", onAbort);
+      await close();
+    }
+  };
+}
+function nodeOnly(ctx, transport) {
+  if (ctx.runtime === "browser" || ctx.runtime === "worker") {
+    failOn(ctx.report, "E_SOURCE_RUNTIME", `the ${transport} transport cannot run in a browser`, {
+      runtime: ctx.runtime,
+      reason: "cors"
+    });
+  }
+}
+function trailingError(text) {
+  for (let at = text.lastIndexOf("{"); at > 0; at = text.lastIndexOf("{", at - 1)) {
+    const tail = parseJson(text.slice(at));
+    if (tail !== null && typeof tail.code === "string") {
+      return tail;
+    }
+  }
+  return null;
+}
+async function neptuneResult(input, response) {
+  const { ctx, m } = input;
+  const origin = ctx.endpoint === null ? "" : originOf(ctx.endpoint);
+  const text = await response.text();
+  const body = parseJson(text);
+  let error = typeof body?.code === "string" ? body : null;
+  if (body === null) {
+    error = trailingError(text);
+  }
+  if (error !== null) {
+    serverError(
+      ctx.report,
+      {
+        code: error.code ?? null,
+        message: error.detailedMessage ?? error.message ?? "",
+        status: response.status,
+        showable: body !== null && response.status >= 400 && response.status < 500
+      },
+      origin,
+      void 0
+    );
+  }
+  if (!response.ok) {
+    failOn(ctx.report, "E_FETCH", `${origin} answered ${String(response.status)}`, {
+      url: origin,
+      status: response.status
+    });
+  }
+  if (body === null || !Array.isArray(body.results)) {
+    failOn(ctx.report, "E_SOURCE_RESPONSE", "the Neptune answer has no results", {
+      expected: "json",
+      contentType: response.headers.get("content-type")
+    });
+  }
+  return objectRows(body.results, (v, column2) => fromNeptune(v, column2, m));
+}
+function neptuneHttpsTransport(input) {
+  const { ctx } = input;
+  nodeOnly(ctx, "neptune-https");
+  return {
+    async run(statement, parameters) {
+      const response = await ctx.fetch("openCypher", {
+        method: "POST",
+        idempotent: true,
+        allowStatus: [400, 500],
+        body: new URLSearchParams({ query: statement, parameters: JSON.stringify(parameters) })
+      });
+      return neptuneResult(input, response);
+    },
+    profile: () => Promise.resolve(neptuneProfile()),
+    probe: async () => {
+      const status = await ctx.fetchJson("status");
+      return neptuneProfile(typeof status.dbEngineVersion === "string" ? status.dbEngineVersion : null);
+    },
+    close: () => Promise.resolve()
+  };
+}
+function neptuneAnalyticsTransport(input) {
+  const { ctx } = input;
+  nodeOnly(ctx, "neptune-analytics");
+  const run = async (statement, parameters) => {
+    const response = await ctx.fetch("queries", {
+      method: "POST",
+      idempotent: true,
+      allowStatus: [400, 500],
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query: statement, language: "OPEN_CYPHER", parameters })
+    });
+    return neptuneResult(input, response);
+  };
+  return {
+    run,
+    profile: () => Promise.resolve(neptuneProfile()),
+    probe: async () => {
+      await run("RETURN 1 AS ok", {});
+      return neptuneProfile();
+    },
+    close: () => Promise.resolve()
+  };
+}
+const TYPED_JSON = "application/vnd.neo4j.query.v1.1";
+const ERROR_STATUSES = [400, 404, 500];
+function queryApiTransport(input) {
+  const { ctx, params, m } = input;
+  const database = params.database ?? "neo4j";
+  const path = `db/${encodeURIComponent(database)}/query/v2`;
+  const origin = ctx.endpoint === null ? "" : originOf(ctx.endpoint);
+  const run = async (statement, parameters) => {
+    const response = await ctx.fetch(path, {
+      method: "POST",
+      idempotent: true,
+      allowStatus: ERROR_STATUSES,
+      headers: { "Content-Type": "application/json", Accept: TYPED_JSON },
+      body: JSON.stringify({ statement, parameters, accessMode: "Read" })
+    });
+    const body = parseJson(await response.text());
+    const first = body?.errors?.[0];
+    if (first !== void 0) {
+      serverError(
+        ctx.report,
+        {
+          code: first.code ?? null,
+          message: first.message ?? "",
+          status: response.status,
+          showable: response.status >= 400 && response.status < 500
+        },
+        origin,
+        params.database
+      );
+    }
+    if (response.status === 404) {
+      failOn(ctx.report, "E_SOURCE_NOT_FOUND", `${origin} has no Query API at ${path}`, {
+        what: "url",
+        value: `${origin}/${path}`
+      });
+    }
+    if (!response.ok) {
+      failOn(ctx.report, "E_FETCH", `${origin} answered ${String(response.status)}`, {
+        url: `${origin}/${path}`,
+        status: response.status
+      });
+    }
+    if (body?.data === void 0) {
+      failOn(ctx.report, "E_SOURCE_RESPONSE", "the Query API answer has no data", {
+        expected: "json",
+        contentType: response.headers.get("content-type")
+      });
+    }
+    const { fields, values } = body.data;
+    return { fields, rows: values.map((row) => row.map((v, i) => fromTypedJson(v, fields[i] ?? "", m))) };
+  };
+  return {
+    run,
+    // the Query API exists from Neo4j 5.26, so ids are elementId()
+    profile: () => Promise.resolve(neo4jProfile(null)),
+    probe: async () => {
+      const res = await run(
+        "CALL dbms.components() YIELD name, versions, edition RETURN name, versions, edition",
+        {}
+      );
+      const kernel = res.rows.find((r) => r[0] === "Neo4j Kernel") ?? res.rows[0];
+      const versions = kernel?.[1];
+      const version = Array.isArray(versions) && typeof versions[0] === "string" ? versions[0] : null;
+      return neo4jProfile(version);
+    },
+    close: () => Promise.resolve()
+  };
+}
+const DIRECTIONS = /* @__PURE__ */ new Set(["out", "in", "both"]);
+function withoutTrailingSemicolons(query) {
+  let end = query.length;
+  while (end > 0 && query[end - 1] === ";") {
+    end--;
+  }
+  return query.slice(0, end);
+}
+function listParam(value, name, report) {
+  if (value === void 0 || value === null) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number") {
+    return [value];
+  }
+  return failOn(report, "E_SOURCE_PARAM", `parameter ${name}: not a list`, { name, reason: "type" });
+}
+function transportName(params, ctx, preset) {
+  if (params.transport !== void 0) {
+    return params.transport;
+  }
+  const scheme = ctx.endpoint?.protocol ?? "";
+  if (scheme.startsWith("bolt") || scheme.startsWith("neo4j")) {
+    return "bolt";
+  }
+  if (ctx.endpoint?.hostname.endsWith(".neptune-graph.amazonaws.com") === true) {
+    return "neptune-analytics";
+  }
+  return preset.transport;
+}
+class Reader {
+  /**
+   * Set up a read.
+   * @param transport - the transport
+   * @param params - the params
+   * @param ctx - the context
+   */
+  constructor(transport, params, ctx) {
+    this.transport = transport;
+    this.params = params;
+    this.ctx = ctx;
+    this.known = null;
+    this.degree = true;
+    const { report } = ctx;
+    this.idProperty = params.idProperty ?? null;
+    this.filters = {
+      labels: listParam(params.labels, "labels", report).map((l) => quoted(l, "labels", report)),
+      relationshipTypes: listParam(params.relationshipTypes, "relationshipTypes", report).map(
+        (t) => quoted(t, "relationshipTypes", report)
+      ),
+      idProperty: this.idProperty === null ? null : quoted(this.idProperty, "idProperty", report)
+    };
+  }
+  /**
+   * The server's profile: the params' choice, else the transport's detection.
+   * @returns the profile
+   */
+  async profile() {
+    if (this.known === null) {
+      const detected = await this.transport.profile();
+      this.known = detected;
+      if (this.params.profile === "neptune") {
+        this.known = neptuneProfile(detected.version);
+      } else if (this.params.profile === "neo4j" && detected.name !== "neo4j") {
+        this.known = neo4jProfile(detected.version);
+      }
+    }
+    return this.known;
+  }
+  /**
+   * Run a generated statement with the degree hint, and without it once if the server refuses it.
+   * @param build - builds the statement, with or without the hint
+   * @param parameters - its parameters
+   * @returns the result, collected
+   */
+  async generated(build, parameters) {
+    let result;
+    try {
+      result = await this.transport.run(build(this.degree), parameters);
+    } catch (err) {
+      if (!this.degree || !(err instanceof ImportError) || err.issue?.code !== SOURCE_ISSUE.E_SOURCE_QUERY) {
+        throw err;
+      }
+      this.degree = false;
+      result = await this.transport.run(build(false), parameters);
+    }
+    const collected = new Collector();
+    collected.add(result, true);
+    return { collected, rows: result.rows, fields: result.fields };
+  }
+  /**
+   * The pages of a read, as `mode` asks.
+   * @param cursor - where to resume
+   * @param counting - whether a first page of mode "all" may count what the source holds
+   * @yields one page at a time
+   */
+  async *pages(cursor, counting = true) {
+    const { params, ctx } = this;
+    const { report } = ctx;
+    const mode = params.mode ?? (typeof params.query === "string" && params.query !== "" ? "query" : "all");
+    if (mode === "query") {
+      if (typeof params.query !== "string" || params.query.trim() === "") {
+        failOn(report, "E_SOURCE_PARAM", "mode query needs a query", { name: "query", reason: "required" });
+      }
+      yield await this.userQuery(params.query, cursor);
+      return;
+    }
+    const profile = await this.profile();
+    if (mode === "neighborhood") {
+      const ids = listParam(params.ids, "ids", report);
+      if (ids.length === 0) {
+        failOn(report, "E_SOURCE_PARAM", "mode neighborhood needs ids", { name: "ids", reason: "required" });
+      }
+      const shape = {
+        depth: checkedInteger(params.depth ?? 1, "depth", 1, MAX_DEPTH, report),
+        direction: "both",
+        limit: ctx.limits.maxNodes === void 0 ? null : checkedInteger(ctx.limits.maxNodes, "maxNodes", 1, Number.MAX_SAFE_INTEGER, report)
+      };
+      const { collected } = await this.generated((d) => neighborhood(profile, this.filters, shape, d), { ids });
+      yield { collected, next: null };
+      return;
+    }
+    yield* this.everything(profile, cursor, counting);
+  }
+  /**
+   * Mode "query": the reader's own query, as written. With a node cap (or a cursor from a capped
+   * run) the server returns at most that many rows (`CALL { query } RETURN * LIMIT n`), and a full
+   * result hands back a cursor that runs the query again with twice the rows, for the caller to
+   * merge. A server that refuses the wrapper runs the query uncapped.
+   * @param query - the query
+   * @param cursor - where to resume: `{ rows }` from an earlier capped run
+   * @returns the one page
+   */
+  async userQuery(query, cursor) {
+    const { params, ctx } = this;
+    const parameters = params.parameters ?? {};
+    const asked = cursor?.rows ?? ctx.limits.maxNodes;
+    const rows = asked === void 0 || asked === null ? null : Number(checkedInteger(asked, "maxNodes", 1, Number.MAX_SAFE_INTEGER, ctx.report));
+    let result;
+    let capped = rows !== null;
+    try {
+      result = await this.transport.run(
+        rows === null ? query : `CALL {
+${withoutTrailingSemicolons(query.trim())}
+}
+RETURN * LIMIT ${String(rows)}`,
+        parameters
+      );
+    } catch (err) {
+      if (!capped || !(err instanceof ImportError) || err.issue?.code !== SOURCE_ISSUE.E_SOURCE_QUERY) {
+        throw err;
+      }
+      capped = false;
+      result = await this.transport.run(query, parameters);
+    }
+    const collected = new Collector();
+    collected.add(result, false);
+    requireGraph(result, collected, ctx.report);
+    const full = capped && rows !== null && result.rows.length >= rows;
+    return { collected, next: full ? { rows: rows * 2 } : null };
+  }
+  /**
+   * Mode "all": the nodes, then the relationships with their ends, each paged by keyset on the
+   * id expression (never SKIP), so a page is stable under unrelated writes.
+   * @param profile - the server's profile
+   * @param cursor - where to resume
+   * @param counting - whether a first page may count what the source holds
+   * @yields one page at a time
+   */
+  async *everything(profile, cursor, counting) {
+    const { params, ctx } = this;
+    const size = checkedInteger(params.pageSize ?? DEFAULT_PAGE_SIZE, "pageSize", 1, MAX_PAGE_SIZE, ctx.report);
+    if (cursor === null && counting) {
+      this.counted = await this.count(profile);
+    }
+    const cap = ctx.limits.maxNodes;
+    if (cap !== void 0 && cursor?.phase !== "edges") {
+      const capped = Number(checkedInteger(cap, "maxNodes", 1, Number.MAX_SAFE_INTEGER, ctx.report));
+      yield* this.cappedNodes(profile, cursor, Math.min(Number(size), capped));
+      return;
+    }
+    let phase = cursor?.phase === "edges" ? "edges" : "nodes";
+    let after = cursor?.after ?? null;
+    const { counted } = this;
+    const total = params.countFirst === true && counted !== void 0 ? (counted.nodes ?? 0) + (counted.edges ?? 0) : void 0;
+    for (; ; ) {
+      const nodes = phase === "nodes";
+      const { collected, rows, fields } = await this.generated(
+        (d) => nodes ? nodePage(profile, this.filters, size, after !== null, d) : edgePage(profile, this.filters, size, after !== null),
+        after === null ? {} : { after }
+      );
+      const next = nextCursor(phase, rows, fields, Number(size));
+      yield { collected, next };
+      const { counts: done } = ctx.report;
+      ctx.progress(done.nodes + done.edges, total, "items");
+      if (next === null) {
+        return;
+      }
+      phase = next.phase === "edges" ? "edges" : "nodes";
+      after = next.after ?? null;
+    }
+  }
+  /**
+   * Mode "all" under a node cap: pages of at most the cap's nodes, each with the relationships
+   * among the nodes loaded so far, so a capped load stops at its cap with its edges, and its
+   * next page (`data.more`) continues by key.
+   * @param profile - the server's profile
+   * @param cursor - where to resume
+   * @param size - the page size
+   * @yields one page at a time
+   */
+  async *cappedNodes(profile, cursor, size) {
+    let after = cursor?.after ?? null;
+    for (; ; ) {
+      const { collected, rows, fields } = await this.generated(
+        (d) => nodePage(profile, this.filters, String(size), after !== null, d),
+        after === null ? {} : { after }
+      );
+      const last = rows.at(-1)?.[fields.indexOf("key")];
+      const key = typeof last === "string" || typeof last === "number" ? last : null;
+      if (key !== null) {
+        const among = await this.transport.run(edgesAmong(profile, this.filters, after !== null), {
+          last: key,
+          ...after === null ? {} : { after }
+        });
+        collected.add(among, false);
+      }
+      const next = rows.length >= size && key !== null ? { phase: "nodes", after: key } : null;
+      yield { collected, next };
+      if (next === null) {
+        return;
+      }
+      after = key;
+    }
+  }
+  /**
+   * What a first page of mode "all" counts: with `countFirst`, the nodes and relationships the
+   * filters match (for progress too); else, on Neo4j with at most one label and the server's
+   * ids, the nodes from the count store; else nothing.
+   * @param profile - the server's profile
+   * @returns the count, or undefined
+   */
+  async count(profile) {
+    const first = async (statement) => {
+      const c = Number((await this.transport.run(statement, {})).rows[0]?.[0]);
+      return Number.isSafeInteger(c) && c >= 0 ? c : void 0;
+    };
+    const { labels, idProperty } = this.filters;
+    if (this.params.countFirst === true) {
+      const [n, r] = counts(this.filters);
+      const [nodes2, edges] = await Promise.all([first(n), first(r)]);
+      return { ...nodes2 === void 0 ? {} : { nodes: nodes2 }, ...edges === void 0 ? {} : { edges } };
+    }
+    if (profile.name !== "neo4j" || labels.length > 1 || idProperty !== null) {
+      return void 0;
+    }
+    const nodes = await first(storeCount(labels[0]));
+    return nodes === void 0 ? void 0 : { nodes };
+  }
+  /**
+   * The server facts and validators of what was read.
+   * @param lines - the canonical rows
+   * @returns the server facts and validators
+   */
+  async facts(lines) {
+    const profile = await this.profile();
+    const contentHash = await sha256Hex([...lines].sort(compareText).join("\n"));
+    return {
+      server: serverFacts(profile),
+      validators: profile.version === null ? { contentHash } : { contentHash, serverVersion: profile.version }
+    };
+  }
+}
+function nextCursor(phase, rows, fields, size) {
+  const last = rows.at(-1)?.[fields.indexOf("key")];
+  const key = typeof last === "string" || typeof last === "number" ? last : null;
+  if (rows.length >= size && key !== null) {
+    return { phase, after: key };
+  }
+  return phase === "nodes" ? { phase: "edges", after: null } : null;
+}
+async function open(params, ctx, preset) {
+  throwIfAborted(ctx.signal);
+  const input = { ctx, params, m: { long: params.long ?? "f64", report: ctx.report } };
+  const name = transportName(params, ctx, preset);
+  let transport;
+  switch (name) {
+    case "bolt":
+      transport = await boltTransport(input);
+      break;
+    case "neptune-https":
+      transport = neptuneHttpsTransport(input);
+      break;
+    case "neptune-analytics":
+      transport = neptuneAnalyticsTransport(input);
+      break;
+    default:
+      transport = queryApiTransport(input);
+      break;
+  }
+  try {
+    return new Reader(transport, params, ctx);
+  } catch (err) {
+    await transport.close();
+    throw err;
+  }
+}
+async function withReader(params, ctx, preset, body) {
+  const reader = await open(params, ctx, preset);
+  try {
+    return await body(reader);
+  } finally {
+    await reader.transport.close();
+  }
+}
+function cypher(preset) {
+  return defineSource({
+    id: preset.id,
+    descriptor: preset.descriptor,
+    import: (params, sink, ctx) => withReader(params, ctx, preset, async (reader) => {
+      const lines = [];
+      let next = null;
+      for await (const page of reader.pages(ctx.cursor)) {
+        writeCollected(page.collected, sink, reader.idProperty, ctx.report, ctx.signal);
+        lines.push(...canonicalRows(page.collected, reader.idProperty));
+        ({ next } = page);
+        if (next !== null && ctx.limits.reached()) {
+          break;
+        }
+      }
+      const total = reader.counted === void 0 ? {} : { total: reader.counted };
+      return ctx.finish({ next, ...total, ...await reader.facts(lines) });
+    }),
+    expand: (request, sink, ctx) => withReader(request.params, ctx, preset, (reader) => expand(reader, request, sink)),
+    probe: (params, ctx) => withReader(params, ctx, preset, async (reader) => {
+      const profile = await reader.transport.probe();
+      return { ok: true, server: serverFacts(profile) };
+    }),
+    validate: (params, seen, ctx) => withReader(params, ctx, preset, async (reader) => {
+      const lines = [];
+      for await (const page of reader.pages(null, false)) {
+        lines.push(...canonicalRows(page.collected, reader.idProperty));
+      }
+      const { validators } = await reader.facts(lines);
+      let status = "unverifiable";
+      if (seen.contentHash !== void 0) {
+        status = seen.contentHash === validators.contentHash ? "current" : "changed";
+      }
+      return { status, via: "hash", validators };
+    })
+  });
+}
+async function expand(reader, request, sink) {
+  const { ctx } = reader;
+  const { report } = ctx;
+  if (request.ids.length === 0) {
+    failOn(report, "E_SOURCE_PARAM", "an expansion needs seed ids", { name: "ids", reason: "required" });
+  }
+  const direction = request.direction ?? "both";
+  if (!DIRECTIONS.has(direction)) {
+    failOn(report, "E_SOURCE_PARAM", "direction must be out, in or both", { name: "direction", reason: "enum" });
+  }
+  const limit = request.limit ?? ctx.limits.maxNodes;
+  const after = ctx.cursor?.after ?? null;
+  const shape = {
+    depth: checkedInteger(request.depth ?? 1, "depth", 1, MAX_DEPTH, report),
+    direction,
+    limit: limit === void 0 ? null : checkedInteger(limit, "limit", 1, Number.MAX_SAFE_INTEGER, report),
+    after: after !== null
+  };
+  const filters = request.relationshipTypes === void 0 ? reader.filters : {
+    ...reader.filters,
+    relationshipTypes: request.relationshipTypes.map((t) => quoted(t, "relationshipTypes", report))
+  };
+  const profile = await reader.profile();
+  const { collected, rows, fields } = await reader.generated((d) => neighborhood(profile, filters, shape, d), {
+    ids: request.ids,
+    ...after === null ? {} : { after }
+  });
+  writeCollected(collected, sink, reader.idProperty, report, ctx.signal);
+  const { server } = await reader.facts([]);
+  const last = rows.at(-1)?.[fields.indexOf("key")];
+  const full = shape.limit !== null && rows.length >= Number(shape.limit);
+  const next = full && (typeof last === "string" || typeof last === "number") ? { after: last } : null;
+  return ctx.finish({ server, next });
+}
+const cypherSource = cypher({
+  id: CYPHER_SOURCE_ID,
+  descriptor: CYPHER_DESCRIPTOR,
+  transport: "query-api"
+});
+const neo4jSource = cypher({
+  id: NEO4J_SOURCE_ID,
+  descriptor: NEO4J_DESCRIPTOR,
+  transport: "query-api"
+});
+const neptuneSource = cypher({
+  id: NEPTUNE_SOURCE_ID,
+  descriptor: NEPTUNE_DESCRIPTOR,
+  transport: "neptune-https"
+});
+export {
+  CYPHER_DESCRIPTOR,
+  NEO4J_DESCRIPTOR,
+  NEPTUNE_DESCRIPTOR,
+  cypherIdentifier,
+  cypherSource,
+  neo4jSource,
+  neptuneSource
+};
+//# sourceMappingURL=sources-cypher.js.map