@loomcli/core 0.1.1 → 0.3.0

package/dist/plugin.js

@@ -0,0 +1,278 @@
+import { DeclarationError } from './errors.js';
+import { buildExtensions, isDescriptor, registerDescriptor } from './extension.js';
+import { checkDeprecated, checkDescription, checkHidden, isPlainObject } from './facts.js';
+import { isProcessSignal } from './signals.js';
+import { buildTheme } from './theme.js';
+import { captureConfig, checkDeclarations } from './validation.js';
+/** Authored values register here, so the public type publishes no state to reach or replace. */
+const nodes = new WeakMap();
+/**
+ * The runtime value `plugin()` returns. `Options` appears in a read position alone, which makes it
+ * covariant: a `plugins` list holds plugins with different options the way `views` holds
+ * overrides for different keys, and `Middleware` and `load` accept a narrower plugin.
+ */
+class PluginDeclaration {
+    constructor(node) {
+        nodes.set(this, node);
+        Object.freeze(this);
+    }
+}
+/**
+ * One plugin: an identity and the contributions it carries. Creating and installing the value runs
+ * none of its code: a hook runs at graph build, and the middleware runs inside an invocation, so an
+ * installed plugin an invocation never reaches costs that invocation its hooks alone.
+ */
+function plugin(identity, definition) {
+    const captured = {
+        ...definition,
+        ...(definition?.theme === undefined
+            ? {}
+            : { theme: isPlainObject(definition.theme) ? { ...definition.theme } : definition.theme }),
+    };
+    return new PluginDeclaration({
+        definition: isPlainObject(definition) ? captured : definition,
+        identity,
+    });
+}
+/** How every plugin diagnostic names one plugin at the start of a sentence. */
+function pluginSentence(identity) {
+    return `Plugin "${identity}"`;
+}
+/** Reads the declarations behind an installed value; anything else is a declaration error. */
+function nodeOf(value) {
+    const node = typeof value === 'object' && value !== null ? nodes.get(value) : undefined;
+    if (!node) {
+        throw new DeclarationError('The Application holds a value that is not a plugin. Supply the value returned by plugin(identity, definition).');
+    }
+    return node;
+}
+/** The identity one installed value declares, which is a nonempty string installed once. */
+function readIdentity(node, installed) {
+    const { identity } = node;
+    if (typeof identity !== 'string') {
+        throw new DeclarationError('A plugin declares an identity that is not a string. Supply a nonempty string, such as the package name.');
+    }
+    if (identity === '') {
+        throw new DeclarationError('A plugin declares an empty identity. Supply a nonempty string, such as the package name.');
+    }
+    if (installed.has(identity)) {
+        throw new DeclarationError(`The Application installs plugin "${identity}" twice. Install each plugin once.`);
+    }
+    return identity;
+}
+/** The declarations one plugin value carries, which a JavaScript author reaches as any value. */
+function definitionOf(identity, node) {
+    const { definition } = node;
+    if (!isPlainObject(definition)) {
+        throw new DeclarationError(`${pluginSentence(identity)} declares a definition that is not an object. Supply { options, middleware, extensions, views }.`);
+    }
+    return definition;
+}
+/**
+ * The installed list in composition order, with the rules that read the list itself. The slot is
+ * read defensively, because a JavaScript author reaches it with any value. Each plugin's own
+ * declarations are read by the build steps that consume them, in the order those steps run.
+ */
+function installPlugins(plugins) {
+    if (!Array.isArray(plugins)) {
+        throw new DeclarationError('The Application plugins must be an array. Supply a list of plugin values.');
+    }
+    const installed = [];
+    const identities = new Set();
+    for (const value of plugins) {
+        const node = nodeOf(value);
+        const identity = readIdentity(node, identities);
+        identities.add(identity);
+        installed.push({ declaration: definitionOf(identity, node), identity });
+    }
+    return installed;
+}
+/** The keys a plugin option may not declare, in the order its diagnostic names them. */
+const forbidden = ['validate', 'validateOmitted', 'required'];
+/** The rules a plugin option answers before every rule an ordinary declaration carries. */
+function checkPluginOption(sentence, config) {
+    if (!isPlainObject(config)) {
+        throw new DeclarationError(`${sentence} is not an option declaration. Supply { type, ... }.`);
+    }
+    const rejected = forbidden.find((key) => key in config);
+    if (rejected !== undefined) {
+        throw new DeclarationError(`${sentence} declares ${rejected}. Remove it; a plugin option carries no schema or presence rule, and the middleware interprets the value.`);
+    }
+    checkDescription(sentence, config.description);
+    checkHidden(sentence, config.hidden);
+    checkDeprecated(sentence, config.deprecated);
+}
+/**
+ * One plugin's option declarations, in declaration order. They join the globals table, so the rules
+ * that pair them with another scope's options belong to that table and not to this reading.
+ */
+function readOptions(identity, declared, build) {
+    if (declared !== undefined && !isPlainObject(declared)) {
+        throw new DeclarationError(`${pluginSentence(identity)} declares options that are not an object. Supply a record of option declarations.`);
+    }
+    const inputs = [];
+    for (const [name, config] of Object.entries(declared ?? {})) {
+        const sentence = `${pluginSentence(identity)} option "${name}"`;
+        checkPluginOption(sentence, config);
+        const input = { config: captureConfig(config), kind: 'option', name };
+        // The shared rules name the plugin and the option, so a fault reads with its contributor.
+        checkDeclarations([input], sentence);
+        build.extensions.set(input, buildExtensions({
+            declared: config.extensions,
+            descriptors: build.descriptors,
+            subject: {
+                phrase: `on ${sentence.slice(0, 1).toLowerCase()}${sentence.slice(1)}`,
+                sentence,
+            },
+            target: 'option',
+        }));
+        inputs.push(input);
+    }
+    return inputs;
+}
+/** One activation name, which must be one of the plugin's own declared options. */
+function readActivationName(identity, name, names) {
+    if (typeof name !== 'string' || !names.has(name)) {
+        throw new DeclarationError(`${pluginSentence(identity)} activates middleware on option "${String(name)}", which it does not declare. Name one of the plugin's own options.`);
+    }
+    return name;
+}
+/** The activation a middleware declares, checked against the options its own plugin declares. */
+function readActivation(identity, declared, names) {
+    if (declared === 'always') {
+        return 'always';
+    }
+    if (!Array.isArray(declared)) {
+        throw new DeclarationError(`${pluginSentence(identity)} declares middleware with no activation. Supply activate: 'always' or a list of the plugin's own option names.`);
+    }
+    const list = declared;
+    if (list.length === 0) {
+        throw new DeclarationError(`${pluginSentence(identity)} declares middleware with an empty activation list. Name at least one of the plugin's options or use 'always'.`);
+    }
+    return list.map((name) => readActivationName(identity, name, names));
+}
+/**
+ * The loader a middleware declares. Core calls it with no arguments and reads whatever it resolves
+ * to, so being callable is the whole runtime claim this check makes.
+ */
+function isLoader(value) {
+    return typeof value === 'function';
+}
+/** One plugin's middleware, or `undefined` for a plugin that declares none. */
+function readMiddleware(identity, declared, names) {
+    if (declared === undefined) {
+        return undefined;
+    }
+    if (!isPlainObject(declared)) {
+        throw new DeclarationError(`${pluginSentence(identity)} declares middleware that is not an object. Supply { activate, load }.`);
+    }
+    const activate = readActivation(identity, declared.activate, names);
+    const { load } = declared;
+    if (!isLoader(load)) {
+        throw new DeclarationError(`${pluginSentence(identity)} declares middleware with no load function. Supply load: () => import('./middleware.js').`);
+    }
+    return { activate, load };
+}
+/**
+ * One plugin's claim on the signals slot, drawn from the closed set core installs listeners for.
+ * An empty list claims nothing, so it leaves the slot free for another plugin.
+ * Each signal is claimed once, because core installs one listener per entry and a second listener
+ * on one signal would take the force path on the first signal the run receives.
+ */
+function readSignals(identity, declared) {
+    if (declared === undefined) {
+        return [];
+    }
+    if (!Array.isArray(declared)) {
+        throw new DeclarationError(`${pluginSentence(identity)} declares signals that are not an array. Supply a list of signal names.`);
+    }
+    const list = declared;
+    const claimed = new Set();
+    for (const value of list) {
+        if (!isProcessSignal(value)) {
+            throw new DeclarationError(`${pluginSentence(identity)} claims signal "${String(value)}". Claim SIGINT or SIGTERM.`);
+        }
+        if (claimed.has(value)) {
+            throw new DeclarationError(`${pluginSentence(identity)} claims signal "${value}" twice. Claim each signal once.`);
+        }
+        claimed.add(value);
+    }
+    return [...claimed];
+}
+/**
+ * A lifecycle hook is a function core calls at one named point, so being callable is the whole
+ * claim this check makes; every rule the calls it makes carry belongs to the build that calls it.
+ */
+function isHook(value) {
+    return typeof value === 'function';
+}
+/** One plugin's `onCommandAttach` hook, or `undefined` for a plugin that declares none. */
+function readHook(identity, declared) {
+    if (declared === undefined) {
+        return undefined;
+    }
+    if (!isHook(declared)) {
+        throw new DeclarationError(`${pluginSentence(identity)} declares onCommandAttach that is not a function. Supply a function of the Command.`);
+    }
+    return declared;
+}
+/** A plugin's own list names the extensions it defines, before any declaration carries one. */
+function defineExtensions(identity, declaration, build) {
+    const { extensions } = declaration;
+    if (extensions !== undefined && !Array.isArray(extensions)) {
+        throw new DeclarationError(`${pluginSentence(identity)} declares extensions that are not an array. Supply a list of extension descriptors.`);
+    }
+    for (const descriptor of extensions ?? []) {
+        if (!isDescriptor(descriptor)) {
+            throw new DeclarationError(`${pluginSentence(identity)} holds a value that is not an extension. Supply the value returned by extension(identity, config).`);
+        }
+        registerDescriptor(build.descriptors, descriptor);
+    }
+}
+/**
+ * Every installed plugin's declarations, in installation order. A plugin's own extensions register
+ * before any declaration carries a value, so a duplicated package copy is reported from the list
+ * that installed it.
+ */
+function buildPlugins(installed, build) {
+    /**
+     * The signals slot has one owner, so the first plugin to claim it names the second claimant's
+     * diagnostic. An empty claim leaves the slot free.
+     */
+    let owner = undefined;
+    let themeOwner = undefined;
+    return installed.map(({ declaration, identity }) => {
+        let theme = undefined;
+        if (declaration.theme !== undefined) {
+            if (themeOwner !== undefined) {
+                throw new DeclarationError(`${pluginSentence(identity)} claims the theme slot, which plugin "${themeOwner}" already holds. Install one owner.`);
+            }
+            theme = buildTheme(declaration.theme, identity);
+            themeOwner = identity;
+        }
+        defineExtensions(identity, declaration, build);
+        const inputs = readOptions(identity, declaration.options, build);
+        const names = new Set(inputs.map((input) => input.name));
+        const signals = readSignals(identity, declaration.signals);
+        if (signals.length > 0) {
+            if (owner !== undefined) {
+                throw new DeclarationError(`${pluginSentence(identity)} claims the signals slot, which plugin "${owner}" already holds. Install one owner.`);
+            }
+            owner = identity;
+        }
+        return {
+            identity,
+            inputs,
+            middleware: readMiddleware(identity, declaration.middleware, names),
+            onCommandAttach: readHook(identity, declaration.onCommandAttach),
+            signals,
+            theme,
+            views: declaration.views,
+        };
+    });
+}
+/** The signals the one slot owner claimed, or none when no installed plugin claims the slot. */
+function ownedSignals(plugins) {
+    return plugins.find((entry) => entry.signals.length > 0)?.signals ?? [];
+}
+export { buildPlugins, installPlugins, ownedSignals, plugin, pluginSentence };

