@lifi/composer-sdk 0.0.1-alpha

package/dist/run/inputs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/run/inputs.ts"],"sourcesContent":["import type {\n  ComposeRun,\n  InputSpec,\n  MaterialiserInput,\n  Precondition,\n  SimulationPolicy,\n  SweepTo,\n} from '@lifi/compose-spec';\n\nimport type { Address, InputSchema, InputSpecOf } from '../types.js';\n\n/**\n * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.\n *\n * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.\n */\nexport interface ComposeRunInput<T extends InputSchema = InputSchema> {\n  /**\n   * Concrete values for each declared flow input. Resource inputs accept a\n   * materialiser or a literal integer amount; scalar inputs accept the matching type.\n   */\n  readonly inputs: { readonly [K in keyof T]: InputSpecOf<T[K]> };\n  /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */\n  readonly preconditions?: readonly Precondition[];\n  /** The `0x`-prefixed address of the transaction signer. */\n  readonly signer: Address;\n  /**\n   * Optional assumed token amounts for resource inputs, keyed by input name.\n   * When a materialiser resolves amounts at execution time rather than upfront,\n   * assumptions let the compiler plan routes using estimated values. The keys\n   * must match the input names declared in the flow schema.\n   */\n  readonly assumptions?: { readonly [K in keyof T]?: bigint };\n  /** Optional integrator referrer identifier. */\n  readonly referrer?: string;\n  /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */\n  readonly maxPriceImpactBps?: number;\n  /**\n   * Destination for sweeping all proxy-held terminal resources after execution.\n   * Pass a literal `0x`-prefixed address or `{ $ref: \"context.sender\" }` to\n   * send remaining tokens to the signer.\n   */\n  readonly sweepTo?: SweepTo;\n  /**\n   * Controls behavior when simulation detects a revert.\n   * `'strict'` (default) returns an error; `'allow-revert'` returns a partial\n   * result with the transaction and revert diagnostics.\n   */\n  readonly simulationPolicy?: SimulationPolicy;\n  /**\n   * When `true`, the server checks on-chain ERC-20 allowances and omits\n   * approvals that are already sufficient. Defaults to `false`.\n   */\n  readonly checkOnChainAllowances?: boolean;\n}\n\n/**\n * Creates an untyped materialiser input spec. This is a low-level escape hatch\n * for materialiser kinds not yet covered by the generated helpers.\n *\n * Prefer the typed helpers in the `materialisers` namespace (e.g.\n * `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide\n * compile-time config validation.\n *\n * @param kind - The materialiser type (e.g. `\"balanceOf\"`, `\"directDeposit\"`).\n * @param config - Optional materialiser-specific configuration.\n * @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.\n *\n * @example\n * ```ts\n * const run = {\n *   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },\n *   signer: '0x...',\n * };\n * ```\n */\nexport const materialiser = (\n  kind: string,\n  config: Record<string, unknown> = {},\n): MaterialiserInput => ({\n  kind,\n  ...config,\n});\n\n/**\n * Assembles a {@link ComposeRun} object from individual parameters.\n * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.\n *\n * @internal\n */\nexport const buildRun = (run: {\n  inputs: Record<string, InputSpec>;\n  preconditions?: readonly Precondition[];\n  signer: string;\n  assumptions?: Record<string, bigint>;\n  referrer?: string;\n  maxPriceImpactBps?: number;\n  sweepTo?: SweepTo;\n  simulationPolicy?: SimulationPolicy;\n  checkOnChainAllowances?: boolean;\n}): ComposeRun => ({\n  inputs: run.inputs,\n  ...(run.preconditions?.length && { preconditions: run.preconditions }),\n  signer: run.signer,\n  ...(run.assumptions && { assumptions: run.assumptions }),\n  ...(run.referrer != null && { referrer: run.referrer }),\n  ...(run.maxPriceImpactBps != null && {\n    maxPriceImpactBps: run.maxPriceImpactBps,\n  }),\n  ...(run.sweepTo != null && { sweepTo: run.sweepTo }),\n  ...(run.simulationPolicy != null && {\n    simulationPolicy: run.simulationPolicy,\n  }),\n  ...(run.checkOnChainAllowances != null && {\n    checkOnChainAllowances: run.checkOnChainAllowances,\n  }),\n});\n"],"mappings":"AA4EO,MAAM,eAAe,CAC1B,MACA,SAAkC,CAAC,OACZ;AAAA,EACvB;AAAA,EACA,GAAG;AACL;AAQO,MAAM,WAAW,CAAC,SAUN;AAAA,EACjB,QAAQ,IAAI;AAAA,EACZ,GAAI,IAAI,eAAe,UAAU,EAAE,eAAe,IAAI,cAAc;AAAA,EACpE,QAAQ,IAAI;AAAA,EACZ,GAAI,IAAI,eAAe,EAAE,aAAa,IAAI,YAAY;AAAA,EACtD,GAAI,IAAI,YAAY,QAAQ,EAAE,UAAU,IAAI,SAAS;AAAA,EACrD,GAAI,IAAI,qBAAqB,QAAQ;AAAA,IACnC,mBAAmB,IAAI;AAAA,EACzB;AAAA,EACA,GAAI,IAAI,WAAW,QAAQ,EAAE,SAAS,IAAI,QAAQ;AAAA,EAClD,GAAI,IAAI,oBAAoB,QAAQ;AAAA,IAClC,kBAAkB,IAAI;AAAA,EACxB;AAAA,EACA,GAAI,IAAI,0BAA0B,QAAQ;AAAA,IACxC,wBAAwB,IAAI;AAAA,EAC9B;AACF;","names":[]}

package/dist/sdk.cjs

@@ -0,0 +1,60 @@
+"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 sdk_exports = {};
+__export(sdk_exports, {
+  createComposeSdk: () => createComposeSdk
+});
+module.exports = __toCommonJS(sdk_exports);
+var import_FlowBuilderCore = require("./authoring/FlowBuilderCore.js");
+var import_client = require("./client.js");
+var import_operations_generated = require("./generated/operations.generated.js");
+var import_inputs = require("./run/inputs.js");
+const createComposeSdk = (options) => {
+  const composeClient = (0, import_client.createComposeClient)(options);
+  const request = (flowDoc, run) => ({
+    flow: flowDoc,
+    run: (0, import_inputs.buildRun)({
+      inputs: run.inputs,
+      preconditions: run.preconditions,
+      signer: run.signer,
+      assumptions: run.assumptions,
+      referrer: run.referrer,
+      maxPriceImpactBps: run.maxPriceImpactBps,
+      sweepTo: run.sweepTo,
+      simulationPolicy: run.simulationPolicy,
+      checkOnChainAllowances: run.checkOnChainAllowances
+    })
+  });
+  const flow = (chainId, opts) => {
+    const core = (0, import_FlowBuilderCore.createFlowBuilderCore)(chainId, opts);
+    const builder = Object.assign(core, (0, import_operations_generated.bindGeneratedOps)(core));
+    const compile = async (run) => {
+      const flowDoc = builder.build();
+      const req = request(flowDoc, run);
+      return composeClient.compile(req);
+    };
+    return Object.assign(builder, { compile });
+  };
+  return { client: composeClient, flow, request };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createComposeSdk
+});
+//# sourceMappingURL=sdk.cjs.map

package/dist/sdk.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sdk.ts"],"sourcesContent":["import type {\n  ComposeCompileRequest,\n  ComposeCompileResult,\n  InputSpec,\n} from '@lifi/compose-spec';\n\nimport {\n  createFlowBuilderCore,\n  type FlowBuilderCore,\n  type FlowOptions,\n  type TypedFlow,\n} from './authoring/FlowBuilderCore.js';\nimport { type ComposeClient, createComposeClient } from './client.js';\nimport {\n  bindGeneratedOps,\n  type GeneratedOps,\n} from './generated/operations.generated.js';\nimport { buildRun, type ComposeRunInput } from './run/inputs.js';\nimport type { InputSchema } from './types.js';\n\nexport type { ComposeRunInput };\n\n/**\n * A flow builder augmented with generated operation methods and a `compile` method\n * that submits the flow to the Compose backend for compilation.\n *\n * Created via {@link ComposeSdk.flow}.\n *\n * @typeParam T - The input schema describing the flow's required inputs.\n */\nexport type FlowBuilder<T extends InputSchema = InputSchema> =\n  FlowBuilderCore<T> &\n    GeneratedOps & {\n      /**\n       * Builds the flow document from the current builder state and submits it\n       * to the Compose API for compilation.\n       *\n       * @param run - Runtime inputs, preconditions, and signer address.\n       * @returns The compiled transaction calldata and metadata.\n       * @throws {@link ComposeError} on network, validation, or server errors.\n       *\n       * @example\n       * ```ts\n       * const result = await builder.compile({\n       *   inputs: { token: materialisers.balanceOf({}) },\n       *   signer: '0xYourAddress...',\n       * });\n       * console.log(result.calldata);\n       * ```\n       */\n      readonly compile: (\n        run: ComposeRunInput<T>,\n      ) => Promise<ComposeCompileResult>;\n    };\n\n/**\n * Configuration for creating a Compose SDK instance.\n */\nexport interface ComposeSdkOptions {\n  /** Base URL of the Compose API (e.g. `\"https://li.quest\"`). */\n  readonly baseUrl: string;\n  /** Optional custom `fetch` implementation. Defaults to `globalThis.fetch`. */\n  readonly fetch?: typeof globalThis.fetch;\n  /** Optional LI.FI API key for authenticated access. Sent as the `x-lifi-api-key` header on every request. */\n  readonly apiKey?: string;\n}\n\n/**\n * The top-level Compose SDK interface.\n *\n * Provides methods to build flows, compile them into executable calldata, and\n * interact with the Compose API directly.\n *\n * @example\n * ```ts\n * import { createComposeSdk, resources, materialisers } from '@lifi/composer-sdk';\n *\n * const sdk = createComposeSdk({ baseUrl: 'https://li.quest' });\n *\n * const builder = sdk.flow(1, {\n *   inputs: { usdc: resources.erc20('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1) },\n * });\n *\n * builder.lifi.swap('swap1', {\n *   bind: { amountIn: builder.inputs.usdc },\n *   config: { resourceOut: resources.native(1) },\n * });\n *\n * const result = await builder.compile({\n *   inputs: { usdc: materialisers.balanceOf({}) },\n *   signer: '0xYourAddress...',\n * });\n * ```\n */\nexport interface ComposeSdk {\n  /** Low-level HTTP client for the Compose API. */\n  readonly client: ComposeClient;\n  /**\n   * Creates a new flow builder targeting the given chain.\n   * @param chainId - The EVM chain ID (e.g. `1` for Ethereum mainnet).\n   * @param options - Flow configuration including input declarations.\n   * @returns A {@link FlowBuilder} with generated operation methods and a `compile` method.\n   * @throws Error if any resource input's `chainId` doesn't match the flow's `chainId`.\n   */\n  readonly flow: <T extends InputSchema>(\n    chainId: number,\n    options: FlowOptions<T>,\n  ) => FlowBuilder<T>;\n  /**\n   * Builds a raw compile request without sending it. Useful for inspecting the\n   * request payload or submitting it through a custom transport.\n   * @param flow - A built flow document (from `builder.build()`).\n   * @param run - Runtime inputs, preconditions, and signer address.\n   * @returns A {@link ComposeCompileRequest} ready to send to the Compose API.\n   */\n  readonly request: <T extends InputSchema>(\n    flow: TypedFlow<T>,\n    run: ComposeRunInput<T>,\n  ) => ComposeCompileRequest;\n}\n\n/**\n * Creates a new Compose SDK instance.\n *\n * @param options - SDK configuration including the API base URL and optional fetch implementation.\n * @returns A {@link ComposeSdk} instance.\n *\n * @example\n * ```ts\n * const sdk = createComposeSdk({ baseUrl: 'https://li.quest' });\n * ```\n */\nexport const createComposeSdk = (options: ComposeSdkOptions): ComposeSdk => {\n  const composeClient = createComposeClient(options);\n\n  const request = <T extends InputSchema>(\n    flowDoc: TypedFlow<T>,\n    run: ComposeRunInput<T>,\n  ): ComposeCompileRequest => ({\n    flow: flowDoc,\n    run: buildRun({\n      inputs: run.inputs as Record<string, InputSpec>,\n      preconditions: run.preconditions,\n      signer: run.signer,\n      assumptions: run.assumptions as Record<string, bigint> | undefined,\n      referrer: run.referrer,\n      maxPriceImpactBps: run.maxPriceImpactBps,\n      sweepTo: run.sweepTo,\n      simulationPolicy: run.simulationPolicy,\n      checkOnChainAllowances: run.checkOnChainAllowances,\n    }),\n  });\n\n  const flow = <T extends InputSchema>(\n    chainId: number,\n    opts: FlowOptions<T>,\n  ): FlowBuilder<T> => {\n    const core = createFlowBuilderCore(chainId, opts);\n    const builder = Object.assign(core, bindGeneratedOps(core));\n\n    const compile = async (\n      run: ComposeRunInput<T>,\n    ): Promise<ComposeCompileResult> => {\n      const flowDoc = builder.build();\n      const req = request(flowDoc, run);\n      return composeClient.compile(req);\n    };\n\n    return Object.assign(builder, { compile });\n  };\n\n  return { client: composeClient, flow, request };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,6BAKO;AACP,oBAAwD;AACxD,kCAGO;AACP,oBAA+C;AAmHxC,MAAM,mBAAmB,CAAC,YAA2C;AAC1E,QAAM,oBAAgB,mCAAoB,OAAO;AAEjD,QAAM,UAAU,CACd,SACA,SAC2B;AAAA,IAC3B,MAAM;AAAA,IACN,SAAK,wBAAS;AAAA,MACZ,QAAQ,IAAI;AAAA,MACZ,eAAe,IAAI;AAAA,MACnB,QAAQ,IAAI;AAAA,MACZ,aAAa,IAAI;AAAA,MACjB,UAAU,IAAI;AAAA,MACd,mBAAmB,IAAI;AAAA,MACvB,SAAS,IAAI;AAAA,MACb,kBAAkB,IAAI;AAAA,MACtB,wBAAwB,IAAI;AAAA,IAC9B,CAAC;AAAA,EACH;AAEA,QAAM,OAAO,CACX,SACA,SACmB;AACnB,UAAM,WAAO,8CAAsB,SAAS,IAAI;AAChD,UAAM,UAAU,OAAO,OAAO,UAAM,8CAAiB,IAAI,CAAC;AAE1D,UAAM,UAAU,OACd,QACkC;AAClC,YAAM,UAAU,QAAQ,MAAM;AAC9B,YAAM,MAAM,QAAQ,SAAS,GAAG;AAChC,aAAO,cAAc,QAAQ,GAAG;AAAA,IAClC;AAEA,WAAO,OAAO,OAAO,SAAS,EAAE,QAAQ,CAAC;AAAA,EAC3C;AAEA,SAAO,EAAE,QAAQ,eAAe,MAAM,QAAQ;AAChD;","names":[]}

package/dist/sdk.d.cts

@@ -0,0 +1,112 @@
+import { ComposeCompileResult, ComposeCompileRequest } from '@lifi/compose-spec';
+import { FlowOptions, FlowBuilderCore, TypedFlow } from './authoring/FlowBuilderCore.cjs';
+import { ComposeClient } from './client.cjs';
+import { GeneratedOps } from './generated/operations.generated.cjs';
+import { ComposeRunInput } from './run/inputs.cjs';
+import { InputSchema } from './types.cjs';
+import './authoring/handles.cjs';
+import './discovery.cjs';
+import './authoring/signatureArgs.cjs';
+import 'abitype';
+import './generated/config.generated.cjs';
+
+/**
+ * A flow builder augmented with generated operation methods and a `compile` method
+ * that submits the flow to the Compose backend for compilation.
+ *
+ * Created via {@link ComposeSdk.flow}.
+ *
+ * @typeParam T - The input schema describing the flow's required inputs.
+ */
+type FlowBuilder<T extends InputSchema = InputSchema> = FlowBuilderCore<T> & GeneratedOps & {
+    /**
+     * Builds the flow document from the current builder state and submits it
+     * to the Compose API for compilation.
+     *
+     * @param run - Runtime inputs, preconditions, and signer address.
+     * @returns The compiled transaction calldata and metadata.
+     * @throws {@link ComposeError} on network, validation, or server errors.
+     *
+     * @example
+     * ```ts
+     * const result = await builder.compile({
+     *   inputs: { token: materialisers.balanceOf({}) },
+     *   signer: '0xYourAddress...',
+     * });
+     * console.log(result.calldata);
+     * ```
+     */
+    readonly compile: (run: ComposeRunInput<T>) => Promise<ComposeCompileResult>;
+};
+/**
+ * Configuration for creating a Compose SDK instance.
+ */
+interface ComposeSdkOptions {
+    /** Base URL of the Compose API (e.g. `"https://li.quest"`). */
+    readonly baseUrl: string;
+    /** Optional custom `fetch` implementation. Defaults to `globalThis.fetch`. */
+    readonly fetch?: typeof globalThis.fetch;
+    /** Optional LI.FI API key for authenticated access. Sent as the `x-lifi-api-key` header on every request. */
+    readonly apiKey?: string;
+}
+/**
+ * The top-level Compose SDK interface.
+ *
+ * Provides methods to build flows, compile them into executable calldata, and
+ * interact with the Compose API directly.
+ *
+ * @example
+ * ```ts
+ * import { createComposeSdk, resources, materialisers } from '@lifi/composer-sdk';
+ *
+ * const sdk = createComposeSdk({ baseUrl: 'https://li.quest' });
+ *
+ * const builder = sdk.flow(1, {
+ *   inputs: { usdc: resources.erc20('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1) },
+ * });
+ *
+ * builder.lifi.swap('swap1', {
+ *   bind: { amountIn: builder.inputs.usdc },
+ *   config: { resourceOut: resources.native(1) },
+ * });
+ *
+ * const result = await builder.compile({
+ *   inputs: { usdc: materialisers.balanceOf({}) },
+ *   signer: '0xYourAddress...',
+ * });
+ * ```
+ */
+interface ComposeSdk {
+    /** Low-level HTTP client for the Compose API. */
+    readonly client: ComposeClient;
+    /**
+     * Creates a new flow builder targeting the given chain.
+     * @param chainId - The EVM chain ID (e.g. `1` for Ethereum mainnet).
+     * @param options - Flow configuration including input declarations.
+     * @returns A {@link FlowBuilder} with generated operation methods and a `compile` method.
+     * @throws Error if any resource input's `chainId` doesn't match the flow's `chainId`.
+     */
+    readonly flow: <T extends InputSchema>(chainId: number, options: FlowOptions<T>) => FlowBuilder<T>;
+    /**
+     * Builds a raw compile request without sending it. Useful for inspecting the
+     * request payload or submitting it through a custom transport.
+     * @param flow - A built flow document (from `builder.build()`).
+     * @param run - Runtime inputs, preconditions, and signer address.
+     * @returns A {@link ComposeCompileRequest} ready to send to the Compose API.
+     */
+    readonly request: <T extends InputSchema>(flow: TypedFlow<T>, run: ComposeRunInput<T>) => ComposeCompileRequest;
+}
+/**
+ * Creates a new Compose SDK instance.
+ *
+ * @param options - SDK configuration including the API base URL and optional fetch implementation.
+ * @returns A {@link ComposeSdk} instance.
+ *
+ * @example
+ * ```ts
+ * const sdk = createComposeSdk({ baseUrl: 'https://li.quest' });
+ * ```
+ */
+declare const createComposeSdk: (options: ComposeSdkOptions) => ComposeSdk;
+
+export { ComposeRunInput, type ComposeSdk, type ComposeSdkOptions, type FlowBuilder, createComposeSdk };

package/dist/sdk.d.ts

@@ -0,0 +1,112 @@
+import { ComposeCompileResult, ComposeCompileRequest } from '@lifi/compose-spec';
+import { FlowOptions, FlowBuilderCore, TypedFlow } from './authoring/FlowBuilderCore.js';
+import { ComposeClient } from './client.js';
+import { GeneratedOps } from './generated/operations.generated.js';
+import { ComposeRunInput } from './run/inputs.js';
+import { InputSchema } from './types.js';
+import './authoring/handles.js';
+import './discovery.js';
+import './authoring/signatureArgs.js';
+import 'abitype';
+import './generated/config.generated.js';
+
+/**
+ * A flow builder augmented with generated operation methods and a `compile` method
+ * that submits the flow to the Compose backend for compilation.
+ *
+ * Created via {@link ComposeSdk.flow}.
+ *
+ * @typeParam T - The input schema describing the flow's required inputs.
+ */
+type FlowBuilder<T extends InputSchema = InputSchema> = FlowBuilderCore<T> & GeneratedOps & {
+    /**
+     * Builds the flow document from the current builder state and submits it
+     * to the Compose API for compilation.
+     *
+     * @param run - Runtime inputs, preconditions, and signer address.
+     * @returns The compiled transaction calldata and metadata.
+     * @throws {@link ComposeError} on network, validation, or server errors.
+     *
+     * @example
+     * ```ts
+     * const result = await builder.compile({
+     *   inputs: { token: materialisers.balanceOf({}) },
+     *   signer: '0xYourAddress...',
+     * });
+     * console.log(result.calldata);
+     * ```
+     */
+    readonly compile: (run: ComposeRunInput<T>) => Promise<ComposeCompileResult>;
+};
+/**
+ * Configuration for creating a Compose SDK instance.
+ */
+interface ComposeSdkOptions {
+    /** Base URL of the Compose API (e.g. `"https://li.quest"`). */
+    readonly baseUrl: string;
+    /** Optional custom `fetch` implementation. Defaults to `globalThis.fetch`. */
+    readonly fetch?: typeof globalThis.fetch;
+    /** Optional LI.FI API key for authenticated access. Sent as the `x-lifi-api-key` header on every request. */
+    readonly apiKey?: string;
+}
+/**
+ * The top-level Compose SDK interface.
+ *
+ * Provides methods to build flows, compile them into executable calldata, and
+ * interact with the Compose API directly.
+ *
+ * @example
+ * ```ts
+ * import { createComposeSdk, resources, materialisers } from '@lifi/composer-sdk';
+ *
+ * const sdk = createComposeSdk({ baseUrl: 'https://li.quest' });
+ *
+ * const builder = sdk.flow(1, {
+ *   inputs: { usdc: resources.erc20('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1) },
+ * });
+ *
+ * builder.lifi.swap('swap1', {
+ *   bind: { amountIn: builder.inputs.usdc },
+ *   config: { resourceOut: resources.native(1) },
+ * });
+ *
+ * const result = await builder.compile({
+ *   inputs: { usdc: materialisers.balanceOf({}) },
+ *   signer: '0xYourAddress...',
+ * });
+ * ```
+ */
+interface ComposeSdk {
+    /** Low-level HTTP client for the Compose API. */
+    readonly client: ComposeClient;
+    /**
+     * Creates a new flow builder targeting the given chain.
+     * @param chainId - The EVM chain ID (e.g. `1` for Ethereum mainnet).
+     * @param options - Flow configuration including input declarations.
+     * @returns A {@link FlowBuilder} with generated operation methods and a `compile` method.
+     * @throws Error if any resource input's `chainId` doesn't match the flow's `chainId`.
+     */
+    readonly flow: <T extends InputSchema>(chainId: number, options: FlowOptions<T>) => FlowBuilder<T>;
+    /**
+     * Builds a raw compile request without sending it. Useful for inspecting the
+     * request payload or submitting it through a custom transport.
+     * @param flow - A built flow document (from `builder.build()`).
+     * @param run - Runtime inputs, preconditions, and signer address.
+     * @returns A {@link ComposeCompileRequest} ready to send to the Compose API.
+     */
+    readonly request: <T extends InputSchema>(flow: TypedFlow<T>, run: ComposeRunInput<T>) => ComposeCompileRequest;
+}
+/**
+ * Creates a new Compose SDK instance.
+ *
+ * @param options - SDK configuration including the API base URL and optional fetch implementation.
+ * @returns A {@link ComposeSdk} instance.
+ *
+ * @example
+ * ```ts
+ * const sdk = createComposeSdk({ baseUrl: 'https://li.quest' });
+ * ```
+ */
+declare const createComposeSdk: (options: ComposeSdkOptions) => ComposeSdk;
+
+export { ComposeRunInput, type ComposeSdk, type ComposeSdkOptions, type FlowBuilder, createComposeSdk };

package/dist/sdk.js

@@ -0,0 +1,40 @@
+import {
+  createFlowBuilderCore
+} from "./authoring/FlowBuilderCore.js";
+import { createComposeClient } from "./client.js";
+import {
+  bindGeneratedOps
+} from "./generated/operations.generated.js";
+import { buildRun } from "./run/inputs.js";
+const createComposeSdk = (options) => {
+  const composeClient = createComposeClient(options);
+  const request = (flowDoc, run) => ({
+    flow: flowDoc,
+    run: buildRun({
+      inputs: run.inputs,
+      preconditions: run.preconditions,
+      signer: run.signer,
+      assumptions: run.assumptions,
+      referrer: run.referrer,
+      maxPriceImpactBps: run.maxPriceImpactBps,
+      sweepTo: run.sweepTo,
+      simulationPolicy: run.simulationPolicy,
+      checkOnChainAllowances: run.checkOnChainAllowances
+    })
+  });
+  const flow = (chainId, opts) => {
+    const core = createFlowBuilderCore(chainId, opts);
+    const builder = Object.assign(core, bindGeneratedOps(core));
+    const compile = async (run) => {
+      const flowDoc = builder.build();
+      const req = request(flowDoc, run);
+      return composeClient.compile(req);
+    };
+    return Object.assign(builder, { compile });
+  };
+  return { client: composeClient, flow, request };
+};
+export {
+  createComposeSdk
+};
+//# sourceMappingURL=sdk.js.map

package/dist/sdk.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sdk.ts"],"sourcesContent":["import type {\n  ComposeCompileRequest,\n  ComposeCompileResult,\n  InputSpec,\n} from '@lifi/compose-spec';\n\nimport {\n  createFlowBuilderCore,\n  type FlowBuilderCore,\n  type FlowOptions,\n  type TypedFlow,\n} from './authoring/FlowBuilderCore.js';\nimport { type ComposeClient, createComposeClient } from './client.js';\nimport {\n  bindGeneratedOps,\n  type GeneratedOps,\n} from './generated/operations.generated.js';\nimport { buildRun, type ComposeRunInput } from './run/inputs.js';\nimport type { InputSchema } from './types.js';\n\nexport type { ComposeRunInput };\n\n/**\n * A flow builder augmented with generated operation methods and a `compile` method\n * that submits the flow to the Compose backend for compilation.\n *\n * Created via {@link ComposeSdk.flow}.\n *\n * @typeParam T - The input schema describing the flow's required inputs.\n */\nexport type FlowBuilder<T extends InputSchema = InputSchema> =\n  FlowBuilderCore<T> &\n    GeneratedOps & {\n      /**\n       * Builds the flow document from the current builder state and submits it\n       * to the Compose API for compilation.\n       *\n       * @param run - Runtime inputs, preconditions, and signer address.\n       * @returns The compiled transaction calldata and metadata.\n       * @throws {@link ComposeError} on network, validation, or server errors.\n       *\n       * @example\n       * ```ts\n       * const result = await builder.compile({\n       *   inputs: { token: materialisers.balanceOf({}) },\n       *   signer: '0xYourAddress...',\n       * });\n       * console.log(result.calldata);\n       * ```\n       */\n      readonly compile: (\n        run: ComposeRunInput<T>,\n      ) => Promise<ComposeCompileResult>;\n    };\n\n/**\n * Configuration for creating a Compose SDK instance.\n */\nexport interface ComposeSdkOptions {\n  /** Base URL of the Compose API (e.g. `\"https://li.quest\"`). */\n  readonly baseUrl: string;\n  /** Optional custom `fetch` implementation. Defaults to `globalThis.fetch`. */\n  readonly fetch?: typeof globalThis.fetch;\n  /** Optional LI.FI API key for authenticated access. Sent as the `x-lifi-api-key` header on every request. */\n  readonly apiKey?: string;\n}\n\n/**\n * The top-level Compose SDK interface.\n *\n * Provides methods to build flows, compile them into executable calldata, and\n * interact with the Compose API directly.\n *\n * @example\n * ```ts\n * import { createComposeSdk, resources, materialisers } from '@lifi/composer-sdk';\n *\n * const sdk = createComposeSdk({ baseUrl: 'https://li.quest' });\n *\n * const builder = sdk.flow(1, {\n *   inputs: { usdc: resources.erc20('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', 1) },\n * });\n *\n * builder.lifi.swap('swap1', {\n *   bind: { amountIn: builder.inputs.usdc },\n *   config: { resourceOut: resources.native(1) },\n * });\n *\n * const result = await builder.compile({\n *   inputs: { usdc: materialisers.balanceOf({}) },\n *   signer: '0xYourAddress...',\n * });\n * ```\n */\nexport interface ComposeSdk {\n  /** Low-level HTTP client for the Compose API. */\n  readonly client: ComposeClient;\n  /**\n   * Creates a new flow builder targeting the given chain.\n   * @param chainId - The EVM chain ID (e.g. `1` for Ethereum mainnet).\n   * @param options - Flow configuration including input declarations.\n   * @returns A {@link FlowBuilder} with generated operation methods and a `compile` method.\n   * @throws Error if any resource input's `chainId` doesn't match the flow's `chainId`.\n   */\n  readonly flow: <T extends InputSchema>(\n    chainId: number,\n    options: FlowOptions<T>,\n  ) => FlowBuilder<T>;\n  /**\n   * Builds a raw compile request without sending it. Useful for inspecting the\n   * request payload or submitting it through a custom transport.\n   * @param flow - A built flow document (from `builder.build()`).\n   * @param run - Runtime inputs, preconditions, and signer address.\n   * @returns A {@link ComposeCompileRequest} ready to send to the Compose API.\n   */\n  readonly request: <T extends InputSchema>(\n    flow: TypedFlow<T>,\n    run: ComposeRunInput<T>,\n  ) => ComposeCompileRequest;\n}\n\n/**\n * Creates a new Compose SDK instance.\n *\n * @param options - SDK configuration including the API base URL and optional fetch implementation.\n * @returns A {@link ComposeSdk} instance.\n *\n * @example\n * ```ts\n * const sdk = createComposeSdk({ baseUrl: 'https://li.quest' });\n * ```\n */\nexport const createComposeSdk = (options: ComposeSdkOptions): ComposeSdk => {\n  const composeClient = createComposeClient(options);\n\n  const request = <T extends InputSchema>(\n    flowDoc: TypedFlow<T>,\n    run: ComposeRunInput<T>,\n  ): ComposeCompileRequest => ({\n    flow: flowDoc,\n    run: buildRun({\n      inputs: run.inputs as Record<string, InputSpec>,\n      preconditions: run.preconditions,\n      signer: run.signer,\n      assumptions: run.assumptions as Record<string, bigint> | undefined,\n      referrer: run.referrer,\n      maxPriceImpactBps: run.maxPriceImpactBps,\n      sweepTo: run.sweepTo,\n      simulationPolicy: run.simulationPolicy,\n      checkOnChainAllowances: run.checkOnChainAllowances,\n    }),\n  });\n\n  const flow = <T extends InputSchema>(\n    chainId: number,\n    opts: FlowOptions<T>,\n  ): FlowBuilder<T> => {\n    const core = createFlowBuilderCore(chainId, opts);\n    const builder = Object.assign(core, bindGeneratedOps(core));\n\n    const compile = async (\n      run: ComposeRunInput<T>,\n    ): Promise<ComposeCompileResult> => {\n      const flowDoc = builder.build();\n      const req = request(flowDoc, run);\n      return composeClient.compile(req);\n    };\n\n    return Object.assign(builder, { compile });\n  };\n\n  return { client: composeClient, flow, request };\n};\n"],"mappings":"AAMA;AAAA,EACE;AAAA,OAIK;AACP,SAA6B,2BAA2B;AACxD;AAAA,EACE;AAAA,OAEK;AACP,SAAS,gBAAsC;AAmHxC,MAAM,mBAAmB,CAAC,YAA2C;AAC1E,QAAM,gBAAgB,oBAAoB,OAAO;AAEjD,QAAM,UAAU,CACd,SACA,SAC2B;AAAA,IAC3B,MAAM;AAAA,IACN,KAAK,SAAS;AAAA,MACZ,QAAQ,IAAI;AAAA,MACZ,eAAe,IAAI;AAAA,MACnB,QAAQ,IAAI;AAAA,MACZ,aAAa,IAAI;AAAA,MACjB,UAAU,IAAI;AAAA,MACd,mBAAmB,IAAI;AAAA,MACvB,SAAS,IAAI;AAAA,MACb,kBAAkB,IAAI;AAAA,MACtB,wBAAwB,IAAI;AAAA,IAC9B,CAAC;AAAA,EACH;AAEA,QAAM,OAAO,CACX,SACA,SACmB;AACnB,UAAM,OAAO,sBAAsB,SAAS,IAAI;AAChD,UAAM,UAAU,OAAO,OAAO,MAAM,iBAAiB,IAAI,CAAC;AAE1D,UAAM,UAAU,OACd,QACkC;AAClC,YAAM,UAAU,QAAQ,MAAM;AAC9B,YAAM,MAAM,QAAQ,SAAS,GAAG;AAChC,aAAO,cAAc,QAAQ,GAAG;AAAA,IAClC;AAEA,WAAO,OAAO,OAAO,SAAS,EAAE,QAAQ,CAAC;AAAA,EAC3C;AAEA,SAAO,EAAE,QAAQ,eAAe,MAAM,QAAQ;AAChD;","names":[]}

package/dist/types.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.cjs.map

package/dist/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import type { Ref } from '@lifi/compose-spec';\nimport {\n  InputSpec,\n  MaterialiserInput,\n  Resource,\n  SolType,\n} from '@lifi/compose-spec';\n\n/**\n * A string that represents a non-negative integer (e.g. \"1000000000\").\n * Uses a template literal type so that only numeric-looking strings\n * are assignable at compile time.\n */\nexport type IntegerString = `${bigint}`;\n\n/**\n * Accepted input for integer-string config fields.\n * Callers may pass either a numeric string (\"1000000000\") or a native bigint\n * (1000000000n). Bigint values are stringified automatically during JSON\n * serialization via the SDK's `bigintReplacer`.\n */\nexport type IntegerStringInput = IntegerString | bigint;\n\n/**\n * A `0x`-prefixed hex string representing an Ethereum address.\n * Template literal type catches obviously wrong values at compile time.\n */\nexport type Address = `0x${string}`;\n\n/** The universe of output port kinds: Solidity scalar types plus `'resource'`. */\nexport type OutputKind = SolType | 'resource';\n\n/**\n * Maps an ABI parameter type string (from abitype's `ParseAbiItem`) to the\n * closest `OutputKind`. When the ABI type is one of the supported `SolType`\n * scalars, the mapping is exact; for all other Solidity types (e.g. tuples,\n * fixed-point decimals) it falls back to `SolType` — accepting any scalar\n * handle but not `'resource'` handles.\n *\n * The fallback excludes `'resource'` because every Solidity type is a scalar;\n * resource handles carry token-amount semantics that should only flow into\n * slots explicitly declared as resources.\n *\n * Extending `SolType` with new members automatically widens the exact-match\n * branch — no changes needed here.\n */\nexport type AbiTypeToOutputKind<T extends string> = T extends SolType\n  ? T\n  : SolType;\n\n/**\n * A typed `$ref` pointer carrying a phantom type parameter.\n * Extends `Ref` so it is accepted anywhere a plain `Ref` is.\n * The `__outputKind` field is never set at runtime — it exists only\n * for TypeScript's structural type checker to distinguish typed refs.\n */\nexport interface TypedRef<T extends OutputKind = OutputKind> extends Ref {\n  readonly __outputKind?: T;\n}\n\n/**\n * An input declaration in a flow schema.\n * `Resource` values become resource inputs (token amounts);\n * `SolType` strings become handle inputs (scalars like addresses).\n */\nexport type InputDecl = Resource | SolType;\n\n/**\n * A record mapping input names to their declarations.\n * Used as the type parameter for generic flow builders and requests.\n */\nexport type InputSchema = Record<string, InputDecl>;\n\n/**\n * Maps an input declaration to the allowed runtime value type.\n * Resource inputs accept materialisers or literal amounts.\n * Handle inputs accept the scalar type matching their SolType.\n */\nexport type InputSpecOf<D> = D extends Resource\n  ? MaterialiserInput | IntegerStringInput\n  : D extends 'address'\n    ? Address\n    : D extends 'bool'\n      ? boolean\n      : D extends `${'u' | ''}int${string}`\n        ? IntegerStringInput\n        : D extends `bytes${string}`\n          ? `0x${string}`\n          : D extends 'string'\n            ? string\n            : InputSpec;\n\n/**\n * A guard applied to an operation, with the `port` field constrained\n * to a specific set of output port names.\n */\nexport interface TypedGuard<Port extends string = string> {\n  readonly kind: string;\n  readonly port: Port;\n  readonly [key: string]: unknown;\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/types.d.cts

@@ -0,0 +1,74 @@
+import { SolType, Ref, Resource, MaterialiserInput, InputSpec } from '@lifi/compose-spec';
+
+/**
+ * A string that represents a non-negative integer (e.g. "1000000000").
+ * Uses a template literal type so that only numeric-looking strings
+ * are assignable at compile time.
+ */
+type IntegerString = `${bigint}`;
+/**
+ * Accepted input for integer-string config fields.
+ * Callers may pass either a numeric string ("1000000000") or a native bigint
+ * (1000000000n). Bigint values are stringified automatically during JSON
+ * serialization via the SDK's `bigintReplacer`.
+ */
+type IntegerStringInput = IntegerString | bigint;
+/**
+ * A `0x`-prefixed hex string representing an Ethereum address.
+ * Template literal type catches obviously wrong values at compile time.
+ */
+type Address = `0x${string}`;
+/** The universe of output port kinds: Solidity scalar types plus `'resource'`. */
+type OutputKind = SolType | 'resource';
+/**
+ * Maps an ABI parameter type string (from abitype's `ParseAbiItem`) to the
+ * closest `OutputKind`. When the ABI type is one of the supported `SolType`
+ * scalars, the mapping is exact; for all other Solidity types (e.g. tuples,
+ * fixed-point decimals) it falls back to `SolType` — accepting any scalar
+ * handle but not `'resource'` handles.
+ *
+ * The fallback excludes `'resource'` because every Solidity type is a scalar;
+ * resource handles carry token-amount semantics that should only flow into
+ * slots explicitly declared as resources.
+ *
+ * Extending `SolType` with new members automatically widens the exact-match
+ * branch — no changes needed here.
+ */
+type AbiTypeToOutputKind<T extends string> = T extends SolType ? T : SolType;
+/**
+ * A typed `$ref` pointer carrying a phantom type parameter.
+ * Extends `Ref` so it is accepted anywhere a plain `Ref` is.
+ * The `__outputKind` field is never set at runtime — it exists only
+ * for TypeScript's structural type checker to distinguish typed refs.
+ */
+interface TypedRef<T extends OutputKind = OutputKind> extends Ref {
+    readonly __outputKind?: T;
+}
+/**
+ * An input declaration in a flow schema.
+ * `Resource` values become resource inputs (token amounts);
+ * `SolType` strings become handle inputs (scalars like addresses).
+ */
+type InputDecl = Resource | SolType;
+/**
+ * A record mapping input names to their declarations.
+ * Used as the type parameter for generic flow builders and requests.
+ */
+type InputSchema = Record<string, InputDecl>;
+/**
+ * Maps an input declaration to the allowed runtime value type.
+ * Resource inputs accept materialisers or literal amounts.
+ * Handle inputs accept the scalar type matching their SolType.
+ */
+type InputSpecOf<D> = D extends Resource ? MaterialiserInput | IntegerStringInput : D extends 'address' ? Address : D extends 'bool' ? boolean : D extends `${'u' | ''}int${string}` ? IntegerStringInput : D extends `bytes${string}` ? `0x${string}` : D extends 'string' ? string : InputSpec;
+/**
+ * A guard applied to an operation, with the `port` field constrained
+ * to a specific set of output port names.
+ */
+interface TypedGuard<Port extends string = string> {
+    readonly kind: string;
+    readonly port: Port;
+    readonly [key: string]: unknown;
+}
+
+export type { AbiTypeToOutputKind, Address, InputDecl, InputSchema, InputSpecOf, IntegerString, IntegerStringInput, OutputKind, TypedGuard, TypedRef };

package/dist/types.d.ts

@@ -0,0 +1,74 @@
+import { SolType, Ref, Resource, MaterialiserInput, InputSpec } from '@lifi/compose-spec';
+
+/**
+ * A string that represents a non-negative integer (e.g. "1000000000").
+ * Uses a template literal type so that only numeric-looking strings
+ * are assignable at compile time.
+ */
+type IntegerString = `${bigint}`;
+/**
+ * Accepted input for integer-string config fields.
+ * Callers may pass either a numeric string ("1000000000") or a native bigint
+ * (1000000000n). Bigint values are stringified automatically during JSON
+ * serialization via the SDK's `bigintReplacer`.
+ */
+type IntegerStringInput = IntegerString | bigint;
+/**
+ * A `0x`-prefixed hex string representing an Ethereum address.
+ * Template literal type catches obviously wrong values at compile time.
+ */
+type Address = `0x${string}`;
+/** The universe of output port kinds: Solidity scalar types plus `'resource'`. */
+type OutputKind = SolType | 'resource';
+/**
+ * Maps an ABI parameter type string (from abitype's `ParseAbiItem`) to the
+ * closest `OutputKind`. When the ABI type is one of the supported `SolType`
+ * scalars, the mapping is exact; for all other Solidity types (e.g. tuples,
+ * fixed-point decimals) it falls back to `SolType` — accepting any scalar
+ * handle but not `'resource'` handles.
+ *
+ * The fallback excludes `'resource'` because every Solidity type is a scalar;
+ * resource handles carry token-amount semantics that should only flow into
+ * slots explicitly declared as resources.
+ *
+ * Extending `SolType` with new members automatically widens the exact-match
+ * branch — no changes needed here.
+ */
+type AbiTypeToOutputKind<T extends string> = T extends SolType ? T : SolType;
+/**
+ * A typed `$ref` pointer carrying a phantom type parameter.
+ * Extends `Ref` so it is accepted anywhere a plain `Ref` is.
+ * The `__outputKind` field is never set at runtime — it exists only
+ * for TypeScript's structural type checker to distinguish typed refs.
+ */
+interface TypedRef<T extends OutputKind = OutputKind> extends Ref {
+    readonly __outputKind?: T;
+}
+/**
+ * An input declaration in a flow schema.
+ * `Resource` values become resource inputs (token amounts);
+ * `SolType` strings become handle inputs (scalars like addresses).
+ */
+type InputDecl = Resource | SolType;
+/**
+ * A record mapping input names to their declarations.
+ * Used as the type parameter for generic flow builders and requests.
+ */
+type InputSchema = Record<string, InputDecl>;
+/**
+ * Maps an input declaration to the allowed runtime value type.
+ * Resource inputs accept materialisers or literal amounts.
+ * Handle inputs accept the scalar type matching their SolType.
+ */
+type InputSpecOf<D> = D extends Resource ? MaterialiserInput | IntegerStringInput : D extends 'address' ? Address : D extends 'bool' ? boolean : D extends `${'u' | ''}int${string}` ? IntegerStringInput : D extends `bytes${string}` ? `0x${string}` : D extends 'string' ? string : InputSpec;
+/**
+ * A guard applied to an operation, with the `port` field constrained
+ * to a specific set of output port names.
+ */
+interface TypedGuard<Port extends string = string> {
+    readonly kind: string;
+    readonly port: Port;
+    readonly [key: string]: unknown;
+}
+
+export type { AbiTypeToOutputKind, Address, InputDecl, InputSchema, InputSpecOf, IntegerString, IntegerStringInput, OutputKind, TypedGuard, TypedRef };

package/dist/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@lifi/composer-sdk",
+  "version": "0.0.1-alpha",
+  "description": "Public Composer SDK for building and submitting flows",
+  "license": "Apache-2.0",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "prettier": {
+    "singleQuote": true
+  },
+  "scripts": {
+    "build": "tsc --noEmit && tsup",
+    "clean": "rm -rf dist out",
+    "pack:local": "yarn build && mkdir -p out && yarn pack --out 'out/%s-%v.tgz'",
+    "generate": "tsx scripts/generate-sdk.ts",
+    "test": "vitest run --config vitest.config.ts",
+    "check:types": "tsc --noEmit",
+    "check:sdk-drift": "vitest run --config vitest.drift.config.ts",
+    "fix": "run-s fix:lint fix:prettier",
+    "fix:lint": "eslint src --fix",
+    "fix:prettier": "prettier \"src/**/*.ts\" --write",
+    "lint": "eslint src",
+    "test:lint": "eslint src",
+    "test:prettier": "prettier \"src/**/*.ts\" --list-different",
+    "example": "tsx src/examples/run.ts"
+  },
+  "peerDependencies": {
+    "@lifi/compose-spec": "0.0.1-alpha"
+  },
+  "dependencies": {
+    "abitype": "^1.2.3",
+    "effect": "^3.21.0"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^1.4.0",
+    "@lifi/compose-spec": "workspace:^",
+    "@types/node": "^25.6.0",
+    "@typescript-eslint/eslint-plugin": "^8.44.1",
+    "@typescript-eslint/parser": "^8.44.1",
+    "eslint": "^9.36.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-eslint-comments": "^3.2.0",
+    "eslint-plugin-import": "^2.22.0",
+    "eslint-plugin-require-extensions": "^0.1.3",
+    "json-schema-to-typescript": "^15.0.4",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^3.0.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.20.4",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "files": [
+    "dist/**",
+    "!dist/**/*.tsbuildinfo",
+    "src/**/*.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/*.test.ts",
+    "!src/**/*.mock.ts",
+    "!src/**/*.typecheck.ts",
+    "!dist/**/*.typecheck.*"
+  ]
+}