@lifi/composer-sdk 0.8.1 → 0.9.0

package/dist/reachability.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/reachability.ts"],"sourcesContent":["/**\n * Client-side reachability over the zap-pack catalog.\n *\n * `GET /compose/zap-packs` lists single routing edges. `POST /compose/route`\n * chains up to the server's hop budget of them, so the set of routable pairs\n * is the closure of the catalog, not the catalog itself. This module computes\n * that closure locally with the planner's admissibility rule, so an integrator\n * can offer every pair `route` connects without a request per pair.\n *\n * The rule, mirrored from the server's route search:\n *\n * - every edge except the last must leave its output in the proxy for the\n *   next edge to consume: no `availability`, no `recipient: 'required'`\n * - the last edge must be synchronous, or `availability: 'future'` when the\n *   caller opts into `allowAsyncRoutes`\n * - a route never visits the same token twice\n *\n * Amount bounds (`inAmountMin` / `inAmountMax`) on an intermediate edge\n * cannot be checked without an amount, so a pair reported here is routable\n * structurally, exactly as a listed edge is. Routes that open with a\n * `lifi.swap` are not enumerable and are not reported. The server also\n * drops blacklisted tokens as intermediates, which is server-side config\n * this module cannot see, so a reported pair may still answer\n * `no_route_error`.\n */\n\nimport type { ZapPackEdge, ZapPackOverview } from './discovery.js';\n\n/** A token identified by address and chain. */\nexport interface TokenRef {\n  readonly address: string;\n  readonly chainId: number;\n}\n\n/** A from/to pair `POST /compose/route` can connect through the catalog. */\nexport interface RoutablePair {\n  readonly in: TokenRef;\n  readonly out: TokenRef;\n  /** Catalog edges on the shortest admissible route; `1` is a listed edge. */\n  readonly hops: number;\n}\n\nexport interface ReachabilityOptions {\n  /**\n   * Hop budget. The server's `no_route_error` reports its effective value in\n   * `details.maxHops`; the deployment default is 2.\n   */\n  readonly maxHops?: number;\n  /**\n   * Admit a route whose last edge has `availability: 'future'`. Mirrors the\n   * `allowAsyncRoutes` request option; such a pair is a `no_route_error`\n   * without it.\n   */\n  readonly allowAsyncRoutes?: boolean;\n}\n\nexport interface Reachability {\n  readonly maxHops: number;\n  /** Whether `route` can connect `from` to `to` through the catalog. */\n  readonly canRoute: (from: TokenRef, to: TokenRef) => boolean;\n  /** Every pair starting at `from`, shortest routes first. */\n  readonly routableFrom: (from: TokenRef) => readonly RoutablePair[];\n  /** Every routable pair in the catalog. */\n  readonly pairs: () => readonly RoutablePair[];\n}\n\nconst DEFAULT_MAX_HOPS = 2;\n\nconst tokenKey = (token: TokenRef): string =>\n  `${token.chainId}:${token.address.toLowerCase()}`;\n\nconst isSync = (edge: ZapPackEdge): boolean => edge.availability === undefined;\n\n// The output stays in the proxy, so a following edge can consume it.\nconst isProxyHeld = (edge: ZapPackEdge): boolean =>\n  isSync(edge) && edge.recipient !== 'required';\n\n// One edge out of a frontier token. Records the pair it completes, and returns\n// its output when a further hop may consume it (proxy-held) and no shorter\n// path already expanded that token.\nconst visitEdge = ({\n  edge,\n  from,\n  depth,\n  sourceKey,\n  isTerminal,\n  found,\n  expanded,\n}: {\n  readonly edge: ZapPackEdge;\n  readonly from: TokenRef;\n  readonly depth: number;\n  readonly sourceKey: string;\n  readonly isTerminal: (edge: ZapPackEdge) => boolean;\n  readonly found: Map<string, RoutablePair>;\n  readonly expanded: Set<string>;\n}): TokenRef | undefined => {\n  const key = tokenKey(edge.out);\n  if (key === sourceKey) return undefined;\n  if (isTerminal(edge) && !found.has(key)) {\n    found.set(key, { in: from, out: edge.out, hops: depth });\n  }\n  if (!isProxyHeld(edge) || expanded.has(key)) return undefined;\n  expanded.add(key);\n  return edge.out;\n};\n\n// Every pair reachable from one token within `maxHops`, breadth-first so the\n// recorded hop count is the shortest one.\nconst closureFrom = ({\n  byIn,\n  from,\n  maxHops,\n  isTerminal,\n}: {\n  readonly byIn: ReadonlyMap<string, readonly ZapPackEdge[]>;\n  readonly from: TokenRef;\n  readonly maxHops: number;\n  readonly isTerminal: (edge: ZapPackEdge) => boolean;\n}): Map<string, RoutablePair> => {\n  const sourceKey = tokenKey(from);\n  const found = new Map<string, RoutablePair>();\n  const expanded = new Set<string>([sourceKey]);\n  let frontier: readonly TokenRef[] = [from];\n  for (let depth = 1; depth <= maxHops && frontier.length > 0; depth++) {\n    const next: TokenRef[] = [];\n    for (const node of frontier) {\n      for (const edge of byIn.get(tokenKey(node)) ?? []) {\n        const out = visitEdge({\n          edge,\n          from,\n          depth,\n          sourceKey,\n          isTerminal,\n          found,\n          expanded,\n        });\n        if (out) next.push(out);\n      }\n    }\n    frontier = next;\n  }\n  return found;\n};\n\nconst indexByIn = (\n  packs: readonly ZapPackOverview[],\n): Map<string, ZapPackEdge[]> => {\n  const byIn = new Map<string, ZapPackEdge[]>();\n  for (const pack of packs) {\n    for (const edge of pack.edges) {\n      const key = tokenKey(edge.in);\n      const list = byIn.get(key);\n      if (list) list.push(edge);\n      else byIn.set(key, [edge]);\n    }\n  }\n  return byIn;\n};\n\n/**\n * Builds a reachability index over the packs returned by\n * {@link ComposeClient.getZapPacks}. Per-source closures are computed on\n * first use and memoised, so `canRoute` on a handful of pairs stays cheap\n * while `pairs()` enumerates everything.\n */\nexport const buildReachability = (\n  packs: readonly ZapPackOverview[],\n  options: ReachabilityOptions = {},\n): Reachability => {\n  const maxHops = options.maxHops ?? DEFAULT_MAX_HOPS;\n  const allowAsync = options.allowAsyncRoutes ?? false;\n  const isTerminal = (edge: ZapPackEdge): boolean =>\n    isSync(edge) || (allowAsync && edge.availability === 'future');\n\n  const byIn = indexByIn(packs);\n  const memo = new Map<string, Map<string, RoutablePair>>();\n  const closure = (from: TokenRef): Map<string, RoutablePair> => {\n    const key = tokenKey(from);\n    const cached = memo.get(key);\n    if (cached) return cached;\n    const computed = closureFrom({ byIn, from, maxHops, isTerminal });\n    memo.set(key, computed);\n    return computed;\n  };\n\n  return {\n    maxHops,\n    canRoute: (from, to) => closure(from).has(tokenKey(to)),\n    routableFrom: (from) => [...closure(from).values()],\n    pairs: () => {\n      const sources = new Map<string, TokenRef>();\n      for (const pack of packs) {\n        for (const edge of pack.edges) sources.set(tokenKey(edge.in), edge.in);\n      }\n      const all: RoutablePair[] = [];\n      for (const source of sources.values()) {\n        all.push(...closure(source).values());\n      }\n      return all;\n    },\n  };\n};\n"],"mappings":"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","names":[]}
+{"version":3,"file":"reachability.cjs","names":[],"sources":["../src/reachability.ts"],"sourcesContent":["/**\n * Client-side reachability over the zap-pack catalog.\n *\n * `GET /compose/zap-packs` lists single routing edges. `POST /compose/route`\n * chains up to the server's hop budget of them, so the set of routable pairs\n * is the closure of the catalog, not the catalog itself. This module computes\n * that closure locally with the planner's admissibility rule, so an integrator\n * can offer every pair `route` connects without a request per pair.\n *\n * The rule, mirrored from the server's route search:\n *\n * - every edge except the last must leave its output in the proxy for the\n *   next edge to consume: no `availability`, no `recipient: 'required'`\n * - the last edge must be synchronous, or `availability: 'future'` when the\n *   caller opts into `allowAsyncRoutes`\n * - a route never visits the same token twice\n *\n * Amount bounds (`inAmountMin` / `inAmountMax`) on an intermediate edge\n * cannot be checked without an amount, so a pair reported here is routable\n * structurally, exactly as a listed edge is. Routes that open with a\n * `lifi.swap` are not enumerable and are not reported. The server also\n * drops blacklisted tokens as intermediates, which is server-side config\n * this module cannot see, so a reported pair may still answer\n * `no_route_error`.\n */\n\nimport type { ZapPackEdge, ZapPackOverview } from './discovery.js';\n\n/** A token identified by address and chain. */\nexport interface TokenRef {\n  readonly address: string;\n  readonly chainId: number;\n}\n\n/** A from/to pair `POST /compose/route` can connect through the catalog. */\nexport interface RoutablePair {\n  readonly in: TokenRef;\n  readonly out: TokenRef;\n  /** Catalog edges on the shortest admissible route; `1` is a listed edge. */\n  readonly hops: number;\n}\n\nexport interface ReachabilityOptions {\n  /**\n   * Hop budget. The server's `no_route_error` reports its effective value in\n   * `details.maxHops`; the deployment default is 2.\n   */\n  readonly maxHops?: number;\n  /**\n   * Admit a route whose last edge has `availability: 'future'`. Mirrors the\n   * `allowAsyncRoutes` request option; such a pair is a `no_route_error`\n   * without it.\n   */\n  readonly allowAsyncRoutes?: boolean;\n}\n\nexport interface Reachability {\n  readonly maxHops: number;\n  /** Whether `route` can connect `from` to `to` through the catalog. */\n  readonly canRoute: (from: TokenRef, to: TokenRef) => boolean;\n  /** Every pair starting at `from`, shortest routes first. */\n  readonly routableFrom: (from: TokenRef) => readonly RoutablePair[];\n  /** Every routable pair in the catalog. */\n  readonly pairs: () => readonly RoutablePair[];\n}\n\nconst DEFAULT_MAX_HOPS = 2;\n\nconst tokenKey = (token: TokenRef): string =>\n  `${token.chainId}:${token.address.toLowerCase()}`;\n\nconst isSync = (edge: ZapPackEdge): boolean => edge.availability === undefined;\n\n// The output stays in the proxy, so a following edge can consume it.\nconst isProxyHeld = (edge: ZapPackEdge): boolean =>\n  isSync(edge) && edge.recipient !== 'required';\n\n// One edge out of a frontier token. Records the pair it completes, and returns\n// its output when a further hop may consume it (proxy-held) and no shorter\n// path already expanded that token.\nconst visitEdge = ({\n  edge,\n  from,\n  depth,\n  sourceKey,\n  isTerminal,\n  found,\n  expanded,\n}: {\n  readonly edge: ZapPackEdge;\n  readonly from: TokenRef;\n  readonly depth: number;\n  readonly sourceKey: string;\n  readonly isTerminal: (edge: ZapPackEdge) => boolean;\n  readonly found: Map<string, RoutablePair>;\n  readonly expanded: Set<string>;\n}): TokenRef | undefined => {\n  const key = tokenKey(edge.out);\n  if (key === sourceKey) return undefined;\n  if (isTerminal(edge) && !found.has(key)) {\n    found.set(key, { in: from, out: edge.out, hops: depth });\n  }\n  if (!isProxyHeld(edge) || expanded.has(key)) return undefined;\n  expanded.add(key);\n  return edge.out;\n};\n\n// Every pair reachable from one token within `maxHops`, breadth-first so the\n// recorded hop count is the shortest one.\nconst closureFrom = ({\n  byIn,\n  from,\n  maxHops,\n  isTerminal,\n}: {\n  readonly byIn: ReadonlyMap<string, readonly ZapPackEdge[]>;\n  readonly from: TokenRef;\n  readonly maxHops: number;\n  readonly isTerminal: (edge: ZapPackEdge) => boolean;\n}): Map<string, RoutablePair> => {\n  const sourceKey = tokenKey(from);\n  const found = new Map<string, RoutablePair>();\n  const expanded = new Set<string>([sourceKey]);\n  let frontier: readonly TokenRef[] = [from];\n  for (let depth = 1; depth <= maxHops && frontier.length > 0; depth++) {\n    const next: TokenRef[] = [];\n    for (const node of frontier) {\n      for (const edge of byIn.get(tokenKey(node)) ?? []) {\n        const out = visitEdge({\n          edge,\n          from,\n          depth,\n          sourceKey,\n          isTerminal,\n          found,\n          expanded,\n        });\n        if (out) next.push(out);\n      }\n    }\n    frontier = next;\n  }\n  return found;\n};\n\nconst indexByIn = (\n  packs: readonly ZapPackOverview[],\n): Map<string, ZapPackEdge[]> => {\n  const byIn = new Map<string, ZapPackEdge[]>();\n  for (const pack of packs) {\n    for (const edge of pack.edges) {\n      const key = tokenKey(edge.in);\n      const list = byIn.get(key);\n      if (list) list.push(edge);\n      else byIn.set(key, [edge]);\n    }\n  }\n  return byIn;\n};\n\n/**\n * Builds a reachability index over the packs returned by\n * {@link ComposeClient.getZapPacks}. Per-source closures are computed on\n * first use and memoised, so `canRoute` on a handful of pairs stays cheap\n * while `pairs()` enumerates everything.\n */\nexport const buildReachability = (\n  packs: readonly ZapPackOverview[],\n  options: ReachabilityOptions = {},\n): Reachability => {\n  const maxHops = options.maxHops ?? DEFAULT_MAX_HOPS;\n  const allowAsync = options.allowAsyncRoutes ?? false;\n  const isTerminal = (edge: ZapPackEdge): boolean =>\n    isSync(edge) || (allowAsync && edge.availability === 'future');\n\n  const byIn = indexByIn(packs);\n  const memo = new Map<string, Map<string, RoutablePair>>();\n  const closure = (from: TokenRef): Map<string, RoutablePair> => {\n    const key = tokenKey(from);\n    const cached = memo.get(key);\n    if (cached) return cached;\n    const computed = closureFrom({ byIn, from, maxHops, isTerminal });\n    memo.set(key, computed);\n    return computed;\n  };\n\n  return {\n    maxHops,\n    canRoute: (from, to) => closure(from).has(tokenKey(to)),\n    routableFrom: (from) => [...closure(from).values()],\n    pairs: () => {\n      const sources = new Map<string, TokenRef>();\n      for (const pack of packs) {\n        for (const edge of pack.edges) sources.set(tokenKey(edge.in), edge.in);\n      }\n      const all: RoutablePair[] = [];\n      for (const source of sources.values()) {\n        all.push(...closure(source).values());\n      }\n      return all;\n    },\n  };\n};\n"],"mappings":";;AAkEA,MAAM,mBAAmB;AAEzB,MAAM,YAAY,UAChB,GAAG,MAAM,QAAQ,GAAG,MAAM,QAAQ,YAAY;AAEhD,MAAM,UAAU,SAA+B,KAAK,iBAAiB,KAAA;AAGrE,MAAM,eAAe,SACnB,OAAO,IAAI,KAAK,KAAK,cAAc;AAKrC,MAAM,aAAa,EACjB,MACA,MACA,OACA,WACA,YACA,OACA,eAS0B;CAC1B,MAAM,MAAM,SAAS,KAAK,GAAG;CAC7B,IAAI,QAAQ,WAAW,OAAO,KAAA;CAC9B,IAAI,WAAW,IAAI,KAAK,CAAC,MAAM,IAAI,GAAG,GACpC,MAAM,IAAI,KAAK;EAAE,IAAI;EAAM,KAAK,KAAK;EAAK,MAAM;CAAM,CAAC;CAEzD,IAAI,CAAC,YAAY,IAAI,KAAK,SAAS,IAAI,GAAG,GAAG,OAAO,KAAA;CACpD,SAAS,IAAI,GAAG;CAChB,OAAO,KAAK;AACd;AAIA,MAAM,eAAe,EACnB,MACA,MACA,SACA,iBAM+B;CAC/B,MAAM,YAAY,SAAS,IAAI;CAC/B,MAAM,wBAAQ,IAAI,IAA0B;CAC5C,MAAM,2BAAW,IAAI,IAAY,CAAC,SAAS,CAAC;CAC5C,IAAI,WAAgC,CAAC,IAAI;CACzC,KAAK,IAAI,QAAQ,GAAG,SAAS,WAAW,SAAS,SAAS,GAAG,SAAS;EACpE,MAAM,OAAmB,CAAC;EAC1B,KAAK,MAAM,QAAQ,UACjB,KAAK,MAAM,QAAQ,KAAK,IAAI,SAAS,IAAI,CAAC,KAAK,CAAC,GAAG;GACjD,MAAM,MAAM,UAAU;IACpB;IACA;IACA;IACA;IACA;IACA;IACA;GACF,CAAC;GACD,IAAI,KAAK,KAAK,KAAK,GAAG;EACxB;EAEF,WAAW;CACb;CACA,OAAO;AACT;AAEA,MAAM,aACJ,UAC+B;CAC/B,MAAM,uBAAO,IAAI,IAA2B;CAC5C,KAAK,MAAM,QAAQ,OACjB,KAAK,MAAM,QAAQ,KAAK,OAAO;EAC7B,MAAM,MAAM,SAAS,KAAK,EAAE;EAC5B,MAAM,OAAO,KAAK,IAAI,GAAG;EACzB,IAAI,MAAM,KAAK,KAAK,IAAI;OACnB,KAAK,IAAI,KAAK,CAAC,IAAI,CAAC;CAC3B;CAEF,OAAO;AACT;;;;;;;AAQA,MAAa,qBACX,OACA,UAA+B,CAAC,MACf;CACjB,MAAM,UAAU,QAAQ,WAAW;CACnC,MAAM,aAAa,QAAQ,oBAAoB;CAC/C,MAAM,cAAc,SAClB,OAAO,IAAI,KAAM,cAAc,KAAK,iBAAiB;CAEvD,MAAM,OAAO,UAAU,KAAK;CAC5B,MAAM,uBAAO,IAAI,IAAuC;CACxD,MAAM,WAAW,SAA8C;EAC7D,MAAM,MAAM,SAAS,IAAI;EACzB,MAAM,SAAS,KAAK,IAAI,GAAG;EAC3B,IAAI,QAAQ,OAAO;EACnB,MAAM,WAAW,YAAY;GAAE;GAAM;GAAM;GAAS;EAAW,CAAC;EAChE,KAAK,IAAI,KAAK,QAAQ;EACtB,OAAO;CACT;CAEA,OAAO;EACL;EACA,WAAW,MAAM,OAAO,QAAQ,IAAI,CAAC,CAAC,IAAI,SAAS,EAAE,CAAC;EACtD,eAAe,SAAS,CAAC,GAAG,QAAQ,IAAI,CAAC,CAAC,OAAO,CAAC;EAClD,aAAa;GACX,MAAM,0BAAU,IAAI,IAAsB;GAC1C,KAAK,MAAM,QAAQ,OACjB,KAAK,MAAM,QAAQ,KAAK,OAAO,QAAQ,IAAI,SAAS,KAAK,EAAE,GAAG,KAAK,EAAE;GAEvE,MAAM,MAAsB,CAAC;GAC7B,KAAK,MAAM,UAAU,QAAQ,OAAO,GAClC,IAAI,KAAK,GAAG,QAAQ,MAAM,CAAC,CAAC,OAAO,CAAC;GAEtC,OAAO;EACT;CACF;AACF"}

