@graphty/graph-io 0.3.47 → 0.3.49

package/dist/graph-io.js

@@ -1,49 +1,65 @@
 import { INVALID_INDEX, GraphFormatError, GraphBuilder } from "@graphty/graph-format";
 import { GraphBuilder as GraphBuilder2, GraphFormatError as GraphFormatError2, INVALID_INDEX as INVALID_INDEX2 } from "@graphty/graph-format";
-import { Z as ImportReportBuilder, aj as isAbortError, ak as BAD_LINE_CODE, al as messageOf, p as plural, am as UNKNOWN_OPTION_CODE, E as EMPTY_INPUT_CODE, an as ImportError, ao as FETCH_CODE, a5 as STYLES_NOT_IMPORTED_CODE, a as agree, ap as EDGES_MERGED_CODE, aq as SELF_LOOPS_DROPPED_CODE, O as OPTION_IGNORED_CODE, ar as WEIGHT_NOT_FOUND_CODE } from "./chunks/format-BpQBx8MZ.js";
-import { a2, Q, K, B, ae, Y, a9, as, C, at, x, au, h, g, f, av, D, b, l, aw, j, q, k, y, ax, r, t, ay, az, ag, a3, H, I, aA, A, z, aB, u, v, aC, W, n, o, M, i, L, J, aD, af, aE, N, aF, G, a6, aG, P, ai, aa, F, R, aH, a4, S, T, V, aI, c, a8, aJ, aK, aL, a1, ah, U, d, s, m, e, aM, aN, a7, ac, X, w, aO, $, a0, aP, ad, aQ } from "./chunks/format-BpQBx8MZ.js";
-import { g as resolveImportOptions, j as reportSinkOptions, i as reportUnusedOptions, I as IdCoercer, l as DirectionResolver, P as LineReader, h as throwIfAborted, s as parseWeightText, Q as describe, f as chooseGraph, S as normalizeInput, U as foreignKind, V as lockReader, W as abortable } from "./chunks/export-BvqAXCKh.js";
-import { X as X2, Y as Y2, L as L2, Z, _, $ as $2, R as R2, a0 as a02, a1 as a12, c as c2, a, a2 as a22, a3 as a32, y as y2, d as d2, a4 as a42, a5, e as e2, a6 as a62, k as k2, a7 as a72, O, a8 as a82, a9 as a92, o as o2, aa as aa2, p, ab, ac as ac2, r as r2, G as G2, t as t2 } from "./chunks/export-BvqAXCKh.js";
-import { T as TextCellWriter } from "./chunks/text-CzJNFOS9.js";
-import { W as W2, i as i2, a as a10, p as p2 } from "./chunks/text-CzJNFOS9.js";
-import { C as C2, c as c3, a as a11 } from "./chunks/children-CA4coBi0.js";
+import { K as ImportReportBuilder, ao as isAbortError, ap as BAD_LINE_CODE, aq as messageOf, p as plural, ah as ImportError, o as MISSING_ID_CODE, ar as UNKNOWN_OPTION_CODE, E as EMPTY_INPUT_CODE, aa as FETCH_CODE, a0 as STYLES_NOT_IMPORTED_CODE, a as agree, as as EDGES_MERGED_CODE, at as SELF_LOOPS_DROPPED_CODE, O as OPTION_IGNORED_CODE, au as WEIGHT_NOT_FOUND_CODE } from "./chunks/report-CwMfYa9J.js";
+import { W, a3, L, B, ac, T, a8, av, C, aw, x, a6, h, g, f, ax, D, b, l, ay, j, q, k, y, az, r, t, aA, a7, ae, Y, H, I, aj, A, z, aB, u, v, aC, Z, n, M, i, $, J, al, ad, aD, N, aE, G, a1, aF, P, ag, a9, F, R, aG, _, S, a5, a4, aH, c, Q, aI, aJ, aK, V, af, U, d, s, m, e, aL, ak, a2, ab, X, w, an } from "./chunks/report-CwMfYa9J.js";
+import { D as DirectionResolver } from "./chunks/format-BXiAb-1h.js";
+import { g as g2, M as M2, P as P2, d as d2, f as f2, a, e as e2, c as c2, p } from "./chunks/format-BXiAb-1h.js";
+import { b as resolveImportOptions, f as reportSinkOptions, d as reportUnusedOptions, I as IdCoercer, p as parseWeightText, W as describe, g as chooseGraph } from "./chunks/export-Cha4dRFz.js";
+import { X as X2, L as L2, Y as Y2, R as R2, Z as Z2, H as H2, c as c3, a as a10, _ as _2, Q as Q2, n as n2, i as i2, $ as $2, e as e3, a0, h as h2, F as F2, U as U2, k as k2, V as V2, a1 as a12, r as r2, z as z2 } from "./chunks/export-Cha4dRFz.js";
+import { L as LineReader, b as throwIfAborted, f as readBytes, n as normalizeInput, g as foreignKind, l as lockReader, h as abortable } from "./chunks/input-CAxt_aV-.js";
+import { e as e4, d as d3, i as i3, r as r3, t as t2 } from "./chunks/input-CAxt_aV-.js";
+import { T as TextCellWriter } from "./chunks/text-ystE2bYi.js";
+import { W as W2, i as i4, a as a11, p as p2 } from "./chunks/text-ystE2bYi.js";
+import { C as C2, c as c4, a as a13 } from "./chunks/children-CA4coBi0.js";
 import { c as collectBytes } from "./chunks/writer-DxjgHwSe.js";
-import { D as D2, d as d3, e as e3, j as j2, t as t3 } from "./chunks/writer-DxjgHwSe.js";
+import { D as D2, d as d4, e as e5, j as j2, t as t3 } from "./chunks/writer-DxjgHwSe.js";
 import { csvImporter, csvExporter } from "./csv.js";
 import { CSV_CAPABILITIES, CSV_ISSUE, CSV_LOSS } from "./csv.js";
-import { d as cxImporter, c as cxExporter } from "./chunks/importer-BSvfrX_h.js";
-import { C as C3, a as a13, b as b2 } from "./chunks/importer-BSvfrX_h.js";
-import { c as cx2Exporter } from "./chunks/exporter-CJgfhF-l.js";
-import { C as C4, a as a14 } from "./chunks/exporter-CJgfhF-l.js";
-import { c as cx2Importer } from "./chunks/importer-CMmeMWlC.js";
-import { C as C5 } from "./chunks/importer-CMmeMWlC.js";
-import { d as cysImporter, c as cysExporter } from "./chunks/importer-iFYPEKaJ.js";
-import { C as C6, a as a15, b as b3 } from "./chunks/importer-iFYPEKaJ.js";
-import { c as dotImporter, d as dotExporter } from "./chunks/importer-COTK9Tsl.js";
-import { D as D3, a as a16, b as b4 } from "./chunks/importer-COTK9Tsl.js";
+import { c as cxExporter } from "./chunks/exporter-_jrBTnos.js";
+import { C as C3, a as a14 } from "./chunks/exporter-_jrBTnos.js";
+import { c as cxImporter } from "./chunks/importer-PqaaKKnY.js";
+import { C as C4 } from "./chunks/importer-PqaaKKnY.js";
+import { c as cx2Exporter } from "./chunks/exporter-nDfxIK5D.js";
+import { C as C5, a as a15 } from "./chunks/exporter-nDfxIK5D.js";
+import { c as cx2Importer } from "./chunks/importer-B92x1xY5.js";
+import { C as C6 } from "./chunks/importer-B92x1xY5.js";
+import { r as readZipDirectory, e as readZipEntry, d as cysImporter, c as cysExporter } from "./chunks/importer-GREKMdIf.js";
+import { C as C7, a as a16, b as b2 } from "./chunks/importer-GREKMdIf.js";
+import { b as dotImporter, d as dotExporter } from "./chunks/importer-DaLTjbds.js";
+import { D as D3, a as a17 } from "./chunks/importer-DaLTjbds.js";
 import { gexfImporter, gexfExporter } from "./gexf.js";
 import { GEXF_1_2_CAPABILITIES, GEXF_ISSUE, GEXF_LOSS } from "./gexf.js";
 import { gmlImporter, gmlExporter } from "./gml.js";
 import { GML_ISSUE, GML_LOSS, GML_STYLE_BLOCK_KEY, GML_STYLE_CAPABILITIES } from "./gml.js";
-import { a as graphmlImporter, g as graphmlExporter } from "./chunks/importer-DiZRmOQG.js";
-import { r as rankFormats, S as SNIFF_HEAD_BYTES, e as jsonImporter, c as jsonExporter } from "./chunks/exporter-CrDWIyiq.js";
-import { G as G3, J as J2, a as a17, b as b5, d as d4, g as g2, h as h2, j as j3, f as f2, n as n2, s as s2, i as i3 } from "./chunks/exporter-CrDWIyiq.js";
+import { a as graphmlImporter, g as graphmlExporter } from "./chunks/importer-CT9mJ1nn.js";
+import { S as SNIFF_HEAD_BYTES, r as rankFormats, e as jsonImporter, c as jsonExporter } from "./chunks/exporter-D2CETOMK.js";
+import { G as G2, J as J2, a as a18, b as b3, d as d5, g as g3, h as h3, j as j3, f as f3, n as n3, i as i5, s as s2, k as k3 } from "./chunks/exporter-D2CETOMK.js";
 import { neo4jImporter, neo4jExporter } from "./neo4j.js";
 import { ID_SPACE_COLUMN, LABELS_COLUMN, NEO4J_CAPABILITIES, NEO4J_ISSUE, NEO4J_LOSS, ORIGINAL_ID_COLUMN, TYPE_COLUMN, exportNeo4jFiles } from "./neo4j.js";