package/dist/rendering.d.ts

@@ -0,0 +1,21 @@
+import type { Host } from './types.js';
+type SwitchPolicy = 'auto' | 'always' | 'never';
+interface RenderingPolicy {
+    color?: SwitchPolicy | undefined;
+    modifiers?: SwitchPolicy | undefined;
+    hyperlinks?: SwitchPolicy | undefined;
+    terminalControls?: 'strip' | 'preserve' | undefined;
+}
+interface Capabilities {
+    color: boolean;
+    modifiers: boolean;
+    hyperlinks: boolean;
+    terminalControls: boolean;
+    depth: 16 | 256 | 'truecolor';
+    mainGlyphs: boolean;
+}
+declare function renderingPolicy(value: unknown): RenderingPolicy;
+/** A run owns captured facts; stdout and stderr each resolve this one policy independently. */
+declare function capabilities(host: Host, destination: 'stdout' | 'stderr', policy: RenderingPolicy): Capabilities;
+export type { Capabilities, RenderingPolicy };
+export { capabilities, renderingPolicy };

package/dist/rendering.js

@@ -0,0 +1,72 @@
+import { DeclarationError } from './errors.js';
+import { isPlainObject } from './facts.js';
+function renderingPolicy(value) {
+    if (value === undefined) {
+        return {};
+    }
+    if (!isPlainObject(value)) {
+        throw new DeclarationError('The rendering policy must be an object.');
+    }
+    const result = {};
+    for (const field of ['color', 'modifiers', 'hyperlinks']) {
+        const policy = value[field];
+        if (policy !== undefined && policy !== 'auto' && policy !== 'always' && policy !== 'never') {
+            throw new DeclarationError(`Rendering ${field} must be auto, always, or never.`);
+        }
+        if (policy !== undefined) {
+            result[field] = policy;
+        }
+    }
+    const controls = value.terminalControls;
+    if (controls !== undefined && controls !== 'strip' && controls !== 'preserve') {
+        throw new DeclarationError('Rendering terminalControls must be strip or preserve.');
+    }
+    if (controls !== undefined) {
+        result.terminalControls = controls;
+    }
+    return result;
+}
+function colorDepth(env) {
+    if (env.COLORTERM === 'truecolor' ||
+        env.COLORTERM === '24bit' ||
+        ['xterm-kitty', 'xterm-ghostty', 'wezterm'].includes(env.TERM ?? '')) {
+        return 'truecolor';
+    }
+    if (env.TERM_PROGRAM === 'iTerm.app') {
+        const major = /^\d+/u.exec(env.TERM_PROGRAM_VERSION ?? '')?.[0];
+        return major !== undefined && Number(major) >= 3 ? 'truecolor' : 256;
+    }
+    return env.TERM_PROGRAM === 'Apple_Terminal' || /-256(?:color)?$/iu.test(env.TERM ?? '')
+        ? 256
+        : 16;
+}
+function mainGlyphs({ env, platform }) {
+    if (platform !== 'win32') {
+        return env.TERM !== 'linux';
+    }
+    return (Boolean(env.CI || env.WT_SESSION || env.TERMINUS_SUBLIME) ||
+        env.ConEmuTask === '{cmd::Cmder}' ||
+        env.TERM_PROGRAM === 'Terminus-Sublime' ||
+        env.TERM_PROGRAM === 'vscode' ||
+        env.TERM === 'xterm-256color' ||
+        env.TERM === 'alacritty' ||
+        env.TERMINAL_EMULATOR === 'JetBrains-JediTerm');
+}
+function enabled(policy, automatic) {
+    return policy === 'always' || (policy !== 'never' && automatic);
+}
+/** A run owns captured facts; stdout and stderr each resolve this one policy independently. */
+function capabilities(host, destination, policy) {
+    const tty = host.terminal[destination].isTTY;
+    const capable = tty && host.env.TERM !== 'dumb';
+    const forced = Boolean(host.env.FORCE_COLOR);
+    return {
+        color: enabled(policy.color, forced || (!host.env.NO_COLOR && capable)),
+        depth: colorDepth(host.env),
+        hyperlinks: enabled(policy.hyperlinks, tty),
+        mainGlyphs: mainGlyphs(host),
+        modifiers: enabled(policy.modifiers, forced || capable),
+        terminalControls: policy.terminalControls === 'preserve',
+    };
+}
+export { capabilities, renderingPolicy };

