tubeless 0.2.6 → 0.2.7

package/docs/api-report.json

@@ -69,7 +69,7 @@
         "StepFactory",
         "StepSkipDecision"
       ],
-      "sha256": "abb2f1fca6d2e21eda1bc1cf72921fee3110f474660834202d223f805300c8d9",
+      "sha256": "84b22a259773f3dcfeb91a3bae96ccef79e4279664946faa25d0219778ef6fd2",
       "specifier": "tubeless"
     },
     {
@@ -109,7 +109,7 @@
         "ReporterTerminalCapabilities",
         "RunReporterConfig"
       ],
-      "sha256": "996eeba686bb2a3124c21f30e4c5b5d36873c1a30cbba89ef2b9629206feef48",
+      "sha256": "fe37491a52df175b666ebffc497f8afea9ad94aa2bb97841b5e7f22e1b71a04c",
       "specifier": "tubeless/cli"
     },
     {
@@ -171,7 +171,7 @@
         "PipelineProjectManifestInput",
         "validatePipelineDocument"
       ],
-      "sha256": "464f5d94a3533c4050c32d902badafa4fabfdec176152bb36bb738cf52ce6e81",
+      "sha256": "316af8da2ed6a5708004ed3d52fb2311a81e19789796bdc926a5902764472a72",
       "specifier": "tubeless/project"
     },
     {
@@ -185,7 +185,7 @@
         "PipelineTestRuntimeOptions",
         "PipelineTestSleep"
       ],
