@tagma/sdk 0.6.11 → 0.7.0

package/src/schema-ports.test.ts

@@ -13,6 +13,34 @@ const WORK_DIR = process.platform === 'win32' ? 'D:\\fake-work' : '/fake-work';
 // ─── resolveConfig preserves ports ───────────────────────────────────
 
 describe('resolveConfig — ports passthrough', () => {
+  test('raw lightweight bindings survive onto the resolved task', () => {
+    const raw: RawPipelineConfig = {
+      name: 'p',
+      tracks: [
+        {
+          id: 't',
+          name: 'T',
+          tasks: [
+            {
+              id: 'a',
+              command: 'echo "{{inputs.city}}"',
+              inputs: {
+                city: { from: 't.plan.outputs.city', required: true },
+              },
+              outputs: {
+                report: { from: 'json.reportPath' },
+              },
+            },
+          ],
+        },
+      ],
+    };
+    const resolved = resolveConfig(raw, WORK_DIR);
+    const task = resolved.tracks[0]!.tasks[0]!;
+    expect(task.inputs).toEqual(raw.tracks[0]!.tasks[0]!.inputs!);
+    expect(task.outputs).toEqual(raw.tracks[0]!.tasks[0]!.outputs!);
+  });
+
   test('raw ports survive onto the resolved task', () => {
     const raw: RawPipelineConfig = {
       name: 'p',
@@ -83,6 +111,35 @@ describe('resolveConfig — ports passthrough', () => {
 // ─── deresolvePipeline preserves ports ───────────────────────────────
 
 describe('deresolvePipeline — ports round-trip', () => {
+  test('lightweight bindings round-trip', () => {
+    const raw: RawPipelineConfig = {
+      name: 'p',
+      tracks: [
+        {
+          id: 't',
+          name: 'T',
+          tasks: [
+            {
+              id: 'a',
+              command: 'echo "{{inputs.city}}"',
+              inputs: {
+                city: { from: 't.plan.outputs.city', required: true },
+                mode: { default: 'quick' },
+              },
+              outputs: {
+                raw: { from: 'stdout' },
+              },
+            },
+          ],
+        },
+      ],
+    };
+    const resolved = resolveConfig(raw, WORK_DIR);
+    const back = deresolvePipeline(resolved, WORK_DIR);
+    expect(back.tracks[0]!.tasks[0]!.inputs).toEqual(raw.tracks[0]!.tasks[0]!.inputs!);
+    expect(back.tracks[0]!.tasks[0]!.outputs).toEqual(raw.tracks[0]!.tasks[0]!.outputs!);
+  });
+
   test('ports with both inputs and outputs round-trip', () => {
     const raw: RawPipelineConfig = {
       name: 'p',
@@ -200,6 +257,35 @@ describe('deresolvePipeline — ports round-trip', () => {
 // ─── parseYaml accepts ports ─────────────────────────────────────────
 
 describe('parseYaml — accepts ports declarations', () => {
+  test('real-world YAML with lightweight bindings parses cleanly', () => {
+    const text = `pipeline:
+  name: demo
+  tracks:
+    - id: t
+      name: Main
+      tasks:
+        - id: build
+          command: bun run build
+          outputs:
+            bundlePath: { from: json.bundlePath }
+        - id: test
+          depends_on: [build]
+          command: 'bun test "{{inputs.bundlePath}}"'
+          inputs:
+            bundlePath:
+              from: t.build.outputs.bundlePath
+              required: true
+`;
+    const config = parseYaml(text);
+    const build = config.tracks[0]!.tasks[0]!;
+    const testTask = config.tracks[0]!.tasks[1]!;
+    expect(build.outputs!.bundlePath).toEqual({ from: 'json.bundlePath' });
+    expect(testTask.inputs!.bundlePath).toEqual({
+      from: 't.build.outputs.bundlePath',
+      required: true,
+    });
+  });
+
   test('real-world YAML with ports parses cleanly', () => {
     const text = `pipeline:
   name: demo

package/src/schema.ts

@@ -97,7 +97,7 @@ function validateRawTask(task: RawTaskConfig, trackId: string): void {
     throw new Error(`task "${task.id}": cannot have both "prompt" and "command"`);
   }
   // Empty-content tasks (e.g. `prompt: ''`) are allowed at parse time and
-  // flagged as non-fatal validation errors by validate-raw.ts.
+  // flagged as hard validation errors by validate-raw.ts.
 }
 
 // ═══ Config Inheritance Resolution ═══
@@ -161,8 +161,10 @@ export function resolveConfig(raw: RawPipelineConfig, workDir: string): Pipeline
         completion: rawTask.completion,
         agent_profile: rawTask.agent_profile ?? rawTrack.agent_profile,
         cwd: rawTask.cwd ? validatePath(rawTask.cwd, workDir) : trackCwd,
-        // Ports: no inheritance — they describe per-task I/O contract, not
-        // cross-task defaults. Passed through as-is (including `undefined`).
+        // Lightweight bindings and ports: no inheritance — they describe
+        // per-task data flow, not cross-task defaults.
+        inputs: rawTask.inputs,
+        outputs: rawTask.outputs,
         ports: rawTask.ports,
       };
     });
@@ -309,6 +311,8 @@ export function deresolvePipeline(config: PipelineConfig, workDir: string): RawP
         ...(task.permissions && !permissionsEqual(task.permissions, track.permissions)
           ? { permissions: task.permissions }
           : {}),
+        ...(task.inputs && Object.keys(task.inputs).length > 0 ? { inputs: task.inputs } : {}),
+        ...(task.outputs && Object.keys(task.outputs).length > 0 ? { outputs: task.outputs } : {}),
         ...(task.ports &&
         ((task.ports.inputs && task.ports.inputs.length > 0) ||
           (task.ports.outputs && task.ports.outputs.length > 0))

package/src/tagma.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, test } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createTagma } from './tagma';
+import type { DriverPlugin, PipelineConfig } from './types';
+
+function makeDir(prefix: string): string {
+  return mkdtempSync(join(tmpdir(), prefix));
+}
+
+function makeDriver(name: string, marker: string[]): DriverPlugin {
+  return {
+    name,
+    capabilities: { sessionResume: false, systemPrompt: false, outputFormat: false },
+    async buildCommand() {
+      marker.push(name);
+      return { args: ['echo', name] };
+    },
+  };
+}
+
+describe('createTagma', () => {
+  test('instances own isolated plugin registries', () => {
+    const seenA: string[] = [];
+    const seenB: string[] = [];
+    const tagmaA = createTagma({ builtins: false });
+    const tagmaB = createTagma({ builtins: false });
+
+    tagmaA.registry.registerPlugin('drivers', 'mock', makeDriver('driver-a', seenA));
+    tagmaB.registry.registerPlugin('drivers', 'mock', makeDriver('driver-b', seenB));
+
+    expect(tagmaA.registry.getHandler<DriverPlugin>('drivers', 'mock').name).toBe('driver-a');
+    expect(tagmaB.registry.getHandler<DriverPlugin>('drivers', 'mock').name).toBe('driver-b');
+    expect(seenA).toEqual([]);
+    expect(seenB).toEqual([]);
+  });
+
+  test('run uses only the instance registry', async () => {
+    const tagma = createTagma({ builtins: false });
+    const dir = makeDir('tagma-instance-run-');
+    try {
+      await expect(
+        tagma.run(
+          {
+            name: 'instance-run',
+            tracks: [
+              {
+                id: 't',
+                name: 'T',
+                tasks: [{ id: 'prompt', name: 'prompt', prompt: 'hello' }],
+              },
+            ],
+          },
+          {
+            cwd: dir,
+            skipPluginLoading: true,
+          },
+        ),
+      ).rejects.toThrow(/driver "opencode" not registered/);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test('validate returns structural pipeline errors without running tasks', () => {
+    const tagma = createTagma({ builtins: false });
+
+    expect(
+      tagma.validate({
+        name: 'invalid',
+        tracks: [
+          {
+            id: 't',
+            name: 'T',
+            tasks: [
+              { id: 'a', name: 'A', command: 'echo a', depends_on: ['missing'] },
+            ],
+          },
+        ],
+      }),
+    ).toEqual(['Task reference "missing" not found']);
+  });
+});

package/src/tagma.ts

@@ -0,0 +1,47 @@
+import { runPipeline, type EngineResult, type RunPipelineOptions } from './engine';
+import { bootstrapBuiltins } from './bootstrap';
+import { PluginRegistry } from './registry';
+import { validateConfig } from './schema';
+import type { PipelineConfig } from './types';
+
+export interface CreateTagmaOptions {
+  /**
+   * Registry used by this SDK instance. Omit to create an isolated registry.
+   */
+  readonly registry?: PluginRegistry;
+  /**
+   * Register built-in drivers/triggers/completions/middlewares into the
+   * instance registry. Defaults to true.
+   */
+  readonly builtins?: boolean;
+}
+
+export interface TagmaRunOptions extends Omit<RunPipelineOptions, 'registry'> {
+  readonly cwd: string;
+}
+
+export interface Tagma {
+  readonly registry: PluginRegistry;
+  run(config: PipelineConfig, options: TagmaRunOptions): Promise<EngineResult>;
+  validate(config: PipelineConfig): readonly string[];
+}
+
+export function createTagma(options: CreateTagmaOptions = {}): Tagma {
+  const registry = options.registry ?? new PluginRegistry();
+  if (options.builtins !== false) {
+    bootstrapBuiltins(registry);
+  }
+
+  return {
+    registry,
+    run(config, { cwd, ...runOptions }) {
+      return runPipeline(config, cwd, {
+        ...runOptions,
+        registry,
+      });
+    },
+    validate(config) {
+      return validateConfig(config);
+    },
+  };
+}

package/src/utils-api.ts

@@ -0,0 +1,8 @@
+export {
+  parseDuration,
+  validatePath,
+  generateRunId,
+  nowISO,
+  truncateForName,
+} from './utils';
+

package/src/validate-raw-ports.test.ts

@@ -38,6 +38,12 @@ function portsErrors(errors: ReturnType<typeof validateRaw>): typeof errors {
   );
 }
 
+function bindingErrors(errors: ReturnType<typeof validateRaw>): typeof errors {
+  return errors.filter(
+    (e) => e.path.includes('.inputs') || e.path.includes('.outputs'),
+  );
+}
+
 // ─── Structural validation (Command Tasks) ───────────────────────────
 
 describe('validateRaw — port structure (command tasks)', () => {
@@ -123,6 +129,66 @@ describe('validateRaw — port structure (command tasks)', () => {
   });
 });
 
+// ─── Lightweight binding validation ──────────────────────────────────
+
+describe('validateRaw — lightweight task bindings', () => {
+  test('accepts top-level inputs for command placeholder references', () => {
+    const errors = errorsFor(
+      commandTask({
+        id: 'a',
+        command: 'echo {{inputs.city}}',
+        inputs: { city: { value: 'Shanghai' } },
+      }),
+    );
+    expect(errors.some((e) => e.message.includes('references "{{inputs.city}}"'))).toBe(false);
+  });
+
+  test('rejects non-object binding maps and entries', () => {
+    const errors = errorsFor(
+      commandTask({
+        id: 'a',
+        inputs: 'bad' as unknown as never,
+        outputs: { ok: 'bad' as unknown as never },
+      }),
+    );
+    const msgs = bindingErrors(errors).map((e) => e.message);
+    expect(msgs.some((m) => /task\.inputs must be an object/.test(m))).toBe(true);
+    expect(msgs.some((m) => /task\.outputs\.ok must be an object/.test(m))).toBe(true);
+  });
+
+  test('rejects invalid binding names and duplicate loose/strict names', () => {
+    const errors = errorsFor(
+      commandTask({
+        id: 'a',
+        inputs: { 'bad-name': { value: 'x' }, city: { value: 'Shanghai' } },
+        outputs: { report: { from: 'stdout' } },
+        ports: {
+          inputs: [{ name: 'city', type: 'string' }],
+          outputs: [{ name: 'report', type: 'string' }],
+        },
+      }),
+    );
+    const msgs = errors.map((e) => e.message);
+    expect(msgs.some((m) => /binding name "bad-name" is invalid/.test(m))).toBe(true);
+    expect(msgs.some((m) => /duplicates strict ports\.inputs/.test(m))).toBe(true);
+    expect(msgs.some((m) => /duplicates strict ports\.outputs/.test(m))).toBe(true);
+  });
+
+  test('fully-qualified binding sources must reference direct dependencies', () => {
+    const errors = validateRaw(
+      pipeline([
+        commandTask({ id: 'up', outputs: { city: {} } }),
+        commandTask({
+          id: 'down',
+          depends_on: [],
+          inputs: { city: { from: 't.up.outputs.city', required: true } },
+        }),
+      ]),
+    );
+    expect(errors.some((e) => /not a direct dependency/.test(e.message))).toBe(true);
+  });
+});
+
 // ─── Input/output separation (Command Tasks) ─────────────────────────
 
 describe('validateRaw — input vs output constraints (command tasks)', () => {

package/src/validate-raw.ts

@@ -538,6 +538,136 @@ function validatePortList(
   }
 }
 
+function validateBindingMap(
+  value: unknown,
+  basePath: string,
+  kind: 'inputs' | 'outputs',
+  errors: ValidationError[],
+): void {
+  if (value === undefined) return;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    errors.push({ path: basePath, message: `task.${kind} must be an object map` });
+    return;
+  }
+
+  const map = value as Record<string, unknown>;
+  for (const [name, rawBinding] of Object.entries(map)) {
+    const path = `${basePath}.${name}`;
+    if (!PORT_NAME_RE.test(name)) {
+      errors.push({
+        path,
+        message: `binding name "${name}" is invalid. Must match /^[A-Za-z_][A-Za-z0-9_]*$/.`,
+      });
+    }
+    if (!rawBinding || typeof rawBinding !== 'object' || Array.isArray(rawBinding)) {
+      errors.push({ path, message: `task.${kind}.${name} must be an object` });
+      continue;
+    }
+    const binding = rawBinding as Record<string, unknown>;
+    if ('from' in binding && typeof binding.from !== 'string') {
+      errors.push({ path: `${path}.from`, message: `task.${kind}.${name}.from must be a string` });
+    }
+    if (kind === 'inputs' && 'required' in binding && typeof binding.required !== 'boolean') {
+      errors.push({
+        path: `${path}.required`,
+        message: `task.inputs.${name}.required must be a boolean`,
+      });
+    }
+    if (kind === 'outputs' && typeof binding.from === 'string') {
+      const source = binding.from;
+      const ok =
+        source === 'stdout' ||
+        source === 'stderr' ||
+        source === 'normalizedOutput' ||
+        /^json\.[A-Za-z_][A-Za-z0-9_]*$/.test(source);
+      if (!ok) {
+        errors.push({
+          path: `${path}.from`,
+          message: `task.outputs.${name}.from must be stdout, stderr, normalizedOutput, or json.<key>`,
+        });
+      }
+    }
+  }
+}
+
+function validateBindingPortNameOverlap(
+  task: RawTaskConfig,
+  taskPath: string,
+  errors: ValidationError[],
+): void {
+  const looseInputs = objectKeys(task.inputs);
+  const looseOutputs = objectKeys(task.outputs);
+  const strictInputs = new Set(
+    Array.isArray(task.ports?.inputs) ? task.ports.inputs.map((p) => p?.name) : [],
+  );
+  const strictOutputs = new Set(
+    Array.isArray(task.ports?.outputs) ? task.ports.outputs.map((p) => p?.name) : [],
+  );
+
+  for (const name of looseInputs) {
+    if (strictInputs.has(name)) {
+      errors.push({
+        path: `${taskPath}.inputs.${name}`,
+        message: `task input binding "${name}" duplicates strict ports.inputs; choose one layer for this name`,
+      });
+    }
+  }
+  for (const name of looseOutputs) {
+    if (strictOutputs.has(name)) {
+      errors.push({
+        path: `${taskPath}.outputs.${name}`,
+        message: `task output binding "${name}" duplicates strict ports.outputs; choose one layer for this name`,
+      });
+    }
+  }
+}
+
+function objectKeys(value: unknown): string[] {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return [];
+  return Object.keys(value as Record<string, unknown>);
+}
+
+function validateInputBindingSources(
+  task: RawTaskConfig,
+  trackId: string,
+  taskPath: string,
+  index: TaskIndex,
+  errors: ValidationError[],
+): void {
+  if (!task.inputs || typeof task.inputs !== 'object' || Array.isArray(task.inputs)) return;
+  for (const [name, rawBinding] of Object.entries(task.inputs)) {
+    if (!rawBinding || typeof rawBinding !== 'object' || Array.isArray(rawBinding)) continue;
+    const source = (rawBinding as Record<string, unknown>).from;
+    if (typeof source !== 'string') continue;
+    const upstreamId = bindingSourceTaskId(source);
+    if (!upstreamId) continue;
+    const deps = task.depends_on ?? [];
+    const isDirectDep = deps.some((dep) => {
+      const resolved = resolveTaskRef(dep, trackId, index);
+      return resolved.kind === 'resolved' && resolved.qid === upstreamId;
+    });
+    if (!isDirectDep) {
+      errors.push({
+        path: `${taskPath}.inputs.${name}.from`,
+        message: `Task "${task.id}": input binding "${name}" from "${source}" references task "${upstreamId}" which is not a direct dependency (must be listed in depends_on)`,
+      });
+    }
+  }
+}
+
+function bindingSourceTaskId(source: string): string | null {
+  const outputMarker = '.outputs.';
+  const outputIdx = source.lastIndexOf(outputMarker);
+  if (outputIdx > 0) return source.slice(0, outputIdx);
+  for (const field of ['stdout', 'stderr', 'normalizedOutput', 'exitCode']) {
+    const suffix = `.${field}`;
+    if (source.endsWith(suffix) && source.length > suffix.length) {
+      return source.slice(0, -suffix.length);
+    }
+  }
+  return null;
+}
+
 function validateTaskPorts(
   task: RawTaskConfig,
   trackId: string,
@@ -550,6 +680,11 @@ function validateTaskPorts(
   const isPromptTask = typeof task.prompt === 'string' && typeof task.command !== 'string';
   const isCommandTask = typeof task.command === 'string' && typeof task.prompt !== 'string';
 
+  validateBindingMap(task.inputs, `${taskPath}.inputs`, 'inputs', errors);
+  validateBindingMap(task.outputs, `${taskPath}.outputs`, 'outputs', errors);
+  validateBindingPortNameOverlap(task, taskPath, errors);
+  validateInputBindingSources(task, trackId, taskPath, index, errors);
+
   // ─── Prompt tasks do not declare ports ──
   //
   // A Prompt Task's I/O contract is inferred from direct-neighbor
@@ -585,6 +720,7 @@ function validateTaskPorts(
   let availableInputs: Set<string>;
   if (isPromptTask) {
     availableInputs = collectUpstreamCommandOutputNames(task, trackId, qidIndex, index);
+    for (const name of objectKeys(task.inputs)) availableInputs.add(name);
   } else {
     // Command Task (or the pathological both-keys case, which is caught
     // earlier as a separate error — tolerate it here).
@@ -593,6 +729,7 @@ function validateTaskPorts(
         ? ports.inputs.filter((p): p is PortDef => !!p && typeof p === 'object').map((p) => p.name)
         : [],
     );
+    for (const name of objectKeys(task.inputs)) availableInputs.add(name);
   }
 
   for (const name of referenced) {

package/src/yaml.ts

@@ -0,0 +1,11 @@
+export {
+  parseYaml,
+  resolveConfig,
+  loadPipeline,
+  serializePipeline,
+  deresolvePipeline,
+  validateConfig,
+} from './schema';
+export { compileYamlContent } from './yaml-compiler';
+export type { YamlCompileResult, CompileYamlOptions } from './yaml-compiler';
+

package/dist/sdk.d.ts

@@ -1,32 +0,0 @@
-export { runPipeline, TriggerBlockedError, TriggerTimeoutError } from './engine';
-export type { EngineResult, RunPipelineOptions, RunEventPayload } from './engine';
-export { PipelineRunner } from './pipeline-runner';
-export type { PipelineRunnerStatus } from './pipeline-runner';
-export { createEmptyPipeline, setPipelineField, upsertTrack, removeTrack, moveTrack, updateTrack, upsertTask, removeTask, moveTask, transferTask, } from './config-ops';
-export { validateRaw } from './validate-raw';
-export type { ValidationError, KnownPluginTypes } from './validate-raw';
-export { compileYamlContent } from './yaml-compiler';
-export type { YamlCompileResult, CompileYamlOptions } from './yaml-compiler';
-export { parseYaml, resolveConfig, loadPipeline, serializePipeline, deresolvePipeline, validateConfig, } from './schema';
-export { buildDag, buildRawDag } from './dag';
-export type { DagNode, Dag, RawDagNode, RawDag } from './dag';
-export { bootstrapBuiltins } from './bootstrap';
-export { PluginRegistry, defaultRegistry, loadPlugins, registerPlugin, unregisterPlugin, getHandler, hasHandler, listRegistered, isValidPluginName, PLUGIN_NAME_RE, readPluginManifest, } from './registry';
-export type { RegisterResult } from './registry';
-export { InMemoryApprovalGateway } from './approval';
-export type { ApprovalGateway, ApprovalRequest, ApprovalDecision, ApprovalOutcome, ApprovalEvent, ApprovalListener, } from './approval';
-export { attachStdinApprovalAdapter } from './adapters/stdin-approval';
-export type { StdinApprovalAdapter } from './adapters/stdin-approval';
-export { attachWebSocketApprovalAdapter } from './adapters/websocket-approval';
-export type { WebSocketApprovalAdapter, WebSocketApprovalAdapterOptions, } from './adapters/websocket-approval';
-export { Logger, tailLines, clip } from './logger';
-export type { LogRecord, LogLevel, LogListener } from './logger';
-export type { HookResult, PipelineInfo, TrackInfo, TaskInfo } from './hooks';
-export { parseDuration, validatePath, generateRunId, nowISO, truncateForName, _resetShellCache, } from './utils';
-export { TASK_ID_RE, isValidTaskId, qualifyTaskId, isQualifiedRef, buildTaskIndex, resolveTaskRef, AMBIGUOUS, } from './task-ref';
-export type { TaskIndex, RefResolution } from './task-ref';
-export { promptDocumentFromString, serializePromptDocument, appendContext, prependContext, renderInputsBlock, renderOutputSchemaBlock, } from './prompt-doc';
-export { substituteInputs, extractInputReferences, resolveTaskInputs, extractTaskOutputs, inferPromptPorts, } from './ports';
-export type { SubstituteResult, InputResolution, ExtractResult, PromptPortInference, PromptPortConflict, PromptUpstreamNeighbor, PromptDownstreamNeighbor, } from './ports';
-export * from './types';
-//# sourceMappingURL=sdk.d.ts.map

package/dist/sdk.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sdk.d.ts","sourceRoot":"","sources":["../src/sdk.ts"],"names":[],"mappings":"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"}

package/dist/sdk.js

@@ -1,41 +0,0 @@
-// ═══ tagma-sdk public API ═══
-//
-// This is the SDK entry point. Import from here, not from internal modules.
-// The CLI (src/index.ts in the CLI project) also imports from here.
-// ── Core engine ──
-export { runPipeline, TriggerBlockedError, TriggerTimeoutError } from './engine';
-// ── Pipeline runner (multi-pipeline lifecycle management) ──
-export { PipelineRunner } from './pipeline-runner';
-// ── Raw config CRUD (visual editor / YAML sync) ──
-export { createEmptyPipeline, setPipelineField, upsertTrack, removeTrack, moveTrack, updateTrack, upsertTask, removeTask, moveTask, transferTask, } from './config-ops';
-// ── Raw config validation (real-time feedback) ──
-export { validateRaw } from './validate-raw';
-// ── YAML compiler (validation + compile log support) ──
-export { compileYamlContent } from './yaml-compiler';
-// ── Schema: parse / resolve / load / serialize / validate ──
-export { parseYaml, resolveConfig, loadPipeline, serializePipeline, deresolvePipeline, validateConfig, } from './schema';
-// ── DAG ──
-export { buildDag, buildRawDag } from './dag';
-// ── Plugin registry ──
-export { bootstrapBuiltins } from './bootstrap';
-export { PluginRegistry, defaultRegistry, loadPlugins, registerPlugin, unregisterPlugin, getHandler, hasHandler, listRegistered, isValidPluginName, PLUGIN_NAME_RE, readPluginManifest, } from './registry';
-// ── Approval gateway ──
-export { InMemoryApprovalGateway } from './approval';
-// ── Approval adapters ──
-export { attachStdinApprovalAdapter } from './adapters/stdin-approval';
-export { attachWebSocketApprovalAdapter } from './adapters/websocket-approval';
-// ── Logger ──
-export { Logger, tailLines, clip } from './logger';
-// ── Utils (public subset) ──
-export { parseDuration, validatePath, generateRunId, nowISO, truncateForName, _resetShellCache, } from './utils';
-// ── Task reference resolution (shared id normalization) ──
-export { TASK_ID_RE, isValidTaskId, qualifyTaskId, isQualifiedRef, buildTaskIndex, resolveTaskRef, AMBIGUOUS, } from './task-ref';
-// ── Prompt document helpers (middleware authors + drivers) ──
-export { promptDocumentFromString, serializePromptDocument, appendContext, prependContext, renderInputsBlock, renderOutputSchemaBlock, } from './prompt-doc';
-// ── Task ports (editor: substitute placeholders, resolve upstream
-//    values, extract downstream outputs; drivers that wrap the prompt
-//    may want substituteInputs on their own envelope) ──
-export { substituteInputs, extractInputReferences, resolveTaskInputs, extractTaskOutputs, inferPromptPorts, } from './ports';
-// ── All types from @tagma/types + runtime constants ──
-export * from './types';
-//# sourceMappingURL=sdk.js.map

package/dist/sdk.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sdk.js","sourceRoot":"","sources":["../src/sdk.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,EAAE;AACF,4EAA4E;AAC5E,oEAAoE;AAEpE,oBAAoB;AACpB,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAGjF,8DAA8D;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGnD,oDAAoD;AACpD,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,WAAW,EACX,WAAW,EACX,SAAS,EACT,WAAW,EACX,UAAU,EACV,UAAU,EACV,QAAQ,EACR,YAAY,GACb,MAAM,cAAc,CAAC;AAEtB,mDAAmD;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAG7C,yDAAyD;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAGrD,8DAA8D;AAC9D,OAAO,EACL,SAAS,EACT,aAAa,EACb,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,GACf,MAAM,UAAU,CAAC;AAElB,YAAY;AACZ,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAG9C,wBAAwB;AACxB,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EACL,cAAc,EACd,eAAe,EACf,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,UAAU,EACV,UAAU,EACV,cAAc,EACd,iBAAiB,EACjB,cAAc,EACd,kBAAkB,GACnB,MAAM,YAAY,CAAC;AAGpB,yBAAyB;AACzB,OAAO,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAUrD,0BAA0B;AAC1B,OAAO,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AAEvE,OAAO,EAAE,8BAA8B,EAAE,MAAM,+BAA+B,CAAC;AAM/E,eAAe;AACf,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAMnD,8BAA8B;AAC9B,OAAO,EACL,aAAa,EACb,YAAY,EACZ,aAAa,EACb,MAAM,EACN,eAAe,EACf,gBAAgB,GACjB,MAAM,SAAS,CAAC;AAEjB,4DAA4D;AAC5D,OAAO,EACL,UAAU,EACV,aAAa,EACb,aAAa,EACb,cAAc,EACd,cAAc,EACd,cAAc,EACd,SAAS,GACV,MAAM,YAAY,CAAC;AAGpB,+DAA+D;AAC/D,OAAO,EACL,wBAAwB,EACxB,uBAAuB,EACvB,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,cAAc,CAAC;AAEtB,mEAAmE;AACnE,sEAAsE;AACtE,yDAAyD;AACzD,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,SAAS,CAAC;AAWjB,wDAAwD;AACxD,cAAc,SAAS,CAAC"}