@lifi/composer-sdk 0.5.1 → 0.6.1

package/dist/responseSchemas.d.cts

@@ -8,12 +8,12 @@ import { SimulationRevert, SimulateResult } from '@lifi/compose-spec';
 declare const parseSimulateResult: (body: unknown) => SimulateResult | null;
 /**
  * The validated members of an HTTP 206 partial compile envelope. `data` is
- * verified to be an object but kept untyped — compose-spec owns its full shape
- * (`ComposeCompilePartialData`) as a hand-authored type, so the caller narrows
- * it. `error` is fully validated.
+ * verified to be an object at runtime but left `unknown` here — compose-spec
+ * owns its full shape (`ComposeCompilePartialData`) as a hand-authored type, so
+ * the caller narrows it in one step. `error` is fully validated.
  */
 interface CompilePartialEnvelope {
-    readonly data: Record<string, unknown>;
+    readonly data: unknown;
     readonly error: {
         readonly kind: string;
         readonly message: string;

package/dist/responseSchemas.d.ts

@@ -8,12 +8,12 @@ import { SimulationRevert, SimulateResult } from '@lifi/compose-spec';
 declare const parseSimulateResult: (body: unknown) => SimulateResult | null;
 /**
  * The validated members of an HTTP 206 partial compile envelope. `data` is
- * verified to be an object but kept untyped — compose-spec owns its full shape
- * (`ComposeCompilePartialData`) as a hand-authored type, so the caller narrows
- * it. `error` is fully validated.
+ * verified to be an object at runtime but left `unknown` here — compose-spec
+ * owns its full shape (`ComposeCompilePartialData`) as a hand-authored type, so
+ * the caller narrows it in one step. `error` is fully validated.
  */
 interface CompilePartialEnvelope {
-    readonly data: Record<string, unknown>;
+    readonly data: unknown;
     readonly error: {
         readonly kind: string;
         readonly message: string;

package/dist/responseSchemas.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/responseSchemas.ts"],"sourcesContent":["import type { SimulateResult, SimulationRevert } from '@lifi/compose-spec';\nimport z from 'zod';\n\n/**\n * Zod-backed parsers for Compose API response bodies.\n *\n * Server responses are untrusted input crossing into the SDK, so the shapes the\n * client reads back are validated here rather than asserted with `as` casts. The\n * schemas are module-private (the package builds with `--isolatedDeclarations`,\n * which forbids exporting un-annotated complex values); the public surface is\n * the typed `parse*` helpers, whose explicit return types double as the contract.\n *\n * The simulate union is the one response the SDK fully owns and parses itself\n * (it is un-enveloped, unlike `/compose`), so it gets a complete schema kept in\n * lockstep with the canonical `SimulateResult` in `@lifi/compose-spec` by the\n * compile-time assertion below — the same anchoring `@lifi/api-schemas` uses for\n * its server-side simulate schema, so the two cannot silently drift.\n */\n\nconst balanceEntrySchema = z.object({\n  token: z.string(),\n  owner: z.string(),\n  amount: z.string(),\n});\n\nconst simulateOkSchema = z.object({\n  status: z.literal('ok'),\n  block: z.number(),\n  timestamp: z.number(),\n  balancesBefore: z.array(balanceEntrySchema),\n  balancesAfter: z.array(balanceEntrySchema),\n  deltas: z.array(balanceEntrySchema),\n  gasUsed: z.string(),\n});\n\nconst simulateRevertDecodeResultSchema = z.object({\n  errorCandidates: z\n    .array(\n      z.object({\n        decodedErrorSignature: z.string(),\n        decodedParams: z.array(z.string()),\n      }),\n    )\n    .optional(),\n  error: z.string().optional(),\n});\n\nconst simulateRevertSchema = z.object({\n  status: z.literal('revert'),\n  block: z.number(),\n  timestamp: z.number(),\n  revertReason: z.string().optional(),\n  code: z.number().optional(),\n  rawErrorBytes: z.string().optional(),\n  decodeResult: simulateRevertDecodeResultSchema.optional(),\n});\n\nconst simulateSetupErrorSchema = z.object({\n  status: z.literal('error'),\n  message: z.string(),\n});\n\nconst simulateResultSchema = z.discriminatedUnion('status', [\n  simulateOkSchema,\n  simulateRevertSchema,\n  simulateSetupErrorSchema,\n]);\n\n// The type the schema actually parses out. Kept private (referencing it from an\n// exported declaration would break `--isolatedDeclarations`) and pinned to the\n// canonical `SimulateResult` inside `parseSimulateResult` below.\ntype SimulateResultWire = z.infer<typeof simulateResultSchema>;\n\n/**\n * Parses a `POST /simulate` body into a {@link SimulateResult}. Returns `null`\n * when the body does not match the `ok`/`revert`/`error` union, letting the\n * caller raise a transport-level error.\n */\nexport const parseSimulateResult = (body: unknown): SimulateResult | null => {\n  const parsed = simulateResultSchema.safeParse(body);\n  if (!parsed.success) return null;\n  // Pin the schema to the canonical contract in both directions, so it cannot\n  // silently drift (mirroring the conformance assertion `@lifi/api-schemas` runs\n  // on its server-side simulate schema). Assigning the inferred wire value to a\n  // `SimulateResult` checks wire→spec; `satisfies SimulateResultWire` checks\n  // spec→wire. A missing or mistyped field on either side fails to compile.\n  const result: SimulateResult = parsed.data;\n  return result satisfies SimulateResultWire;\n};\n\n/**\n * The validated members of an HTTP 206 partial compile envelope. `data` is\n * verified to be an object but kept untyped — compose-spec owns its full shape\n * (`ComposeCompilePartialData`) as a hand-authored type, so the caller narrows\n * it. `error` is fully validated.\n */\nexport interface CompilePartialEnvelope {\n  readonly data: Record<string, unknown>;\n  readonly error: { readonly kind: string; readonly message: string };\n}\n\nconst compilePartialEnvelopeSchema = z.object({\n  data: z.record(z.string(), z.unknown()),\n  error: z.object({ kind: z.string(), message: z.string() }),\n});\n\n/** Parses an HTTP 206 partial compile envelope; `null` when it does not match. */\nexport const parseCompilePartialEnvelope = (\n  body: unknown,\n): CompilePartialEnvelope | null => {\n  const parsed = compilePartialEnvelopeSchema.safeParse(body);\n  return parsed.success ? parsed.data : null;\n};\n\n/**\n * A single prepared-op failure inside a `preparation_error` envelope. `kind` is\n * kept as `string` here — the narrowing to `GenericComposeErrorKind` happens in\n * `errorFromHttpResponse`, where the value is lifted onto `ComposeError`.\n */\nexport interface ServerFailedPreparedOp {\n  readonly callId: string;\n  readonly op: string;\n  readonly kind: string;\n  readonly message: string;\n  readonly path?: string;\n}\n\n/** Error envelope returned on non-2xx responses. */\nexport interface ServerErrorBody {\n  readonly error?: {\n    readonly kind?: string;\n    readonly message?: string;\n    readonly path?: string;\n    readonly sdkVersion?: string;\n    readonly serverVersion?: string;\n    readonly minimumSdkVersion?: string;\n    readonly details?: SimulationRevert;\n    readonly failedOps?: readonly ServerFailedPreparedOp[];\n    readonly succeededOps?: readonly string[];\n  };\n}\n\nconst failedPreparedOpSchema = z.object({\n  callId: z.string(),\n  op: z.string(),\n  kind: z.string(),\n  message: z.string(),\n  path: z.string().optional(),\n});\n\n// `details` is passed through (`z.custom`) rather than parsed: the SDK does not\n// own the `SimulationRevert` schema and forwards the field verbatim onto\n// `ComposeError`.\n//\n// `failedOps`/`succeededOps` are optional here because every error kind shares\n// this envelope; they are only populated for `preparation_error` (422). Zod\n// strips undeclared keys, so omitting them would silently drop them.\nconst serverErrorBodySchema = z.object({\n  error: z\n    .object({\n      kind: z.string().optional(),\n      message: z.string().optional(),\n      path: z.string().optional(),\n      sdkVersion: z.string().optional(),\n      serverVersion: z.string().optional(),\n      minimumSdkVersion: z.string().optional(),\n      details: z.custom<SimulationRevert>().optional(),\n      failedOps: z.array(failedPreparedOpSchema).readonly().optional(),\n      succeededOps: z.array(z.string()).readonly().optional(),\n    })\n    .optional(),\n});\n\n/** Validates an already-parsed error envelope; `null` when it does not match. */\nexport const parseServerErrorBody = (json: unknown): ServerErrorBody | null => {\n  const parsed = serverErrorBodySchema.safeParse(json);\n  return parsed.success ? parsed.data : null;\n};\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/responseSchemas.ts"],"sourcesContent":["import type { SimulateResult, SimulationRevert } from '@lifi/compose-spec';\nimport z from 'zod';\n\n/**\n * Zod-backed parsers for Compose API response bodies.\n *\n * Server responses are untrusted input crossing into the SDK, so the shapes the\n * client reads back are validated here rather than asserted with `as` casts. The\n * schemas are module-private (the package builds with `--isolatedDeclarations`,\n * which forbids exporting un-annotated complex values); the public surface is\n * the typed `parse*` helpers, whose explicit return types double as the contract.\n *\n * The simulate union is the one response the SDK fully owns and parses itself\n * (it is un-enveloped, unlike `/compose`), so it gets a complete schema kept in\n * lockstep with the canonical `SimulateResult` in `@lifi/compose-spec` by the\n * compile-time assertion below — the same anchoring `@lifi/api-schemas` uses for\n * its server-side simulate schema, so the two cannot silently drift.\n */\n\nconst balanceEntrySchema = z.object({\n  token: z.string(),\n  owner: z.string(),\n  amount: z.string(),\n});\n\nconst simulateOkSchema = z.object({\n  status: z.literal('ok'),\n  block: z.number(),\n  timestamp: z.number(),\n  balancesBefore: z.array(balanceEntrySchema),\n  balancesAfter: z.array(balanceEntrySchema),\n  deltas: z.array(balanceEntrySchema),\n  gasUsed: z.string(),\n});\n\nconst simulateRevertDecodeResultSchema = z.object({\n  errorCandidates: z\n    .array(\n      z.object({\n        decodedErrorSignature: z.string(),\n        decodedParams: z.array(z.string()),\n      }),\n    )\n    .optional(),\n  error: z.string().optional(),\n});\n\nconst simulateRevertSchema = z.object({\n  status: z.literal('revert'),\n  block: z.number(),\n  timestamp: z.number(),\n  revertReason: z.string().optional(),\n  code: z.number().optional(),\n  rawErrorBytes: z.string().optional(),\n  decodeResult: simulateRevertDecodeResultSchema.optional(),\n});\n\nconst simulateSetupErrorSchema = z.object({\n  status: z.literal('error'),\n  message: z.string(),\n});\n\nconst simulateResultSchema = z.discriminatedUnion('status', [\n  simulateOkSchema,\n  simulateRevertSchema,\n  simulateSetupErrorSchema,\n]);\n\n// The type the schema actually parses out. Kept private (referencing it from an\n// exported declaration would break `--isolatedDeclarations`) and pinned to the\n// canonical `SimulateResult` inside `parseSimulateResult` below.\ntype SimulateResultWire = z.infer<typeof simulateResultSchema>;\n\n/**\n * Parses a `POST /simulate` body into a {@link SimulateResult}. Returns `null`\n * when the body does not match the `ok`/`revert`/`error` union, letting the\n * caller raise a transport-level error.\n */\nexport const parseSimulateResult = (body: unknown): SimulateResult | null => {\n  const parsed = simulateResultSchema.safeParse(body);\n  if (!parsed.success) return null;\n  // Pin the schema to the canonical contract in both directions, so it cannot\n  // silently drift (mirroring the conformance assertion `@lifi/api-schemas` runs\n  // on its server-side simulate schema). Assigning the inferred wire value to a\n  // `SimulateResult` checks wire→spec; `satisfies SimulateResultWire` checks\n  // spec→wire. A missing or mistyped field on either side fails to compile.\n  const result: SimulateResult = parsed.data;\n  return result satisfies SimulateResultWire;\n};\n\n/**\n * The validated members of an HTTP 206 partial compile envelope. `data` is\n * verified to be an object at runtime but left `unknown` here — compose-spec\n * owns its full shape (`ComposeCompilePartialData`) as a hand-authored type, so\n * the caller narrows it in one step. `error` is fully validated.\n */\nexport interface CompilePartialEnvelope {\n  readonly data: unknown;\n  readonly error: { readonly kind: string; readonly message: string };\n}\n\nconst compilePartialEnvelopeSchema = z.object({\n  data: z.record(z.string(), z.unknown()),\n  error: z.object({ kind: z.string(), message: z.string() }),\n});\n\n/** Parses an HTTP 206 partial compile envelope; `null` when it does not match. */\nexport const parseCompilePartialEnvelope = (\n  body: unknown,\n): CompilePartialEnvelope | null => {\n  const parsed = compilePartialEnvelopeSchema.safeParse(body);\n  return parsed.success ? parsed.data : null;\n};\n\n/**\n * A single prepared-op failure inside a `preparation_error` envelope. `kind` is\n * kept as `string` here — the narrowing to `GenericComposeErrorKind` happens in\n * `errorFromHttpResponse`, where the value is lifted onto `ComposeError`.\n */\nexport interface ServerFailedPreparedOp {\n  readonly callId: string;\n  readonly op: string;\n  readonly kind: string;\n  readonly message: string;\n  readonly path?: string;\n}\n\n/** Error envelope returned on non-2xx responses. */\nexport interface ServerErrorBody {\n  readonly error?: {\n    readonly kind?: string;\n    readonly message?: string;\n    readonly path?: string;\n    readonly sdkVersion?: string;\n    readonly serverVersion?: string;\n    readonly minimumSdkVersion?: string;\n    readonly details?: SimulationRevert;\n    readonly failedOps?: readonly ServerFailedPreparedOp[];\n    readonly succeededOps?: readonly string[];\n  };\n}\n\nconst failedPreparedOpSchema = z.object({\n  callId: z.string(),\n  op: z.string(),\n  kind: z.string(),\n  message: z.string(),\n  path: z.string().optional(),\n});\n\n// `details` is passed through (`z.custom`) rather than parsed: the SDK does not\n// own the `SimulationRevert` schema and forwards the field verbatim onto\n// `ComposeError`.\n//\n// `failedOps`/`succeededOps` are optional here because every error kind shares\n// this envelope; they are only populated for `preparation_error` (422). Zod\n// strips undeclared keys, so omitting them would silently drop them.\nconst serverErrorBodySchema = z.object({\n  error: z\n    .object({\n      kind: z.string().optional(),\n      message: z.string().optional(),\n      path: z.string().optional(),\n      sdkVersion: z.string().optional(),\n      serverVersion: z.string().optional(),\n      minimumSdkVersion: z.string().optional(),\n      details: z.custom<SimulationRevert>().optional(),\n      failedOps: z.array(failedPreparedOpSchema).readonly().optional(),\n      succeededOps: z.array(z.string()).readonly().optional(),\n    })\n    .optional(),\n});\n\n/** Validates an already-parsed error envelope; `null` when it does not match. */\nexport const parseServerErrorBody = (json: unknown): ServerErrorBody | null => {\n  const parsed = serverErrorBodySchema.safeParse(json);\n  return parsed.success ? parsed.data : null;\n};\n"],"mappings":"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","names":[]}

package/dist/types.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import type { LiteralBinding, 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 * A literal bind value carrying a phantom type parameter.\n *\n * The wire format accepts a constant in a bind slot as\n * `{ kind: <solType>, value: <string> }`, alongside `$ref` pointers. Use it\n * for a value that must be baked into the flow document rather than supplied\n * at run time — the destination of a flow the backend stores and re-runs\n * later (a `continuation.settle` node's `continuationFlow`) has no run to\n * take an input from.\n *\n * @typeParam T - The Solidity type of the literal (e.g. `'address'`).\n */\nexport interface TypedLiteral<\n  T extends SolType = SolType,\n> extends LiteralBinding {\n  readonly kind: T;\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":[]}
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import type { LiteralBinding, 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 * Phantom brand key for {@link TypedRef}.\n *\n * Declared, never assigned: it exists only so the type checker can tell a\n * typed ref from an arbitrary `{ $ref }` object. Keying it on a `unique\n * symbol` means no caller can produce one by writing an object literal.\n */\nexport declare const typedRefKind: unique symbol;\n\n/**\n * A typed `$ref` pointer carrying a phantom type parameter.\n *\n * On the wire, and at run time, this is exactly `{ $ref: string }` — the\n * brand is erased. The brand is *required* in the type so a plain `Ref` does\n * not satisfy `TypedRef` structurally, which is the contract `RefBindable`\n * advertises: an untyped `{ $ref }` never enters a typed bind slot. Build one\n * with `raw.ref<T>()`.\n */\nexport interface TypedRef<T extends OutputKind = OutputKind> extends Ref {\n  readonly [typedRefKind]: T;\n}\n\n/**\n * A literal bind value carrying a phantom type parameter.\n *\n * The wire format accepts a constant in a bind slot as\n * `{ kind: <solType>, value: <string> }`, alongside `$ref` pointers. Use it\n * for a value that must be baked into the flow document rather than supplied\n * at run time — the destination of a flow the backend stores and re-runs\n * later (a `continuation.settle` node's `continuationFlow`) has no run to\n * take an input from.\n *\n * @typeParam T - The Solidity type of the literal (e.g. `'address'`).\n */\nexport interface TypedLiteral<\n  T extends SolType = SolType,\n> extends LiteralBinding {\n  readonly kind: T;\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

@@ -35,14 +35,25 @@ type OutputKind = SolType | 'resource';
  * branch — no changes needed here.
  */
 type AbiTypeToOutputKind<T extends string> = T extends SolType ? T : SolType;
+/**
+ * Phantom brand key for {@link TypedRef}.
+ *
+ * Declared, never assigned: it exists only so the type checker can tell a
+ * typed ref from an arbitrary `{ $ref }` object. Keying it on a `unique
+ * symbol` means no caller can produce one by writing an object literal.
+ */
+declare const typedRefKind: unique symbol;
 /**
  * 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.
+ *
+ * On the wire, and at run time, this is exactly `{ $ref: string }` — the
+ * brand is erased. The brand is *required* in the type so a plain `Ref` does
+ * not satisfy `TypedRef` structurally, which is the contract `RefBindable`
+ * advertises: an untyped `{ $ref }` never enters a typed bind slot. Build one
+ * with `raw.ref<T>()`.
  */
 interface TypedRef<T extends OutputKind = OutputKind> extends Ref {
-    readonly __outputKind?: T;
+    readonly [typedRefKind]: T;
 }
 /**
  * A literal bind value carrying a phantom type parameter.
@@ -87,4 +98,4 @@ interface TypedGuard<Port extends string = string> {
     readonly [key: string]: unknown;
 }
 
-export type { AbiTypeToOutputKind, Address, InputDecl, InputSchema, InputSpecOf, IntegerString, IntegerStringInput, OutputKind, TypedGuard, TypedLiteral, TypedRef };
+export { type AbiTypeToOutputKind, type Address, type InputDecl, type InputSchema, type InputSpecOf, type IntegerString, type IntegerStringInput, type OutputKind, type TypedGuard, type TypedLiteral, type TypedRef, typedRefKind };

package/dist/types.d.ts

@@ -35,14 +35,25 @@ type OutputKind = SolType | 'resource';
  * branch — no changes needed here.
  */
 type AbiTypeToOutputKind<T extends string> = T extends SolType ? T : SolType;
+/**
+ * Phantom brand key for {@link TypedRef}.
+ *
+ * Declared, never assigned: it exists only so the type checker can tell a
+ * typed ref from an arbitrary `{ $ref }` object. Keying it on a `unique
+ * symbol` means no caller can produce one by writing an object literal.
+ */
+declare const typedRefKind: unique symbol;
 /**
  * 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.
+ *
+ * On the wire, and at run time, this is exactly `{ $ref: string }` — the
+ * brand is erased. The brand is *required* in the type so a plain `Ref` does
+ * not satisfy `TypedRef` structurally, which is the contract `RefBindable`
+ * advertises: an untyped `{ $ref }` never enters a typed bind slot. Build one
+ * with `raw.ref<T>()`.
  */
 interface TypedRef<T extends OutputKind = OutputKind> extends Ref {
-    readonly __outputKind?: T;
+    readonly [typedRefKind]: T;
 }
 /**
  * A literal bind value carrying a phantom type parameter.
@@ -87,4 +98,4 @@ interface TypedGuard<Port extends string = string> {
     readonly [key: string]: unknown;
 }
 
-export type { AbiTypeToOutputKind, Address, InputDecl, InputSchema, InputSpecOf, IntegerString, IntegerStringInput, OutputKind, TypedGuard, TypedLiteral, TypedRef };
+export { type AbiTypeToOutputKind, type Address, type InputDecl, type InputSchema, type InputSpecOf, type IntegerString, type IntegerStringInput, type OutputKind, type TypedGuard, type TypedLiteral, type TypedRef, typedRefKind };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifi/composer-sdk",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "Public Composer SDK for building and submitting flows",
   "license": "Apache-2.0",
   "repository": {
@@ -34,8 +34,9 @@
     "pack:local": "yarn build && mkdir -p out && yarn pack --out 'out/%s-%v.tgz'",
     "generate": "tsx scripts/generate-sdk/index.ts",
     "generate:staged": "tsx scripts/generate-sdk/index.ts --staged",
-    "test": "vitest run --config vitest.config.ts",
+    "test": "yarn check:types:test && vitest run --config vitest.config.ts",
     "check:types": "tsc --noEmit",
+    "check:types:test": "tsc -p tsconfig.test.json --noEmit",
     "check:sdk-drift": "vitest run --config vitest.drift.config.ts",
     "fix": "yarn fix:lint",
     "fix:lint": "eslint src --fix",
@@ -46,7 +47,7 @@
     "example:staged": "tsx src/examples/run.ts --staged"
   },
   "peerDependencies": {
-    "@lifi/compose-spec": "0.5.1"
+    "@lifi/compose-spec": "0.6.1"
   },
   "dependencies": {
     "abitype": "^1.2.3",

package/src/authoring/FlowBuilderCore.ts

@@ -4,6 +4,7 @@ import type {
   Call,
   Flow,
   FlowInput,
+  Ref,
   Resource,
   SolType,
 } from '@lifi/compose-spec';
@@ -39,13 +40,21 @@ export interface CallArgs {
 
 /**
  * Any value that can be bound to an operation parameter: an input handle, an
- * output handle from a previous operation, a typed `$ref` pointer, or a typed
- * literal.
+ * output handle from a previous operation, a typed `$ref` pointer, a typed
+ * literal, or a bare `{ $ref }` pointer.
+ *
+ * This is the bind type of {@link FlowBuilderInternal.call}, the entry point
+ * every generated operation lowers into — not a public authoring surface. A
+ * bare `Ref` belongs here because a generated op resolves its own typed binds
+ * to wire refs (`toBindRef` in `./signatureArgs.js`) before calling it. Typed
+ * operation slots use `Bindable<T>`, which rejects a bare `Ref`; see
+ * `RefBindable` in `./handles.js`.
  *
  * Use `raw.ref<T>()` to create a typed ref from a raw path string, and
  * `raw.literal<T>()` to bake in a constant.
  */
-export type AnyBindable = InputHandle | OutputHandle | TypedRef | TypedLiteral;
+export type AnyBindable =
+  InputHandle | OutputHandle | TypedRef | TypedLiteral | Ref;
 
 /**
  * Provides references to runtime context values available inside a flow.

package/src/authoring/handles.ts

@@ -1,5 +1,6 @@
 import type {
   BindValue,
+  Ref,
   Resource,
   SolType,
   StaticSolType,
@@ -122,5 +123,5 @@ type LiteralBindable<K extends OutputKind> = K extends SolType
  * `$ref` pointers, refs and literals pass through as-is.
  */
 export const toBindValue = (
-  bindable: InputHandle | OutputHandle | TypedRef | TypedLiteral,
+  bindable: InputHandle | OutputHandle | TypedRef | TypedLiteral | Ref,
 ): BindValue => ('_tag' in bindable ? handleToRef(bindable) : bindable);

package/src/authoring/raw.ts

@@ -35,9 +35,10 @@ import type { OutputKind, TypedLiteral, TypedRef } from '../types.js';
  * });
  * ```
  */
-export const ref = <T extends OutputKind>(path: string): TypedRef<T> => ({
-  $ref: path,
-});
+export const ref = <T extends OutputKind>(path: string): TypedRef<T> =>
+  // The brand is phantom, so the runtime value is the bare wire ref. This is
+  // the only place a `TypedRef` is minted; the cast is what the brand buys.
+  ({ $ref: path }) as TypedRef<T>;
 
 /**
  * Creates a typed literal for use in bind slots: a constant baked into the

package/src/client.ts

@@ -123,11 +123,11 @@ export interface ComposeClient {
    * the server, not the shape of this contract.
    *
    * Only synchronous edges are considered unless the request sets
-   * `allowAsyncRoutes: true`, so by default every produced resource comes back
-   * `availability: 'now'` and a pair reachable only after settlement is a
+   * `allowAsyncRoutes: true`, so by default every terminal output comes back
+   * `delivery.when: 'now'` and a pair reachable only after settlement is a
    * `no_route_error`. Opting in adds the `lifi.zapAsync` fallback, which still
    * loses to a synchronous edge when the pair has one; read
-   * `producedResources[*].availability` to see which representation you got.
+   * `outputs[*].delivery.when` to see which representation you got.
    *
    * Use {@link compile} for what the server does not author for you: several
    * chained operations, splits, explicit preconditions, or per-op guards.
@@ -200,16 +200,11 @@ const isNonNullObject = (v: unknown): v is Record<string, unknown> =>
 // Non-negative decimal integer string, as the server sends token amounts.
 const INTEGER_STRING = /^\d+$/;
 
-const decodeAmount = (
-  value: unknown,
-  key: string,
-  field: 'amountOut' | 'amountOutMin',
-  url: string,
-): bigint => {
+const decodeAmount = (value: unknown, path: string, url: string): bigint => {
   if (typeof value !== 'string' || !INTEGER_STRING.test(value)) {
     throw new ComposeError(
       'UNKNOWN_ERROR',
-      `Malformed compose response: producedResources.${key}.simulated.${field} is ${
+      `Malformed compose response: ${path} is ${
         value === undefined ? 'absent' : 'not an integer string'
       }`,
       { url },
@@ -218,46 +213,83 @@ const decodeAmount = (
   return BigInt(value);
 };
 
-// `simulated.amountOut` / `.amountOutMin` are declared `bigint` on
-// `SimulatedAmounts` (the domain truth: `compose-core` produces real bigints)
-// but arrive as decimal strings on the wire (the backend stringifies them).
-// Decode at this seam so a consumer reading the declared type gets the value
-// the type promises. A resource without `simulated` is left untouched; a
-// `simulated` claiming a missing or non-numeric amount is a contract violation
-// and surfaces as a `ComposeError` rather than `NaN` / `BigInt(undefined)`.
-const decodeSimulatedAmounts = (data: unknown, url: string): void => {
-  if (!isNonNullObject(data)) return;
-  const resources = data.producedResources;
-  if (!isNonNullObject(resources)) return;
-  for (const key of Object.keys(resources)) {
-    const resource = resources[key];
-    if (!isNonNullObject(resource)) continue;
-    const simulated = resource.simulated;
-    if (simulated === undefined) continue;
-    if (!isNonNullObject(simulated)) {
-      throw new ComposeError(
-        'UNKNOWN_ERROR',
-        `Malformed compose response: producedResources.${key}.simulated is not an object`,
-        { url },
-      );
-    }
-    simulated.amountOut = decodeAmount(
-      simulated.amountOut,
-      key,
-      'amountOut',
+// The two records this seam reads out of a compile-family response body. Each
+// is `unknown` because the seam is what establishes its shape: it validates
+// every field before writing a decoded `bigint` back over the wire string.
+interface WireAmountBody {
+  outputs?: unknown;
+}
+
+// One `Amount` as it arrives: each leaf is `unknown` until this seam has
+// checked it, and is overwritten in place with the decoded `bigint`.
+interface WireAmount {
+  estimate?: unknown;
+  minimum?: unknown;
+}
+
+const malformed = (path: string, what: string, url: string): ComposeError =>
+  new ComposeError(
+    'UNKNOWN_ERROR',
+    `Malformed compose response: ${path} ${what}`,
+    { url },
+  );
+
+// Decode one `Estimate` / `Minimum` leaf in place: `{ basis, value }` with
+// `value` a decimal string on the wire and a `bigint` on `Amount`.
+const decodeAmountLeaf = (
+  amount: WireAmount,
+  field: 'estimate' | 'minimum',
+  path: string,
+  url: string,
+): void => {
+  const leaf = amount[field];
+  if (leaf === undefined) return;
+  if (!isNonNullObject(leaf)) {
+    throw malformed(`${path}.${field}`, 'is not an object', url);
+  }
+  leaf.value = decodeAmount(leaf.value, `${path}.${field}.value`, url);
+};
+
+// `outputs` is REQUIRED on every compile-family body and is the record a
+// caller reads amounts from, so its structure is checked here — the body is
+// cast, not schema-parsed — before each `value` leaf becomes a `bigint`.
+const decodeOutputs = (data: WireAmountBody, url: string): void => {
+  const outputs = data.outputs;
+  if (!isNonNullObject(outputs)) {
+    throw malformed(
+      'outputs',
+      outputs === undefined ? 'is absent' : 'is not an object',
       url,
     );
-    if (simulated.amountOutMin !== undefined) {
-      simulated.amountOutMin = decodeAmount(
-        simulated.amountOutMin,
-        key,
-        'amountOutMin',
+  }
+  for (const key of Object.keys(outputs)) {
+    const entry = outputs[key];
+    if (!isNonNullObject(entry)) {
+      throw malformed(`outputs.${key}`, 'is not an object', url);
+    }
+    const amount = entry.amount;
+    if (!isNonNullObject(amount)) {
+      throw malformed(
+        `outputs.${key}.amount`,
+        amount === undefined ? 'is absent' : 'is not an object',
         url,
       );
     }
+    decodeAmountLeaf(amount, 'estimate', `outputs.${key}.amount`, url);
+    decodeAmountLeaf(amount, 'minimum', `outputs.${key}.amount`, url);
   }
 };
 
+// THE decode seam for a compile-family response body: every amount the wire
+// renders as a decimal string becomes the `bigint` its declared type promises.
+// The amount record is handled here so the body is narrowed once — a
+// non-object body is not this function's error to raise, since the enveloping
+// parse already rejected it.
+const decodeWireAmounts = (data: unknown, url: string): void => {
+  if (!isNonNullObject(data)) return;
+  decodeOutputs(data, url);
+};
+
 const parseBody = async <T>(res: Response, url: string): Promise<T> => {
   const body = await res.json().catch((_) => null);
   if (!isNonNullObject(body) || !('data' in body)) {
@@ -273,7 +305,7 @@ const parseCompileSuccessBody = async (
   url: string,
 ): Promise<ComposeCompileResult> => {
   const data = await parseBody<ComposeCompileSuccessData>(res, url);
-  decodeSimulatedAmounts(data, url);
+  decodeWireAmounts(data, url);
   return { ...data, status: 'success' as const };
 };
 
@@ -293,8 +325,8 @@ const parsePartialBody = async (
   // `data` is validated as an object by the schema; compose-spec owns its full
   // shape as a hand-authored type, so we narrow it here rather than re-declaring
   // that type as a schema. `error` is fully validated — no cast needed.
-  const data = envelope.data as unknown as ComposeCompilePartialData;
-  decodeSimulatedAmounts(data, url);
+  const data = envelope.data as ComposeCompilePartialData;
+  decodeWireAmounts(data, url);
   return { ...data, status: 'partial' as const, error: envelope.error };
 };
 

package/src/examples/flySwap.ts

@@ -54,14 +54,14 @@ const WETH = '0x4200000000000000000000000000000000000006';
  * basis points, not percent.
  *
  * Widening it is safe but not free. The bottom of the band is what the compose
- * response publishes as `amountOutMin`, so a wider band advertises a weaker
+ * response publishes as the output's `amount.minimum`, so a wider band
  * minimum to whoever consumes your quote.
  *
  * ## Ignore the 50% slippage in the Fly calldata
  *
  * If you inspect the compiled transaction you will see a 50% slippage figure
  * where you configured 1%. That is deliberate and it is not your setting. All
- * Fly's own `slippage` parameter does is price its `amountOutMin`, which is an
+ * Fly's own `slippage` parameter does is price its minimum-out floor, which is an
  * absolute amount fixed at quote time and therefore cannot scale down when a
  * legitimately smaller input arrives. The op sends a high value so that floor
  * can never be the binding constraint, and enforces its own rate-based bound
@@ -137,7 +137,7 @@ export const buildFlySwapExample = (): {
   //
   // No slippage guard here, and none is accepted: `amountOut` declares
   // `providesMinimum`, so the op owns its own bound. Attaching one is a
-  // `guard_error`. The published `amountOutMin` is the op's, derived from the
+  // `guard_error`. The published `amount.minimum` is the op's, derived from the
   // bottom of the input band.
   builder.fly.swap('swapAllToWeth', {
     bind: { amountIn: exitPt.amountOut },

package/src/examples/lifiZapAsync.ts

@@ -21,15 +21,16 @@ export interface LifiZapAsyncInput {
  * - `lifi.zapAsync`, the future-availability sibling of `lifi.zap`
  * - Binding the required `recipient` input (the async op has no optional
  *   recipient — the decl is non-optional, so `bind.recipient` is mandatory)
- * - Omitting `sweepTo`: `availability: 'future'` governs custody, so the
+ * - Omitting `sweepTo`: a future delivery governs custody, so the
  *   output is delivered externally and never enters the execution VM — a
  *   sweep would find nothing to move (custody, not amount reporting)
- * - Amount reporting is unaffected by availability: when the async lowering
- *   binds a terminal handle the output still reports `simulated.amountOut`,
- *   the protocol's in-transaction expected value (an estimate; the delivered
- *   amount arrives after settlement). `simulated.amountOutMin` appears only
- *   when a minimum source exists — for a future output that means a floor the
- *   edge lowering itself reported, never a user guard
+ * - Amount reporting is unaffected by delivery timing: when the async lowering
+ *   binds a terminal handle the output still reports an `amount.estimate`
+ *   (`basis: 'simulated'`), the protocol's in-transaction expected value (the
+ *   delivered amount arrives after settlement, when `delivery.when` is
+ *   `'future'`). An `amount.minimum` appears only when a minimum source
+ *   exists — for a future output that means a floor the edge lowering itself
+ *   reported, never a user guard
  * - No output guards: the reported value is the initiating-transaction
  *   estimate, not the asynchronously delivered amount a guard could enforce,
  *   so `amountOut` is excluded from the generated `TypedGuard` union

package/src/examples/swapAndZap.ts

@@ -20,6 +20,13 @@ const A_ETH_USDC = '0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c';
  * - Chaining a swap into a zap by threading output handles
  * - The swap's amountOut feeds directly into the zap's amountIn
  * - Slippage guard on the zap output (swap output has providesMinimum)
+ *
+ * Reading the result of compiling this flow:
+ * - `result.outputs['swap.amountOut']` has `role: 'consumed'` (the zap consumes
+ *   it); `consumedBy` is `'zap'` and `amount.minimum` is the swap floor the
+ *   router enforces on the intermediate USDC.
+ * - `result.outputs['zap.amountOut']` has `role: 'terminal'`; its
+ *   `amount.minimum` carries the guard floor set above.
  */
 export const buildSwapAndZapExample = (): {
   flow: Flow;

package/src/examples/swapWithAllowRevert.ts

@@ -91,18 +91,28 @@ export const handleCompileResult = async (): Promise<void> => {
 
   if (result.status === 'success') {
     // Full success — transactionRequest includes gasLimit.
-    const { transactionRequest, userProxy, producedResources } = result;
+    const { transactionRequest, userProxy, outputs } = result;
     void transactionRequest;
     void userProxy;
-    void producedResources;
+    // Every linear resource output port appears in `outputs`, keyed
+    // `<nodeId>.<port>`. The swap's terminal output carries the amount.
+    const swapOut = outputs['swap.amountOut'];
+    void swapOut?.amount.estimate?.value; // simulated estimate on a 200
+    void swapOut?.amount.minimum?.value; // enforced floor, absent if none known
     return;
   }
 
   // Partial result — simulation reverted but a transaction is still available.
   // transactionRequest omits gasLimit; the caller must estimate gas themselves.
-  const { transactionRequest, simulationRevert, error } = result;
+  const { transactionRequest, outputs, simulationRevert, error } = result;
   void transactionRequest;
 
+  // Nothing was measured, so the estimate is a quote and the minimum is
+  // op-sourced (or absent) rather than a guard floor.
+  const swapOut = outputs['swap.amountOut'];
+  void swapOut?.amount.estimate?.value; // quoted on a 206
+  void swapOut?.amount.minimum?.value; // op/declared floor, absent if none
+
   // Inspect the revert reason.
   void simulationRevert.code;
   void simulationRevert.rawErrorBytes;

package/src/generated/config.generated.ts

@@ -60,6 +60,55 @@ export interface LifiSwapConfig {
   };
 }
 
+/**
+ * a string starting with "0x"
+ */
+export type StartsWith0X = string;
+/**
+ * a number between 0 and 1
+ */
+export type Between01 = number;
+
+export interface LifiBridgeConfig {
+  resourceOut:
+    | {
+        kind: 'native';
+        chainId: Positive;
+      }
+    | {
+        kind: 'erc20';
+        token: Address;
+        chainId: Positive;
+      };
+  destination: StartsWith0X;
+  slippage?: Between01;
+  timing?: {
+    swapStepTimingStrategies?: {
+      strategy: 'minWaitTime';
+      minWaitTimeMs: number;
+      startingExpectedResults: number;
+      reduceEveryMs: number;
+    }[];
+    routeTimingStrategies?: {
+      strategy: 'minWaitTime';
+      minWaitTimeMs: number;
+      startingExpectedResults: number;
+      reduceEveryMs: number;
+    }[];
+  };
+  bridges?: {
+    allow?: MaxItems50;
+    deny?: MaxItems50;
+    prefer?: MaxItems50;
+  };
+  exchanges?: {
+    allow?: MaxItems50;
+    deny?: MaxItems50;
+    prefer?: MaxItems50;
+  };
+  order?: 'FASTEST' | 'CHEAPEST';
+}
+
 export interface InvariantNumericConfig {
   op: 'gte' | 'gt' | 'lte' | 'lt' | 'eq' | 'neq';
   threshold: IntegerStringInput;
@@ -671,10 +720,6 @@ export type ContinuationAssertReadyConfig =
       comparator: 'gte' | 'eq' | 'lte';
       value: string;
     };
-/**
- * a string starting with "0x"
- */
-export type StartsWith0X = string;
 
 export interface LifiZapConfig {
   resourceOut: