@lifi/composer-sdk 0.8.1 → 0.10.0

package/dist/authoring/handles.d.cts

@@ -1,39 +1,39 @@
-import { StaticSolType, SolType, Resource, Ref, BindValue } from '@lifi/compose-spec';
-import { OutputKind, TypedRef, TypedLiteral } from '../types.cjs';
-
+import { OutputKind, TypedLiteral, TypedRef } from "../types.cjs";
+import { BindValue, Ref, Resource, SolType, StaticSolType } from "@lifi/compose-spec";
+//#region src/authoring/handles.d.ts
 /**
  * A handle referencing a flow input declared in the flow's input schema.
  * The phantom `__outputKind` field carries the type parameter through
  * TypeScript's structural type system without affecting runtime shape.
  */
-interface InputHandle<T extends OutputKind = OutputKind> {
-    readonly _tag: 'input';
-    readonly inputName: string;
-    readonly __outputKind?: T;
+export interface InputHandle<T extends OutputKind = OutputKind> {
+  readonly _tag: "input";
+  readonly inputName: string;
+  readonly __outputKind?: T;
 }
 /**
  * An input handle for a resource (token) input, carrying the resource
  * declaration alongside the reference.
  */
-interface ResourceInputHandle extends InputHandle<'resource'> {
-    readonly resource: Resource;
+export interface ResourceInputHandle extends InputHandle<"resource"> {
+  readonly resource: Resource;
 }
 /**
  * A handle referencing an output port of a previously declared operation node.
  * The phantom `__outputKind` field carries the type parameter through
  * TypeScript's structural type system without affecting runtime shape.
  */
-interface OutputHandle<T extends OutputKind = OutputKind> {
-    readonly _tag: 'output';
-    readonly nodeId: string;
-    readonly portName: string;
-    readonly __outputKind?: T;
+export interface OutputHandle<T extends OutputKind = OutputKind> {
+  readonly _tag: "output";
+  readonly nodeId: string;
+  readonly portName: string;
+  readonly __outputKind?: T;
 }
 /**
  * What an output family's sizing parameter accepts, given the config field the
  * family counts from: an array of that field's elements, or a number.
  */
-type FamilySource<Field> = Field extends readonly (infer E)[] ? readonly E[] : number;
+export type FamilySource<Field> = Field extends readonly (infer E)[] ? readonly E[] : number;
 /** Whether a number literal is a valid family count: a non-negative integer. */
 type IsCountLiteral<N extends number> = `${N}` extends `-${string}` | `${string}.${string}` | `${string}e${string}` ? false : true;
 /**
@@ -41,16 +41,14 @@ type IsCountLiteral<N extends number> = `${N}` extends `-${string}` | `${string}
  * not a valid count, gives an open array; {@link FamilyCount} rejects the
  * invalid literal at the call site.
  */
-type HandleTuple<N extends number, Acc extends readonly OutputHandle<'resource'>[] = readonly []> = number extends N ? readonly OutputHandle<'resource'>[] : IsCountLiteral<N> extends false ? readonly OutputHandle<'resource'>[] : Acc['length'] extends N ? Acc : HandleTuple<N, readonly [...Acc, OutputHandle<'resource'>]>;
+type HandleTuple<N extends number, Acc extends readonly OutputHandle<"resource">[] = readonly []> = number extends N ? readonly OutputHandle<"resource">[] : IsCountLiteral<N> extends false ? readonly OutputHandle<"resource">[] : Acc["length"] extends N ? Acc : HandleTuple<N, readonly [...Acc, OutputHandle<"resource">]>;
 /**
  * The handles of an output family: one resource {@link OutputHandle} per
  * element of the config array the family counts from, or as many as the config
  * count. A literal array or count yields a tuple of that length, so indexing
  * past the last instance is a type error.
  */
-type OutputFamilyHandles<TCount extends readonly unknown[] | number> = TCount extends readonly unknown[] ? {
-    readonly [I in keyof TCount]: OutputHandle<'resource'>;
-} : TCount extends number ? HandleTuple<TCount> : never;
+export type OutputFamilyHandles<TCount extends readonly unknown[] | number> = TCount extends readonly unknown[] ? { readonly [I in keyof TCount]: OutputHandle<"resource">; } : TCount extends number ? HandleTuple<TCount> : never;
 /**
  * Holds the config value an output family counts from to the op's own type. A
  * runtime-sized array or count passes as is. A literal tuple must also satisfy
@@ -58,23 +56,23 @@ type OutputFamilyHandles<TCount extends readonly unknown[] | number> = TCount ex
  * instead of at the server's bind step. A literal count must be a non-negative
  * integer.
  */
-type FamilyCount<TCount extends readonly unknown[] | number, Shape> = TCount extends readonly unknown[] ? number extends TCount['length'] ? unknown : TCount extends Shape ? unknown : {
-    readonly 'output family config array has too few entries': never;
+export type FamilyCount<TCount extends readonly unknown[] | number, Shape> = TCount extends readonly unknown[] ? number extends TCount["length"] ? unknown : TCount extends Shape ? unknown : {
+  readonly "output family config array has too few entries": never;
 } : TCount extends number ? IsCountLiteral<TCount> extends true ? unknown : {
-    readonly 'output family count must be a non-negative integer': never;
+  readonly "output family count must be a non-negative integer": never;
 } : unknown;
 /** Discriminated union of all handle types that can be bound to operation arguments. */
-type AnyHandle = InputHandle | OutputHandle;
+export type AnyHandle = InputHandle | OutputHandle;
 /** Type guard that narrows an {@link AnyHandle} to an {@link InputHandle}. */
-declare const isInputHandle: (h: AnyHandle) => h is InputHandle;
+export declare const isInputHandle: (h: AnyHandle) => h is InputHandle;
 /** Type guard that narrows an {@link AnyHandle} to an {@link OutputHandle}. */
-declare const isOutputHandle: (h: AnyHandle) => h is OutputHandle;
+export declare const isOutputHandle: (h: AnyHandle) => h is OutputHandle;
 /**
  * Converts a handle to a JSON `$ref` pointer used in the flow document.
  * Input handles become `"input.<name>"`; output handles become `"<nodeId>.<port>"`.
  */
-declare const handleToRef: (h: AnyHandle) => {
-    $ref: string;
+export declare const handleToRef: (h: AnyHandle) => {
+  $ref: string;
 };
 /**
  * For a bind slot expecting type T, widen the set of accepted handle types:
@@ -86,7 +84,7 @@ declare const handleToRef: (h: AnyHandle) => {
  *   handles (resources are uint256 amounts).
  * - every other type keeps exact-SolType matching.
  */
-type SlotAssignable<T extends OutputKind> = T extends 'bytes32' ? StaticSolType | 'resource' : T extends 'uint256' ? T | 'resource' : T;
+type SlotAssignable<T extends OutputKind> = T extends "bytes32" ? StaticSolType | "resource" : T extends "uint256" ? T | "resource" : T;
 /**
  * The values accepted by a typed slot that must resolve to a `$ref`:
  * - `OutputHandle<T>` / `InputHandle<T>` (same type)
@@ -97,11 +95,11 @@ type SlotAssignable<T extends OutputKind> = T extends 'bytes32' ? StaticSolType
  * Plain `{ $ref: '...' }` objects are **not** accepted - use `raw.ref<T>()`
  * to create a typed ref when you need to reference a raw path.
  */
-type RefBindable<T extends OutputKind> = OutputHandle<SlotAssignable<T>> | InputHandle<SlotAssignable<T>> | TypedRef<SlotAssignable<T>>;
+export type RefBindable<T extends OutputKind> = OutputHandle<SlotAssignable<T>> | InputHandle<SlotAssignable<T>> | TypedRef<SlotAssignable<T>>;
 /**
  * Any ref-resolving bindable, with no per-slot type constraint.
  */
-type AnyRefBindable = InputHandle | OutputHandle | TypedRef;
+export type AnyRefBindable = InputHandle | OutputHandle | TypedRef;
 /**
  * The set of values accepted by a typed operation bind slot: everything
  * {@link RefBindable} accepts, plus a {@link TypedLiteral} constant baked
@@ -110,12 +108,13 @@ type AnyRefBindable = InputHandle | OutputHandle | TypedRef;
  *
  * Use `raw.literal<T>()` to create one.
  */
-type Bindable<T extends OutputKind> = RefBindable<T> | LiteralBindable<SlotAssignable<T>>;
+export type Bindable<T extends OutputKind> = RefBindable<T> | LiteralBindable<SlotAssignable<T>>;
 type LiteralBindable<K extends OutputKind> = K extends SolType ? TypedLiteral<K> : never;
 /**
  * Converts a bindable to the wire `bind` value it denotes: handles become
  * `$ref` pointers, refs and literals pass through as-is.
  */
-declare const toBindValue: (bindable: InputHandle | OutputHandle | TypedRef | TypedLiteral | Ref) => BindValue;
-
-export { type AnyHandle, type AnyRefBindable, type Bindable, type FamilyCount, type FamilySource, type InputHandle, type OutputFamilyHandles, type OutputHandle, type RefBindable, type ResourceInputHandle, handleToRef, isInputHandle, isOutputHandle, toBindValue };
+export declare const toBindValue: (bindable: InputHandle | OutputHandle | TypedRef | TypedLiteral | Ref) => BindValue;
+//#endregion
+export {};
+//# sourceMappingURL=handles.d.cts.map

package/dist/authoring/handles.d.ts

@@ -1,39 +1,39 @@
-import { StaticSolType, SolType, Resource, Ref, BindValue } from '@lifi/compose-spec';
-import { OutputKind, TypedRef, TypedLiteral } from '../types.js';
-
+import { OutputKind, TypedLiteral, TypedRef } from "../types.js";
+import { BindValue, Ref, Resource, SolType, StaticSolType } from "@lifi/compose-spec";
+//#region src/authoring/handles.d.ts
 /**
  * A handle referencing a flow input declared in the flow's input schema.
  * The phantom `__outputKind` field carries the type parameter through
  * TypeScript's structural type system without affecting runtime shape.
  */
-interface InputHandle<T extends OutputKind = OutputKind> {
-    readonly _tag: 'input';
-    readonly inputName: string;
-    readonly __outputKind?: T;
+export interface InputHandle<T extends OutputKind = OutputKind> {
+  readonly _tag: "input";
+  readonly inputName: string;
+  readonly __outputKind?: T;
 }
 /**
  * An input handle for a resource (token) input, carrying the resource
  * declaration alongside the reference.
  */
-interface ResourceInputHandle extends InputHandle<'resource'> {
-    readonly resource: Resource;
+export interface ResourceInputHandle extends InputHandle<"resource"> {
+  readonly resource: Resource;
 }
 /**
  * A handle referencing an output port of a previously declared operation node.
  * The phantom `__outputKind` field carries the type parameter through
  * TypeScript's structural type system without affecting runtime shape.
  */
-interface OutputHandle<T extends OutputKind = OutputKind> {
-    readonly _tag: 'output';
-    readonly nodeId: string;
-    readonly portName: string;
-    readonly __outputKind?: T;
+export interface OutputHandle<T extends OutputKind = OutputKind> {
+  readonly _tag: "output";
+  readonly nodeId: string;
+  readonly portName: string;
+  readonly __outputKind?: T;
 }
 /**
  * What an output family's sizing parameter accepts, given the config field the
  * family counts from: an array of that field's elements, or a number.
  */
-type FamilySource<Field> = Field extends readonly (infer E)[] ? readonly E[] : number;
+export type FamilySource<Field> = Field extends readonly (infer E)[] ? readonly E[] : number;
 /** Whether a number literal is a valid family count: a non-negative integer. */
 type IsCountLiteral<N extends number> = `${N}` extends `-${string}` | `${string}.${string}` | `${string}e${string}` ? false : true;
 /**
@@ -41,16 +41,14 @@ type IsCountLiteral<N extends number> = `${N}` extends `-${string}` | `${string}
  * not a valid count, gives an open array; {@link FamilyCount} rejects the
  * invalid literal at the call site.
  */
-type HandleTuple<N extends number, Acc extends readonly OutputHandle<'resource'>[] = readonly []> = number extends N ? readonly OutputHandle<'resource'>[] : IsCountLiteral<N> extends false ? readonly OutputHandle<'resource'>[] : Acc['length'] extends N ? Acc : HandleTuple<N, readonly [...Acc, OutputHandle<'resource'>]>;
+type HandleTuple<N extends number, Acc extends readonly OutputHandle<"resource">[] = readonly []> = number extends N ? readonly OutputHandle<"resource">[] : IsCountLiteral<N> extends false ? readonly OutputHandle<"resource">[] : Acc["length"] extends N ? Acc : HandleTuple<N, readonly [...Acc, OutputHandle<"resource">]>;
 /**
  * The handles of an output family: one resource {@link OutputHandle} per
  * element of the config array the family counts from, or as many as the config
  * count. A literal array or count yields a tuple of that length, so indexing
  * past the last instance is a type error.
  */
-type OutputFamilyHandles<TCount extends readonly unknown[] | number> = TCount extends readonly unknown[] ? {
-    readonly [I in keyof TCount]: OutputHandle<'resource'>;
-} : TCount extends number ? HandleTuple<TCount> : never;
+export type OutputFamilyHandles<TCount extends readonly unknown[] | number> = TCount extends readonly unknown[] ? { readonly [I in keyof TCount]: OutputHandle<"resource">; } : TCount extends number ? HandleTuple<TCount> : never;
 /**
  * Holds the config value an output family counts from to the op's own type. A
  * runtime-sized array or count passes as is. A literal tuple must also satisfy
@@ -58,23 +56,23 @@ type OutputFamilyHandles<TCount extends readonly unknown[] | number> = TCount ex
  * instead of at the server's bind step. A literal count must be a non-negative
  * integer.
  */
-type FamilyCount<TCount extends readonly unknown[] | number, Shape> = TCount extends readonly unknown[] ? number extends TCount['length'] ? unknown : TCount extends Shape ? unknown : {
-    readonly 'output family config array has too few entries': never;
+export type FamilyCount<TCount extends readonly unknown[] | number, Shape> = TCount extends readonly unknown[] ? number extends TCount["length"] ? unknown : TCount extends Shape ? unknown : {
+  readonly "output family config array has too few entries": never;
 } : TCount extends number ? IsCountLiteral<TCount> extends true ? unknown : {
-    readonly 'output family count must be a non-negative integer': never;
+  readonly "output family count must be a non-negative integer": never;
 } : unknown;
 /** Discriminated union of all handle types that can be bound to operation arguments. */
-type AnyHandle = InputHandle | OutputHandle;
+export type AnyHandle = InputHandle | OutputHandle;
 /** Type guard that narrows an {@link AnyHandle} to an {@link InputHandle}. */
-declare const isInputHandle: (h: AnyHandle) => h is InputHandle;
+export declare const isInputHandle: (h: AnyHandle) => h is InputHandle;
 /** Type guard that narrows an {@link AnyHandle} to an {@link OutputHandle}. */
-declare const isOutputHandle: (h: AnyHandle) => h is OutputHandle;
+export declare const isOutputHandle: (h: AnyHandle) => h is OutputHandle;
 /**
  * Converts a handle to a JSON `$ref` pointer used in the flow document.
  * Input handles become `"input.<name>"`; output handles become `"<nodeId>.<port>"`.
  */
-declare const handleToRef: (h: AnyHandle) => {
-    $ref: string;
+export declare const handleToRef: (h: AnyHandle) => {
+  $ref: string;
 };
 /**
  * For a bind slot expecting type T, widen the set of accepted handle types:
@@ -86,7 +84,7 @@ declare const handleToRef: (h: AnyHandle) => {
  *   handles (resources are uint256 amounts).
  * - every other type keeps exact-SolType matching.
  */
-type SlotAssignable<T extends OutputKind> = T extends 'bytes32' ? StaticSolType | 'resource' : T extends 'uint256' ? T | 'resource' : T;
+type SlotAssignable<T extends OutputKind> = T extends "bytes32" ? StaticSolType | "resource" : T extends "uint256" ? T | "resource" : T;
 /**
  * The values accepted by a typed slot that must resolve to a `$ref`:
  * - `OutputHandle<T>` / `InputHandle<T>` (same type)
@@ -97,11 +95,11 @@ type SlotAssignable<T extends OutputKind> = T extends 'bytes32' ? StaticSolType
  * Plain `{ $ref: '...' }` objects are **not** accepted - use `raw.ref<T>()`
  * to create a typed ref when you need to reference a raw path.
  */
-type RefBindable<T extends OutputKind> = OutputHandle<SlotAssignable<T>> | InputHandle<SlotAssignable<T>> | TypedRef<SlotAssignable<T>>;
+export type RefBindable<T extends OutputKind> = OutputHandle<SlotAssignable<T>> | InputHandle<SlotAssignable<T>> | TypedRef<SlotAssignable<T>>;
 /**
  * Any ref-resolving bindable, with no per-slot type constraint.
  */
-type AnyRefBindable = InputHandle | OutputHandle | TypedRef;
+export type AnyRefBindable = InputHandle | OutputHandle | TypedRef;
 /**
  * The set of values accepted by a typed operation bind slot: everything
  * {@link RefBindable} accepts, plus a {@link TypedLiteral} constant baked
@@ -110,12 +108,13 @@ type AnyRefBindable = InputHandle | OutputHandle | TypedRef;
  *
  * Use `raw.literal<T>()` to create one.
  */
-type Bindable<T extends OutputKind> = RefBindable<T> | LiteralBindable<SlotAssignable<T>>;
+export type Bindable<T extends OutputKind> = RefBindable<T> | LiteralBindable<SlotAssignable<T>>;
 type LiteralBindable<K extends OutputKind> = K extends SolType ? TypedLiteral<K> : never;
 /**
  * Converts a bindable to the wire `bind` value it denotes: handles become
  * `$ref` pointers, refs and literals pass through as-is.
  */
-declare const toBindValue: (bindable: InputHandle | OutputHandle | TypedRef | TypedLiteral | Ref) => BindValue;
-
-export { type AnyHandle, type AnyRefBindable, type Bindable, type FamilyCount, type FamilySource, type InputHandle, type OutputFamilyHandles, type OutputHandle, type RefBindable, type ResourceInputHandle, handleToRef, isInputHandle, isOutputHandle, toBindValue };
+export declare const toBindValue: (bindable: InputHandle | OutputHandle | TypedRef | TypedLiteral | Ref) => BindValue;
+//#endregion
+export {};
+//# sourceMappingURL=handles.d.ts.map

package/dist/authoring/handles.js

@@ -1,19 +1,27 @@
+//#region src/authoring/handles.ts
+/** Type guard that narrows an {@link AnyHandle} to an {@link InputHandle}. */
 const isInputHandle = (h) => h._tag === "input";
+/** Type guard that narrows an {@link AnyHandle} to an {@link OutputHandle}. */
 const isOutputHandle = (h) => h._tag === "output";
+/**
+* Converts a handle to a JSON `$ref` pointer used in the flow document.
+* Input handles become `"input.<name>"`; output handles become `"<nodeId>.<port>"`.
+*/
 const handleToRef = (h) => {
-  if (h._tag === "input") {
-    if (!h.inputName) throw new Error("InputHandle has empty inputName");
-    return { $ref: `input.${h.inputName}` };
-  }
-  if (!h.nodeId) throw new Error("OutputHandle has empty nodeId");
-  if (!h.portName) throw new Error("OutputHandle has empty portName");
-  return { $ref: `${h.nodeId}.${h.portName}` };
+	if (h._tag === "input") {
+		if (!h.inputName) throw new Error("InputHandle has empty inputName");
+		return { $ref: `input.${h.inputName}` };
+	}
+	if (!h.nodeId) throw new Error("OutputHandle has empty nodeId");
+	if (!h.portName) throw new Error("OutputHandle has empty portName");
+	return { $ref: `${h.nodeId}.${h.portName}` };
 };
+/**
+* Converts a bindable to the wire `bind` value it denotes: handles become
+* `$ref` pointers, refs and literals pass through as-is.
+*/
 const toBindValue = (bindable) => "_tag" in bindable ? handleToRef(bindable) : bindable;
-export {
-  handleToRef,
-  isInputHandle,
-  isOutputHandle,
-  toBindValue
-};
+//#endregion
+export { handleToRef, isInputHandle, isOutputHandle, toBindValue };
+
 //# sourceMappingURL=handles.js.map

package/dist/authoring/handles.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/authoring/handles.ts"],"sourcesContent":["import type {\n  BindValue,\n  Ref,\n  Resource,\n  SolType,\n  StaticSolType,\n} from '@lifi/compose-spec';\n\nimport type { OutputKind, TypedLiteral, TypedRef } from '../types.js';\n\n/**\n * A handle referencing a flow input declared in the flow's input schema.\n * The phantom `__outputKind` field carries the type parameter through\n * TypeScript's structural type system without affecting runtime shape.\n */\nexport interface InputHandle<T extends OutputKind = OutputKind> {\n  readonly _tag: 'input';\n  readonly inputName: string;\n  readonly __outputKind?: T;\n}\n\n/**\n * An input handle for a resource (token) input, carrying the resource\n * declaration alongside the reference.\n */\nexport interface ResourceInputHandle extends InputHandle<'resource'> {\n  readonly resource: Resource;\n}\n\n/**\n * A handle referencing an output port of a previously declared operation node.\n * The phantom `__outputKind` field carries the type parameter through\n * TypeScript's structural type system without affecting runtime shape.\n */\nexport interface OutputHandle<T extends OutputKind = OutputKind> {\n  readonly _tag: 'output';\n  readonly nodeId: string;\n  readonly portName: string;\n  readonly __outputKind?: T;\n}\n\n/**\n * What an output family's sizing parameter accepts, given the config field the\n * family counts from: an array of that field's elements, or a number.\n */\nexport type FamilySource<Field> = Field extends readonly (infer E)[]\n  ? readonly E[]\n  : number;\n\n/** Whether a number literal is a valid family count: a non-negative integer. */\ntype IsCountLiteral<N extends number> = `${N}` extends\n  `-${string}` | `${string}.${string}` | `${string}e${string}`\n  ? false\n  : true;\n\n/**\n * `N` resource handles as a tuple. A non-literal `number`, or a literal that is\n * not a valid count, gives an open array; {@link FamilyCount} rejects the\n * invalid literal at the call site.\n */\ntype HandleTuple<\n  N extends number,\n  Acc extends readonly OutputHandle<'resource'>[] = readonly [],\n> = number extends N\n  ? readonly OutputHandle<'resource'>[]\n  : IsCountLiteral<N> extends false\n    ? readonly OutputHandle<'resource'>[]\n    : Acc['length'] extends N\n      ? Acc\n      : HandleTuple<N, readonly [...Acc, OutputHandle<'resource'>]>;\n\n/**\n * The handles of an output family: one resource {@link OutputHandle} per\n * element of the config array the family counts from, or as many as the config\n * count. A literal array or count yields a tuple of that length, so indexing\n * past the last instance is a type error.\n */\nexport type OutputFamilyHandles<TCount extends readonly unknown[] | number> =\n  TCount extends readonly unknown[]\n    ? { readonly [I in keyof TCount]: OutputHandle<'resource'> }\n    : TCount extends number\n      ? HandleTuple<TCount>\n      : never;\n\n/**\n * Holds the config value an output family counts from to the op's own type. A\n * runtime-sized array or count passes as is. A literal tuple must also satisfy\n * `Shape`, so a tuple shorter than the op's `minItems` fails at the call site\n * instead of at the server's bind step. A literal count must be a non-negative\n * integer.\n */\nexport type FamilyCount<\n  TCount extends readonly unknown[] | number,\n  Shape,\n> = TCount extends readonly unknown[]\n  ? number extends TCount['length']\n    ? unknown\n    : TCount extends Shape\n      ? unknown\n      : { readonly 'output family config array has too few entries': never }\n  : TCount extends number\n    ? IsCountLiteral<TCount> extends true\n      ? unknown\n      : {\n          readonly 'output family count must be a non-negative integer': never;\n        }\n    : unknown;\n\n/** Discriminated union of all handle types that can be bound to operation arguments. */\nexport type AnyHandle = InputHandle | OutputHandle;\n\n/** Type guard that narrows an {@link AnyHandle} to an {@link InputHandle}. */\nexport const isInputHandle = (h: AnyHandle): h is InputHandle =>\n  h._tag === 'input';\n\n/** Type guard that narrows an {@link AnyHandle} to an {@link OutputHandle}. */\nexport const isOutputHandle = (h: AnyHandle): h is OutputHandle =>\n  h._tag === 'output';\n\n/**\n * Converts a handle to a JSON `$ref` pointer used in the flow document.\n * Input handles become `\"input.<name>\"`; output handles become `\"<nodeId>.<port>\"`.\n */\nexport const handleToRef = (h: AnyHandle): { $ref: string } => {\n  if (h._tag === 'input') {\n    if (!h.inputName) throw new Error('InputHandle has empty inputName');\n    return { $ref: `input.${h.inputName}` };\n  }\n  if (!h.nodeId) throw new Error('OutputHandle has empty nodeId');\n  if (!h.portName) throw new Error('OutputHandle has empty portName');\n  return { $ref: `${h.nodeId}.${h.portName}` };\n};\n\n/**\n * For a bind slot expecting type T, widen the set of accepted handle types:\n * - `'bytes32'` is the raw 32-byte word type: accept any static-32-byte handle\n *   (`uint256`/`uintN`/`address`/`bool`/`bytes32`) plus `'resource'` (a uint256\n *   amount). At the IR1 boundary every value is a type-erased word, so any\n *   static-32-byte handle is a sound bind for a `bytes32` payload port.\n * - `'uint256'` keeps its existing widening to also accept `'resource'`-tagged\n *   handles (resources are uint256 amounts).\n * - every other type keeps exact-SolType matching.\n */\ntype SlotAssignable<T extends OutputKind> = T extends 'bytes32'\n  ? StaticSolType | 'resource'\n  : T extends 'uint256'\n    ? T | 'resource'\n    : T;\n\n/**\n * The values accepted by a typed slot that must resolve to a `$ref`:\n * - `OutputHandle<T>` / `InputHandle<T>` (same type)\n * - For `'uint256'` slots, also `'resource'`-tagged handles\n * - For `'bytes32'` slots, any static-32-byte handle (and `'resource'`)\n * - `TypedRef<T>` (typed context refs, subject to `SlotAssignable`)\n *\n * Plain `{ $ref: '...' }` objects are **not** accepted - use `raw.ref<T>()`\n * to create a typed ref when you need to reference a raw path.\n */\nexport type RefBindable<T extends OutputKind> =\n  | OutputHandle<SlotAssignable<T>>\n  | InputHandle<SlotAssignable<T>>\n  | TypedRef<SlotAssignable<T>>;\n\n/**\n * Any ref-resolving bindable, with no per-slot type constraint.\n */\nexport type AnyRefBindable = InputHandle | OutputHandle | TypedRef;\n\n/**\n * The set of values accepted by a typed operation bind slot: everything\n * {@link RefBindable} accepts, plus a {@link TypedLiteral} constant baked\n * into the flow document. A `'resource'` slot rejects a literal: a token\n * resource is not a scalar constant.\n *\n * Use `raw.literal<T>()` to create one.\n */\nexport type Bindable<T extends OutputKind> =\n  RefBindable<T> | LiteralBindable<SlotAssignable<T>>;\n\n// Distributes over the slot's assignable kinds and keeps the scalar ones: a\n// `'resource'` slot has no scalar arm, so its literal arm collapses to\n// `never` and a literal is rejected outright.\ntype LiteralBindable<K extends OutputKind> = K extends SolType\n  ? TypedLiteral<K>\n  : never;\n\n/**\n * Converts a bindable to the wire `bind` value it denotes: handles become\n * `$ref` pointers, refs and literals pass through as-is.\n */\nexport const toBindValue = (\n  bindable: InputHandle | OutputHandle | TypedRef | TypedLiteral | Ref,\n): BindValue => ('_tag' in bindable ? handleToRef(bindable) : bindable);\n"],"mappings":"AAgHO,MAAM,gBAAgB,CAAC,MAC5B,EAAE,SAAS;AAGN,MAAM,iBAAiB,CAAC,MAC7B,EAAE,SAAS;AAMN,MAAM,cAAc,CAAC,MAAmC;AAC7D,MAAI,EAAE,SAAS,SAAS;AACtB,QAAI,CAAC,EAAE,UAAW,OAAM,IAAI,MAAM,iCAAiC;AACnE,WAAO,EAAE,MAAM,SAAS,EAAE,SAAS,GAAG;AAAA,EACxC;AACA,MAAI,CAAC,EAAE,OAAQ,OAAM,IAAI,MAAM,+BAA+B;AAC9D,MAAI,CAAC,EAAE,SAAU,OAAM,IAAI,MAAM,iCAAiC;AAClE,SAAO,EAAE,MAAM,GAAG,EAAE,MAAM,IAAI,EAAE,QAAQ,GAAG;AAC7C;AA4DO,MAAM,cAAc,CACzB,aACe,UAAU,WAAW,YAAY,QAAQ,IAAI;","names":[]}
+{"version":3,"file":"handles.js","names":[],"sources":["../../src/authoring/handles.ts"],"sourcesContent":["import type {\n  BindValue,\n  Ref,\n  Resource,\n  SolType,\n  StaticSolType,\n} from '@lifi/compose-spec';\n\nimport type { OutputKind, TypedLiteral, TypedRef } from '../types.js';\n\n/**\n * A handle referencing a flow input declared in the flow's input schema.\n * The phantom `__outputKind` field carries the type parameter through\n * TypeScript's structural type system without affecting runtime shape.\n */\nexport interface InputHandle<T extends OutputKind = OutputKind> {\n  readonly _tag: 'input';\n  readonly inputName: string;\n  readonly __outputKind?: T;\n}\n\n/**\n * An input handle for a resource (token) input, carrying the resource\n * declaration alongside the reference.\n */\nexport interface ResourceInputHandle extends InputHandle<'resource'> {\n  readonly resource: Resource;\n}\n\n/**\n * A handle referencing an output port of a previously declared operation node.\n * The phantom `__outputKind` field carries the type parameter through\n * TypeScript's structural type system without affecting runtime shape.\n */\nexport interface OutputHandle<T extends OutputKind = OutputKind> {\n  readonly _tag: 'output';\n  readonly nodeId: string;\n  readonly portName: string;\n  readonly __outputKind?: T;\n}\n\n/**\n * What an output family's sizing parameter accepts, given the config field the\n * family counts from: an array of that field's elements, or a number.\n */\nexport type FamilySource<Field> = Field extends readonly (infer E)[]\n  ? readonly E[]\n  : number;\n\n/** Whether a number literal is a valid family count: a non-negative integer. */\ntype IsCountLiteral<N extends number> = `${N}` extends\n  `-${string}` | `${string}.${string}` | `${string}e${string}`\n  ? false\n  : true;\n\n/**\n * `N` resource handles as a tuple. A non-literal `number`, or a literal that is\n * not a valid count, gives an open array; {@link FamilyCount} rejects the\n * invalid literal at the call site.\n */\ntype HandleTuple<\n  N extends number,\n  Acc extends readonly OutputHandle<'resource'>[] = readonly [],\n> = number extends N\n  ? readonly OutputHandle<'resource'>[]\n  : IsCountLiteral<N> extends false\n    ? readonly OutputHandle<'resource'>[]\n    : Acc['length'] extends N\n      ? Acc\n      : HandleTuple<N, readonly [...Acc, OutputHandle<'resource'>]>;\n\n/**\n * The handles of an output family: one resource {@link OutputHandle} per\n * element of the config array the family counts from, or as many as the config\n * count. A literal array or count yields a tuple of that length, so indexing\n * past the last instance is a type error.\n */\nexport type OutputFamilyHandles<TCount extends readonly unknown[] | number> =\n  TCount extends readonly unknown[]\n    ? { readonly [I in keyof TCount]: OutputHandle<'resource'> }\n    : TCount extends number\n      ? HandleTuple<TCount>\n      : never;\n\n/**\n * Holds the config value an output family counts from to the op's own type. A\n * runtime-sized array or count passes as is. A literal tuple must also satisfy\n * `Shape`, so a tuple shorter than the op's `minItems` fails at the call site\n * instead of at the server's bind step. A literal count must be a non-negative\n * integer.\n */\nexport type FamilyCount<\n  TCount extends readonly unknown[] | number,\n  Shape,\n> = TCount extends readonly unknown[]\n  ? number extends TCount['length']\n    ? unknown\n    : TCount extends Shape\n      ? unknown\n      : { readonly 'output family config array has too few entries': never }\n  : TCount extends number\n    ? IsCountLiteral<TCount> extends true\n      ? unknown\n      : {\n          readonly 'output family count must be a non-negative integer': never;\n        }\n    : unknown;\n\n/** Discriminated union of all handle types that can be bound to operation arguments. */\nexport type AnyHandle = InputHandle | OutputHandle;\n\n/** Type guard that narrows an {@link AnyHandle} to an {@link InputHandle}. */\nexport const isInputHandle = (h: AnyHandle): h is InputHandle =>\n  h._tag === 'input';\n\n/** Type guard that narrows an {@link AnyHandle} to an {@link OutputHandle}. */\nexport const isOutputHandle = (h: AnyHandle): h is OutputHandle =>\n  h._tag === 'output';\n\n/**\n * Converts a handle to a JSON `$ref` pointer used in the flow document.\n * Input handles become `\"input.<name>\"`; output handles become `\"<nodeId>.<port>\"`.\n */\nexport const handleToRef = (h: AnyHandle): { $ref: string } => {\n  if (h._tag === 'input') {\n    if (!h.inputName) throw new Error('InputHandle has empty inputName');\n    return { $ref: `input.${h.inputName}` };\n  }\n  if (!h.nodeId) throw new Error('OutputHandle has empty nodeId');\n  if (!h.portName) throw new Error('OutputHandle has empty portName');\n  return { $ref: `${h.nodeId}.${h.portName}` };\n};\n\n/**\n * For a bind slot expecting type T, widen the set of accepted handle types:\n * - `'bytes32'` is the raw 32-byte word type: accept any static-32-byte handle\n *   (`uint256`/`uintN`/`address`/`bool`/`bytes32`) plus `'resource'` (a uint256\n *   amount). At the IR1 boundary every value is a type-erased word, so any\n *   static-32-byte handle is a sound bind for a `bytes32` payload port.\n * - `'uint256'` keeps its existing widening to also accept `'resource'`-tagged\n *   handles (resources are uint256 amounts).\n * - every other type keeps exact-SolType matching.\n */\ntype SlotAssignable<T extends OutputKind> = T extends 'bytes32'\n  ? StaticSolType | 'resource'\n  : T extends 'uint256'\n    ? T | 'resource'\n    : T;\n\n/**\n * The values accepted by a typed slot that must resolve to a `$ref`:\n * - `OutputHandle<T>` / `InputHandle<T>` (same type)\n * - For `'uint256'` slots, also `'resource'`-tagged handles\n * - For `'bytes32'` slots, any static-32-byte handle (and `'resource'`)\n * - `TypedRef<T>` (typed context refs, subject to `SlotAssignable`)\n *\n * Plain `{ $ref: '...' }` objects are **not** accepted - use `raw.ref<T>()`\n * to create a typed ref when you need to reference a raw path.\n */\nexport type RefBindable<T extends OutputKind> =\n  | OutputHandle<SlotAssignable<T>>\n  | InputHandle<SlotAssignable<T>>\n  | TypedRef<SlotAssignable<T>>;\n\n/**\n * Any ref-resolving bindable, with no per-slot type constraint.\n */\nexport type AnyRefBindable = InputHandle | OutputHandle | TypedRef;\n\n/**\n * The set of values accepted by a typed operation bind slot: everything\n * {@link RefBindable} accepts, plus a {@link TypedLiteral} constant baked\n * into the flow document. A `'resource'` slot rejects a literal: a token\n * resource is not a scalar constant.\n *\n * Use `raw.literal<T>()` to create one.\n */\nexport type Bindable<T extends OutputKind> =\n  RefBindable<T> | LiteralBindable<SlotAssignable<T>>;\n\n// Distributes over the slot's assignable kinds and keeps the scalar ones: a\n// `'resource'` slot has no scalar arm, so its literal arm collapses to\n// `never` and a literal is rejected outright.\ntype LiteralBindable<K extends OutputKind> = K extends SolType\n  ? TypedLiteral<K>\n  : never;\n\n/**\n * Converts a bindable to the wire `bind` value it denotes: handles become\n * `$ref` pointers, refs and literals pass through as-is.\n */\nexport const toBindValue = (\n  bindable: InputHandle | OutputHandle | TypedRef | TypedLiteral | Ref,\n): BindValue => ('_tag' in bindable ? handleToRef(bindable) : bindable);\n"],"mappings":";;AAgHA,MAAa,iBAAiB,MAC5B,EAAE,SAAS;;AAGb,MAAa,kBAAkB,MAC7B,EAAE,SAAS;;;;;AAMb,MAAa,eAAe,MAAmC;CAC7D,IAAI,EAAE,SAAS,SAAS;EACtB,IAAI,CAAC,EAAE,WAAW,MAAM,IAAI,MAAM,iCAAiC;EACnE,OAAO,EAAE,MAAM,SAAS,EAAE,YAAY;CACxC;CACA,IAAI,CAAC,EAAE,QAAQ,MAAM,IAAI,MAAM,+BAA+B;CAC9D,IAAI,CAAC,EAAE,UAAU,MAAM,IAAI,MAAM,iCAAiC;CAClE,OAAO,EAAE,MAAM,GAAG,EAAE,OAAO,GAAG,EAAE,WAAW;AAC7C;;;;;AA4DA,MAAa,eACX,aACe,UAAU,WAAW,YAAY,QAAQ,IAAI"}

package/dist/authoring/raw.cjs

@@ -1,48 +1,89 @@
-"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 raw_exports = {};
-__export(raw_exports, {
-  literal: () => literal,
-  rawGuard: () => rawGuard,
-  ref: () => ref
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/authoring/raw.ts
+/**
+* Creates a typed `$ref` pointer for use in bind slots.
+*
+* This is an **escape hatch** for referencing values that the typed builder
+* API doesn't cover — for example, outputs of an `untypedOp` node or custom
+* context paths. The caller is responsible for choosing the correct type
+* parameter; no runtime validation occurs.
+*
+* Prefer typed handles (`OutputHandle`, `InputHandle`) and `builder.context`
+* whenever possible. Use `ref` only when you need to construct a `$ref` path
+* manually and want it accepted by a `Bindable<T>` slot.
+*
+* @typeParam T - The output kind this ref represents (e.g. `'address'`, `'uint256'`, `'resource'`).
+* @param path - The `$ref` path (e.g. `"context.sender"`, `"myNode.result"`).
+* @returns A {@link TypedRef} accepted by `Bindable<T>` slots matching `T`.
+*
+* @example
+* ```ts
+* import { raw } from '@lifi/composer-sdk';
+*
+* // Reference an untypedOp output in a typed operation:
+* builder.untypedOp('custom', 'some.op', {
+*   bind: { x: { $ref: 'input.token' } },
+*   config: {},
+* });
+* builder.core.add('sum', {
+*   bind: {
+*     a: raw.ref<'uint256'>('custom.result'),
+*     b: someTypedHandle,
+*   },
+* });
+* ```
+*/
+const ref = (path) => ({ $ref: path });
+/**
+* Creates a typed literal for use in bind slots: a constant baked into the
+* flow document rather than supplied at run time.
+*
+* Prefer a declared flow input and `builder.inputs.<name>` — a value the
+* caller supplies per run stays out of the document. Use a literal when the
+* flow has no run of its own to take the value from: the `continuationFlow`
+* of a `continuation.settle` node is stored by the settlement backend and
+* re-run later against the deferred proceeds, so its delivery address has to
+* be part of the committed document.
+*
+* @typeParam T - The Solidity type of the literal (e.g. `'address'`).
+* @param kind - The literal's Solidity type.
+* @param value - The literal value, as the wire format carries it: a string.
+* @returns A {@link TypedLiteral} accepted by `Bindable<T>` slots matching `T`.
+*
+* @example
+* ```ts
+* import { raw } from '@lifi/composer-sdk';
+*
+* builder.core.transfer('deliver', {
+*   bind: {
+*     amount: zap.amountOut,
+*     recipient: raw.literal('address', '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'),
+*   },
+*   config: {},
+* });
+* ```
+*/
+const literal = (kind, value) => ({
+	kind,
+	value
 });
-module.exports = __toCommonJS(raw_exports);
-const ref = (path) => (
-  // 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 }
-);
-const literal = (kind, value) => ({ kind, value });
+/**
+* Creates a raw guard object for use in the `guards` array of an operation call.
+*
+* @param kind - The guard type (e.g. `"slippage"`).
+* @param config - Guard-specific configuration (e.g. `{ toleranceBps: 300 }`).
+* @returns An {@link AppliedGuard} object.
+*/
 const rawGuard = (kind, config = {}) => {
-  if ("kind" in config) {
-    throw new Error(
-      `rawGuard: 'kind' must not appear in config (got "${String(
-        config.kind
-      )}"). Pass it as the first argument instead.`
-    );
-  }
-  return { ...config, kind };
+	if ("kind" in config) throw new Error(`rawGuard: 'kind' must not appear in config (got "${String(config.kind)}"). Pass it as the first argument instead.`);
+	return {
+		...config,
+		kind
+	};
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  literal,
-  rawGuard,
-  ref
-});
+//#endregion
+exports.literal = literal;
+exports.rawGuard = rawGuard;
+exports.ref = ref;
+
 //# sourceMappingURL=raw.cjs.map

package/dist/authoring/raw.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/authoring/raw.ts"],"sourcesContent":["import type { AppliedGuard, SolType } from '@lifi/compose-spec';\n\nimport type { OutputKind, TypedLiteral, TypedRef } from '../types.js';\n\n/**\n * Creates a typed `$ref` pointer for use in bind slots.\n *\n * This is an **escape hatch** for referencing values that the typed builder\n * API doesn't cover — for example, outputs of an `untypedOp` node or custom\n * context paths. The caller is responsible for choosing the correct type\n * parameter; no runtime validation occurs.\n *\n * Prefer typed handles (`OutputHandle`, `InputHandle`) and `builder.context`\n * whenever possible. Use `ref` only when you need to construct a `$ref` path\n * manually and want it accepted by a `Bindable<T>` slot.\n *\n * @typeParam T - The output kind this ref represents (e.g. `'address'`, `'uint256'`, `'resource'`).\n * @param path - The `$ref` path (e.g. `\"context.sender\"`, `\"myNode.result\"`).\n * @returns A {@link TypedRef} accepted by `Bindable<T>` slots matching `T`.\n *\n * @example\n * ```ts\n * import { raw } from '@lifi/composer-sdk';\n *\n * // Reference an untypedOp output in a typed operation:\n * builder.untypedOp('custom', 'some.op', {\n *   bind: { x: { $ref: 'input.token' } },\n *   config: {},\n * });\n * builder.core.add('sum', {\n *   bind: {\n *     a: raw.ref<'uint256'>('custom.result'),\n *     b: someTypedHandle,\n *   },\n * });\n * ```\n */\nexport const ref = <T extends OutputKind>(path: string): TypedRef<T> =>\n  // The brand is phantom, so the runtime value is the bare wire ref. This is\n  // the only place a `TypedRef` is minted; the cast is what the brand buys.\n  ({ $ref: path }) as TypedRef<T>;\n\n/**\n * Creates a typed literal for use in bind slots: a constant baked into the\n * flow document rather than supplied at run time.\n *\n * Prefer a declared flow input and `builder.inputs.<name>` — a value the\n * caller supplies per run stays out of the document. Use a literal when the\n * flow has no run of its own to take the value from: the `continuationFlow`\n * of a `continuation.settle` node is stored by the settlement backend and\n * re-run later against the deferred proceeds, so its delivery address has to\n * be part of the committed document.\n *\n * @typeParam T - The Solidity type of the literal (e.g. `'address'`).\n * @param kind - The literal's Solidity type.\n * @param value - The literal value, as the wire format carries it: a string.\n * @returns A {@link TypedLiteral} accepted by `Bindable<T>` slots matching `T`.\n *\n * @example\n * ```ts\n * import { raw } from '@lifi/composer-sdk';\n *\n * builder.core.transfer('deliver', {\n *   bind: {\n *     amount: zap.amountOut,\n *     recipient: raw.literal('address', '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'),\n *   },\n *   config: {},\n * });\n * ```\n */\nexport const literal = <T extends SolType>(\n  kind: T,\n  value: string,\n): TypedLiteral<T> => ({ kind, value });\n\n/**\n * Creates a raw guard object for use in the `guards` array of an operation call.\n *\n * @param kind - The guard type (e.g. `\"slippage\"`).\n * @param config - Guard-specific configuration (e.g. `{ toleranceBps: 300 }`).\n * @returns An {@link AppliedGuard} object.\n */\nexport const rawGuard = (\n  kind: string,\n  config: Record<string, unknown> = {},\n): AppliedGuard => {\n  if ('kind' in config) {\n    throw new Error(\n      `rawGuard: 'kind' must not appear in config (got \"${String(\n        config.kind,\n      )}\"). Pass it as the first argument instead.`,\n    );\n  }\n  return { ...config, kind };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAqCO,MAAM,MAAM,CAAuB;AAAA;AAAA;AAAA,EAGvC,EAAE,MAAM,KAAK;AAAA;AA+BT,MAAM,UAAU,CACrB,MACA,WACqB,EAAE,MAAM,MAAM;AAS9B,MAAM,WAAW,CACtB,MACA,SAAkC,CAAC,MAClB;AACjB,MAAI,UAAU,QAAQ;AACpB,UAAM,IAAI;AAAA,MACR,oDAAoD;AAAA,QAClD,OAAO;AAAA,MACT,CAAC;AAAA,IACH;AAAA,EACF;AACA,SAAO,EAAE,GAAG,QAAQ,KAAK;AAC3B;","names":[]}
+{"version":3,"file":"raw.cjs","names":[],"sources":["../../src/authoring/raw.ts"],"sourcesContent":["import type { AppliedGuard, SolType } from '@lifi/compose-spec';\n\nimport type { OutputKind, TypedLiteral, TypedRef } from '../types.js';\n\n/**\n * Creates a typed `$ref` pointer for use in bind slots.\n *\n * This is an **escape hatch** for referencing values that the typed builder\n * API doesn't cover — for example, outputs of an `untypedOp` node or custom\n * context paths. The caller is responsible for choosing the correct type\n * parameter; no runtime validation occurs.\n *\n * Prefer typed handles (`OutputHandle`, `InputHandle`) and `builder.context`\n * whenever possible. Use `ref` only when you need to construct a `$ref` path\n * manually and want it accepted by a `Bindable<T>` slot.\n *\n * @typeParam T - The output kind this ref represents (e.g. `'address'`, `'uint256'`, `'resource'`).\n * @param path - The `$ref` path (e.g. `\"context.sender\"`, `\"myNode.result\"`).\n * @returns A {@link TypedRef} accepted by `Bindable<T>` slots matching `T`.\n *\n * @example\n * ```ts\n * import { raw } from '@lifi/composer-sdk';\n *\n * // Reference an untypedOp output in a typed operation:\n * builder.untypedOp('custom', 'some.op', {\n *   bind: { x: { $ref: 'input.token' } },\n *   config: {},\n * });\n * builder.core.add('sum', {\n *   bind: {\n *     a: raw.ref<'uint256'>('custom.result'),\n *     b: someTypedHandle,\n *   },\n * });\n * ```\n */\nexport const ref = <T extends OutputKind>(path: string): TypedRef<T> =>\n  // The brand is phantom, so the runtime value is the bare wire ref. This is\n  // the only place a `TypedRef` is minted; the cast is what the brand buys.\n  ({ $ref: path }) as TypedRef<T>;\n\n/**\n * Creates a typed literal for use in bind slots: a constant baked into the\n * flow document rather than supplied at run time.\n *\n * Prefer a declared flow input and `builder.inputs.<name>` — a value the\n * caller supplies per run stays out of the document. Use a literal when the\n * flow has no run of its own to take the value from: the `continuationFlow`\n * of a `continuation.settle` node is stored by the settlement backend and\n * re-run later against the deferred proceeds, so its delivery address has to\n * be part of the committed document.\n *\n * @typeParam T - The Solidity type of the literal (e.g. `'address'`).\n * @param kind - The literal's Solidity type.\n * @param value - The literal value, as the wire format carries it: a string.\n * @returns A {@link TypedLiteral} accepted by `Bindable<T>` slots matching `T`.\n *\n * @example\n * ```ts\n * import { raw } from '@lifi/composer-sdk';\n *\n * builder.core.transfer('deliver', {\n *   bind: {\n *     amount: zap.amountOut,\n *     recipient: raw.literal('address', '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'),\n *   },\n *   config: {},\n * });\n * ```\n */\nexport const literal = <T extends SolType>(\n  kind: T,\n  value: string,\n): TypedLiteral<T> => ({ kind, value });\n\n/**\n * Creates a raw guard object for use in the `guards` array of an operation call.\n *\n * @param kind - The guard type (e.g. `\"slippage\"`).\n * @param config - Guard-specific configuration (e.g. `{ toleranceBps: 300 }`).\n * @returns An {@link AppliedGuard} object.\n */\nexport const rawGuard = (\n  kind: string,\n  config: Record<string, unknown> = {},\n): AppliedGuard => {\n  if ('kind' in config) {\n    throw new Error(\n      `rawGuard: 'kind' must not appear in config (got \"${String(\n        config.kind,\n      )}\"). Pass it as the first argument instead.`,\n    );\n  }\n  return { ...config, kind };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,OAA6B,UAGvC,EAAE,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BhB,MAAa,WACX,MACA,WACqB;CAAE;CAAM;AAAM;;;;;;;;AASrC,MAAa,YACX,MACA,SAAkC,CAAC,MAClB;CACjB,IAAI,UAAU,QACZ,MAAM,IAAI,MACR,oDAAoD,OAClD,OAAO,IACT,EAAE,2CACJ;CAEF,OAAO;EAAE,GAAG;EAAQ;CAAK;AAC3B"}

package/dist/authoring/raw.d.cts

@@ -1,6 +1,6 @@
-import { AppliedGuard, SolType } from '@lifi/compose-spec';
-import { TypedLiteral, OutputKind, TypedRef } from '../types.cjs';
-
+import { OutputKind, TypedLiteral, TypedRef } from "../types.cjs";
+import { AppliedGuard, SolType } from "@lifi/compose-spec";
+//#region src/authoring/raw.d.ts
 /**
  * Creates a typed `$ref` pointer for use in bind slots.
  *
@@ -34,7 +34,7 @@ import { TypedLiteral, OutputKind, TypedRef } from '../types.cjs';
  * });
  * ```
  */
-declare const ref: <T extends OutputKind>(path: string) => TypedRef<T>;
+export declare const ref: <T extends OutputKind>(path: string) => TypedRef<T>;
 /**
  * Creates a typed literal for use in bind slots: a constant baked into the
  * flow document rather than supplied at run time.
@@ -64,7 +64,7 @@ declare const ref: <T extends OutputKind>(path: string) => TypedRef<T>;
  * });
  * ```
  */
-declare const literal: <T extends SolType>(kind: T, value: string) => TypedLiteral<T>;
+export declare const literal: <T extends SolType>(kind: T, value: string) => TypedLiteral<T>;
 /**
  * Creates a raw guard object for use in the `guards` array of an operation call.
  *
@@ -72,6 +72,6 @@ declare const literal: <T extends SolType>(kind: T, value: string) => TypedLiter
  * @param config - Guard-specific configuration (e.g. `{ toleranceBps: 300 }`).
  * @returns An {@link AppliedGuard} object.
  */
-declare const rawGuard: (kind: string, config?: Record<string, unknown>) => AppliedGuard;
-
-export { literal, rawGuard, ref };
+export declare const rawGuard: (kind: string, config?: Record<string, unknown>) => AppliedGuard;
+//#endregion
+//# sourceMappingURL=raw.d.cts.map

package/dist/authoring/raw.d.ts

@@ -1,6 +1,6 @@
-import { AppliedGuard, SolType } from '@lifi/compose-spec';
-import { TypedLiteral, OutputKind, TypedRef } from '../types.js';
-
+import { OutputKind, TypedLiteral, TypedRef } from "../types.js";
+import { AppliedGuard, SolType } from "@lifi/compose-spec";
+//#region src/authoring/raw.d.ts
 /**
  * Creates a typed `$ref` pointer for use in bind slots.
  *
@@ -34,7 +34,7 @@ import { TypedLiteral, OutputKind, TypedRef } from '../types.js';
  * });
  * ```
  */
-declare const ref: <T extends OutputKind>(path: string) => TypedRef<T>;
+export declare const ref: <T extends OutputKind>(path: string) => TypedRef<T>;
 /**
  * Creates a typed literal for use in bind slots: a constant baked into the
  * flow document rather than supplied at run time.
@@ -64,7 +64,7 @@ declare const ref: <T extends OutputKind>(path: string) => TypedRef<T>;
  * });
  * ```
  */
-declare const literal: <T extends SolType>(kind: T, value: string) => TypedLiteral<T>;
+export declare const literal: <T extends SolType>(kind: T, value: string) => TypedLiteral<T>;
 /**
  * Creates a raw guard object for use in the `guards` array of an operation call.
  *
@@ -72,6 +72,6 @@ declare const literal: <T extends SolType>(kind: T, value: string) => TypedLiter
  * @param config - Guard-specific configuration (e.g. `{ toleranceBps: 300 }`).
  * @returns An {@link AppliedGuard} object.
  */
-declare const rawGuard: (kind: string, config?: Record<string, unknown>) => AppliedGuard;
-
-export { literal, rawGuard, ref };
+export declare const rawGuard: (kind: string, config?: Record<string, unknown>) => AppliedGuard;
+//#endregion
+//# sourceMappingURL=raw.d.ts.map