package/dist/sequence.d.ts

@@ -0,0 +1,41 @@
+import type { IncompleteResult } from './lanes.js';
+import type { ViewContext } from './types.js';
+import type { ResolvedRowView } from './view.js';
+/**
+ * The view one sequence writes through. A row view writes each row as the source yields it; a
+ * whole view collects every row and renders once at the end of the source.
+ */
+type SequenceView<Row> = {
+    kind: 'rows';
+    view: ResolvedRowView<Row>;
+} | {
+    kind: 'whole';
+    render: (rows: readonly Row[], context: ViewContext) => unknown;
+};
+/** What one sequence writes through, supplied by the output that reserved its place. */
+interface SequenceWriter<Row> {
+    /** The context of the destination the pieces reach. */
+    context: ViewContext;
+    /** Ends the reservation, so later output to that destination writes after this sequence. */
+    close: () => void;
+    /** Writes the incomplete-result line on stderr, before the fault's own report. */
+    incomplete: (facts: IncompleteResult) => void;
+    path: readonly string[];
+    /** Resolves and queues one piece on the reserved place, rejecting on a view or write fault. */
+    piece: (produce: () => unknown) => Promise<void>;
+    signal: AbortSignal;
+    source: Iterable<Row> | AsyncIterable<Row>;
+    /** Records a source failure, which this invocation reports after its primary outcome. */
+    stopped: (cause: unknown) => void;
+    view: SequenceView<Row>;
+}
+/** One sequence in flight: the promise its call answers with, and the switch that ends it early. */
+interface LiveSequence {
+    pending: Promise<void>;
+    /** Ends the sequence where it next would go on. A finished sequence answers it with nothing. */
+    stop: () => void;
+}
+/** One sequence, started here and stoppable from the invocation that issued it. */
+declare function writeSequence<Row>(writer: SequenceWriter<Row>): LiveSequence;
+export type { LiveSequence, SequenceView, SequenceWriter };
+export { writeSequence };