-import { c as oboImporter, o as oboExporter } from "./chunks/exporter--Mk9gXCJ.js";
-import { O as O2, a as a18, b as b6 } from "./chunks/exporter--Mk9gXCJ.js";
-import { d as pajekImporter, p as pajekExporter } from "./chunks/importer-e6LGpqHB.js";
-import { P as P2, a as a19, b as b7, c as c4 } from "./chunks/importer-e6LGpqHB.js";
-import { x as xgmmlExporter } from "./chunks/exporter-DndFlGSa.js";
-import { x as xgmmlImporter } from "./chunks/importer-yh_aBCU6.js";
-import { e as extractStyles } from "./chunks/generic-Dq1ntt9q.js";
-import { p as prepareStyleExport, i as isKeptGraphtyProperty } from "./chunks/writer-DMKvthQE.js";
-import { G as G4, a as a20 } from "./chunks/constants-BKwqelYD.js";
-import { G as G5 } from "./chunks/styles-yed-BF5x3_Y5.js";
-import { X as X3, a as a21 } from "./chunks/styles-BQnsga7p.js";
-import { M as M2, d as d5, c as c5, f as f3, h as h3, t as t4, x as x2 } from "./chunks/escape-CgzxiYPg.js";
-import { S as S2 } from "./chunks/block-DiGq58c3.js";
-import { j as j4, a as a23 } from "./chunks/styles-D3fRphrO.js";
+import { c as oboImporter, o as oboExporter } from "./chunks/exporter-BP6otMO6.js";
+import { O, a as a19, b as b4 } from "./chunks/exporter-BP6otMO6.js";
+import { d as pajekImporter, p as pajekExporter } from "./chunks/importer-vRq4h3j5.js";
+import { P as P3, a as a20, b as b5, c as c5 } from "./chunks/importer-vRq4h3j5.js";
+import { x as xgmmlExporter } from "./chunks/exporter-D9yMtocA.js";
+import { x as xgmmlImporter } from "./chunks/importer-Vn5QvmmJ.js";
+import { C as CYPHER_DESCRIPTOR, N as NEO4J_DESCRIPTOR, a as NEPTUNE_DESCRIPTOR } from "./chunks/codes-BE2xir2k.js";
+import { S as S2 } from "./chunks/codes-BE2xir2k.js";
+import { N as NDEX_SOURCE_ID, C as CYPHER_SOURCE_ID, h as NEO4J_SOURCE_ID, i as NEPTUNE_SOURCE_ID, R as REST_SOURCE_ID, O as OPENALEX_SOURCE_ID, S as SPARQL_SOURCE_ID, j as SOURCE_FORMAT_PREFIX, f as failOn, k as checkParams, w as warnOn, o as originOf, l as checkLazySource, m as checkSource, b as failAlone } from "./chunks/credentials-DXHx7nwR.js";
+import { n as n4, p as p3, e as e6, g as g4, c as c6, d as d6, q as q2, s as s3 } from "./chunks/credentials-DXHx7nwR.js";
+import { N as NDEX_DESCRIPTOR } from "./chunks/descriptor-C-YDhtsn.js";
+import { R as REST_DESCRIPTOR, O as OPENALEX_DESCRIPTOR } from "./chunks/descriptor-DLA5kINx.js";
+import { S as SPARQL_DESCRIPTOR } from "./chunks/descriptor-B28U25x4.js";
+import { c as createSourceContext, L as LimitStop, d as detectRuntime } from "./chunks/context-C3p0RQxR.js";
+import { e as extractStyles } from "./chunks/generic-ymWCETAJ.js";
+import { s as prepareStyleExport, t as isKeptGraphtyProperty } from "./chunks/styles-Cm62yyQX.js";
+import { D as D4 } from "./chunks/styles-Cm62yyQX.js";
+import { sha256Hex } from "./chunks/sigv4-EokFic1V.js";
+import { G as G3, a as a21 } from "./chunks/constants-CKkYLPtt.js";
+import { G as G4 } from "./chunks/styles-yed-UMFdNqze.js";
+import { X as X3, a as a22 } from "./chunks/styles-CCs214_3.js";
+import { M as M3, d as d7, c as c7, p as p4, o, t as t4, x as x2 } from "./chunks/escape-CuCIzNMB.js";
+import { S as S3 } from "./chunks/block-iptrlMBb.js";
+import { j as j4, a as a23 } from "./chunks/styles-DPQQIig4.js";
 const USED = /* @__PURE__ */ new Set(["ids", "defaultDirected", "weightFrom", "addMissingNodes"]);
 function defineLineFormat(definition) {
   const { format, extensions, mimeTypes = [], directed = false, comment = "#", sniff: sniff2, parseLine } = definition;
@@ -84,9 +100,9 @@ function defineLineFormat(definition) {
         edge: (source, target, attributes2) => {
           const raw = opts.weightFrom === null ? void 0 : attributes2?.[opts.weightFrom];
           const weight = raw === null || raw === void 0 ? void 0 : parseWeightText(String(raw), report);
-          const [s3, t5] = [ids.text(source), ids.text(target)];
-          const added = new Set([s3, t5].filter((id) => sink.indexOf(id) === INVALID_INDEX)).size;
-          const edge = edges.addEdge(s3, t5, kind, weight, { line });
+          const [s4, t5] = [ids.text(source), ids.text(target)];
+          const added = new Set([s4, t5].filter((id) => sink.indexOf(id) === INVALID_INDEX)).size;
+          const edge = edges.addEdge(s4, t5, kind, weight, { line });
           report.counts.nodes += added;
           report.counts.edges++;
           write("edge", edge, attributes2);
@@ -181,18 +197,18 @@ function compareSnapshots(expected, actual, options = {}) {
   const tolerance = options.tolerance ?? 0;
   const ctx = {
     options,
-    diff: (path, e4, a24, message) => {
+    diff: (path, e7, a24, message) => {
       diffs.push({
         path,
-        expected: e4,
+        expected: e7,
         actual: a24,
-        message: message ?? `${path}: expected ${show(e4)}, got ${show(a24)}`
+        message: message ?? `${path}: expected ${show(e7)}, got ${show(a24)}`
       });
       if (diffs.length >= limit) {
         throw new LimitReached();
       }
     },
-    same: (e4, a24) => valuesEqual(e4, a24, tolerance)
+    same: (e7, a24) => valuesEqual(e7, a24, tolerance)
   };
   try {
     compareGraphs(expected, actual, ctx);
@@ -232,10 +248,10 @@ function compareGraphs(expected, actual, ctx) {
 function compareIds(expected, actual, diff) {
   const expectedIds = expected.ids.toArray();
   const actualIds = actual.ids.toArray();
-  const n3 = Math.min(expectedIds.length, actualIds.length);
-  for (let i4 = 0; i4 < n3; i4++) {
-    if (!Object.is(expectedIds[i4], actualIds[i4])) {
-      diff(`ids[${i4}]`, expectedIds[i4], actualIds[i4]);
+  const n5 = Math.min(expectedIds.length, actualIds.length);
+  for (let i6 = 0; i6 < n5; i6++) {
+    if (!Object.is(expectedIds[i6], actualIds[i6])) {
+      diff(`ids[${i6}]`, expectedIds[i6], actualIds[i6]);
     }
   }
 }
@@ -247,10 +263,10 @@ function compareTopology(expected, actual, diff) {
     diff("colIdx", expected.colIdx, actual.colIdx, "colIdx differs");
   }
   const el = expected.edgeList();
-  const al = actual.edgeList();
-  for (let e4 = 0; e4 < expected.edgeCount; e4++) {
-    if (el.src[e4] !== al.src[e4] || el.dst[e4] !== al.dst[e4]) {
-      diff(`edge[${e4}]`, `${el.src[e4]}->${el.dst[e4]}`, `${al.src[e4]}->${al.dst[e4]}`);
+  const al2 = actual.edgeList();
+  for (let e7 = 0; e7 < expected.edgeCount; e7++) {
+    if (el.src[e7] !== al2.src[e7] || el.dst[e7] !== al2.dst[e7]) {
+      diff(`edge[${e7}]`, `${el.src[e7]}->${el.dst[e7]}`, `${al2.src[e7]}->${al2.dst[e7]}`);
     }
   }
 }
@@ -278,22 +294,22 @@ function compareWeights(expected, actual, ctx) {
   }
   const ew = expected.edgeList().weights;
   const aw2 = actual.edgeList().weights;
-  for (let e4 = 0; e4 < expected.edgeCount; e4++) {
-    const ev = ew === null ? 1 : ew[e4];
-    const av2 = aw2 === null ? 1 : aw2[e4];
+  for (let e7 = 0; e7 < expected.edgeCount; e7++) {
+    const ev = ew === null ? 1 : ew[e7];
+    const av2 = aw2 === null ? 1 : aw2[e7];
     if (!ctx.same(ev, av2)) {
-      ctx.diff(`weight[${e4}]`, ev, av2);
+      ctx.diff(`weight[${e7}]`, ev, av2);
     }
   }
 }
 function compareExactWeights(edgeCount, expected, actual, ctx) {
-  for (let e4 = 0; e4 < edgeCount; e4++) {
-    const eSet = expected.isSet(e4);
-    const aSet = actual.isSet(e4);
+  for (let e7 = 0; e7 < edgeCount; e7++) {
+    const eSet = expected.isSet(e7);
+    const aSet = actual.isSet(e7);
     if (ctx.options.weightExplicitness !== false && eSet !== aSet) {
-      ctx.diff(`weightExplicit[${e4}]`, eSet, aSet);
-    } else if (eSet && aSet && !ctx.same(expected.value(e4), actual.value(e4))) {
-      ctx.diff(`weight[${e4}]`, expected.value(e4), actual.value(e4));
+      ctx.diff(`weightExplicit[${e7}]`, eSet, aSet);
+    } else if (eSet && aSet && !ctx.same(expected.value(e7), actual.value(e7))) {
+      ctx.diff(`weight[${e7}]`, expected.value(e7), actual.value(e7));
     }
   }
 }
@@ -350,35 +366,35 @@ function compareColumn(path, column, other, ctx) {
     ctx.diff(`${path}.length`, column.length, other.length);
     return;
   }
-  for (let r3 = 0; r3 < column.length; r3++) {
-    const eSet = column.isSet(r3);
-    const aSet = other.isSet(r3);
+  for (let r4 = 0; r4 < column.length; r4++) {
+    const eSet = column.isSet(r4);
+    const aSet = other.isSet(r4);
     if (eSet !== aSet) {
-      ctx.diff(`${path}[${r3}]`, eSet ? column.value(r3) : void 0, aSet ? other.value(r3) : void 0);
+      ctx.diff(`${path}[${r4}]`, eSet ? column.value(r4) : void 0, aSet ? other.value(r4) : void 0);
     } else if (eSet) {
-      const ev = cellValue(column, r3);
-      const av2 = cellValue(other, r3);
+      const ev = cellValue(column, r4);
+      const av2 = cellValue(other, r4);
       if (!ctx.same(ev, av2)) {
-        ctx.diff(`${path}[${r3}]`, ev, av2);
+        ctx.diff(`${path}[${r4}]`, ev, av2);
       }
     }
   }
 }
 function compareDeclaration(path, column, other, ctx) {
   const { options, diff } = ctx;
-  const e4 = column.meta;
+  const e7 = column.meta;
   const a24 = other.meta;
   if (options.dtypes !== false) {
     for (const key of ["dtype", "itemDtype", "components"]) {
-      if (e4[key] !== a24[key]) {
-        diff(`${path}.${key}`, e4[key], a24[key]);
+      if (e7[key] !== a24[key]) {
+        diff(`${path}.${key}`, e7[key], a24[key]);
       }
     }
   }
-  if (options.roles !== false && e4.role !== a24.role) {
-    diff(`${path}.role`, e4.role, a24.role);
+  if (options.roles !== false && e7.role !== a24.role) {
+    diff(`${path}.role`, e7.role, a24.role);
   }
-  const eType = e4.origin?.type ?? null;
+  const eType = e7.origin?.type ?? null;
   const aType = a24.origin?.type ?? null;
   if (options.originType === true && eType !== aType) {
     diff(`${path}.origin.type`, eType, aType);
@@ -396,38 +412,38 @@ function cellValue(column, row) {
     }
   }
 }
-function valuesEqual(e4, a24, tolerance) {
-  if (typeof e4 === "number" && typeof a24 === "number") {
-    if (Object.is(e4, a24)) {
+function valuesEqual(e7, a24, tolerance) {
+  if (typeof e7 === "number" && typeof a24 === "number") {
+    if (Object.is(e7, a24)) {
       return true;
     }
-    return Number.isFinite(e4) && Number.isFinite(a24) && Math.abs(e4 - a24) <= tolerance;
+    return Number.isFinite(e7) && Number.isFinite(a24) && Math.abs(e7 - a24) <= tolerance;
   }
-  if (Array.isArray(e4) || ArrayBuffer.isView(e4)) {
-    const ea = Array.from(e4);
+  if (Array.isArray(e7) || ArrayBuffer.isView(e7)) {
+    const ea = Array.from(e7);
     if (!(Array.isArray(a24) || ArrayBuffer.isView(a24))) {
       return false;
     }
-    const aa3 = Array.from(a24);
-    return ea.length === aa3.length && ea.every((v2, i4) => valuesEqual(v2, aa3[i4], tolerance));
+    const aa = Array.from(a24);
+    return ea.length === aa.length && ea.every((v2, i6) => valuesEqual(v2, aa[i6], tolerance));
   }
-  if (typeof e4 === "object" && e4 !== null && typeof a24 === "object" && a24 !== null) {
-    const eo = e4;
+  if (typeof e7 === "object" && e7 !== null && typeof a24 === "object" && a24 !== null) {
+    const eo = e7;
     const ao = a24;
     const keys = Object.keys(eo);
     if (keys.length !== Object.keys(ao).length) {
       return false;
     }
-    return keys.every((k3) => Object.hasOwn(ao, k3) && valuesEqual(eo[k3], ao[k3], tolerance));
+    return keys.every((k4) => Object.hasOwn(ao, k4) && valuesEqual(eo[k4], ao[k4], tolerance));
   }
-  return Object.is(e4, a24);
+  return Object.is(e7, a24);
 }
-function typedEqual(a24, b8) {
-  if (a24.length !== b8.length) {
+function typedEqual(a24, b6) {
+  if (a24.length !== b6.length) {
     return false;
   }
-  for (let i4 = 0; i4 < a24.length; i4++) {
-    if (a24[i4] !== b8[i4]) {
+  for (let i6 = 0; i6 < a24.length; i6++) {
+    if (a24[i6] !== b6[i6]) {
       return false;
     }
   }
@@ -446,7 +462,7 @@ function show(v2) {
   }
 }
 function describeDiffs(diffs) {
-  return diffs.length === 0 ? "no differences" : diffs.map((d6) => `  - ${d6.message}`).join("\n");
+  return diffs.length === 0 ? "no differences" : diffs.map((d8) => `  - ${d8.message}`).join("\n");
 }
 const TOO_MANY_EMPTY_CELLS_CODE = "E_TOO_MANY_EMPTY_CELLS";
 const DEFAULT_MAX_EMPTY_CELLS = 2 ** 24;
@@ -571,6 +587,716 @@ class CellBudgetBuilder extends GraphBuilder {
     }
   }
 }
+function builtinSources() {
+  return [
+    {
+      id: NDEX_SOURCE_ID,
+      descriptor: NDEX_DESCRIPTOR,
+      load: async () => (await import("./sources-ndex.js")).ndexSource
+    },
+    {
+      id: CYPHER_SOURCE_ID,
+      descriptor: CYPHER_DESCRIPTOR,
+      load: async () => (await import("./sources-cypher.js")).cypherSource
+    },
+    {
+      id: NEO4J_SOURCE_ID,
+      descriptor: NEO4J_DESCRIPTOR,
+      load: async () => (await import("./sources-cypher.js")).neo4jSource
+    },
+    {
+      id: NEPTUNE_SOURCE_ID,
+      descriptor: NEPTUNE_DESCRIPTOR,
+      load: async () => (await import("./sources-cypher.js")).neptuneSource
+    },
+    {
+      id: REST_SOURCE_ID,
+      descriptor: REST_DESCRIPTOR,
+      load: async () => (await import("./sources-rest.js")).restMappingSource
+    },
+    {
+      id: OPENALEX_SOURCE_ID,
+      descriptor: OPENALEX_DESCRIPTOR,
+      load: async () => (await import("./sources-rest.js")).openalexSource
+    },
+    {
+      id: SPARQL_SOURCE_ID,
+      descriptor: SPARQL_DESCRIPTOR,
+      load: async () => (await import("./sources-sparql.js")).sparqlSource
+    }
+  ];
+}
+const CURSOR_VERSION_KEY = "~v";
+const SOURCE_OPTION_KEYS = /* @__PURE__ */ new Set([
+  "endpoint",
+  "credential",
+  "cursor",
+  "limits",
+  "retry",
+  "idPrefix",
+  "allowInsecure",
+  "fetch",
+  "userAgent",
+  "builder",
+  "freeze",
+  "onProgress",
+  "signal"
+]);
+const AUTH_CODES = /* @__PURE__ */ new Set(["E_SOURCE_AUTH", "E_SOURCE_FORBIDDEN"]);
+function sourceFormat(id) {
+  return `${SOURCE_FORMAT_PREFIX}${id}`;
+}
+function wrapCursor(next, version) {
+  return next === null || next === void 0 ? null : Object.freeze({ ...next, [CURSOR_VERSION_KEY]: version });
+}
+function prepare(source, rawParams, options, unit) {
+  const { descriptor } = source;
+  const version = descriptor?.version ?? 1;
+  const report = new ImportReportBuilder(sourceFormat(source.id), options.errorLimit ?? 100);
+  checkRuntime(source, report);
+  checkParams(rawParams, descriptor, report);
+  const params = {};
+  for (const p5 of descriptor?.params ?? []) {
+    if (p5.default !== void 0) {
+      params[p5.name] = p5.default;
+    }
+  }
+  Object.assign(params, rawParams);
+  const endpoint = resolveEndpoint(options.endpoint ?? descriptor?.defaultEndpoint ?? null, report);
+  if (options.credential?.origins.length === 0 && endpoint === null) {
+    failOn(report, "E_SOURCE_PARAM", "a credential needs an endpoint or its own origins", {
+      name: "credential",
+      reason: "credential-unbound"
+    });
+  }
+  const cursor = resumeCursor(options.cursor, version, report);
+  const counts = { nodes: /* @__PURE__ */ new Set(), edgesAtStart: 0, sink: null };
+  const created = createSourceContext({
+    id: source.id,
+    descriptor,
+    options,
+    report,
+    endpoint,
+    cursor,
+    unit,
+    counts: () => ({
+      nodes: counts.nodes.size,
+      edges: counts.sink === null ? 0 : counts.sink.edgeCount - counts.edgesAtStart
+    })
+  });
+  return { report, created, params, counts };
+}
+function checkRuntime(source, report) {
+  const { descriptor } = source;
+  const runtime = detectRuntime();
+  const support = descriptor?.runtimes?.[runtime];
+  if (support?.supported === false) {
+    failOn(report, "E_SOURCE_RUNTIME", `source ${source.id} cannot run in ${runtime}`, {
+      runtime,
+      reason: support.reason ?? "unsupported"
+    });
+  }
+  if (descriptor?.needs?.secureContext === true && runtime === "browser" && globalThis.isSecureContext === false) {
+    failOn(report, "E_SOURCE_RUNTIME", `source ${source.id} needs a secure context`, {
+      runtime,
+      reason: "needs-secure-context"
+    });
+  }
+}
+function resolveEndpoint(given, report) {
+  if (given === null) {
+    return null;
+  }
+  let endpoint;
+  try {
+    endpoint = new URL(given);
+  } catch {
+    failOn(report, "E_SOURCE_PARAM", "the endpoint is not a URL", { name: "endpoint", reason: "type" });
+  }
+  if (endpoint.username !== "" || endpoint.password !== "") {
+    failOn(report, "E_SOURCE_PARAM", "the endpoint may not carry a user name or password", {
+      name: "endpoint",
+      reason: "credentials-in-url"
+    });
+  }
+  return endpoint;
+}
+function resumeCursor(given, version, report) {
+  if (given === void 0 || given === null) {
+    return null;
+  }
+  const { [CURSOR_VERSION_KEY]: recorded, ...rest } = given;
+  if (recorded !== void 0 && recorded !== version) {
+    failOn(report, "E_SOURCE_PARAM", "the cursor was made by another version of the source", {
+      name: "cursor",
+      reason: "stale-cursor"
+    });
+  }
+  return Object.freeze(rest);
+}
+function wrapSink(sink, prepared, prefix) {
+  prepared.counts.sink = sink;
+  prepared.counts.edgesAtStart = sink.edgeCount;
+  const seen = prepared.counts.nodes;
+  const id = (value) => prefix === void 0 || prefix === "" ? value : `${prefix}${String(value)}`;
+  const node = (index) => {
+    seen.add(index);
+    return index;
+  };
+  const ends = (edge) => {
+    const [a24, b6] = sink.edgeEndpoints(edge);
+    seen.add(a24);
+    seen.add(b6);
+    return edge;
+  };
+  return new Proxy(sink, {
+    get(target, key) {
+      switch (key) {
+        case "addNode":
+          return (v2) => node(target.addNode(id(v2)));
+        case "addNodeRecord":
+          return (v2, attrs) => node(target.addNodeRecord(id(v2), attrs));
+        case "addNodes":
+          return (ids, out) => {
+            const result2 = target.addNodes(Array.from(ids, id), out);
+            result2.forEach((i6) => seen.add(i6));
+            return result2;
+          };
+        case "addEdge":
+          return (s4, t5, w2) => ends(target.addEdge(id(s4), id(t5), w2));
+        case "addEdgeRecord":
+          return (s4, t5, attrs, weightKey) => ends(target.addEdgeRecord(id(s4), id(t5), attrs, weightKey));
+        case "indexOf":
+          return (v2) => target.indexOf(id(v2));
+        default: {
+          const value = Reflect.get(target, key, target);
+          return typeof value === "function" ? value.bind(target) : value;
+        }
+      }
+    }
+  });
+}
+function importerOptions$1(options, signal) {
+  const out = { signal };
+  for (const [key, value] of Object.entries(options)) {
+    if (!SOURCE_OPTION_KEYS.has(key)) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function writeMeta(sink, meta) {
+  const patch = {};
+  for (const [key, value] of Object.entries(meta)) {
+    if ((key === "name" || key === "description" || key === "modified") && typeof value === "string") {
+      patch[key] = value;
+    } else if (key !== "directed" && (typeof value === "string" || typeof value === "number" || typeof value === "boolean")) {
+      sink.setGraphValue(key, value);
+    }
+  }
+  if (Object.keys(patch).length > 0) {
+    sink.setMeta(patch);
+  }
+}
+function writeBatch(batch, sink, source, prepared, first) {
+  const idKey = source.idKey ?? "id";
+  const sourceKey = source.sourceKey ?? "source";
+  const targetKey = source.targetKey ?? "target";
+  const meta = batch.meta ?? {};
+  if (first && typeof meta.directed === "boolean" && sink.edgeCount === 0) {
+    sink.setDirected(meta.directed);
+  }
+  writeMeta(sink, meta);
+  const n5 = writeNodes(batch, sink, idKey, prepared);
+  writeEdges(batch, sink, sourceKey, targetKey, prepared, n5);
+}
+function writeNodes(batch, sink, idKey, prepared) {
+  const { report } = prepared;
+  const { signal } = prepared.created.ctx;
+  let n5 = 0;
+  for (const record of batch.nodes ?? []) {
+    if (n5++ % 64 === 0) {
+      throwIfAborted(signal);
+    }
+    const { [idKey]: id, ...attrs } = record;
+    if (typeof id !== "string" && typeof id !== "number") {
+      report.error("missing-value", MISSING_ID_CODE, `a node record has no ${idKey}`);
+      report.counts.skippedNodes++;
+      continue;
+    }
+    try {
+      sink.addNodeRecord(id, attrs);
+      report.counts.nodes++;
+    } catch (err) {
+      report.recordError(err, { element: String(id) });
+      report.counts.skippedNodes++;
+    }
+  }
+  return n5;
+}
+function writeEdges(batch, sink, sourceKey, targetKey, prepared, start) {
+  const { report } = prepared;
+  const { signal } = prepared.created.ctx;
+  let n5 = start;
+  let edgeIds = null;
+  for (const record of batch.edges ?? []) {
+    if (n5++ % 64 === 0) {
+      throwIfAborted(signal);
+    }
+    const s4 = record[sourceKey];
+    const t5 = record[targetKey];
+    const edgeId = record.id;
+    const fields = Object.fromEntries(
+      Object.entries(record).filter(([k4]) => k4 !== sourceKey && k4 !== targetKey && k4 !== "id")
+    );
+    if (typeof s4 !== "string" && typeof s4 !== "number" || typeof t5 !== "string" && typeof t5 !== "number") {
+      report.error("missing-value", MISSING_ID_CODE, `an edge record has no ${sourceKey} or ${targetKey}`);
+      report.counts.skippedEdges++;
+      continue;
+    }
+    try {
+      const e7 = sink.addEdgeRecord(s4, t5, fields);
+      if (typeof edgeId === "string" || typeof edgeId === "number") {
+        edgeIds ??= edgeIdColumn(sink);
+        sink.setEdgeValue(edgeIds, e7, String(edgeId));
+      }
+      report.counts.edges++;
+    } catch (err) {
+      report.recordError(err, { element: `${String(s4)} -> ${String(t5)}` });
+      report.counts.skippedEdges++;
+    }
+  }
+}
+function endpointOrigin(endpoint) {
+  return endpoint === null ? "" : originOf(endpoint);
+}
+function edgeIdColumn(sink) {
+  const existing = sink.edgeColumn("id");
+  return existing === INVALID_INDEX ? sink.declareEdgeColumn({ name: "id", dtype: "string", role: "id", nullable: true }) : existing;
+}
+function pages(out) {
+  if (Symbol.asyncIterator in out) {
+    return out[Symbol.asyncIterator]();
+  }
+  let done = false;
+  return {
+    async next() {
+      if (done) {
+        return { done: true, value: void 0 };
+      }
+      done = true;
+      return { done: false, value: await out };
+    }
+  };
+}
+function stopOrThrow(err, page, prepared) {
+  if (err instanceof LimitStop) {
+    return;
+  }
+  if (page > 0 && err instanceof ImportError && AUTH_CODES.has(String(err.issue?.code))) {
+    const p5 = err.issue?.params ?? {};
+    warnOn(prepared.report, "W_SOURCE_AUTH", "a later page needs a credential; the pages before it are kept", {
+      origin: typeof p5.origin === "string" ? p5.origin : endpointOrigin(prepared.created.ctx.endpoint),
+      status: typeof p5.status === "number" ? p5.status : null
+    });
+    return;
+  }
+  throw err;
+}
+async function runRecords(source, sink, prepared) {
+  const { ctx } = prepared.created;
+  const records = source.records;
+  const iterator = pages(records(prepared.params, ctx));
+  let next = ctx.cursor;
+  let page = 0;
+  let stopped = false;
+  try {
+    for (; ; ) {
+      let step;
+      try {
+        step = await iterator.next();
+      } catch (err) {
+        stopOrThrow(err, page, prepared);
+        stopped = true;
+        return next;
+      }
+      if (step.done === true) {
+        return page === 0 ? null : next;
+      }
+      writeBatch(step.value, sink, source, prepared, page === 0);
+      page++;
+      next = step.value.next ?? null;
+      ctx.progress(prepared.report.counts.nodes + prepared.report.counts.edges, void 0, "items");
+      if (ctx.limits.reached()) {
+        stopped = true;
+        return next;
+      }
+    }
+  } finally {
+    if (stopped) {
+      await iterator.return?.().catch(() => void 0);
+    }
+  }
+}
+async function fileInput(file, formats, signal) {
+  let input = file.body instanceof Response ? file.body.body ?? new Uint8Array(0) : file.body;
+  let { filename } = file;
+  let mimeType = file.mimeType ?? (file.body instanceof Response ? file.body.headers.get("content-type") ?? void 0 : void 0);
+  const gzip = /\.gz$/i.test(filename ?? "") || /gzip/i.test(mimeType ?? "");
+  const zip = /\.zip$/i.test(filename ?? "") || /\/(x-)?zip\b/i.test(mimeType ?? "");
+  if (gzip) {
+    const stream = input instanceof ReadableStream ? input : new Response(await bytesOf(input, signal)).body;
+    input = (stream ?? new Response("").body ?? new ReadableStream()).pipeThrough(
+      new DecompressionStream("gzip")
+    );
+    filename = filename?.replace(/\.gz$/i, "");
+    mimeType = void 0;
+  } else if (zip) {
+    const bytes = await bytesOf(input, signal);
+    const entry = readZipDirectory(bytes).find((e7) => !e7.directory && formats.sniff({ filename: e7.name }) !== null);
+    if (entry === void 0) {
+      throw new ImportError("the zip holds no graph file", new ImportReportBuilder("zip", 0).finish());
+    }
+    input = await readZipEntry(bytes, entry, { signal, maxBytes: Number.MAX_SAFE_INTEGER, maxRatio: 1e3 });
+    filename = entry.name;
+    mimeType = void 0;
+  }
+  return { input, filename, mimeType };
+}
+async function bytesOf(input, signal) {
+  return await readBytes(input, { signal }) ?? new TextEncoder().encode(typeof input === "string" ? input : "");
+}
+async function runFile(source, sink, prepared, formats, options) {
+  const { ctx } = prepared.created;
+  const read = source.file;
+  const file = await read(prepared.params, ctx);
+  const { input, filename, mimeType } = await fileInput(file, formats, ctx.signal);
+  let { format } = file;
+  let body = input;
+  if (format === void 0) {
+    const bytes = await bytesOf(input, ctx.signal);
+    format = formats.sniff({ filename, mimeType, head: bytes.subarray(0, SNIFF_HEAD_BYTES) })?.format;
+    body = bytes;
+    if (format === void 0) {
+      failOn(prepared.report, "E_SOURCE_RESPONSE", "the file is in no format graph-io reads", {
+        expected: "graph-file",
+        contentType: mimeType ?? null
+      });
+    }
+  }
+  const importer = formats.importer(format);
+  prepared.report.include(await importer.import(body, sink, importerOptions$1(options, ctx.signal)));
+  writeMeta(sink, file.meta ?? {});
+  return format;
+}
+async function runIntoSink(source, params, sink, options, formats) {
+  const prepared = prepare(source, params, options, typeof source.file === "function" ? "bytes" : "items");
+  const { ctx } = prepared.created;
+  const version = source.descriptor?.version ?? 1;
+  const wrapped = wrapSink(sink, prepared, options.idPrefix);
+  try {
+    if (typeof source.records === "function") {
+      const next = await runRecords(source, wrapped, prepared);
+      throwIfAborted(ctx.signal);
+      return {
+        report: withSource(prepared.report.finish(), prepared, wrapCursor(next, version)),
+        format: sourceFormat(source.id)
+      };
+    }
+    if (typeof source.file === "function") {
+      const format = await runFile(source, wrapped, prepared, formats, options);
+      return { report: withSource(prepared.report.finish(), prepared, null), format };
+    }
+    const run = source.import;
+    const report = await stopAtLimit(run(prepared.params, wrapped, ctx), prepared);
+    throwIfAborted(ctx.signal);
+    return {
+      report: withSource(report, prepared, wrapCursor(prepared.created.state.finish?.next, version)),
+      format: sourceFormat(source.id)
+    };
+  } catch (err) {
+    throw settle(err, prepared);
+  } finally {
+    prepared.created.dispose();
+  }
+}
+async function runMethod(source, feature, params, options, call) {
+  if (typeof source[feature] !== "function") {
+    failOn(
+      new ImportReportBuilder(sourceFormat(source.id), 0),
+      "E_SOURCE_UNSUPPORTED",
+      `source ${source.id} has no ${feature}`,
+      {
+        feature
+      }
+    );
+  }
+  const prepared = prepare(source, params, options, "items");
+  try {
+    const out = await call(prepared);
+    throwIfAborted(prepared.created.ctx.signal);
+    return out;
+  } catch (err) {
+    throw settle(err, prepared);
+  } finally {
+    prepared.created.dispose();
+  }
+}
+function withSource(report, prepared, next) {
+  const own = prepared.report.finish();
+  const missing = own.issues.filter((i6) => !report.issues.includes(i6));
+  return Object.freeze({
+    ...report,
+    issues: missing.length === 0 ? report.issues : Object.freeze([...report.issues, ...missing]),
+    warningCount: report.warningCount + missing.filter((i6) => i6.severity === "warning").length,
+    errorCount: report.errorCount + missing.filter((i6) => i6.severity === "error").length,
+    source: prepared.created.info(next)
+  });
+}
+function settle(err, prepared) {
+  const { signal } = prepared.created.ctx;
+  if (signal.aborted) {
+    return signal.reason;
+  }
+  if (err instanceof LimitStop) {
+    return settle(limitError(err, prepared), prepared);
+  }
+  if (err instanceof ImportError && err.report.source === void 0) {
+    const withInfo = new ImportError(
+      err.message,
+      { ...err.report, source: prepared.created.info(null) },
+      err.details
+    );
+    withInfo.stack = err.stack;
+    return withInfo;
+  }
+  return err;
+}
+function limitError(stop, prepared) {
+  try {
+    return failOn(prepared.report, "E_SOURCE_LIMIT", stop.message, { limit: stop.limit, value: stop.value });
+  } catch (err) {
+    return err;
+  }
+}
+async function stopAtLimit(run, prepared) {
+  try {
+    return await run;
+  } catch (err) {
+    if (err instanceof LimitStop) {
+      return prepared.report.finish();
+    }
+    throw err;
+  }
+}
+function isLazy(value) {
+  const v2 = value;
+  return typeof v2.load === "function" && v2.records === void 0 && v2.file === void 0 && v2.import === void 0;
+}
+class SourceRegistry {
+  /**
+   * Create one for a format registry, whose importers read `file` sources.
+   * @param formats - the format registry
+   * @param building - how it builds and freezes graphs
+   */
+  constructor(formats, building) {
+    this.formats = formats;
+    this.building = building;
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a source or a lazy source. A malformed one, or an id already taken, throws an
+   * ImportError with E_SOURCE_INVALID.
+   * @param source - the source
+   */
+  register(source) {
+    if (isLazy(source)) {
+      checkLazySource(source);
+    } else {
+      checkSource(source);
+    }
+    if (this.entries.has(source.id)) {
+      failAlone("E_SOURCE_INVALID", `a source with id ${source.id} is already registered`, {
+        id: source.id,
+        reason: "duplicate"
+      });
+    }
+    const lazy = isLazy(source) ? source : null;
+    this.entries.set(source.id, {
+      descriptor: source.descriptor ?? { plainName: source.id, params: [] },
+      lazy,
+      source: lazy === null ? source : null,
+      loading: null
+    });
+  }
+  /**
+   * Whether a source id is registered.
+   * @param id - the id
+   * @returns true when registered
+   */
+  has(id) {
+    return this.entries.has(id);
+  }
+  /**
+   * Every registered source, without loading any code.
+   * @returns one entry per source, in registration order
+   */
+  list() {
+    return Object.freeze(
+      [...this.entries].map(
+        ([id, e7]) => Object.freeze({ id, descriptor: e7.descriptor, loaded: e7.source !== null })
+      )
+    );
+  }
+  /**
+   * A source by id, loading a lazy one; a source object passes through after its checks.
+   * @param source - the id or the source
+   * @returns the loaded source
+   */
+  async resolve(source) {
+    if (typeof source !== "string") {
+      checkSource(source);
+      return source;
+    }
+    const entry = this.entries.get(source);
+    if (entry === void 0) {
+      return failAlone(
+        "E_SOURCE_UNKNOWN",
+        `no source has id ${JSON.stringify(source)}`,
+        { id: source, known: [...this.entries.keys()] },
+        sourceFormat(source)
+      );
+    }
+    if (entry.source !== null) {
+      return entry.source;
+    }
+    const lazy = entry.lazy;
+    entry.loading ??= lazy.load().then(
+      (loaded) => {
+        if (loaded.id !== lazy.id) {
+          failAlone("E_SOURCE_INVALID", `lazy source ${lazy.id} loaded a source with id ${loaded.id}`, {
+            id: lazy.id,
+            reason: "lazy"
+          });
+        }
+        checkSource(loaded, lazy.descriptor);
+        entry.source = loaded.descriptor === void 0 ? { ...loaded, descriptor: lazy.descriptor } : loaded;
+        return entry.source;
+      },
+      (err) => {
+        entry.loading = null;
+        throw err;
+      }
+    );
+    return entry.loading;
+  }
+  /**
+   * Load a graph from a source.
+   * @param source - the id or the source
+   * @param params - its params
+   * @param options - endpoint, credential, cursor, caps and the import options
+   * @returns the graph and the report
+   */
+  async load(source, params, options = {}) {
+    const resolved = await this.resolve(source);
+    const builder = this.building.newBuilder(options, sourceFormat(resolved.id));
+    const { report, format } = await runIntoSink(resolved, params, builder, options, this.formats);
+    return this.building.freeze(format, builder, report, options);
+  }
+  /**
+   * Load from a source into a sink you own.
+   * @param source - the id or the source
+   * @param params - its params
+   * @param sink - where to write
+   * @param options - the options
+   * @returns the report
+   */
+  async import(source, params, sink, options = {}) {
+    const resolved = await this.resolve(source);
+    return (await runIntoSink(resolved, params, sink, options, this.formats)).report;
+  }
+  /**
+   * Fetch the neighborhood of some nodes: a snapshot of only what was fetched.
+   * @param source - the id or the source
+   * @param request - the seeds and how far to go
+   * @param options - the options
+   * @returns the fetched part and the report
+   */
+  async expand(source, request, options = {}) {
+    const resolved = await this.resolve(source);
+    const builder = this.building.newBuilder(options, sourceFormat(resolved.id));
+    const report = await runMethod(resolved, "expand", request.params, options, async (prepared) => {
+      const sink = wrapSink(builder, prepared, options.idPrefix);
+      const run = resolved.expand?.({ ...request, params: prepared.params }, sink, prepared.created.ctx);
+      const out = await stopAtLimit(run, prepared);
+      return withSource(
+        out,
+        prepared,
+        wrapCursor(prepared.created.state.finish?.next, resolved.descriptor?.version ?? 1)
+      );
+    });
+    return this.building.freeze(sourceFormat(resolved.id), builder, report, options);
+  }
+  /**
+   * Check params and credential without loading.
+   * @param source - the id or the source
+   * @param params - its params
+   * @param options - the options
+   * @returns what the service said
+   */
+  async probe(source, params, options = {}) {
+    const resolved = await this.resolve(source);
+    return runMethod(
+      resolved,
+      "probe",
+      params,
+      options,
+      (prepared) => resolved.probe?.(prepared.params, prepared.created.ctx)
+    );
+  }
+  /**
+   * Search what a source holds.
+   * @param source - the id or the source
+   * @param query - the search
+   * @param options - the options
+   * @returns one page of results
+   */
+  async search(source, query, options = {}) {
+    const resolved = await this.resolve(source);
+    const partial = resolved.descriptor === void 0 ? void 0 : {
+      ...resolved.descriptor,
+      params: resolved.descriptor.params.map((p5) => ({ ...p5, required: false }))
+    };
+    return runMethod(
+      { ...resolved, descriptor: partial },
+      "list",
+      query.params,
+      options,
+      (prepared) => resolved.list?.(
+        { ...query, params: prepared.params },
+        prepared.created.ctx
+      )
+    );
+  }
+  /**
+   * Tell whether data loaded earlier changed.
+   * @param source - the id or the source
+   * @param params - the params it was loaded with
+   * @param seen - the validators recorded then
+   * @param options - the options
+   * @returns whether it changed
+   */
+  async validate(source, params, seen, options = {}) {
+    const resolved = await this.resolve(source);
+    return runMethod(
+      resolved,
+      "validate",
+      params,
+      options,
+      (prepared) => resolved.validate?.(prepared.params, seen, prepared.created.ctx)
+    );
+  }
+}
 const UNKNOWN_FORMAT_CODE = "E_UNKNOWN_FORMAT";
 const SNIFF_FAILED_CODE = "W_SNIFF_FAILED";
 const FUNCTION_OPTIONS = /* @__PURE__ */ new Set([
@@ -615,6 +1341,112 @@ class FormatRegistry {
   constructor() {
     this.importerMap = /* @__PURE__ */ new Map();
     this.exporterMap = /* @__PURE__ */ new Map();
+    this.sources = new SourceRegistry(this, {
+      newBuilder: (options, format) => seededBuilder(options, format),
+      freeze: (format, builder, report, options) => result(
+        { importer: { format }, sniff: null, warnings: [] },
+        builder,
+        report,
+        options
+      )
+    });
+  }
+  /**
+   * Register a network source, or a lazy one whose code loads on first use. Source ids are their
+   * own name space, apart from format names. Throws an ImportError with E_SOURCE_INVALID for a
+   * malformed source or an id already taken. Experimental.
+   * @param source - the source
+   * @returns this registry
+   */
+  registerSource(source) {
+    this.sources.register(source);
+    return this;
+  }
+  /**
+   * A registered source by id, its code loaded. Rejects with E_SOURCE_UNKNOWN for an id no
+   * source has. Experimental.
+   * @param id - the source id
+   * @returns the source
+   */
+  source(id) {
+    return this.sources.resolve(id);
+  }
+  /**
+   * Whether a source id is registered. Experimental.
+   * @param id - the source id
+   * @returns true when registered
+   */
+  hasSource(id) {
+    return this.sources.has(id);
+  }
+  /**
+   * Every registered source with its descriptor, loading no source code. Experimental.
+   * @returns one entry per source
+   */
+  listSources() {
+    return this.sources.list();
+  }
+  /**
+   * Load a graph from a network source; see the top-level loadFromSource(). Experimental.
+   * @param source - the source id or the source
+   * @param params - its params
+   * @param options - endpoint, credential, cursor, caps and import options
+   * @returns the graph and the report
+   */
+  loadFromSource(source, params, options) {
+    return this.sources.load(source, params, options);
+  }
+  /**
+   * Load from a network source into a sink you own. Experimental.
+   * @param source - the source id or the source
+   * @param params - its params
+   * @param sink - where to write
+   * @param options - the options
+   * @returns the report
+   */
+  importFromSource(source, params, sink, options) {
+    return this.sources.import(source, params, sink, options);
+  }
+  /**
+   * Fetch the neighborhood of some nodes from a network source. Experimental.
+   * @param source - the source id or the source
+   * @param request - the seeds and how far to go
+   * @param options - the options
+   * @returns a graph of only what was fetched
+   */
+  expandFromSource(source, request, options) {
+    return this.sources.expand(source, request, options);
+  }
+  /**
+   * Check a source's params and credential without loading. Experimental.
+   * @param source - the source id or the source
+   * @param params - its params
+   * @param options - the options
+   * @returns what the service said
+   */
+  probeSource(source, params, options) {
+    return this.sources.probe(source, params, options);
+  }
+  /**
+   * Search what a source holds. Experimental.
+   * @param source - the source id or the source
+   * @param query - the search
+   * @param options - the options
+   * @returns one page of results
+   */
+  listFromSource(source, query, options) {
+    return this.sources.search(source, query, options);
+  }
+  /**
+   * Tell whether data loaded from a source changed. Experimental.
+   * @param source - the source id or the source
+   * @param params - the params it was loaded with
+   * @param seen - the validators recorded then (`report.source.validators`)
+   * @param options - the options
+   * @returns whether it changed
+   */
+  validateSource(source, params, seen, options) {
+    return this.sources.validate(source, params, seen, options);
   }
   /**
    * Register an importer under its format name, replacing one of the same name in place (the
@@ -740,7 +1572,7 @@ class FormatRegistry {
     const { importer } = chosen;
     if ((opts.graphIndex !== void 0 || opts.graphName !== void 0) && importer.importAll !== void 0 && importer.listGraphs === void 0) {
       const all = await this.readAll(chosen, opts);
-      const names = all.map((r3) => r3.snapshot.meta.name);
+      const names = all.map((r4) => r4.snapshot.meta.name);
       return all[chooseGraph(names, opts, new ImportReportBuilder(importer.format, 0))];
     }
     let builder;
@@ -846,11 +1678,11 @@ class FormatRegistry {
         builders.length - 1
       );
     }
-    return reports.map((report, i4) => {
+    return reports.map((report, i6) => {
       try {
-        return result(chosen, builders[i4], report, options);
+        return result(chosen, builders[i6], report, options);
       } catch (err) {
-        throw inGraph(err, i4);
+        throw inGraph(err, i6);
       }
     });
   }
@@ -1038,11 +1870,11 @@ class FormatRegistry {
     if (styled === null) {
       notes = this.exporter(format).check(snapshot, options);
     } else if (styled.refusal === null) {
-      const key = (n3) => `${n3.code}\0${n3.style?.target ?? ""}\0${n3.style?.property ?? ""}`;
-      const reported = new Set(styled.notes.filter((n3) => n3.style !== void 0).map(key));
+      const key = (n5) => `${n5.code}\0${n5.style?.target ?? ""}\0${n5.style?.property ?? ""}`;
+      const reported = new Set(styled.notes.filter((n5) => n5.style !== void 0).map(key));
       notes = [
         ...styled.exporter.check(styled.snapshot, styled.options).filter(
-          (n3) => n3.style === void 0 || !reported.has(key(n3)) && !isKeptGraphtyProperty(n3, styled.exporter)
+          (n5) => n5.style === void 0 || !reported.has(key(n5)) && !isKeptGraphtyProperty(n5, styled.exporter)
         ),
         ...styled.notes
       ];
@@ -1135,7 +1967,11 @@ class FormatRegistry {
   }
 }
 function createRegistry() {
-  return new FormatRegistry().registerImporter(jsonImporter).registerExporter(jsonExporter).registerImporter(graphmlImporter).registerExporter(graphmlExporter).registerImporter(gexfImporter).registerExporter(gexfExporter).registerImporter(csvImporter).registerExporter(csvExporter).registerImporter(gmlImporter).registerExporter(gmlExporter).registerImporter(dotImporter).registerExporter(dotExporter).registerImporter(pajekImporter).registerExporter(pajekExporter).registerImporter(neo4jImporter).registerExporter(neo4jExporter).registerImporter(xgmmlImporter).registerExporter(xgmmlExporter).registerImporter(cx2Importer).registerExporter(cx2Exporter).registerImporter(cxImporter).registerExporter(cxExporter).registerImporter(oboImporter).registerExporter(oboExporter).registerImporter(cysImporter).registerExporter(cysExporter);
+  const formats = new FormatRegistry().registerImporter(jsonImporter).registerExporter(jsonExporter).registerImporter(graphmlImporter).registerExporter(graphmlExporter).registerImporter(gexfImporter).registerExporter(gexfExporter).registerImporter(csvImporter).registerExporter(csvExporter).registerImporter(gmlImporter).registerExporter(gmlExporter).registerImporter(dotImporter).registerExporter(dotExporter).registerImporter(pajekImporter).registerExporter(pajekExporter).registerImporter(neo4jImporter).registerExporter(neo4jExporter).registerImporter(xgmmlImporter).registerExporter(xgmmlExporter).registerImporter(cx2Importer).registerExporter(cx2Exporter).registerImporter(cxImporter).registerExporter(cxExporter).registerImporter(oboImporter).registerExporter(oboExporter).registerImporter(cysImporter).registerExporter(cysExporter);
+  for (const source of builtinSources()) {
+    formats.registerSource(source);
+  }
+  return formats;
 }
 const registry = /* @__PURE__ */ createRegistry();
 function importGraph(input, options) {
@@ -1295,7 +2131,7 @@ function result(chosen, builder, report, options) {
   return Object.freeze(result2);
 }
 function withoutStylesNotImported(report) {
-  const issues = report.issues.filter((i4) => i4.code !== STYLES_NOT_IMPORTED_CODE);
+  const issues = report.issues.filter((i6) => i6.code !== STYLES_NOT_IMPORTED_CODE);
   if (issues.length === report.issues.length) {
     return report;
   }
@@ -1326,7 +2162,7 @@ function unknownOptionText(name) {
   return `option ${JSON.stringify(name)} is not an option of any format or of the load and save functions, so it has no effect; check its spelling`;
 }
 function weightNotFound(report, snapshot, weightFrom) {
-  if (typeof weightFrom !== "string" || snapshot.edgeCount === 0 || snapshot.edgeList().weights !== null || report.issues.some((i4) => i4.code === OPTION_IGNORED_CODE && i4.element === "weightFrom")) {
+  if (typeof weightFrom !== "string" || snapshot.edgeCount === 0 || snapshot.edgeList().weights !== null || report.issues.some((i6) => i6.code === OPTION_IGNORED_CODE && i6.element === "weightFrom")) {
     return report;
   }
   const issue = Object.freeze({
@@ -1441,10 +2277,10 @@ async function peekHead(input, bytes, signal) {
   return { head: joinHead(buffered, bytes), input: replayed, close: () => replayed.close() };
 }
 function joinHead(chunks, bytes) {
-  if (chunks.every((c6) => c6 instanceof Uint8Array)) {
+  if (chunks.every((c8) => c8 instanceof Uint8Array)) {
     const total = Math.min(
       bytes,
-      chunks.reduce((sum, c6) => sum + c6.byteLength, 0)
+      chunks.reduce((sum, c8) => sum + c8.byteLength, 0)
     );
     const head = new Uint8Array(total);
     let offset = 0;
@@ -1537,61 +2373,166 @@ function readerIterator(stream, signal) {
     }
   };
 }
+function loadFromSource(source, params, options) {
+  return registry.loadFromSource(source, params, options);
+}
+function importFromSource(source, params, sink, options) {
+  return registry.importFromSource(source, params, sink, options);
+}
+function expandFromSource(source, request, options) {
+  return registry.expandFromSource(source, request, options);
+}
+function probeSource(source, params, options) {
+  return registry.probeSource(source, params, options);
+}
+function listFromSource(source, query, options) {
+  return registry.listFromSource(source, query, options);
+}
+function validateSource(source, params, seen, options) {
+  return registry.validateSource(source, params, seen, options);
+}
+function registerSource(source) {
+  registry.registerSource(source);
+}
+function listSources() {
+  return registry.listSources();
+}
+function replayFetch(recordings, options = {}) {
+  const secretQuery = new Set(options.secretQuery ?? []);
+  const secretHeaders = ["authorization", ...(options.secretHeaders ?? []).map((h4) => h4.toLowerCase())];
+  const used = /* @__PURE__ */ new Set();
+  const calls = [];
+  const key = (url) => {
+    const params = [...url.searchParams].filter(([k4]) => !secretQuery.has(k4)).sort(compare);
+    return `${url.origin}${url.pathname}?${new URLSearchParams(params).toString()}`;
+  };
+  const replay2 = async (input, init) => {
+    const request = new Request(input, init);
+    request.signal.throwIfAborted();
+    const url = new URL(request.url);
+    const method = request.method.toUpperCase();
+    const body = method === "GET" || method === "HEAD" ? "" : await request.clone().text();
+    const credential = secretHeaders.some((h4) => request.headers.has(h4)) || [...url.searchParams.keys()].some((k4) => secretQuery.has(k4));
+    const wanted = key(url);
+    const matches = [];
+    recordings.forEach((r22, i6) => {
+      if ((r22.method ?? "GET").toUpperCase() === method && key(new URL(r22.url)) === wanted && (r22.credential === void 0 || r22.credential === credential) && (r22.requestBody === void 0 || sameBody(r22.requestBody, body))) {
+        matches.push(i6);
+      }
+    });
+    const index = matches.find((i6) => !used.has(i6)) ?? matches.at(-1);
+    if (index === void 0) {
+      throw new Error(`replayFetch: no recording for ${method} ${url.origin}${url.pathname}`);
+    }
+    used.add(index);
+    calls.push({ method, url: `${url.origin}${url.pathname}`, credential });
+    const r4 = recordings[index];
+    const status = r4.status ?? 200;
+    const text = bodyText(r4.body);
+    const headers = new Headers(r4.headers);
+    if (text !== null && typeof r4.body !== "string" && !headers.has("content-type")) {
+      headers.set("content-type", "application/json");
+    }
+    const nullBody = status === 204 || status === 304 || status >= 300 && status < 400 && text === null;
+    return new Response(nullBody ? null : text, { status, headers });
+  };
+  return Object.assign(replay2, { calls });
+}
+function bodyText(body) {
+  if (body === void 0 || body === null) {
+    return null;
+  }
+  return typeof body === "string" ? body : JSON.stringify(body);
+}
+function compare(a24, b6) {
+  return a24[0] === b6[0] ? a24[1].localeCompare(b6[1]) : a24[0].localeCompare(b6[0]);
+}
+function sameBody(recorded, sent) {
+  try {
+    return JSON.stringify(JSON.parse(recorded)) === JSON.stringify(JSON.parse(sent));
+  } catch {
+    return recorded === sent;
+  }
+}
+async function recordingFrom(request, response, options = {}) {
+  const headers = {};
+  for (const name of ["content-type", ...options.keepHeaders ?? []]) {
+    const value = response.headers.get(name);
+    if (value !== null) {
+      headers[name.toLowerCase()] = value;
+    }
+  }
+  const url = new URL(request.url);
+  for (const name of options.secretQuery ?? []) {
+    url.searchParams.delete(name);
+  }
+  const method = request.method.toUpperCase();
+  const requestBody = method === "GET" || method === "HEAD" ? void 0 : await request.clone().text();
+  return {
+    method,
+    url: url.toString(),
+    ...requestBody === void 0 || requestBody === "" ? {} : { requestBody },
+    status: response.status,
+    headers,
+    body: await response.text()
+  };
+}
 export {
-  a2 as AMBIGUOUS_GRAPH_NAME_CODE,
-  Q as ASPECT_ORDER_CODE,
-  K as BAD_ASPECT_BLOCK_CODE,
+  W as AMBIGUOUS_GRAPH_NAME_CODE,
+  a3 as ASPECT_ORDER_CODE,
+  L as BAD_ASPECT_BLOCK_CODE,
   B as BAD_DEFAULT_CODE,
   BAD_LINE_CODE,
-  ae as BAD_OPTIONS_CODE,
-  Y as BAD_VALUE_CODE,
-  a9 as COLUMN_AS_PROPERTY_VALUE_CODE,
-  as as COLUMN_DROPPED_CODE,
+  ac as BAD_OPTIONS_CODE,
+  T as BAD_VALUE_CODE,
+  a8 as COLUMN_AS_PROPERTY_VALUE_CODE,
+  av as COLUMN_DROPPED_CODE,
   C as COLUMN_RENAMED_CODE,
-  at as COLUMN_RENAMED_LOSS_CODE,
+  aw as COLUMN_RENAMED_LOSS_CODE,
   x as COLUMN_TYPE_CODE,
-  au as CONTROL_CHARACTER_CODE,
+  a6 as CONTROL_CHARACTER_CODE,
   h as COUNT_HINT_CODE,
   g as COUNT_MISMATCH_CODE,
   CSV_CAPABILITIES,
   CSV_ISSUE,
   CSV_LOSS,
-  C4 as CX2_CAPABILITIES,
-  C5 as CX2_ISSUE,
-  a14 as CX2_LOSS,
+  C5 as CX2_CAPABILITIES,
+  C6 as CX2_ISSUE,
+  a15 as CX2_LOSS,
   C3 as CX_CAPABILITIES,
-  a13 as CX_ISSUE,
-  b2 as CX_LOSS,
-  C6 as CYS_CAPABILITIES,
-  a15 as CYS_ISSUE,
-  b3 as CYS_LOSS,
+  C4 as CX_ISSUE,
+  a14 as CX_LOSS,
+  CYPHER_SOURCE_ID,
+  C7 as CYS_CAPABILITIES,
+  a16 as CYS_ISSUE,
+  b2 as CYS_LOSS,
   C2 as ChildrenCsr,
   f as DANGLING_REFERENCE_CODE,
   D2 as DEFAULT_CHUNK_BYTES,
   X2 as DEFAULT_ERROR_LIMIT,
-  Y2 as DIRECTED_COLUMN,
-  av as DIRECTION_DROPPED_CODE,
+  g2 as DIRECTED_COLUMN,
+  ax as DIRECTION_DROPPED_CODE,
   D as DIRECTION_FORCED_CODE,
   b as DIRECTION_REFUSED_CODE,
   D3 as DOT_ISSUE,
-  a16 as DOT_LOSS,
-  S2 as DOT_STYLE_BLOCK_ATTRIBUTE,
-  b4 as DOT_STYLE_CAPABILITIES,
+  a17 as DOT_LOSS,
+  S3 as DOT_STYLE_BLOCK_ATTRIBUTE,
+  D4 as DOT_STYLE_CAPABILITIES,
   l as DUPLICATE_ATTRIBUTE_CODE,
-  aw as DUPLICATE_EDGE_CODE,
+  ay as DUPLICATE_EDGE_CODE,
   j as DUPLICATE_EDGE_ID_CODE,
   q as DUPLICATE_KEY_CODE,
   k as DUPLICATE_NODE_CODE,
   DirectionResolver,
   EDGES_MERGED_CODE,
   y as ELEMENT_ISSUE,
-  ax as EMPTY_COLUMN_DROPPED_CODE,
+  az as EMPTY_COLUMN_DROPPED_CODE,
   EMPTY_INPUT_CODE,
   r as ENCODING_CONFLICT_CODE,
   t as ENCODING_FALLBACK_CODE,
-  ay as EQUATION_AS_TEXT_CODE,
+  aA as EQUATION_AS_TEXT_CODE,
   FETCH_CODE,
-  az as FOREIGN_FORMAT_CODE,
+  a7 as FOREIGN_FORMAT_CODE,
   FormatRegistry,
   GEXF_1_2_CAPABILITIES,
   GEXF_ISSUE,
@@ -1601,19 +2542,19 @@ export {
   GML_LOSS,
   GML_STYLE_BLOCK_KEY,
   GML_STYLE_CAPABILITIES,
-  G4 as GRAPHML_ISSUE,
-  a20 as GRAPHML_LOSS,
-  G5 as GRAPHML_STYLE_CAPABILITIES,
+  G3 as GRAPHML_ISSUE,
+  a21 as GRAPHML_LOSS,
+  G4 as GRAPHML_STYLE_CAPABILITIES,
   a23 as GRAPHTY_XML_NAMESPACE,
-  ag as GRAPH_COLUMN_AS_METADATA_CODE,
-  G3 as GRAPH_FORMATS,
-  a3 as GRAPH_NOT_FOUND_CODE,
+  ae as GRAPH_COLUMN_AS_METADATA_CODE,
+  G2 as GRAPH_FORMATS,
+  Y as GRAPH_NOT_FOUND_CODE,
   GraphBuilder2 as GraphBuilder,
   GraphFormatError2 as GraphFormatError,
   H as HYPEREDGE_CODE,
   I as ID_MERGED_CODE,
   ID_SPACE_COLUMN,
-  aA as ID_TEXT_COLLISION_CODE,
+  aj as ID_TEXT_COLLISION_CODE,
   A as ID_TEXT_TYPE_CODE,
   z as INPUT_ISSUE,
   aB as INTEGRAL_F64_CODE,
@@ -1625,65 +2566,77 @@ export {
   ImportError,
   ImportReportBuilder,
   J2 as JSON_DIALECTS,
-  a17 as JSON_ISSUE,
-  b5 as JSON_LOSS,
-  W as JSON_NONSTANDARD_NUMBER_CODE,
+  a18 as JSON_ISSUE,
+  b3 as JSON_LOSS,
+  Z as JSON_NONSTANDARD_NUMBER_CODE,
   LABELS_COLUMN,
   L2 as LOSS,
   LineReader,
-  M2 as MAX_XML_DEPTH,
+  M3 as MAX_XML_DEPTH,
   n as MISSING_ENDPOINT_CODE,
-  o as MISSING_ID_CODE,
+  MISSING_ID_CODE,
   M as MIXED_DIRECTION_CODE,
   i as MULTIPLE_GRAPHS_CODE,
-  L as MULTI_ASPECT_FRAGMENT_CODE,
+  $ as MULTI_ASPECT_FRAGMENT_CODE,
   J as MUTUAL_AS_UNDIRECTED_CODE,
-  Z as MUTUAL_COLUMN,
-  aD as MUTUAL_EXPANDED_CODE,
+  M2 as MUTUAL_COLUMN,
+  al as MUTUAL_EXPANDED_CODE,
+  NDEX_SOURCE_ID,
   NEO4J_CAPABILITIES,
   NEO4J_ISSUE,
   NEO4J_LOSS,
-  af as NODE_ORDER_CODE,
-  aE as NONFINITE_AS_NULL_CODE,
-  _ as NO_CAPABILITIES,
+  NEO4J_SOURCE_ID,
+  NEPTUNE_SOURCE_ID,
+  ad as NODE_ORDER_CODE,
+  aD as NONFINITE_AS_NULL_CODE,
+  Y2 as NO_CAPABILITIES,
   N as NO_GRAPH_CODE,
-  O2 as OBO_CAPABILITIES,
-  a18 as OBO_ISSUE,
-  b6 as OBO_LOSS,
-  aF as OPTIONS_GAINED_CODE,
+  O as OBO_CAPABILITIES,
+  a19 as OBO_ISSUE,
+  b4 as OBO_LOSS,
+  OPENALEX_SOURCE_ID,
+  aE as OPTIONS_GAINED_CODE,
   OPTION_IGNORED_CODE,
   ORIGINAL_ID_COLUMN,
-  $2 as PAIR_COLUMN,
-  P2 as PAJEK_ISSUE,
-  a19 as PAJEK_LOSS,
-  b7 as PAJEK_STYLE_CAPABILITIES,
-  c4 as PAJEK_STYLE_COMMENT,
+  P2 as PAIR_COLUMN,
+  P3 as PAJEK_ISSUE,
+  a20 as PAJEK_LOSS,
+  b5 as PAJEK_STYLE_CAPABILITIES,
+  c5 as PAJEK_STYLE_COMMENT,
   G as PARENTS_DROPPED_CODE,
-  a6 as PARENT_CYCLE_CODE,
-  aG as PARSE_ERROR_CODE,
+  a1 as PARENT_CYCLE_CODE,
+  aF as PARSE_ERROR_CODE,
   P as PRECISION_CODE,
-  ai as RELATION_ASSUMED_CODE,
+  ag as RELATION_ASSUMED_CODE,
   R2 as RENAMED_CODE,
-  aa as ROLE_ASSUMED_CODE,
+  REST_SOURCE_ID,
+  a9 as ROLE_ASSUMED_CODE,
   F as ROLE_DROPPED_CODE,
   R as ROLE_TAKEN_CODE,
   SELF_LOOPS_DROPPED_CODE,
-  aH as SELF_LOOP_CODE,
-  a4 as SINGLE_OBJECT_ASPECT_CODE,
+  aG as SELF_LOOP_CODE,
+  _ as SINGLE_OBJECT_ASPECT_CODE,
   S as SINK_OPTION_CODE,
   SNIFF_FAILED_CODE,
   SNIFF_HEAD_BYTES,
-  T as STATUS_FAILED_CODE,
-  V as STATUS_WARNING_CODE,
-  aI as STORAGE_CLASS_CODE,
+  n4 as SOURCE_ATTR_PREFIX,
+  p3 as SOURCE_DEGREE_ATTR,
+  e6 as SOURCE_ENTITY_ATTR,
+  SOURCE_FORMAT_PREFIX,
+  S2 as SOURCE_ISSUE,
+  g4 as SOURCE_STUB_ATTR,
+  SPARQL_SOURCE_ID,
+  a5 as STATUS_FAILED_CODE,
+  a4 as STATUS_WARNING_CODE,
+  aH as STORAGE_CLASS_CODE,
   c as STRAY_TEXT_CODE,
   STYLES_NOT_IMPORTED_CODE,
-  a8 as SYNTAX_CODE,
-  aJ as TEMPORAL_DROPPED_CODE,
-  aK as TEMPORAL_TEXT_DROPPED_CODE,
-  aL as TEXT_INFERRED_CODE,
-  a1 as TOO_LARGE_CODE,
-  ah as TYPEDEF_NODES_CODE,
+  Q as SYNTAX_CODE,
+  aI as TEMPORAL_DROPPED_CODE,
+  aJ as TEMPORAL_TEXT_DROPPED_CODE,
+  aK as TEXT_INFERRED_CODE,
+  V as TOO_LARGE_CODE,
+  af as TYPEDEF_NODES_CODE,
   TYPE_COLUMN,
   TextCellWriter,
   U as UNKNOWN_ATTR_TYPE_CODE,
@@ -1692,33 +2645,34 @@ export {
   UNKNOWN_FORMAT_CODE,
   UNKNOWN_OPTION_CODE,
   m as UNKNOWN_PARENT_CODE,
-  a02 as UNKNOWN_TYPE_CODE,
+  Z2 as UNKNOWN_TYPE_CODE,
   e as UNKNOWN_XML_ATTRIBUTE_CODE,
-  aM as WEIGHTS_DROPPED_CODE,
-  aN as WEIGHT_KEY_CLASH_CODE,
+  aL as WEIGHTS_DROPPED_CODE,
+  ak as WEIGHT_KEY_CLASH_CODE,
   WEIGHT_NOT_FOUND_CODE,
-  a7 as WIDENED_CODE,
+  a2 as WIDENED_CODE,
   W2 as WIDENING_UNSUPPORTED_CODE,
   X3 as XGMML_ISSUE,
-  a21 as XGMML_LOSS,
-  ac as XML_ILLEGAL_CHAR_CODE,
+  a22 as XGMML_LOSS,
+  ab as XML_ILLEGAL_CHAR_CODE,
   X as XML_NESTING_CODE,
   w as XML_SYNTAX_CODE,
-  d5 as XmlNestingError,
-  c5 as XmlSyntaxError,
-  f3 as XmlTokenizer,
-  a12 as canonicalId,
-  c2 as capabilities,
-  a as checkCapabilities,
+  d7 as XmlNestingError,
+  c7 as XmlSyntaxError,
+  p4 as XmlTokenizer,
+  H2 as canonicalId,
+  c3 as capabilities,
+  a10 as checkCapabilities,
   checkExport,
-  c3 as childrenCsr,
-  a11 as childrenFromColumn,
+  c4 as childrenCsr,
+  a13 as childrenFromColumn,
   chooseGraph,
-  a22 as coerceId,
-  a32 as coerceIdText,
+  _2 as coerceId,
+  Q2 as coerceIdText,
   collectBytes,
   compareSnapshots,
   createRegistry,
+  c6 as credentials,
   csvExporter,
   csvImporter,
   cx2Exporter,
@@ -1727,64 +2681,71 @@ export {
   cxImporter,
   cysExporter,
   cysImporter,
-  y2 as declareCompanion,
-  d2 as declareResolved,
-  d3 as decodeChunks,
-  a42 as decodeEntryName,
+  n2 as declareCompanion,
+  i2 as declareResolved,
+  d4 as decodeChunks,
+  e4 as decodeEntryName,
   defineLineFormat,
+  d6 as defineSource,
   describeDiffs,
-  d4 as dialectCapabilities,
+  d5 as dialectCapabilities,
   dotExporter,
   dotImporter,
   downloadGraph,
-  a5 as edgeWeights,
-  e3 as encodeChunks,
-  e2 as explicitWeights,
+  $2 as edgeWeights,
+  e5 as encodeChunks,
+  expandFromSource,
+  e3 as explicitWeights,
   exportGraph,
   exportGraphToBlob,
   exportGraphToBytes,
   exportGraphToString,
   exportNeo4jFiles,
-  g2 as extensionOf,
-  a62 as forDecodedText,
-  aO as formatDecimal,
-  $ as formatF32,
-  a0 as formatF64,
-  aP as formatGmlReal,
-  ad as formatInteger,
+  g3 as extensionOf,
+  a0 as forDecodedText,
+  d2 as formatDecimal,
+  f2 as formatF32,
+  a as formatF64,
+  e2 as formatGmlReal,
+  c2 as formatInteger,
+  q2 as fromStorableCredential,
   gexfExporter,
   gexfImporter,
   gmlExporter,
   gmlImporter,
-  k2 as graphChosen,
+  h2 as graphChosen,
   graphmlExporter,
   graphmlImporter,
-  h3 as hasIllegalXmlChar,
-  h2 as headBytes,
+  o as hasIllegalXmlChar,
+  h3 as headBytes,
   importAllGraphs,
+  importFromSource,
   importGraph,
-  i2 as inferTextDtype,
-  a72 as inputLength,
+  i4 as inferTextDtype,
+  d3 as inputLength,
   isAbortError,
-  O as isCanonicalIntegerText,
-  a82 as isImportInput,
-  a92 as isNmtoken,
-  a10 as isNumericText,
-  o2 as isWeightField,
+  F2 as isCanonicalIntegerText,
+  i3 as isImportInput,
+  U2 as isNmtoken,
+  a11 as isNumericText,
+  k2 as isWeightField,
   j2 as joinText,
   j3 as jsonCapabilities,
   jsonExporter,
   jsonImporter,
-  f2 as jsonShapeOf,
-  aQ as keptForStyles,
+  f3 as jsonShapeOf,
+  an as keptForStyles,
   listFormats,
+  listFromSource,
   listGraphs,
+  listSources,
   loadFromFile,
+  loadFromSource,
   loadFromUrl,
-  aa2 as mangleNmtoken,
+  V2 as mangleNmtoken,
   neo4jExporter,
   neo4jImporter,
-  n2 as normalizeMimeType,
+  n3 as normalizeMimeType,
   oboExporter,
   oboImporter,
   p as pairFolding,
@@ -1792,22 +2753,30 @@ export {
   pajekImporter,
   p2 as parseTextCell,
   parseWeightText,
+  probeSource,
   rankFormats,
-  ab as readText,
-  ac2 as refusedSave,
+  r3 as readText,
+  recordingFrom,
+  a12 as refusedSave,
+  registerSource,
   registry,
+  replayFetch,
   reportSinkOptions,
   reportUnusedOptions,
   r2 as resolveExportOptions,
   resolveImportOptions,
-  G2 as sanitizeIds,
+  z2 as sanitizeIds,
+  sha256Hex,
   sniff,
-  s2 as sniffFormat,
-  i3 as sniffJsonDialectHead,
+  i5 as sniffFormat,
+  s2 as sniffJsonDialect,
+  k3 as sniffJsonDialectHead,
+  s3 as storableCredential,
   t2 as textChunks,
   throwIfAborted,
   t3 as toReadableStream,
   t4 as tokenizeXml,
+  validateSource,
   xgmmlExporter,
   xgmmlImporter,
   x2 as xmlIllegalTextNotes