@silyze/browsary-pipeline v1.0.0

Browsary Pipeline

Core library for defining, compiling, and executing JSON-defined pipelines in Browsary.

Installation

npm install @silyze/browsary-pipeline

Quick Start

import { createJsonLogger } from "@silyze/logger";
import {
  hasPipeline,
  PipelineCompiler,
  StandardLibraryProvider,
  waitForPipelineThread,
} from "@silyze/browsary-pipeline";
import { UrlBrowserProvider } from "@silyze/browser-provider";

const pipelineSource = {
  create_browser: {
    node: "browser::create",
    inputs: {},
    outputs: { browser: "browser" },
    dependsOn: [],
  },
  goto_google: {
    node: "page::goto",
    inputs: {
      page: {
        type: "outputOf",
        nodeName: "create_browser",
        outputName: "browser",
      },
      url: { type: "constant", value: "https://www.google.com" },
      waitUntil: { type: "constant", value: "load" },
    },
    outputs: {},
    dependsOn: "create_browser",
  },
};

async function main() {
  const compiler = new PipelineCompiler();
  const result = compiler.compile(pipelineSource);

  if (!hasPipeline(result)) {
    console.error("Compilation errors:", result.errors);
    return;
  }

  const logger = createJsonLogger(console.log);
  const evaluation = result.pipeline.createEvaluation({
    logger,
    browserProvider: new UrlBrowserProvider(),
    libraryProvider: StandardLibraryProvider,
    viewport: { width: 1024, height: 768 },
  });

  try {
    for await (const thread of evaluation.evaluate()) {
      const outputs = await waitForPipelineThread(thread);
      console.log("Thread outputs:", outputs);
    }
  } finally {
    evaluation.stop();
  }
}

main();

API Reference

Classes & Functions

PipelineCompiler

constructor(): PipelineCompiler
compile(source: PipelineSchema): PipelineCompileResult

• Validates source against pipelineSchema and returns:

  • { errors: PipelineCompileError[] } on failure
  • { errors: []; pipeline: Pipeline } on success

hasPipeline

declare function hasPipeline(
  result: PipelineCompileResult
): result is { pipeline: Pipeline };

Type guard for compile results.

waitForPipelineThread

declare function waitForPipelineThread(
  thread: PipelineThread
): Promise<Record<string, unknown>>;

Awaits a single thread’s completion and returns its outputs.

pipelineSchema

AJV JSON schema for pipeline definitions.

Types & Interfaces

PipelineSchema

type PipelineSchema = Record<string, GenericNodeDefinition>;

GenericNodeDefinition

interface GenericNodeDefinition {
  node: string;
  inputs?: Record<string, InputNode>;
  outputs?: Record<string, string>;
  dependsOn?: string | string[];
}

InputNode

type InputNode =
  | { type: "constant"; value: unknown }
  | { type: "outputOf"; nodeName: string; outputName: string };

PipelineCompileResult

type PipelineCompileResult =
  | { errors: PipelineCompileError[] }
  | { errors: []; pipeline: Pipeline };

Pipeline

interface Pipeline {
  createEvaluation(config: EvaluationConfig): PipelineEvaluation;
}

PipelineEvaluation

interface PipelineEvaluation {
  evaluate(): AsyncIterable<PipelineThread>;
  stop(): void;
}

PipelineThread

Opaque execution path handle. Use waitForPipelineThread.

PipelineCompileError

export type PipelineCompileError = {
  type: string;
  message: string;
  [key: string]: unknown;
};

EvaluationConfig

interface EvaluationConfig {
  logger: Logger;
  browserProvider: BrowserProvider;
  libraryProvider: EvaluationLibrary;
  viewport?: ViewportConfig;
}

StandardLibraryProvider Nodes

Built-in node implementations available via StandardLibraryProvider: