@crouton-kit/capture 1.3.21 → 1.4.0

package/src/contracts/results.ts

@@ -1,208 +0,0 @@
-/**
- * Frozen result-lane contracts (U1). Two lanes only:
- *
- *  - `bounded:<domain>`  — one typed projection through the bounded output
- *    kernel: at most {@link MAX_BOUNDED_BYTES} UTF-8 bytes independently in
- *    prose and JSON, with fixed identity/summary/scope/coverage/count/artifact
- *    metadata that is NEVER dropped, and optional records removed only at
- *    record boundaries (never byte-sliced) until both encodings fit.
- *  - `exact-raw:<payload>` — handler-produced bytes/text for one named payload,
- *    unbounded and preserved exactly (including final-newline presence); empty
- *    stderr on success. Global `--json` is rejected before effects.
- *
- * This module is type/interface + pure validators only. It imports no print or
- * exit API. The "no direct stdout" rule is a contract on the handlers that
- * produce these values, encoded in the descriptor layer (see `routes.ts`).
- */
-
-import {
-  MAX_BOUNDED_BYTES,
-  OK,
-  ValidationResult,
-  combine,
-  contextualize,
-  fail,
-  isObject,
-  utf8ByteLength,
-} from './primitives.js';
-
-export { MAX_BOUNDED_BYTES };
-
-/** Discriminator for the two public result lanes plus the effect-only branch/launcher rows. */
-export type ResultLaneKind = 'bounded' | 'exact-raw' | 'branch' | 'launcher-metadata';
-
-/** A `bounded:<domain>` lane naming exactly one bounded projection domain. */
-export interface BoundedLane {
-  readonly kind: 'bounded';
-  readonly domain: string;
-  /** The JSON/prose schema name the bounded kernel serializes. */
-  readonly schema: string;
-}
-
-/** An exact raw lane naming its handler-owned unbounded payload. */
-export interface ExactRawLane {
-  readonly kind: 'exact-raw';
-  /** The payload type, e.g. `recorded HAR bytes`. */
-  readonly payload: string;
-}
-
-/** A branch row: help + child assembly, no result. */
-export interface BranchLane {
-  readonly kind: 'branch';
-}
-
-/** The launcher `--version` metadata row. */
-export interface LauncherMetadataLane {
-  readonly kind: 'launcher-metadata';
-}
-
-export type ResultLane = BoundedLane | ExactRawLane | BranchLane | LauncherMetadataLane;
-
-// ---------------------------------------------------------------------------
-// Byte/list bounds descriptor a bounded leaf declares.
-// ---------------------------------------------------------------------------
-
-/**
- * Every bounded leaf declares its collection and byte bounds up front so the
- * registry can reject a growing collection that lacks an omission contract.
- */
-export interface BoundedBounds {
-  /** Independent max UTF-8 bytes of prose and JSON. Always {@link MAX_BOUNDED_BYTES}. */
-  readonly maxBytes: number;
-  /** Max displayed records for the primary collection (e.g. 20). */
-  readonly maxRecords: number;
-  /**
-   * Whether the primary collection can grow with the underlying source. A
-   * growing collection MUST declare `paginated` so a cursor covers every row.
-   */
-  readonly growing: boolean;
-  /** True iff this leaf adopts the immutable-cursor pagination service. */
-  readonly paginated: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Bounded projection payload shape (the kernel's typed input, pre-encoding).
-// ---------------------------------------------------------------------------
-
-/** Fixed metadata every bounded projection carries and never drops when bounding. */
-export interface BoundedFixedMeta {
-  readonly domain: string;
-  readonly schema: string;
-  /** Identity of the subject the projection describes (snapshot id, session id, tree id, …). */
-  readonly identity: Record<string, string>;
-  /** Scope and source coverage (populations/caps/availability), preserved verbatim. */
-  readonly coverage: unknown;
-  /** total/displayed/omitted/limit for the primary collection. */
-  readonly counts: BoundedCollectionCounts;
-  /** Absolute artifact paths a caller can re-read for the exhaustive evidence. */
-  readonly artifacts: readonly string[];
-}
-
-/** total/displayed/omitted/limit accounting for one bounded collection. */
-export interface BoundedCollectionCounts {
-  readonly total: number;
-  readonly displayed: number;
-  readonly omitted: number;
-  readonly limit: number;
-  /** Machine-stable reasons the omitted records were dropped (e.g. `byte-bound`, `record-limit`). */
-  readonly omissionCauses: readonly string[];
-}
-
-/**
- * A capped string reports byte accounting and an exact RFC-6901 pointer into
- * the exhaustive artifact rather than silently truncating.
- */
-export interface CappedStringMeta {
-  readonly sourceBytes: number;
-  readonly displayedBytes: number;
-  readonly omittedBytes: number;
-  /** Absolute artifact path + RFC-6901 JSON Pointer to the full value. */
-  readonly artifactPath: string;
-  readonly jsonPointer: string;
-}
-
-/**
- * A structured public error (bounded, factual). Written to stderr by the result
- * owner, never by a handler. Exit 2 = invalid route/grammar/selection/cursor
- * input; exit 3 = source/runtime/publication failure.
- */
-export interface BoundedError {
-  readonly message: string;
-  readonly exit: 2 | 3;
-  readonly details?: Record<string, unknown>;
-}
-
-// ---------------------------------------------------------------------------
-// Validators.
-// ---------------------------------------------------------------------------
-
-export function validateResultLane(lane: ResultLane): ValidationResult {
-  switch (lane.kind) {
-    case 'bounded':
-      if (!lane.domain) return fail('bounded lane missing domain');
-      if (!lane.schema) return fail('bounded lane missing schema');
-      return OK;
-    case 'exact-raw':
-      if (!lane.payload) return fail('exact-raw lane missing payload type');
-      return OK;
-    case 'branch':
-    case 'launcher-metadata':
-      return OK;
-    default:
-      return fail(`unknown result lane kind: ${(lane as { kind: string }).kind}`);
-  }
-}
-
-export function validateBoundedBounds(bounds: BoundedBounds): ValidationResult {
-  const errs: ValidationResult[] = [];
-  if (bounds.maxBytes !== MAX_BOUNDED_BYTES) {
-    errs.push(fail(`bounded maxBytes must be ${MAX_BOUNDED_BYTES}, got ${bounds.maxBytes}`));
-  }
-  if (!(bounds.maxRecords >= 0)) errs.push(fail('bounded maxRecords must be >= 0'));
-  if (bounds.growing && !bounds.paginated) {
-    errs.push(fail('a growing bounded collection must declare pagination (cursor coverage)'));
-  }
-  return combine(...errs);
-}
-
-/** True iff both encodings fit the independent byte bound. */
-export function fitsBoundedBounds(prose: string, json: string): ValidationResult {
-  const errs: ValidationResult[] = [];
-  const p = utf8ByteLength(prose);
-  const j = utf8ByteLength(json);
-  if (p > MAX_BOUNDED_BYTES) errs.push(fail(`prose is ${p} bytes, exceeds ${MAX_BOUNDED_BYTES}`));
-  if (j > MAX_BOUNDED_BYTES) errs.push(fail(`json is ${j} bytes, exceeds ${MAX_BOUNDED_BYTES}`));
-  return combine(...errs);
-}
-
-/** Validate collection counts are internally consistent: displayed+omitted==total, displayed<=limit. */
-export function validateCollectionCounts(counts: BoundedCollectionCounts): ValidationResult {
-  const errs: ValidationResult[] = [];
-  if (counts.displayed + counts.omitted !== counts.total) {
-    errs.push(fail(`displayed(${counts.displayed}) + omitted(${counts.omitted}) != total(${counts.total})`));
-  }
-  if (counts.displayed > counts.limit) {
-    errs.push(fail(`displayed(${counts.displayed}) exceeds limit(${counts.limit})`));
-  }
-  if (counts.omitted > 0 && counts.omissionCauses.length === 0) {
-    errs.push(fail('omitted records present but no omissionCauses declared'));
-  }
-  return combine(...errs);
-}
-
-/** Validate the fixed metadata block that must precede any bounded records. */
-export function validateBoundedFixedMeta(meta: unknown): ValidationResult {
-  if (!isObject(meta)) return fail('bounded fixed meta must be an object');
-  const errs: ValidationResult[] = [];
-  if (typeof meta.domain !== 'string' || !meta.domain) errs.push(fail('missing domain'));
-  if (typeof meta.schema !== 'string' || !meta.schema) errs.push(fail('missing schema'));
-  if (!isObject(meta.identity)) errs.push(fail('missing identity object'));
-  if (!('coverage' in meta)) errs.push(fail('missing coverage'));
-  if (!Array.isArray(meta.artifacts)) errs.push(fail('artifacts must be an array of absolute paths'));
-  if (isObject(meta.counts)) {
-    errs.push(contextualize('counts', validateCollectionCounts(meta.counts as BoundedCollectionCounts)));
-  } else {
-    errs.push(fail('missing counts'));
-  }
-  return combine(...errs);
-}

package/src/contracts/routes.ts

@@ -1,140 +0,0 @@
-/**
- * Frozen public route/leaf descriptor contract. A descriptor is the sole truth
- * for one canonical public path. It names inputs, effects, output lane, bounds,
- * stderr, exits, and an opaque handler slot; it never imports a handler.
- */
-import { OK, ValidationResult, combine, contextualize, fail } from './primitives.js';
-import { BoundedBounds, ResultLane, validateBoundedBounds, validateResultLane } from './results.js';
-
-export interface RouteEffects {
-  readonly browser: boolean;
-  readonly session: boolean;
-  readonly artifact: boolean;
-  readonly environment: boolean;
-}
-export const NO_EFFECTS: RouteEffects = { browser: false, session: false, artifact: false, environment: false };
-
-export interface PositionalSpec { readonly name: string; readonly grammar: string; readonly required: boolean; readonly variadic?: boolean; }
-export interface FlagSpec {
-  readonly name: string;
-  readonly grammar: string | 'boolean';
-  /** Required singleton unless repeatable is explicitly declared. */
-  readonly required?: boolean;
-  /** Repetition is accepted; required means at least one occurrence. */
-  readonly repeatable?: boolean;
-  readonly values?: readonly string[];
-  readonly default?: string | number | boolean;
-  readonly units?: string;
-}
-export type StderrPolicy = 'empty-on-success' | 'declared-progress';
-export type LeafExit = 0 | 2 | 3 | 10 | 11 | 130 | 143;
-
-export interface BranchDescriptor { readonly kind: 'branch'; readonly path: string; readonly summary: string; }
-export interface LeafDescriptor {
-  readonly kind: 'leaf'; readonly path: string; readonly summary: string;
-  readonly positionals: readonly PositionalSpec[]; readonly flags: readonly FlagSpec[];
-  readonly mutualExclusions: readonly (readonly string[])[]; readonly effects: RouteEffects;
-  readonly result: ResultLane; readonly bounds?: BoundedBounds; readonly stderr: StderrPolicy;
-  readonly exits: readonly LeafExit[]; readonly handler: string;
-}
-export type RouteDescriptor = BranchDescriptor | LeafDescriptor;
-
-/** All public non-root branches in the seven-noun Capture topology. */
-export const EXPECTED_BRANCH_PATHS: readonly string[] = [
-  'session', 'page', 'measure', 'measure map', 'measure variation', 'motion',
-  'traffic', 'traffic har', 'browser', 'library',
-];
-
-/** Every public runnable path, exactly once. There are no aliases. */
-export const EXPECTED_LEAF_PATHS: readonly string[] = [
-  'session start', 'session stop', 'session list', 'session view', 'session log',
-  'page a11y', 'page screenshot', 'page click', 'page type', 'page navigate', 'page exec',
-  'measure snap', 'measure check', 'measure geometry', 'measure map focus', 'measure map scroll', 'measure map layers', 'measure explain', 'measure variation diff', 'measure variation census', 'measure variation sweep',
-  'motion rec', 'motion mask', 'motion timeline', 'motion jank', 'motion response',
-  'traffic record', 'traffic har create', 'traffic har read', 'traffic har delete',
-  'browser detect', 'browser list', 'browser open', 'browser reset', 'browser network', 'browser cdp',
-  'library list', 'library search', 'library show', 'library read',
-];
-
-export const PAGINATED_LEAF_PATHS: readonly string[] = [
-  'browser detect', 'browser list', 'library list', 'library search', 'library show',
-];
-
-/** Exact raw leaves are handler-owned bytes/text, never global JSON envelopes. */
-export const EXACT_RAW_LEAF_PAYLOADS: Readonly<Record<string, string>> = {
-  'session log': 'recorded session log bytes',
-  'page a11y': 'full accessibility-tree text',
-  'page exec': 'handler evaluation bytes/text',
-  'traffic har read': 'stored HAR bytes',
-  'browser cdp': 'raw protocol response bytes',
-  'library read': 'bundled function source bytes',
-};
-
-/** Legacy spellings are deliberately unreachable after the U15 cutover. */
-export const FORBIDDEN_PUBLIC_PATHS: readonly string[] = [
-  '-v', 'version', 'log', 'detect', 'list', 'open', 'reset-tab', 'screenshot',
-  'click', 'type', 'a11y', 'record', 'navigate', 'network', 'har', 'lib', 'cdp',
-  'exec', 'motion observations', '__bridge-serve',
-];
-
-function flagNames(leaf: LeafDescriptor): Set<string> { return new Set(leaf.flags.map((flag) => flag.name)); }
-
-export function validateLeafDescriptor(leaf: LeafDescriptor): ValidationResult {
-  const errors: ValidationResult[] = [];
-  if (!leaf.path) errors.push(fail('leaf has empty path'));
-  const fixed = leaf.positionals.filter((positional) => !positional.variadic);
-  const required = fixed.filter((positional) => positional.required);
-  const optional = fixed.filter((positional) => !positional.required);
-  if (required.length > 1 || optional.length > 1 || fixed.length > 2 || (fixed.length === 2 && (!fixed[0].required || fixed[1].required))) {
-    errors.push(fail(`leaf ${leaf.path} permits only one required positional followed by one optional trailing positional`));
-  }
-  const names = flagNames(leaf);
-  if (names.size !== leaf.flags.length) errors.push(fail(`leaf ${leaf.path} declares duplicate flag names`));
-  for (const flag of leaf.flags) {
-    if (!flag.name.startsWith('--')) errors.push(fail(`leaf ${leaf.path} flag ${flag.name} is not a long option`));
-    if (flag.grammar === 'boolean' && (flag.values || flag.default !== undefined || flag.units)) errors.push(fail(`boolean flag ${flag.name} must not declare value metadata`));
-    if (flag.repeatable && flag.default !== undefined) errors.push(fail(`repeatable flag ${flag.name} must not declare a default`));
-  }
-  for (const group of leaf.mutualExclusions) for (const name of group) if (!names.has(name)) errors.push(fail(`leaf ${leaf.path} mutual-exclusion references undeclared flag ${name}`));
-  errors.push(contextualize(`leaf ${leaf.path} result`, validateResultLane(leaf.result)));
-  if (leaf.result.kind === 'bounded') {
-    if (!leaf.bounds) errors.push(fail(`bounded leaf ${leaf.path} missing byte/list bounds`));
-    else errors.push(contextualize(`leaf ${leaf.path} bounds`, validateBoundedBounds(leaf.bounds)));
-  } else if (leaf.result.kind === 'exact-raw') {
-    if (leaf.bounds) errors.push(fail(`exact raw leaf ${leaf.path} must not declare bounded bounds`));
-    if (leaf.stderr !== 'empty-on-success') errors.push(fail(`exact raw leaf ${leaf.path} must have empty-on-success stderr`));
-  } else errors.push(fail(`leaf ${leaf.path} must use bounded or exact-raw result lane`));
-  if (!leaf.handler) errors.push(fail(`leaf ${leaf.path} missing handler slot`));
-  if (!leaf.exits.length) errors.push(fail(`leaf ${leaf.path} declares no exits`));
-  return combine(...errors);
-}
-
-export function validateBranchDescriptor(branch: BranchDescriptor): ValidationResult {
-  if (!branch.path) return fail('branch has empty path');
-  if ((branch as unknown as { handler?: unknown }).handler !== undefined) return fail(`branch ${branch.path} must not declare a handler`);
-  return OK;
-}
-
-/** Validate an assembled public registry against the canonical seven-noun census. */
-export function validateRegistry(descriptors: readonly RouteDescriptor[]): ValidationResult {
-  const errors: ValidationResult[] = [];
-  const seen = new Set<string>(); const leaves = new Set<string>(); const branches = new Set<string>();
-  for (const descriptor of descriptors) {
-    if (seen.has(descriptor.path)) errors.push(fail(`duplicate route path: ${descriptor.path}`));
-    seen.add(descriptor.path);
-    if (FORBIDDEN_PUBLIC_PATHS.includes(descriptor.path)) errors.push(fail(`forbidden public path present: ${descriptor.path}`));
-    if (descriptor.kind === 'leaf') {
-      leaves.add(descriptor.path); errors.push(validateLeafDescriptor(descriptor));
-      const expectedPayload = EXACT_RAW_LEAF_PAYLOADS[descriptor.path];
-      if (expectedPayload && (descriptor.result.kind !== 'exact-raw' || descriptor.result.payload !== expectedPayload)) errors.push(fail(`leaf ${descriptor.path} must be exact-raw:${expectedPayload}`));
-      if (!expectedPayload && descriptor.result.kind === 'exact-raw') errors.push(fail(`leaf ${descriptor.path} is not declared exact-raw by the public output contract`));
-      const paginated = descriptor.result.kind === 'bounded' && descriptor.bounds?.paginated === true;
-      if (PAGINATED_LEAF_PATHS.includes(descriptor.path) !== paginated) errors.push(fail(`leaf ${descriptor.path} pagination declaration disagrees with census`));
-    } else { branches.add(descriptor.path); errors.push(validateBranchDescriptor(descriptor)); }
-  }
-  for (const path of EXPECTED_LEAF_PATHS) if (!leaves.has(path)) errors.push(fail(`missing expected leaf path: ${path}`));
-  for (const path of EXPECTED_BRANCH_PATHS) if (!branches.has(path)) errors.push(fail(`missing expected branch path: ${path}`));
-  for (const path of leaves) if (!EXPECTED_LEAF_PATHS.includes(path)) errors.push(fail(`unexpected leaf path (not in census): ${path}`));
-  for (const path of branches) if (!EXPECTED_BRANCH_PATHS.includes(path)) errors.push(fail(`unexpected branch path (not in census): ${path}`));
-  return combine(...errors);
-}

package/src/output/exact-raw.ts

@@ -1,114 +0,0 @@
-/**
- * Leaf-owned exact-raw output foundation. It deliberately has no structured
- * fallback: successful payloads are written exactly as their handler supplied
- * them, and global --json is rejected before the handler can perform effects.
- */
-import { OK, type ValidationResult, fail } from '../contracts/primitives.js';
-
-export type ExactRawPayload = string | Uint8Array;
-
-/** The only two public leaf output modes at the hard cut. */
-export type LeafOutputMode = 'structured-json-capable' | 'exact-raw-json-rejected';
-
-export interface StructuredOutputOwner {
-  readonly mode: 'structured-json-capable';
-  readonly canonicalPath: string;
-}
-
-export interface ExactRawOutputOwner {
-  readonly mode: 'exact-raw-json-rejected';
-  readonly canonicalPath: string;
-  readonly payloadType: string;
-  readonly size: 'unbounded';
-}
-
-export type LeafOutputOwner = StructuredOutputOwner | ExactRawOutputOwner;
-
-/** The fixed exhaustive public output-mode matrix. */
-export const PUBLIC_OUTPUT_OWNERS: readonly LeafOutputOwner[] = [
-  ...['session start', 'session stop', 'session list', 'session view'].map((canonicalPath) => ({ mode: 'structured-json-capable' as const, canonicalPath })),
-  ...['page screenshot', 'page click', 'page type', 'page navigate'].map((canonicalPath) => ({ mode: 'structured-json-capable' as const, canonicalPath })),
-  ...['measure snap', 'measure check', 'measure geometry', 'measure map focus', 'measure map scroll', 'measure map layers', 'measure explain', 'measure variation diff', 'measure variation census', 'measure variation sweep'].map((canonicalPath) => ({ mode: 'structured-json-capable' as const, canonicalPath })),
-  ...['motion rec', 'motion mask', 'motion timeline', 'motion jank', 'motion response'].map((canonicalPath) => ({ mode: 'structured-json-capable' as const, canonicalPath })),
-  ...['traffic record', 'traffic har create', 'traffic har delete'].map((canonicalPath) => ({ mode: 'structured-json-capable' as const, canonicalPath })),
-  ...['browser detect', 'browser list', 'browser open', 'browser reset', 'browser network'].map((canonicalPath) => ({ mode: 'structured-json-capable' as const, canonicalPath })),
-  ...['library list', 'library search', 'library show'].map((canonicalPath) => ({ mode: 'structured-json-capable' as const, canonicalPath })),
-  { mode: 'exact-raw-json-rejected', canonicalPath: 'session log', payloadType: 'recorded session log bytes', size: 'unbounded' },
-  { mode: 'exact-raw-json-rejected', canonicalPath: 'page a11y', payloadType: 'full accessibility-tree text', size: 'unbounded' },
-  { mode: 'exact-raw-json-rejected', canonicalPath: 'page exec', payloadType: 'handler evaluation bytes/text', size: 'unbounded' },
-  { mode: 'exact-raw-json-rejected', canonicalPath: 'traffic har read', payloadType: 'stored HAR bytes', size: 'unbounded' },
-  { mode: 'exact-raw-json-rejected', canonicalPath: 'browser cdp', payloadType: 'raw protocol response bytes', size: 'unbounded' },
-  { mode: 'exact-raw-json-rejected', canonicalPath: 'library read', payloadType: 'bundled function source bytes', size: 'unbounded' },
-];
-
-/** Validate a registry's exhaustive output-mode partition before route effects are bound. */
-export function validateLeafOutputOwners(owners: readonly LeafOutputOwner[]): ValidationResult {
-  const expected = new Map(PUBLIC_OUTPUT_OWNERS.map((owner) => [owner.canonicalPath, owner]));
-  const paths = new Set<string>();
-  const errors: string[] = [];
-  for (const owner of owners) {
-    if (!owner.canonicalPath) errors.push('output owner has empty canonical path');
-    if (paths.has(owner.canonicalPath)) errors.push(`duplicate output owner path: ${owner.canonicalPath}`);
-    paths.add(owner.canonicalPath);
-    const required = expected.get(owner.canonicalPath);
-    if (!required) { errors.push(`unexpected output owner path: ${owner.canonicalPath}`); continue; }
-    if (owner.mode !== required.mode) { errors.push(`wrong output mode for ${owner.canonicalPath}`); continue; }
-    if (owner.mode === 'exact-raw-json-rejected' && (owner.payloadType !== required.payloadType || owner.size !== 'unbounded')) {
-      errors.push(`wrong exact raw declaration for ${owner.canonicalPath}`);
-    }
-  }
-  for (const path of expected.keys()) if (!paths.has(path)) errors.push(`missing output owner path: ${path}`);
-  return errors.length === 0 ? OK : fail(...errors);
-}
-
-export interface ExactRawJsonRejection {
-  readonly code: 'output_mode_unsupported';
-  readonly field: '--json';
-  readonly expected: 'omit --json for exact raw output';
-  readonly next_action: string;
-}
-
-export interface ExactRawLeaf {
-  readonly canonicalPath: string;
-  readonly argv: readonly string[];
-  /** The leaf handler; callers must put all effects inside this callback. */
-  readonly produce: () => ExactRawPayload | Promise<ExactRawPayload>;
-}
-
-export type ExactRawRunResult =
-  | { readonly ok: true }
-  | { readonly ok: false; readonly error: ExactRawJsonRejection };
-
-export function exactRawJsonRejection(canonicalPath: string): ExactRawJsonRejection {
-  if (!canonicalPath) throw new Error('canonical exact-raw path must not be empty');
-  return {
-    code: 'output_mode_unsupported',
-    field: '--json',
-    expected: 'omit --json for exact raw output',
-    next_action: `run ${canonicalPath} -h`,
-  };
-}
-
-/** True only for the global JSON switch, never for payload text that resembles it. */
-export function rejectsGlobalJson(argv: readonly string[]): boolean {
-  for (const token of argv) {
-    if (token === '--') return false;
-    if (token === '--json') return true;
-  }
-  return false;
-}
-
-/** Writes a supplied payload with no newline insertion or any transformation. */
-export function emitExactRaw(payload: ExactRawPayload, write: (chunk: ExactRawPayload) => void = process.stdout.write.bind(process.stdout)): void {
-  write(payload);
-}
-
-/**
- * Execute an exact-raw leaf. `produce` is intentionally unreachable whenever
- * --json is present, giving route adapters a pre-effect validation seam.
- */
-export async function runExactRaw(leaf: ExactRawLeaf, write: (chunk: ExactRawPayload) => void = process.stdout.write.bind(process.stdout)): Promise<ExactRawRunResult> {
-  if (rejectsGlobalJson(leaf.argv)) return { ok: false, error: exactRawJsonRejection(leaf.canonicalPath) };
-  emitExactRaw(await leaf.produce(), write);
-  return { ok: true };
-}