package/dist/reachability.d.cts

@@ -1,64 +1,38 @@
-import { ZapPackOverview } from './discovery.cjs';
-
-/**
- * Client-side reachability over the zap-pack catalog.
- *
- * `GET /compose/zap-packs` lists single routing edges. `POST /compose/route`
- * chains up to the server's hop budget of them, so the set of routable pairs
- * is the closure of the catalog, not the catalog itself. This module computes
- * that closure locally with the planner's admissibility rule, so an integrator
- * can offer every pair `route` connects without a request per pair.
- *
- * The rule, mirrored from the server's route search:
- *
- * - every edge except the last must leave its output in the proxy for the
- *   next edge to consume: no `availability`, no `recipient: 'required'`
- * - the last edge must be synchronous, or `availability: 'future'` when the
- *   caller opts into `allowAsyncRoutes`
- * - a route never visits the same token twice
- *
- * Amount bounds (`inAmountMin` / `inAmountMax`) on an intermediate edge
- * cannot be checked without an amount, so a pair reported here is routable
- * structurally, exactly as a listed edge is. Routes that open with a
- * `lifi.swap` are not enumerable and are not reported. The server also
- * drops blacklisted tokens as intermediates, which is server-side config
- * this module cannot see, so a reported pair may still answer
- * `no_route_error`.
- */
-
+import { ZapPackOverview } from "./discovery.cjs";
+//#region src/reachability.d.ts
 /** A token identified by address and chain. */