-      "sha256": "9510932b8aec600ecf2bcfdb1a188257dad48a3108087c974689c6e6ec3ad5c9",
+      "sha256": "6eb6f55eaa2bb1b75a1085dafd5e136dc5d76566dfe405a60b40942a5e40b958",
       "specifier": "tubeless/testing"
     },
     {

package/docs/child-pipeline-composition.md

@@ -3,10 +3,10 @@
 Use a child pipeline when part of a workflow is useful on its own and should
 also run inside a larger pipeline. Tubeless provides two step builders:
 
-| Builder                | Use it to                                       | Step output                              |
-| ---------------------- | ----------------------------------------------- | ---------------------------------------- |
-| `step.fromPipeline`    | Run one child pipeline                          | The child's final result                 |
-| `step.forEachPipeline` | Run the same child pipeline for a list of items | An array of child results in input order |
+| Builder           | Use it to                                       | Step output                              |
+| ----------------- | ----------------------------------------------- | ---------------------------------------- |
+| `fromPipeline`    | Run one child pipeline                          | The child's final result                 |
+| `forEachPipeline` | Run the same child pipeline for a list of items | An array of child results in input order |
 
 Both builders infer the child options and result types. They forward the
 parent's runtime context and report child progress through the parent step.
@@ -20,7 +20,9 @@ parent step's dependency outputs and context, and returns the inputs the child
 needs. Add `mapResult` if the parent needs a different result shape.
 
 ```ts
-const seedIndexStage = step.fromPipeline("seed-index", {
+const { fromPipeline } = createSteps<ParentOptions>();
+
+const seedIndexStage = fromPipeline("seed-index", {
   pipeline: IndexSeedPipeline,
   dependsOn: [seedCatalogStage],
   description: "Seed a precomputed search index",
@@ -38,7 +40,9 @@ Use `items` to return the list to process, `key` for stable item IDs, and
 `concurrency` to limit simultaneous child runs:
 
 ```ts
-const processShards = step.forEachPipeline("process-shards", {
+const { forEachPipeline } = createSteps<ParentOptions>();
+
+const processShards = forEachPipeline("process-shards", {
   pipeline: ShardPipeline,
   dependsOn: [resolveShards],
   items: ({ "resolve-shards": shards }) => shards,
@@ -53,10 +57,12 @@ const processShards = step.forEachPipeline("process-shards", {
 });
 ```
 
-To skip the whole step when there are no items, use the skippable builder:
+To skip the whole step when there are no items, add `skip` to its definition:
 
 ```ts
-const processShards = step.forEachPipeline.skippable("process-shards", {
+const { forEachPipeline } = createSteps<ParentOptions>();
+
+const processShards = forEachPipeline("process-shards", {
   pipeline: ShardPipeline,
   dependsOn: [resolveShards],
   skip: ({ "resolve-shards": shards }) =>
@@ -80,17 +86,16 @@ Keys must be stable and unique; duplicate keys fail before any child starts.
 All running children finish or cancel before the parent step returns a failure.
 The parent therefore cannot finalize while those children are still running.
 
-Use `.skippable` when the entire child step may be intentionally omitted.
-Its `skip` callback returns `false` to proceed, a non-empty reason string to
-skip, or `{ reason, value }` to skip with an output. A skip without a value
-publishes `undefined`. Policy skips allow required dependents to run, so those
-dependents must handle `undefined` explicitly.
-
-The ordinary builders reject `skip` and keep non-optional output types.
-`fromPipeline.skippable` returns `T | undefined`, and
-`forEachPipeline.skippable` returns `readonly T[] | undefined`. For fan-out,
-the skip value is the complete result array. Skipping does not call `items`,
-run children, or apply `mapResult`.
+Add `skip` to a `fromPipeline` or `forEachPipeline` definition when the entire
+child step may be intentionally omitted. The callback returns `false` to proceed,
+a non-empty reason string to skip, or `{ reason, value }` to skip with an output.
+A skip without a value publishes `undefined`. Policy skips allow required
+dependents to run, so those dependents must handle `undefined` explicitly.
+
+Without `skip`, `fromPipeline` returns `T` and `forEachPipeline` returns
+`readonly T[]`. Adding `skip` widens those types to `T | undefined` and
+`readonly T[] | undefined`. For fan-out, the skip value is the complete result
+array. Skipping does not call `items`, run children, or apply `mapResult`.
 
 ## Planning and execution controls
 

package/docs/concepts.md

@@ -6,8 +6,9 @@ A pipeline describes a series of steps and the values passed between them.
 Each step has an ID, a function to run, and any dependencies. A finalizer
 combines step outputs into the value returned to the caller.
 
-Create steps with one `createSteps<TOptions>()` builder per pipeline. Pass a
-step object to another step's `dependsOn` array to require its output;
+Create steps with one `createSteps<TOptions>()` factory per pipeline. Take its
+`step` constructor, then pass a step object to another step's
+`dependsOn` array to require its output;
 TypeScript then infers that input's type.
 
 `definePipeline` checks the graph immediately. Duplicate or reserved IDs,
@@ -45,15 +46,16 @@ or fail while running. These cases have different effects on dependent steps.
 | Outcome         | What happened                                                                             | What dependents receive                              |
 | --------------- | ----------------------------------------------------------------------------------------- | ---------------------------------------------------- |
 | Structural skip | A filter, dry-run rule, missing dependency, abort, or earlier failure prevented execution | No output; required dependents cannot run            |
-| Policy skip     | A `step.skippable` predicate decided that work was unnecessary                            | The supplied skip value, or `undefined`              |
+| Policy skip     | A step's `skip` predicate decided that work was unnecessary                               | The supplied skip value, or `undefined`              |
 | Failure         | The step's work failed                                                                    | No successful output; required dependents cannot run |
 
 Fail-fast is the default: a failure stops new work. Set `continueOnError` to
 allow independent steps to proceed. The run still reports failure, and
 `runOrThrow` still throws. Use `run` to inspect any partial result.
 
-A `step.skippable` output is always typed as `T | undefined`, even if all current
-skip paths return a value. Dependent steps must handle that possible absence.
+Adding `skip` to a step definition makes it skippable. Its output is always
+typed as `T | undefined`, even if all current skip paths return a value.
+Dependent steps must handle that possible absence.
 
 ## Execution controls
 
@@ -302,7 +304,7 @@ Schema V1. Tubeless accepts these schemas without importing a validation library
 `resultSchema` to `definePipeline`:
 
 ```ts
-const step = createSteps(optionsSchema);
+const { step } = createSteps(optionsSchema);
 
 const parse = step("parse", {
   outputSchema: parsedRowsSchema,
@@ -349,18 +351,18 @@ options-schema factory scopes.
 
 ## Child pipelines
 
-Use `step.fromPipeline` to run one reusable child pipeline. Use
-`step.forEachPipeline` to run that child for each item in a list. The parent
+Use `fromPipeline` to run one reusable child pipeline. Use `forEachPipeline` to
+run that child for each item in a list. The parent
 plan contains one wrapper step; child activity appears as progress beneath it.
 Read [child-pipeline composition](./child-pipeline-composition.md) for option
 mapping, selection, failures, and progress controls.
 
-Use `step.forEachPipeline.skippable` when the entire batch may be intentionally
-omitted. Its output can be `undefined`, which dependent code must handle.
+Add `skip` to either child-step definition when the entire child step may be
+intentionally omitted. Its output can be `undefined`, which dependent code must handle.
 
 ## Remote steps
 
-Use `step.fromRemote` to call a service or execution engine from one step.
+Use `fromRemote` to call a service or execution engine from one step.
 The parent pipeline still runs locally. The step's `remote.engine` and optional
 `remote.target` describe the destination for display and inspection.
 

package/docs/getting-started.md

@@ -51,15 +51,15 @@ const lines = ["  First row  ", "", "Second row"];
 
 ## 2. Create typed steps
 
-Call `createSteps` once to create a step builder for these options. The `load`
-step returns the input lines. The `normalize` step declares `dependsOn: [load]`,
+Call `createSteps` once and take its `step` constructor for these options. The
+`load` step returns the input lines. The `normalize` step declares `dependsOn: [load]`,
 so it receives the output of `load` as a typed input. TypeScript infers that
 `rows` is a read-only array of strings.
 
 ```ts
 import { createSteps } from "tubeless";
 
-const step = createSteps<ImportOptions>();
+const { step } = createSteps<ImportOptions>();
 
 const load = step("load", {
   description: "Read source rows",

package/docs/recipes.md

@@ -15,12 +15,12 @@ one of these recipes.
 | Validate options, outputs, and results        | [`validated-boundaries.ts`](../examples/validated-boundaries.ts)         | Standard Schema, `outputSchema`, `resultSchema`                            |
 | Inspect, plan, or graph a pipeline or command | [`typed-import.ts`](../examples/typed-import.ts)                         | `tubeless inspect`, `tubeless plan`, `tubeless graph`, `toMermaid`         |
 | Safe write/publish preview                    | [`publish-with-gates.ts`](../examples/publish-with-gates.ts)             | `dryRun`, `optionalDependsOn`, `skipAfterFailureOf`                        |
-| Deliberately omit unnecessary work            | [`conditional-step.ts`](../examples/conditional-step.ts)                 | `step.skippable`, valued skip, skip-aware output typing                    |
+| Deliberately omit unnecessary work            | [`conditional-step.ts`](../examples/conditional-step.ts)                 | `step` with `skip`, valued skip, skip-aware output typing                  |
 | Preserve independent work after failure       | [`best-effort.ts`](../examples/best-effort.ts)                           | `continueOnError`, structured `run` result                                 |
 | Compose one reusable workflow                 | [`child-pipeline.ts`](../examples/child-pipeline.ts)                     | `fromPipeline`, `mapOptions`, resolved async `mapResult`                   |
 | Call a real HTTP service                      | [`remote-steps.ts`](../examples/remote-steps.ts)                         | `fromRemote`, fetch cancellation, validated HTTP output                    |
 | Host a pipeline in a durable engine           | [`host-embedding.ts`](../examples/host-embedding.ts)                     | `runOrThrow`, pass `correlationId` / `parentRunId`                         |
-| Fan out over runtime items                    | [`fan-out-progress.ts`](../examples/fan-out-progress.ts)                 | `forEachPipeline.skippable`, stable keys, concurrency, progress            |
+| Fan out over runtime items                    | [`fan-out-progress.ts`](../examples/fan-out-progress.ts)                 | `forEachPipeline` with `skip`, stable keys, concurrency, progress          |
 | Inspect keyed fan-out failures                | [`fan-out-progress.ts`](../examples/fan-out-progress.ts)                 | `error.fanOut`, bounded diagnostics, caller-directed reruns                |
 | Show determinate progress                     | [`fan-out-progress.ts`](../examples/fan-out-progress.ts)                 | `reportProgress`, bounded live CLI rows, complete final trees              |
 | Watch the live TTY reporter                   | [`live-tui.ts`](../examples/live-tui.ts)                                 | named steps, nested `details`; persist with `--store`                      |
@@ -68,12 +68,12 @@ pipeline does not require credentials.
 1. Use an ordinary step for one unit of domain work.
 2. Set `dryRun: "skip"` or provide a side-effect-free `dryRun` handler before
    exposing side-effecting work through CLI dry-run support.
-3. Use `step.skippable` only for a successful policy decision, never to hide an error.
+3. Add `skip` only for a successful policy decision, never to hide an error.
 4. Use a child pipeline when the child has value independently; use a normal
    helper function when it does not.
 5. Use `forEachPipeline` when every item needs child-pipeline lifecycle and
-   reporting. Opt into `forEachPipeline.skippable` when policy may omit the
-   whole fan-out and a skip should appear in reports. Use `runConcurrent`
+   reporting. Add `skip` to `forEachPipeline` when policy may omit the whole
+   fan-out and a skip should appear in reports. Use `runConcurrent`
    for lightweight worker functions that should
    throw on the first failure. Use `runConcurrentSettled` when the caller needs
    completed results plus that failure without throwing.

package/docs/remote-step-composition.md

@@ -1,6 +1,6 @@
 # Remote-step composition
 
-Use `step.fromRemote` when a pipeline step needs to call a service or execution
+Use `fromRemote` when a pipeline step needs to call a service or execution
 engine outside the current process. The step sends input through an adapter,
 waits for the result, and validates it before dependent steps run.
 
@@ -10,8 +10,9 @@ The required fields are `adapter`, `mapInput`, and `outputSchema`:
 - `mapInput` builds the request from local step inputs and context.
 - `outputSchema` checks the returned value and provides its type to dependents.
 
-Use `fromRemote.skippable` when the request may be intentionally omitted. As
-with other skippable steps, dependent code must handle a possible `undefined`.
+Add `skip` to the `fromRemote` definition when the request may be intentionally
+omitted. As with other skippable steps, dependent code must handle a possible
+`undefined`.
 See the [HTTP example](../examples/remote-steps.ts) for a complete implementation.
 
 ## Choose where the pipeline runs

package/examples/best-effort.ts

@@ -4,7 +4,7 @@ interface AuditOptions {
   failLinks?: boolean;
 }
 
-const step = createSteps<AuditOptions>();
+const { step } = createSteps<AuditOptions>();
 
 const checkLinks = step("check-links", {
   description: "Validate links independently",

package/examples/cancellation-and-testing.ts

@@ -5,7 +5,7 @@ interface PollOptions {
   attempts: number;
 }
 
-const step = createSteps<PollOptions>();
+const { step } = createSteps<PollOptions>();
 
 const poll = step("poll", {
   description: "Poll cooperatively with an injected, cancellation-aware sleep",

package/examples/catalog/pipelines/enrich.ts

@@ -43,7 +43,7 @@ interface EnrichOptions {
   lines: readonly string[];
 }
 
-const step = createSteps<EnrichOptions>();
+const { step, fromRemote } = createSteps<EnrichOptions>();
 
 const parseRows = step("parse-rows", {
   description: "Trim and drop blank rows from caller input.",
@@ -66,7 +66,7 @@ const enrichAdapter: RemoteStepAdapter<
   },
 };
 
-const enrichRows = step.fromRemote("enrich-rows", {
+const enrichRows = fromRemote("enrich-rows", {
   dependsOn: [parseRows],
   description: "Rehearse a remote enrich during dry-run.",
   adapter: enrichAdapter,
@@ -84,7 +84,7 @@ const chargeAdapter: RemoteStepAdapter<EnrichOptions, { orderId: string }, Charg
   invoke: async (payload) => ({ charged: true, orderId: payload.orderId }),
 };
 
-const chargeOrder = step.fromRemote("charge-order", {
+const chargeOrder = fromRemote("charge-order", {
   dependsOn: [enrichRows],
   description: "Skip remote charge during dry-run.",
   adapter: chargeAdapter,

package/examples/catalog/pipelines/import.ts

@@ -5,14 +5,14 @@ interface ImportOptions {
   lines: readonly string[];
 }
 
-const step = createSteps<ImportOptions>();
+const { step, forEachPipeline } = createSteps<ImportOptions>();
 
 const loadRows = step("load-rows", {
   description: "Read raw input records from the caller.",
   run: (_inputs, context) => context.options.lines,
 });
 
-const normalizedImport = step.forEachPipeline.skippable("normalized-import", {
+const normalizedImport = forEachPipeline("normalized-import", {
   dependsOn: [loadRows],
   description: "Normalize rows through mapped child pipelines when input is present.",
   pipeline: NormalizePipeline,

package/examples/catalog/pipelines/normalize.ts

@@ -4,7 +4,7 @@ interface NormalizeOptions {
   rows: readonly string[];
 }
 
-const step = createSteps<NormalizeOptions>();
+const { step } = createSteps<NormalizeOptions>();
 
 const normalizeRows = step("normalize-rows", {
   description: "Trim, lowercase, and drop blank rows.",

package/examples/catalog/pipelines/publish.ts

@@ -9,7 +9,7 @@ interface Artifact {
   size: number;
 }
 
-const step = createSteps<PublishOptions>();
+const { step } = createSteps<PublishOptions>();
 
 const buildArtifact = step("build-artifact", {
   description: "Build an artifact that can be validated and published.",

package/examples/catalog/tubeless.project.ts

@@ -7,6 +7,8 @@ import { definePipelineProject } from "tubeless/project";
 // execution. Command argv flags stay --step/--target, while mapOptions and hooks
 // receive stepIds and targets.
 // When converting existing code, use the tubeless-make-pipeline agent skill.
+// Pipeline files destructure the constructors they need from createSteps.
+// Adding skip to any definition marks that step as intentionally omittable.
 // Adapt this layout to the consumer; retain its established IDs and caller contracts.
 // For caller-directed fan-out reruns, see ../fan-out-progress.ts: inspect
 // error.fanOut and check omitted entries and truncated keys before selecting inputs.

package/examples/child-pipeline.ts

@@ -4,7 +4,7 @@ interface NormalizeOptions {
   rows: readonly string[];
 }
 
-const normalizeStep = createSteps<NormalizeOptions>();
+const { step: normalizeStep } = createSteps<NormalizeOptions>();
 
 const normalizeRows = normalizeStep("normalize-rows", {
   run: (_inputs, context) =>
@@ -22,9 +22,9 @@ interface ImportOptions {
   lines: readonly string[];
 }
 
-const importStep = createSteps<ImportOptions>();
+const { fromPipeline } = createSteps<ImportOptions>();
 
-const normalizedImport = importStep.fromPipeline("normalized-import", {
+const normalizedImport = fromPipeline("normalized-import", {
   pipeline: NormalizePipeline,
   mapOptions: (_inputs, context) => ({ rows: context.options.lines }),
   mapResult: (rows) => ({ count: rows.length, rows }),
@@ -44,7 +44,7 @@ export async function runChildPipelineExample() {
 
 // oxlint-disable-next-line no-constant-condition -- typecheck-only compile probe
 if (false) {
-  importStep.fromPipeline("invalid-child-selection", {
+  fromPipeline("invalid-child-selection", {
     pipeline: NormalizePipeline,
     // @ts-expect-error Child run options are checked against its declared target IDs.
     mapOptions: () => ({ rows: [], targets: ["normalise-rows"] }),

package/examples/cli-job.ts

@@ -7,7 +7,7 @@ interface ImportOptions {
   limit?: number;
 }
 
-const step = createSteps<ImportOptions>();
+const { step } = createSteps<ImportOptions>();
 
 const loadRows = step("load-rows", {
   description: "Read raw input records from the caller.",

package/examples/conditional-step.ts

@@ -5,9 +5,9 @@ interface CacheOptions {
   refresh: boolean;
 }
 
-const step = createSteps<CacheOptions>();
+const { step } = createSteps<CacheOptions>();
 
-const resolveValue = step.skippable("resolve-value", {
+const resolveValue = step("resolve-value", {
   description: "Reuse a cached value unless a refresh is required",
   skip: (_inputs, context) =>
     !context.options.refresh && context.options.cachedValue !== undefined

package/examples/fan-out-progress.ts

@@ -5,7 +5,7 @@ interface ShardOptions {
   shardId: string;
 }
 
-const shardStep = createSteps<ShardOptions>();
+const { step: shardStep } = createSteps<ShardOptions>();
 
 const processRecords = shardStep("process-records", {
   name: "Process records",
@@ -46,9 +46,9 @@ interface FanOutOptions {
   shards: readonly { id: string; records: readonly string[] }[];
 }
 
-const fanOutStep = createSteps<FanOutOptions>();
+const { forEachPipeline } = createSteps<FanOutOptions>();
 
-const processShards = fanOutStep.forEachPipeline.skippable("process-shards", {
+const processShards = forEachPipeline("process-shards", {
   pipeline: ShardPipeline,
   description: "Process shards with bounded concurrency and stable identities",
   skip: (_inputs, context) =>

package/examples/host-embedding.ts

@@ -1,6 +1,6 @@
 import { createSteps, definePipeline, requireOutputs } from "tubeless";
 
-const step = createSteps<{ lines: readonly string[] }>();
+const { step } = createSteps<{ lines: readonly string[] }>();
 const normalize = step("normalize", {
   description: "Normalize rows within one host-owned invocation",
   run: (_inputs, context) => context.options.lines.map((line) => line.trim()),

package/examples/live-tui.ts

@@ -11,7 +11,7 @@ const SOURCES = ["west", "east", "north", "south"] as const;
 const ARTIFACTS = ["index.json", "manifest.json", "checksums.txt"] as const;
 const DEFAULT_DELAY_MS = 450;
 
-const step = createSteps<LiveTuiOptions>();
+const { step } = createSteps<LiveTuiOptions>();
 
 function sequentialStatus(index: number, current: number): DetailStatus {
   if (index < current) return "completed";

package/examples/node-artifacts.ts

@@ -2,7 +2,7 @@ import { createSteps, definePipeline } from "tubeless";
 import { definePaths, writeJson } from "tubeless/node";
 
 const paths = definePaths({ artifact: "build/artifacts/rows.json" });
-const step = createSteps<{ rows: readonly string[] }>();
+const { step } = createSteps<{ rows: readonly string[] }>();
 
 const normalize = step("normalize", {
   description: "Normalize the caller's rows before writing an artifact.",

package/examples/peloton.ts

@@ -39,13 +39,16 @@ const START_LIST_FILES = ["start-list.json", "timing.log", "weather.txt"] as con
 
 type DetailStatus = "completed" | "pending" | "running";
 
-const normalizeStep = createSteps<{ delay: number; riders: readonly PelotonRider[] }>();
-const inspectStep = createSteps<{
+const { step: normalizeStep } = createSteps<{
+  delay: number;
+  riders: readonly PelotonRider[];
+}>();
+const { step: inspectStep } = createSteps<{
   delay: number;
   kit: readonly string[];
   riderId: string;
 }>();
-const step = createSteps<PelotonOptions>();
+const { step, fromPipeline, forEachPipeline } = createSteps<PelotonOptions>();
 
 function sequentialStatus(index: number, current: number): DetailStatus {
   if (index < current) return "completed";
@@ -176,7 +179,7 @@ const discoverPeloton = step("discover-peloton", {
   },
 });
 
-const resolveWeather = step.skippable("resolve-weather", {
+const resolveWeather = step("resolve-weather", {
   name: "Resolve Weather",
   description: "Reuse a posted forecast unless the race asks for a refresh.",
   skip: (_inputs, context) =>
@@ -192,7 +195,7 @@ const resolveWeather = step.skippable("resolve-weather", {
   },
 });
 
-const normalizedBikes = step.fromPipeline("normalize-bikes", {
+const normalizedBikes = fromPipeline("normalize-bikes", {
   name: "Normalize Bikes",
   dependsOn: [discoverPeloton],
   description: "Normalize kit lists through the independently useful child pipeline.",
@@ -203,7 +206,7 @@ const normalizedBikes = step.fromPipeline("normalize-bikes", {
   }),
 });
 
-const inspectBikes = step.forEachPipeline("inspect-bikes", {
+const inspectBikes = forEachPipeline("inspect-bikes", {
   name: "Inspect Bikes",
   dependsOn: [normalizedBikes],
   description: "Fan out bike inspections with bounded concurrency and stable rider keys.",

package/examples/publish-with-gates.ts

@@ -9,7 +9,7 @@ interface Artifact {
   size: number;
 }
 
-const step = createSteps<PublishOptions>();
+const { step } = createSteps<PublishOptions>();
 
 const buildArtifact = step("build-artifact", {
   description: "Build an artifact that can be validated and published.",

package/examples/remote-steps.ts

@@ -75,13 +75,13 @@ const enrichAdapter: RemoteStepAdapter<RemoteStepsOptions, RemotePayload, unknow
   },
 };
 
-const step = createSteps<RemoteStepsOptions>();
+const { step, fromRemote } = createSteps<RemoteStepsOptions>();
 const parse = step("parse", {
   description: "Trim input rows before sending them to the remote service",
   run: (_inputs, context) =>
     context.options.lines.map((line) => line.trim()).filter((line) => line.length > 0),
 });
-const enrich = step.fromRemote("enrich", {
+const enrich = fromRemote("enrich", {
   description: "Validate the HTTP service result before local consumption",
   dependsOn: [parse],
   adapter: enrichAdapter,

package/examples/resumable-enrichment.ts

@@ -15,7 +15,7 @@ interface EnrichedItem {
   summary: string;
 }
 
-const step = createSteps<EnrichmentOptions>();
+const { step } = createSteps<EnrichmentOptions>();
 
 const loadPendingItems = step("load-pending-items", {
   description: "Skip work that was already checkpointed by a previous run.",

package/examples/tracing.ts

@@ -99,7 +99,7 @@ interface TracingExampleOptions {
   rows: readonly string[];
 }
 
-const step = createSteps<TracingExampleOptions>();
+const { step } = createSteps<TracingExampleOptions>();
 const normalize = step("normalize", {
   run: async (_inputs, context) =>
     withRetry(

package/examples/typed-import.ts

@@ -4,7 +4,7 @@ interface ImportOptions {
   lines: readonly string[];
 }
 
-const step = createSteps<ImportOptions>();
+const { step } = createSteps<ImportOptions>();
 
 const loadRows = step("load-rows", {
   description: "Read raw input records from the caller.",

package/examples/validated-boundaries.ts

@@ -42,7 +42,7 @@ const resultSchema = standardSchema<
   return { value: { ...result, validated: true } };
 });
 
-const step = createSteps(optionsSchema);
+const { step } = createSteps(optionsSchema);
 
 const load = step("load", {
   outputSchema: rowsSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tubeless",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "Typed pipeline primitives for composable data-processing workflows.",
   "author": {
     "name": "Chet Mancini",

package/skills/tubeless/SKILL.md

@@ -25,16 +25,18 @@ the installed declarations before using them; do not silently upgrade Tubeless.
 
 ## Authoring decisions
 
-- Use `createSteps<TDomainOptions>()` per pipeline. Domain options contain
-  business inputs; pass built-in controls separately to `run(options, controls?)`.
+- Use `createSteps<TDomainOptions>()` per pipeline and destructure every
+  constructor it needs: `step`, `fromPipeline`, `fromRemote`, and/or
+  `forEachPipeline`. Domain options contain business inputs; pass built-in
+  controls separately to `run(options, controls?)`.
 - Give steps stable kebab-case IDs and descriptions of their domain work.
   `name` is an optional display label. Return values from steps and consume
   inferred dependency outputs instead of sharing mutable state.
 - Use `dependsOn` for required outputs, `optionalDependsOn` for expected
   absence, and `skipAfterFailureOf` for a failure gate without a required value.
   Keep publication dependent on successful validation.
-- Use `step.skippable` for an intentional successful omission. Handle its
-  `T | undefined` output explicitly; do not turn exceptions into skips.
+- Add `skip` to a step definition for an intentional successful omission. Handle
+  its `T | undefined` output explicitly; do not turn exceptions into skips.
 - Set `dryRun: "skip"` on writes and other external side effects, or supply a
   side-effect-free typed preview handler. Unmarked steps still run in dry runs.
 - Use `requireOutputs` when the final result requires specific outputs. A plain

package/skills/tubeless-make-pipeline/SKILL.md

@@ -57,9 +57,10 @@ has a coherent output and a reason to appear in a plan or failure report.
 
 ## Keep the graph typed
 
-Use one `createSteps<TDomainOptions>()` builder and one `definePipeline` per
-pipeline. Import from `tubeless` and its public subpaths. Keep business inputs
-in domain options; built-in run controls belong in the separate controls argument.
+Use one `createSteps<TDomainOptions>()` factory and one `definePipeline` per
+pipeline. Define ordinary steps with the returned `step` constructor. Import from `tubeless` and
+its public subpaths. Keep business inputs in domain options; built-in run
+controls belong in the separate controls argument.
 
 Give each step a stable literal kebab-case ID and an operational description.
 Let `dependsOn: [step]` infer input types from returned outputs. Preserve
@@ -88,7 +89,7 @@ a missing required output to an empty array, `false`, or a fake success value.
   write to make dry runs pass.
 - Keep validation required for publication. Test this even with
   `continueOnError` if the caller enables best-effort execution.
-- Use `step.skippable` only for a successful policy decision. Preserve thrown
+- Add `skip` only for a successful policy decision. Preserve thrown
   failures and their causes; branch on structured Tubeless error fields.
   Map pipeline errors at the caller boundary if existing callers require a
   specific error contract.