package/dist/sequence.js

@@ -0,0 +1,225 @@
+import { InternalError, routedSubject } from './errors.js';
+/**
+ * A failure the source raised, so the writer tells it apart from the view and write faults its own
+ * pieces raise, which the output path has accounted for already.
+ */
+class SourceFault {
+    cause;
+    constructor(cause) {
+        this.cause = cause;
+    }
+}
+/**
+ * The value a stopped writer unwinds with, compared by identity where the sequence ends. The
+ * invocation that stopped it has a primary failure of its own, so this value reports nothing.
+ */
+const stopRequested = Symbol('stopped');
+/**
+ * The steps one source answers with, under whichever protocol it carries. The asynchronous one
+ * answers first, as the language's own `for await` does.
+ * A value that iterates neither way answers with nothing, and its caller reports the fault.
+ */
+function iterate(source) {
+    const asynchronous = source?.[Symbol.asyncIterator];
+    if (typeof asynchronous === 'function') {
+        return asynchronous.call(source);
+    }
+    const synchronous = source?.[Symbol.iterator];
+    if (typeof synchronous === 'function') {
+        return synchronous.call(source);
+    }
+    return undefined;
+}
+/**
+ * The steps one source answers with, with whatever the protocol raised marked as the source's own
+ * failure. A value that iterates neither way is the same fault, named for the Command that emitted
+ * it, because the types reject it and a JavaScript author alone reaches it.
+ */
+function stepsOf(writer) {
+    let steps = undefined;
+    try {
+        steps = iterate(writer.source);
+    }
+    catch (error) {
+        throw new SourceFault(error);
+    }
+    if (!steps) {
+        throw new SourceFault(new InternalError(`The result of ${routedSubject(writer.path)} is not iterable.`, undefined));
+    }
+    return steps;
+}
+/** One request of the source, with whatever it raised marked as the source's own failure. */
+async function pull(steps) {
+    try {
+        const result = await steps.next();
+        return result.done === true ? { done: true } : { done: false, value: result.value };
+    }
+    catch (error) {
+        throw new SourceFault(error);
+    }
+}
+/**
+ * The stop, read before the writer requests the next row and before it writes the piece it holds.
+ * A cancelled run stops here too, so core requests no further rows and writes no further pieces
+ * from the moment the signal aborted.
+ */
+function halt(reading) {
+    if (reading.live.stopped || reading.signal.aborted) {
+        throw stopRequested;
+    }
+}
+/** One step, counted where the source produced a row. A stopped writer requests none. */
+async function step(reading) {
+    halt(reading);
+    const result = await pull(reading.steps);
+    if (!result.done) {
+        reading.counts.yielded += 1;
+    }
+    // A row an in-flight request delivered after the stop is counted, and nothing is written for it.
+    halt(reading);
+    return result;
+}
+/**
+ * The source is told the writer wants no more rows, so a generator runs its own cleanup.
+ * The settlement is never awaited: a cleanup that never settles would pin the destination's tail,
+ * and the failure that stopped the sequence would never be reported.
+ * Whatever that cleanup raises is the source's business, and it is observed here alone, because the
+ * stop is reported through the fault that raised it and a second failure would replace it.
+ */
+function endSteps(steps) {
+    try {
+        const ended = steps.return?.();
+        void Promise.resolve(ended).catch(() => undefined);
+    }
+    catch {
+        // A cleanup that throws outright is the same business, and it ends here too.
+    }
+}
+/** The opening piece, skipped where the view supplies no `head` function. */
+async function writeHead(writer, produce) {
+    if (produce) {
+        await writer.piece(() => produce(writer.context));
+    }
+}
+/** The closing piece, skipped where the view supplies no `tail` function. */
+async function writeTail(writer, produce, count) {
+    if (produce) {
+        await writer.piece(() => produce(count, writer.context));
+    }
+}
+/**
+ * Every piece but `tail`: `head`, then each row as the source yields it. Each piece is awaited
+ * before the next row is requested, so a slow destination applies back-pressure to the source.
+ */
+async function writeEachRow(writer, view, reading) {
+    halt(reading);
+    await writeHead(writer, view.head);
+    for (;;) {
+        const next = await step(reading);
+        if (next.done) {
+            return;
+        }
+        const index = reading.counts.yielded - 1;
+        await writer.piece(() => view.row(next.value, index, writer.context));
+        reading.counts.written += 1;
+    }
+}
+/** Every row the source produced, which a whole view renders once at the end of the source. */
+async function collectRows(reading) {
+    const collected = [];
+    for (;;) {
+        const next = await step(reading);
+        if (next.done) {
+            return collected;
+        }
+        collected.push(next.value);
+    }
+}
+/**
+ * Every piece the source decides, and the closing piece a complete sequence ends with: `head` and
+ * each row under a row view, whose closing piece is `tail`, and the collected rows under a whole
+ * view, whose closing piece is its one render. A whole view queues nothing before the source ends,
+ * so `written` counts no row under it.
+ */
+async function writePieces(writer, reading) {
+    if (writer.view.kind === 'whole') {
+        const { render } = writer.view;
+        const collected = await collectRows(reading);
+        return () => writer.piece(() => render(collected, writer.context));
+    }
+    const { view } = writer.view;
+    await writeEachRow(writer, view, reading);
+    return () => writeTail(writer, view.tail, reading.counts.written);
+}
+/** The same pieces, with the source told to stop where one of them raised. */
+async function closingPiece(writer, reading) {
+    try {
+        return await writePieces(writer, reading);
+    }
+    catch (error) {
+        endSteps(reading.steps);
+        throw error;
+    }
+}
+/**
+ * The sequence itself: every piece the source decides, then the closing piece. Every piece is
+ * awaited before the next row is requested, so a slow destination applies back-pressure to the
+ * source. The stop is read once more between the source's end and the closing piece, so a run
+ * cancelled there, and an action that failed there, never write it and a truncated result never
+ * reads as a complete one.
+ */
+async function writeRows(writer, live, counts) {
+    const reading = { counts, live, signal: writer.signal, steps: stepsOf(writer) };
+    const close = await closingPiece(writer, reading);
+    if (live.stopped || writer.signal.aborted) {
+        return false;
+    }
+    await close();
+    return true;
+}
+/**
+ * One sequence written on the place its call reserved. A stop before the end retracts nothing, adds
+ * no `tail`, and writes one incomplete-result line on stderr before the fault's own report; a
+ * source failure is recorded there, because a call the action never awaited observes none.
+ */
+async function runSequence(writer, live) {
+    const counts = { written: 0, yielded: 0 };
+    try {
+        if (!(await writeRows(writer, live, counts))) {
+            writer.incomplete({ path: writer.path, ...counts });
+        }
+    }
+    catch (error) {
+        writer.incomplete({ path: writer.path, ...counts });
+        raise(writer, error);
+    }
+    finally {
+        writer.close();
+    }
+}
+/**
+ * What one stop leaves behind once its line is written: nothing, where the invocation asked for
+ * the stop and reports its own failure, the source's failure recorded and raised, or the fault of
+ * a piece, which the output path has accounted for already.
+ */
+function raise(writer, error) {
+    if (error === stopRequested) {
+        return;
+    }
+    if (error instanceof SourceFault) {
+        writer.stopped(error.cause);
+        throw error.cause;
+    }
+    throw error;
+}
+/** One sequence, started here and stoppable from the invocation that issued it. */
+function writeSequence(writer) {
+    const live = { stopped: false };
+    return {
+        pending: runSequence(writer, live),
+        stop: () => {
+            live.stopped = true;
+        },
+    };
+}
+export { writeSequence };