-interface TokenRef {
-    readonly address: string;
-    readonly chainId: number;
+export interface TokenRef {
+  readonly address: string;
+  readonly chainId: number;
 }
 /** A from/to pair `POST /compose/route` can connect through the catalog. */
-interface RoutablePair {
-    readonly in: TokenRef;
-    readonly out: TokenRef;
-    /** Catalog edges on the shortest admissible route; `1` is a listed edge. */
-    readonly hops: number;
+export interface RoutablePair {
+  readonly in: TokenRef;
+  readonly out: TokenRef;
+  /** Catalog edges on the shortest admissible route; `1` is a listed edge. */
+  readonly hops: number;
 }
-interface ReachabilityOptions {
-    /**
-     * Hop budget. The server's `no_route_error` reports its effective value in
-     * `details.maxHops`; the deployment default is 2.
-     */
-    readonly maxHops?: number;
-    /**
-     * Admit a route whose last edge has `availability: 'future'`. Mirrors the
-     * `allowAsyncRoutes` request option; such a pair is a `no_route_error`
-     * without it.
-     */
-    readonly allowAsyncRoutes?: boolean;
+export interface ReachabilityOptions {
+  /**
+   * Hop budget. The server's `no_route_error` reports its effective value in
+   * `details.maxHops`; the deployment default is 2.
+   */
+  readonly maxHops?: number;
+  /**
+   * Admit a route whose last edge has `availability: 'future'`. Mirrors the
+   * `allowAsyncRoutes` request option; such a pair is a `no_route_error`
+   * without it.
+   */
+  readonly allowAsyncRoutes?: boolean;
 }
-interface Reachability {
-    readonly maxHops: number;
-    /** Whether `route` can connect `from` to `to` through the catalog. */
-    readonly canRoute: (from: TokenRef, to: TokenRef) => boolean;
-    /** Every pair starting at `from`, shortest routes first. */
-    readonly routableFrom: (from: TokenRef) => readonly RoutablePair[];
-    /** Every routable pair in the catalog. */
-    readonly pairs: () => readonly RoutablePair[];
+export interface Reachability {
+  readonly maxHops: number;
+  /** Whether `route` can connect `from` to `to` through the catalog. */
+  readonly canRoute: (from: TokenRef, to: TokenRef) => boolean;
+  /** Every pair starting at `from`, shortest routes first. */
+  readonly routableFrom: (from: TokenRef) => readonly RoutablePair[];
+  /** Every routable pair in the catalog. */
+  readonly pairs: () => readonly RoutablePair[];
 }
 /**
  * Builds a reachability index over the packs returned by
@@ -66,6 +40,6 @@ interface Reachability {
  * first use and memoised, so `canRoute` on a handful of pairs stays cheap
  * while `pairs()` enumerates everything.
  */
-declare const buildReachability: (packs: readonly ZapPackOverview[], options?: ReachabilityOptions) => Reachability;
-
-export { type Reachability, type ReachabilityOptions, type RoutablePair, type TokenRef, buildReachability };
+export declare const buildReachability: (packs: readonly ZapPackOverview[], options?: ReachabilityOptions) => Reachability;
+//#endregion
+//# sourceMappingURL=reachability.d.cts.map

package/dist/reachability.d.ts

@@ -1,64 +1,38 @@
-import { ZapPackOverview } from './discovery.js';
-
-/**
- * Client-side reachability over the zap-pack catalog.
- *
- * `GET /compose/zap-packs` lists single routing edges. `POST /compose/route`
- * chains up to the server's hop budget of them, so the set of routable pairs
- * is the closure of the catalog, not the catalog itself. This module computes
- * that closure locally with the planner's admissibility rule, so an integrator
- * can offer every pair `route` connects without a request per pair.
- *
- * The rule, mirrored from the server's route search:
- *
- * - every edge except the last must leave its output in the proxy for the
- *   next edge to consume: no `availability`, no `recipient: 'required'`
- * - the last edge must be synchronous, or `availability: 'future'` when the
- *   caller opts into `allowAsyncRoutes`
- * - a route never visits the same token twice
- *
- * Amount bounds (`inAmountMin` / `inAmountMax`) on an intermediate edge
- * cannot be checked without an amount, so a pair reported here is routable
- * structurally, exactly as a listed edge is. Routes that open with a
- * `lifi.swap` are not enumerable and are not reported. The server also
- * drops blacklisted tokens as intermediates, which is server-side config
- * this module cannot see, so a reported pair may still answer
- * `no_route_error`.
- */
-
+import { ZapPackOverview } from "./discovery.js";
+//#region src/reachability.d.ts
 /** A token identified by address and chain. */
-interface TokenRef {
-    readonly address: string;
-    readonly chainId: number;
+export interface TokenRef {
+  readonly address: string;
+  readonly chainId: number;
 }
 /** A from/to pair `POST /compose/route` can connect through the catalog. */
-interface RoutablePair {
-    readonly in: TokenRef;
-    readonly out: TokenRef;
-    /** Catalog edges on the shortest admissible route; `1` is a listed edge. */
-    readonly hops: number;
+export interface RoutablePair {
+  readonly in: TokenRef;
+  readonly out: TokenRef;
+  /** Catalog edges on the shortest admissible route; `1` is a listed edge. */
+  readonly hops: number;
 }
-interface ReachabilityOptions {
-    /**
-     * Hop budget. The server's `no_route_error` reports its effective value in
-     * `details.maxHops`; the deployment default is 2.
-     */
-    readonly maxHops?: number;
-    /**
-     * Admit a route whose last edge has `availability: 'future'`. Mirrors the
-     * `allowAsyncRoutes` request option; such a pair is a `no_route_error`
-     * without it.
-     */
-    readonly allowAsyncRoutes?: boolean;
+export interface ReachabilityOptions {
+  /**
+   * Hop budget. The server's `no_route_error` reports its effective value in
+   * `details.maxHops`; the deployment default is 2.
+   */
+  readonly maxHops?: number;
+  /**
+   * Admit a route whose last edge has `availability: 'future'`. Mirrors the
+   * `allowAsyncRoutes` request option; such a pair is a `no_route_error`
+   * without it.
+   */
+  readonly allowAsyncRoutes?: boolean;
 }
-interface Reachability {
-    readonly maxHops: number;
-    /** Whether `route` can connect `from` to `to` through the catalog. */
-    readonly canRoute: (from: TokenRef, to: TokenRef) => boolean;
-    /** Every pair starting at `from`, shortest routes first. */
-    readonly routableFrom: (from: TokenRef) => readonly RoutablePair[];
-    /** Every routable pair in the catalog. */
-    readonly pairs: () => readonly RoutablePair[];
+export interface Reachability {
+  readonly maxHops: number;
+  /** Whether `route` can connect `from` to `to` through the catalog. */
+  readonly canRoute: (from: TokenRef, to: TokenRef) => boolean;
+  /** Every pair starting at `from`, shortest routes first. */
+  readonly routableFrom: (from: TokenRef) => readonly RoutablePair[];
+  /** Every routable pair in the catalog. */
+  readonly pairs: () => readonly RoutablePair[];
 }
 /**
  * Builds a reachability index over the packs returned by
@@ -66,6 +40,6 @@ interface Reachability {
  * first use and memoised, so `canRoute` on a handful of pairs stays cheap
  * while `pairs()` enumerates everything.
  */
-declare const buildReachability: (packs: readonly ZapPackOverview[], options?: ReachabilityOptions) => Reachability;
-
-export { type Reachability, type ReachabilityOptions, type RoutablePair, type TokenRef, buildReachability };
+export declare const buildReachability: (packs: readonly ZapPackOverview[], options?: ReachabilityOptions) => Reachability;
+//#endregion
+//# sourceMappingURL=reachability.d.ts.map

package/dist/reachability.js

@@ -1,99 +1,92 @@
+//#region src/reachability.ts
 const DEFAULT_MAX_HOPS = 2;
 const tokenKey = (token) => `${token.chainId}:${token.address.toLowerCase()}`;
 const isSync = (edge) => edge.availability === void 0;
 const isProxyHeld = (edge) => isSync(edge) && edge.recipient !== "required";
-const visitEdge = ({
-  edge,
-  from,
-  depth,
-  sourceKey,
-  isTerminal,
-  found,
-  expanded
-}) => {
-  const key = tokenKey(edge.out);
-  if (key === sourceKey) return void 0;
-  if (isTerminal(edge) && !found.has(key)) {
-    found.set(key, { in: from, out: edge.out, hops: depth });
-  }
-  if (!isProxyHeld(edge) || expanded.has(key)) return void 0;
-  expanded.add(key);
-  return edge.out;
+const visitEdge = ({ edge, from, depth, sourceKey, isTerminal, found, expanded }) => {
+	const key = tokenKey(edge.out);
+	if (key === sourceKey) return void 0;
+	if (isTerminal(edge) && !found.has(key)) found.set(key, {
+		in: from,
+		out: edge.out,
+		hops: depth
+	});
+	if (!isProxyHeld(edge) || expanded.has(key)) return void 0;
+	expanded.add(key);
+	return edge.out;
 };
-const closureFrom = ({
-  byIn,
-  from,
-  maxHops,
-  isTerminal
-}) => {
-  const sourceKey = tokenKey(from);
-  const found = /* @__PURE__ */ new Map();
-  const expanded = /* @__PURE__ */ new Set([sourceKey]);
-  let frontier = [from];
-  for (let depth = 1; depth <= maxHops && frontier.length > 0; depth++) {
-    const next = [];
-    for (const node of frontier) {
-      for (const edge of byIn.get(tokenKey(node)) ?? []) {
-        const out = visitEdge({
-          edge,
-          from,
-          depth,
-          sourceKey,
-          isTerminal,
-          found,
-          expanded
-        });
-        if (out) next.push(out);
-      }
-    }
-    frontier = next;
-  }
-  return found;
+const closureFrom = ({ byIn, from, maxHops, isTerminal }) => {
+	const sourceKey = tokenKey(from);
+	const found = /* @__PURE__ */ new Map();
+	const expanded = /* @__PURE__ */ new Set([sourceKey]);
+	let frontier = [from];
+	for (let depth = 1; depth <= maxHops && frontier.length > 0; depth++) {
+		const next = [];
+		for (const node of frontier) for (const edge of byIn.get(tokenKey(node)) ?? []) {
+			const out = visitEdge({
+				edge,
+				from,
+				depth,
+				sourceKey,
+				isTerminal,
+				found,
+				expanded
+			});
+			if (out) next.push(out);
+		}
+		frontier = next;
+	}
+	return found;
 };
 const indexByIn = (packs) => {
-  const byIn = /* @__PURE__ */ new Map();
-  for (const pack of packs) {
-    for (const edge of pack.edges) {
-      const key = tokenKey(edge.in);
-      const list = byIn.get(key);
-      if (list) list.push(edge);
-      else byIn.set(key, [edge]);
-    }
-  }
-  return byIn;
+	const byIn = /* @__PURE__ */ new Map();
+	for (const pack of packs) for (const edge of pack.edges) {
+		const key = tokenKey(edge.in);
+		const list = byIn.get(key);
+		if (list) list.push(edge);
+		else byIn.set(key, [edge]);
+	}
+	return byIn;
 };
+/**
+* Builds a reachability index over the packs returned by
+* {@link ComposeClient.getZapPacks}. Per-source closures are computed on
+* first use and memoised, so `canRoute` on a handful of pairs stays cheap
+* while `pairs()` enumerates everything.
+*/
 const buildReachability = (packs, options = {}) => {
-  const maxHops = options.maxHops ?? DEFAULT_MAX_HOPS;
-  const allowAsync = options.allowAsyncRoutes ?? false;
-  const isTerminal = (edge) => isSync(edge) || allowAsync && edge.availability === "future";
-  const byIn = indexByIn(packs);
-  const memo = /* @__PURE__ */ new Map();
-  const closure = (from) => {
-    const key = tokenKey(from);
-    const cached = memo.get(key);
-    if (cached) return cached;
-    const computed = closureFrom({ byIn, from, maxHops, isTerminal });
-    memo.set(key, computed);
-    return computed;
-  };
-  return {
-    maxHops,
-    canRoute: (from, to) => closure(from).has(tokenKey(to)),
-    routableFrom: (from) => [...closure(from).values()],
-    pairs: () => {
-      const sources = /* @__PURE__ */ new Map();
-      for (const pack of packs) {
-        for (const edge of pack.edges) sources.set(tokenKey(edge.in), edge.in);
-      }
-      const all = [];
-      for (const source of sources.values()) {
-        all.push(...closure(source).values());
-      }
-      return all;
-    }
-  };
-};
-export {
-  buildReachability
+	const maxHops = options.maxHops ?? DEFAULT_MAX_HOPS;
+	const allowAsync = options.allowAsyncRoutes ?? false;
+	const isTerminal = (edge) => isSync(edge) || allowAsync && edge.availability === "future";
+	const byIn = indexByIn(packs);
+	const memo = /* @__PURE__ */ new Map();
+	const closure = (from) => {
+		const key = tokenKey(from);
+		const cached = memo.get(key);
+		if (cached) return cached;
+		const computed = closureFrom({
+			byIn,
+			from,
+			maxHops,
+			isTerminal
+		});
+		memo.set(key, computed);
+		return computed;
+	};
+	return {
+		maxHops,
+		canRoute: (from, to) => closure(from).has(tokenKey(to)),
+		routableFrom: (from) => [...closure(from).values()],
+		pairs: () => {
+			const sources = /* @__PURE__ */ new Map();
+			for (const pack of packs) for (const edge of pack.edges) sources.set(tokenKey(edge.in), edge.in);
+			const all = [];
+			for (const source of sources.values()) all.push(...closure(source).values());
+			return all;
+		}
+	};
 };
+//#endregion
+export { buildReachability };
+
 //# sourceMappingURL=reachability.js.map

package/dist/reachability.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/reachability.ts"],"sourcesContent":["/**\n * Client-side reachability over the zap-pack catalog.\n *\n * `GET /compose/zap-packs` lists single routing edges. `POST /compose/route`\n * chains up to the server's hop budget of them, so the set of routable pairs\n * is the closure of the catalog, not the catalog itself. This module computes\n * that closure locally with the planner's admissibility rule, so an integrator\n * can offer every pair `route` connects without a request per pair.\n *\n * The rule, mirrored from the server's route search:\n *\n * - every edge except the last must leave its output in the proxy for the\n *   next edge to consume: no `availability`, no `recipient: 'required'`\n * - the last edge must be synchronous, or `availability: 'future'` when the\n *   caller opts into `allowAsyncRoutes`\n * - a route never visits the same token twice\n *\n * Amount bounds (`inAmountMin` / `inAmountMax`) on an intermediate edge\n * cannot be checked without an amount, so a pair reported here is routable\n * structurally, exactly as a listed edge is. Routes that open with a\n * `lifi.swap` are not enumerable and are not reported. The server also\n * drops blacklisted tokens as intermediates, which is server-side config\n * this module cannot see, so a reported pair may still answer\n * `no_route_error`.\n */\n\nimport type { ZapPackEdge, ZapPackOverview } from './discovery.js';\n\n/** A token identified by address and chain. */\nexport interface TokenRef {\n  readonly address: string;\n  readonly chainId: number;\n}\n\n/** A from/to pair `POST /compose/route` can connect through the catalog. */\nexport interface RoutablePair {\n  readonly in: TokenRef;\n  readonly out: TokenRef;\n  /** Catalog edges on the shortest admissible route; `1` is a listed edge. */\n  readonly hops: number;\n}\n\nexport interface ReachabilityOptions {\n  /**\n   * Hop budget. The server's `no_route_error` reports its effective value in\n   * `details.maxHops`; the deployment default is 2.\n   */\n  readonly maxHops?: number;\n  /**\n   * Admit a route whose last edge has `availability: 'future'`. Mirrors the\n   * `allowAsyncRoutes` request option; such a pair is a `no_route_error`\n   * without it.\n   */\n  readonly allowAsyncRoutes?: boolean;\n}\n\nexport interface Reachability {\n  readonly maxHops: number;\n  /** Whether `route` can connect `from` to `to` through the catalog. */\n  readonly canRoute: (from: TokenRef, to: TokenRef) => boolean;\n  /** Every pair starting at `from`, shortest routes first. */\n  readonly routableFrom: (from: TokenRef) => readonly RoutablePair[];\n  /** Every routable pair in the catalog. */\n  readonly pairs: () => readonly RoutablePair[];\n}\n\nconst DEFAULT_MAX_HOPS = 2;\n\nconst tokenKey = (token: TokenRef): string =>\n  `${token.chainId}:${token.address.toLowerCase()}`;\n\nconst isSync = (edge: ZapPackEdge): boolean => edge.availability === undefined;\n\n// The output stays in the proxy, so a following edge can consume it.\nconst isProxyHeld = (edge: ZapPackEdge): boolean =>\n  isSync(edge) && edge.recipient !== 'required';\n\n// One edge out of a frontier token. Records the pair it completes, and returns\n// its output when a further hop may consume it (proxy-held) and no shorter\n// path already expanded that token.\nconst visitEdge = ({\n  edge,\n  from,\n  depth,\n  sourceKey,\n  isTerminal,\n  found,\n  expanded,\n}: {\n  readonly edge: ZapPackEdge;\n  readonly from: TokenRef;\n  readonly depth: number;\n  readonly sourceKey: string;\n  readonly isTerminal: (edge: ZapPackEdge) => boolean;\n  readonly found: Map<string, RoutablePair>;\n  readonly expanded: Set<string>;\n}): TokenRef | undefined => {\n  const key = tokenKey(edge.out);\n  if (key === sourceKey) return undefined;\n  if (isTerminal(edge) && !found.has(key)) {\n    found.set(key, { in: from, out: edge.out, hops: depth });\n  }\n  if (!isProxyHeld(edge) || expanded.has(key)) return undefined;\n  expanded.add(key);\n  return edge.out;\n};\n\n// Every pair reachable from one token within `maxHops`, breadth-first so the\n// recorded hop count is the shortest one.\nconst closureFrom = ({\n  byIn,\n  from,\n  maxHops,\n  isTerminal,\n}: {\n  readonly byIn: ReadonlyMap<string, readonly ZapPackEdge[]>;\n  readonly from: TokenRef;\n  readonly maxHops: number;\n  readonly isTerminal: (edge: ZapPackEdge) => boolean;\n}): Map<string, RoutablePair> => {\n  const sourceKey = tokenKey(from);\n  const found = new Map<string, RoutablePair>();\n  const expanded = new Set<string>([sourceKey]);\n  let frontier: readonly TokenRef[] = [from];\n  for (let depth = 1; depth <= maxHops && frontier.length > 0; depth++) {\n    const next: TokenRef[] = [];\n    for (const node of frontier) {\n      for (const edge of byIn.get(tokenKey(node)) ?? []) {\n        const out = visitEdge({\n          edge,\n          from,\n          depth,\n          sourceKey,\n          isTerminal,\n          found,\n          expanded,\n        });\n        if (out) next.push(out);\n      }\n    }\n    frontier = next;\n  }\n  return found;\n};\n\nconst indexByIn = (\n  packs: readonly ZapPackOverview[],\n): Map<string, ZapPackEdge[]> => {\n  const byIn = new Map<string, ZapPackEdge[]>();\n  for (const pack of packs) {\n    for (const edge of pack.edges) {\n      const key = tokenKey(edge.in);\n      const list = byIn.get(key);\n      if (list) list.push(edge);\n      else byIn.set(key, [edge]);\n    }\n  }\n  return byIn;\n};\n\n/**\n * Builds a reachability index over the packs returned by\n * {@link ComposeClient.getZapPacks}. Per-source closures are computed on\n * first use and memoised, so `canRoute` on a handful of pairs stays cheap\n * while `pairs()` enumerates everything.\n */\nexport const buildReachability = (\n  packs: readonly ZapPackOverview[],\n  options: ReachabilityOptions = {},\n): Reachability => {\n  const maxHops = options.maxHops ?? DEFAULT_MAX_HOPS;\n  const allowAsync = options.allowAsyncRoutes ?? false;\n  const isTerminal = (edge: ZapPackEdge): boolean =>\n    isSync(edge) || (allowAsync && edge.availability === 'future');\n\n  const byIn = indexByIn(packs);\n  const memo = new Map<string, Map<string, RoutablePair>>();\n  const closure = (from: TokenRef): Map<string, RoutablePair> => {\n    const key = tokenKey(from);\n    const cached = memo.get(key);\n    if (cached) return cached;\n    const computed = closureFrom({ byIn, from, maxHops, isTerminal });\n    memo.set(key, computed);\n    return computed;\n  };\n\n  return {\n    maxHops,\n    canRoute: (from, to) => closure(from).has(tokenKey(to)),\n    routableFrom: (from) => [...closure(from).values()],\n    pairs: () => {\n      const sources = new Map<string, TokenRef>();\n      for (const pack of packs) {\n        for (const edge of pack.edges) sources.set(tokenKey(edge.in), edge.in);\n      }\n      const all: RoutablePair[] = [];\n      for (const source of sources.values()) {\n        all.push(...closure(source).values());\n      }\n      return all;\n    },\n  };\n};\n"],"mappings":"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","names":[]}
+{"version":3,"file":"reachability.js","names":[],"sources":["../src/reachability.ts"],"sourcesContent":["/**\n * Client-side reachability over the zap-pack catalog.\n *\n * `GET /compose/zap-packs` lists single routing edges. `POST /compose/route`\n * chains up to the server's hop budget of them, so the set of routable pairs\n * is the closure of the catalog, not the catalog itself. This module computes\n * that closure locally with the planner's admissibility rule, so an integrator\n * can offer every pair `route` connects without a request per pair.\n *\n * The rule, mirrored from the server's route search:\n *\n * - every edge except the last must leave its output in the proxy for the\n *   next edge to consume: no `availability`, no `recipient: 'required'`\n * - the last edge must be synchronous, or `availability: 'future'` when the\n *   caller opts into `allowAsyncRoutes`\n * - a route never visits the same token twice\n *\n * Amount bounds (`inAmountMin` / `inAmountMax`) on an intermediate edge\n * cannot be checked without an amount, so a pair reported here is routable\n * structurally, exactly as a listed edge is. Routes that open with a\n * `lifi.swap` are not enumerable and are not reported. The server also\n * drops blacklisted tokens as intermediates, which is server-side config\n * this module cannot see, so a reported pair may still answer\n * `no_route_error`.\n */\n\nimport type { ZapPackEdge, ZapPackOverview } from './discovery.js';\n\n/** A token identified by address and chain. */\nexport interface TokenRef {\n  readonly address: string;\n  readonly chainId: number;\n}\n\n/** A from/to pair `POST /compose/route` can connect through the catalog. */\nexport interface RoutablePair {\n  readonly in: TokenRef;\n  readonly out: TokenRef;\n  /** Catalog edges on the shortest admissible route; `1` is a listed edge. */\n  readonly hops: number;\n}\n\nexport interface ReachabilityOptions {\n  /**\n   * Hop budget. The server's `no_route_error` reports its effective value in\n   * `details.maxHops`; the deployment default is 2.\n   */\n  readonly maxHops?: number;\n  /**\n   * Admit a route whose last edge has `availability: 'future'`. Mirrors the\n   * `allowAsyncRoutes` request option; such a pair is a `no_route_error`\n   * without it.\n   */\n  readonly allowAsyncRoutes?: boolean;\n}\n\nexport interface Reachability {\n  readonly maxHops: number;\n  /** Whether `route` can connect `from` to `to` through the catalog. */\n  readonly canRoute: (from: TokenRef, to: TokenRef) => boolean;\n  /** Every pair starting at `from`, shortest routes first. */\n  readonly routableFrom: (from: TokenRef) => readonly RoutablePair[];\n  /** Every routable pair in the catalog. */\n  readonly pairs: () => readonly RoutablePair[];\n}\n\nconst DEFAULT_MAX_HOPS = 2;\n\nconst tokenKey = (token: TokenRef): string =>\n  `${token.chainId}:${token.address.toLowerCase()}`;\n\nconst isSync = (edge: ZapPackEdge): boolean => edge.availability === undefined;\n\n// The output stays in the proxy, so a following edge can consume it.\nconst isProxyHeld = (edge: ZapPackEdge): boolean =>\n  isSync(edge) && edge.recipient !== 'required';\n\n// One edge out of a frontier token. Records the pair it completes, and returns\n// its output when a further hop may consume it (proxy-held) and no shorter\n// path already expanded that token.\nconst visitEdge = ({\n  edge,\n  from,\n  depth,\n  sourceKey,\n  isTerminal,\n  found,\n  expanded,\n}: {\n  readonly edge: ZapPackEdge;\n  readonly from: TokenRef;\n  readonly depth: number;\n  readonly sourceKey: string;\n  readonly isTerminal: (edge: ZapPackEdge) => boolean;\n  readonly found: Map<string, RoutablePair>;\n  readonly expanded: Set<string>;\n}): TokenRef | undefined => {\n  const key = tokenKey(edge.out);\n  if (key === sourceKey) return undefined;\n  if (isTerminal(edge) && !found.has(key)) {\n    found.set(key, { in: from, out: edge.out, hops: depth });\n  }\n  if (!isProxyHeld(edge) || expanded.has(key)) return undefined;\n  expanded.add(key);\n  return edge.out;\n};\n\n// Every pair reachable from one token within `maxHops`, breadth-first so the\n// recorded hop count is the shortest one.\nconst closureFrom = ({\n  byIn,\n  from,\n  maxHops,\n  isTerminal,\n}: {\n  readonly byIn: ReadonlyMap<string, readonly ZapPackEdge[]>;\n  readonly from: TokenRef;\n  readonly maxHops: number;\n  readonly isTerminal: (edge: ZapPackEdge) => boolean;\n}): Map<string, RoutablePair> => {\n  const sourceKey = tokenKey(from);\n  const found = new Map<string, RoutablePair>();\n  const expanded = new Set<string>([sourceKey]);\n  let frontier: readonly TokenRef[] = [from];\n  for (let depth = 1; depth <= maxHops && frontier.length > 0; depth++) {\n    const next: TokenRef[] = [];\n    for (const node of frontier) {\n      for (const edge of byIn.get(tokenKey(node)) ?? []) {\n        const out = visitEdge({\n          edge,\n          from,\n          depth,\n          sourceKey,\n          isTerminal,\n          found,\n          expanded,\n        });\n        if (out) next.push(out);\n      }\n    }\n    frontier = next;\n  }\n  return found;\n};\n\nconst indexByIn = (\n  packs: readonly ZapPackOverview[],\n): Map<string, ZapPackEdge[]> => {\n  const byIn = new Map<string, ZapPackEdge[]>();\n  for (const pack of packs) {\n    for (const edge of pack.edges) {\n      const key = tokenKey(edge.in);\n      const list = byIn.get(key);\n      if (list) list.push(edge);\n      else byIn.set(key, [edge]);\n    }\n  }\n  return byIn;\n};\n\n/**\n * Builds a reachability index over the packs returned by\n * {@link ComposeClient.getZapPacks}. Per-source closures are computed on\n * first use and memoised, so `canRoute` on a handful of pairs stays cheap\n * while `pairs()` enumerates everything.\n */\nexport const buildReachability = (\n  packs: readonly ZapPackOverview[],\n  options: ReachabilityOptions = {},\n): Reachability => {\n  const maxHops = options.maxHops ?? DEFAULT_MAX_HOPS;\n  const allowAsync = options.allowAsyncRoutes ?? false;\n  const isTerminal = (edge: ZapPackEdge): boolean =>\n    isSync(edge) || (allowAsync && edge.availability === 'future');\n\n  const byIn = indexByIn(packs);\n  const memo = new Map<string, Map<string, RoutablePair>>();\n  const closure = (from: TokenRef): Map<string, RoutablePair> => {\n    const key = tokenKey(from);\n    const cached = memo.get(key);\n    if (cached) return cached;\n    const computed = closureFrom({ byIn, from, maxHops, isTerminal });\n    memo.set(key, computed);\n    return computed;\n  };\n\n  return {\n    maxHops,\n    canRoute: (from, to) => closure(from).has(tokenKey(to)),\n    routableFrom: (from) => [...closure(from).values()],\n    pairs: () => {\n      const sources = new Map<string, TokenRef>();\n      for (const pack of packs) {\n        for (const edge of pack.edges) sources.set(tokenKey(edge.in), edge.in);\n      }\n      const all: RoutablePair[] = [];\n      for (const source of sources.values()) {\n        all.push(...closure(source).values());\n      }\n      return all;\n    },\n  };\n};\n"],"mappings":";AAkEA,MAAM,mBAAmB;AAEzB,MAAM,YAAY,UAChB,GAAG,MAAM,QAAQ,GAAG,MAAM,QAAQ,YAAY;AAEhD,MAAM,UAAU,SAA+B,KAAK,iBAAiB,KAAA;AAGrE,MAAM,eAAe,SACnB,OAAO,IAAI,KAAK,KAAK,cAAc;AAKrC,MAAM,aAAa,EACjB,MACA,MACA,OACA,WACA,YACA,OACA,eAS0B;CAC1B,MAAM,MAAM,SAAS,KAAK,GAAG;CAC7B,IAAI,QAAQ,WAAW,OAAO,KAAA;CAC9B,IAAI,WAAW,IAAI,KAAK,CAAC,MAAM,IAAI,GAAG,GACpC,MAAM,IAAI,KAAK;EAAE,IAAI;EAAM,KAAK,KAAK;EAAK,MAAM;CAAM,CAAC;CAEzD,IAAI,CAAC,YAAY,IAAI,KAAK,SAAS,IAAI,GAAG,GAAG,OAAO,KAAA;CACpD,SAAS,IAAI,GAAG;CAChB,OAAO,KAAK;AACd;AAIA,MAAM,eAAe,EACnB,MACA,MACA,SACA,iBAM+B;CAC/B,MAAM,YAAY,SAAS,IAAI;CAC/B,MAAM,wBAAQ,IAAI,IAA0B;CAC5C,MAAM,2BAAW,IAAI,IAAY,CAAC,SAAS,CAAC;CAC5C,IAAI,WAAgC,CAAC,IAAI;CACzC,KAAK,IAAI,QAAQ,GAAG,SAAS,WAAW,SAAS,SAAS,GAAG,SAAS;EACpE,MAAM,OAAmB,CAAC;EAC1B,KAAK,MAAM,QAAQ,UACjB,KAAK,MAAM,QAAQ,KAAK,IAAI,SAAS,IAAI,CAAC,KAAK,CAAC,GAAG;GACjD,MAAM,MAAM,UAAU;IACpB;IACA;IACA;IACA;IACA;IACA;IACA;GACF,CAAC;GACD,IAAI,KAAK,KAAK,KAAK,GAAG;EACxB;EAEF,WAAW;CACb;CACA,OAAO;AACT;AAEA,MAAM,aACJ,UAC+B;CAC/B,MAAM,uBAAO,IAAI,IAA2B;CAC5C,KAAK,MAAM,QAAQ,OACjB,KAAK,MAAM,QAAQ,KAAK,OAAO;EAC7B,MAAM,MAAM,SAAS,KAAK,EAAE;EAC5B,MAAM,OAAO,KAAK,IAAI,GAAG;EACzB,IAAI,MAAM,KAAK,KAAK,IAAI;OACnB,KAAK,IAAI,KAAK,CAAC,IAAI,CAAC;CAC3B;CAEF,OAAO;AACT;;;;;;;AAQA,MAAa,qBACX,OACA,UAA+B,CAAC,MACf;CACjB,MAAM,UAAU,QAAQ,WAAW;CACnC,MAAM,aAAa,QAAQ,oBAAoB;CAC/C,MAAM,cAAc,SAClB,OAAO,IAAI,KAAM,cAAc,KAAK,iBAAiB;CAEvD,MAAM,OAAO,UAAU,KAAK;CAC5B,MAAM,uBAAO,IAAI,IAAuC;CACxD,MAAM,WAAW,SAA8C;EAC7D,MAAM,MAAM,SAAS,IAAI;EACzB,MAAM,SAAS,KAAK,IAAI,GAAG;EAC3B,IAAI,QAAQ,OAAO;EACnB,MAAM,WAAW,YAAY;GAAE;GAAM;GAAM;GAAS;EAAW,CAAC;EAChE,KAAK,IAAI,KAAK,QAAQ;EACtB,OAAO;CACT;CAEA,OAAO;EACL;EACA,WAAW,MAAM,OAAO,QAAQ,IAAI,CAAC,CAAC,IAAI,SAAS,EAAE,CAAC;EACtD,eAAe,SAAS,CAAC,GAAG,QAAQ,IAAI,CAAC,CAAC,OAAO,CAAC;EAClD,aAAa;GACX,MAAM,0BAAU,IAAI,IAAsB;GAC1C,KAAK,MAAM,QAAQ,OACjB,KAAK,MAAM,QAAQ,KAAK,OAAO,QAAQ,IAAI,SAAS,KAAK,EAAE,GAAG,KAAK,EAAE;GAEvE,MAAM,MAAsB,CAAC;GAC7B,KAAK,MAAM,UAAU,QAAQ,OAAO,GAClC,IAAI,KAAK,GAAG,QAAQ,MAAM,CAAC,CAAC,OAAO,CAAC;GAEtC,OAAO;EACT;CACF;AACF"}

package/dist/resources.cjs

@@ -1,39 +1,54 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var resources_exports = {};
-__export(resources_exports, {
-  erc20: () => erc20,
-  native: () => native
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/resources.ts
+var resources_exports = /* @__PURE__ */ require("./_virtual/_rolldown/runtime.cjs").__exportAll({
+	erc20: () => erc20,
+	native: () => native
 });
-module.exports = __toCommonJS(resources_exports);
+/**
+* Creates a native token resource declaration.
+*
+* @param chainId - The EVM chain ID the native token belongs to.
+* @returns A {@link NativeResource} for use in flow input schemas.
+*
+* @example
+* ```ts
+* const builder = sdk.flow(1, {
+*   inputs: { eth: native(1) },
+* });
+* ```
+*/
 const native = (chainId) => ({
-  kind: "native",
-  chainId
+	kind: "native",
+	chainId
 });
+/**
+* Creates an ERC-20 token resource declaration.
+*
+* @param token - The `0x`-prefixed contract address of the ERC-20 token.
+* @param chainId - The EVM chain ID the token is deployed on.
+* @returns An {@link Erc20Resource} for use in flow input schemas.
+*
+* @example
+* ```ts
+* const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+* const builder = sdk.flow(1, {
+*   inputs: { usdc: erc20(USDC, 1) },
+* });
+* ```
+*/
 const erc20 = (token, chainId) => ({
-  kind: "erc20",
-  token,
-  chainId
+	kind: "erc20",
+	token,
+	chainId
 });
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  erc20,
-  native
+//#endregion
+exports.erc20 = erc20;
+exports.native = native;
+Object.defineProperty(exports, "resources_exports", {
+	enumerable: true,
+	get: function() {
+		return resources_exports;
+	}
 });
+
 //# sourceMappingURL=resources.cjs.map

package/dist/resources.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/resources.ts"],"sourcesContent":["import type { Address } from './types.js';\n\n// These resource types are SDK-local declarations that mirror the shape of\n// `Resource` from `@lifi/compose-spec`. They exist so the SDK can be used\n// without directly depending on `@lifi/compose-spec` at the call site.\n// The types are structurally compatible, so they are assignable to each other.\n\n/** A resource declaration representing the chain's native token (e.g. ETH, MATIC). */\nexport interface NativeResource {\n  readonly kind: 'native';\n  readonly chainId: number;\n}\n\n/** A resource declaration representing an ERC-20 token at a specific address. */\nexport interface Erc20Resource {\n  readonly kind: 'erc20';\n  readonly token: Address;\n  readonly chainId: number;\n}\n\n/** A token resource — either the chain's native token or an ERC-20. */\nexport type Resource = NativeResource | Erc20Resource;\n\n/**\n * Creates a native token resource declaration.\n *\n * @param chainId - The EVM chain ID the native token belongs to.\n * @returns A {@link NativeResource} for use in flow input schemas.\n *\n * @example\n * ```ts\n * const builder = sdk.flow(1, {\n *   inputs: { eth: native(1) },\n * });\n * ```\n */\nexport const native = (chainId: number): NativeResource => ({\n  kind: 'native',\n  chainId,\n});\n\n/**\n * Creates an ERC-20 token resource declaration.\n *\n * @param token - The `0x`-prefixed contract address of the ERC-20 token.\n * @param chainId - The EVM chain ID the token is deployed on.\n * @returns An {@link Erc20Resource} for use in flow input schemas.\n *\n * @example\n * ```ts\n * const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';\n * const builder = sdk.flow(1, {\n *   inputs: { usdc: erc20(USDC, 1) },\n * });\n * ```\n */\nexport const erc20 = (token: Address, chainId: number): Erc20Resource => ({\n  kind: 'erc20',\n  token,\n  chainId,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoCO,MAAM,SAAS,CAAC,aAAqC;AAAA,EAC1D,MAAM;AAAA,EACN;AACF;AAiBO,MAAM,QAAQ,CAAC,OAAgB,aAAoC;AAAA,EACxE,MAAM;AAAA,EACN;AAAA,EACA;AACF;","names":[]}
+{"version":3,"file":"resources.cjs","names":[],"sources":["../src/resources.ts"],"sourcesContent":["import type { Address } from './types.js';\n\n// These resource types are SDK-local declarations that mirror the shape of\n// `Resource` from `@lifi/compose-spec`. They exist so the SDK can be used\n// without directly depending on `@lifi/compose-spec` at the call site.\n// The types are structurally compatible, so they are assignable to each other.\n\n/** A resource declaration representing the chain's native token (e.g. ETH, MATIC). */\nexport interface NativeResource {\n  readonly kind: 'native';\n  readonly chainId: number;\n}\n\n/** A resource declaration representing an ERC-20 token at a specific address. */\nexport interface Erc20Resource {\n  readonly kind: 'erc20';\n  readonly token: Address;\n  readonly chainId: number;\n}\n\n/** A token resource — either the chain's native token or an ERC-20. */\nexport type Resource = NativeResource | Erc20Resource;\n\n/**\n * Creates a native token resource declaration.\n *\n * @param chainId - The EVM chain ID the native token belongs to.\n * @returns A {@link NativeResource} for use in flow input schemas.\n *\n * @example\n * ```ts\n * const builder = sdk.flow(1, {\n *   inputs: { eth: native(1) },\n * });\n * ```\n */\nexport const native = (chainId: number): NativeResource => ({\n  kind: 'native',\n  chainId,\n});\n\n/**\n * Creates an ERC-20 token resource declaration.\n *\n * @param token - The `0x`-prefixed contract address of the ERC-20 token.\n * @param chainId - The EVM chain ID the token is deployed on.\n * @returns An {@link Erc20Resource} for use in flow input schemas.\n *\n * @example\n * ```ts\n * const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';\n * const builder = sdk.flow(1, {\n *   inputs: { usdc: erc20(USDC, 1) },\n * });\n * ```\n */\nexport const erc20 = (token: Address, chainId: number): Erc20Resource => ({\n  kind: 'erc20',\n  token,\n  chainId,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoCA,MAAa,UAAU,aAAqC;CAC1D,MAAM;CACN;AACF;;;;;;;;;;;;;;;;AAiBA,MAAa,SAAS,OAAgB,aAAoC;CACxE,MAAM;CACN;CACA;AACF"}