@kensio/yulin 1.6.1 → 1.8.0

package/dist/cli/watch/sim-watch-restarts.js

@@ -0,0 +1,62 @@
+/**
+ * Runs restarts one at a time, and does not lose an edit made during one.
+ *
+ * Changes arrive whenever they arrive, and a restart takes as long as the
+ * project takes to start. Running two at once would leave two processes racing
+ * for the same port, and dropping the second would mean a save silently doing
+ * nothing, so a change that arrives mid-restart waits for its turn.
+ *
+ * Only the latest is kept. A restart takes whatever is on disk at the time, so
+ * two changes queued behind one restart are one restart.
+ */
+export class SimWatchRestarts {
+    restart;
+    onFailure;
+    running = false;
+    queuedPath;
+    constructor(properties) {
+        const { restart, onFailure } = properties;
+        this.restart = restart;
+        this.onFailure = onFailure;
+    }
+    /**
+     * Restart for a change, now or as soon as the current restart is done.
+     */
+    request(changedPath) {
+        if (this.running) {
+            this.queuedPath = changedPath;
+            return;
+        }
+        this.running = true;
+        // eslint-disable-next-line unicorn/prefer-await
+        this.run(changedPath).catch((error) => {
+            this.onFailure(error);
+        });
+    }
+    async run(changedPath) {
+        try {
+            await this.restart(changedPath);
+        }
+        catch (error) {
+            // A restart that failed is the end of this run. Whatever asked for it
+            // decides what happens next, and a change queued behind it would be a
+            // restart nobody is waiting for any more.
+            this.queuedPath = undefined;
+            throw error;
+        }
+        finally {
+            this.running = false;
+        }
+        await this.drain();
+    }
+    async drain() {
+        const queuedPath = this.queuedPath;
+        this.queuedPath = undefined;
+        if (queuedPath === undefined) {
+            return;
+        }
+        this.running = true;
+        await this.run(queuedPath);
+    }
+}
+//# sourceMappingURL=sim-watch-restarts.js.map

package/dist/cli/watch/sim-watch-restarts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-restarts.js","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-restarts.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,gBAAgB;IACV,OAAO,CAAyC;IAChD,SAAS,CAA2B;IAC7C,OAAO,GAAG,KAAK,CAAC;IAChB,UAAU,CAAqB;IAEvC,YAAY,UAAsC;QAChD,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,UAAU,CAAC;QAC1C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,WAAmB;QACzB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,IAAI,CAAC,UAAU,GAAG,WAAW,CAAC;YAC9B,OAAO;QACT,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QAEpB,gDAAgD;QAChD,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;YAC7C,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACxB,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,GAAG,CAAC,WAAmB;QACnC,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QAClC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,sEAAsE;YACtE,sEAAsE;YACtE,0CAA0C;YAC1C,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;YAC5B,MAAM,KAAK,CAAC;QACd,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACvB,CAAC;QAED,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;IAEO,KAAK,CAAC,KAAK;QACjB,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACnC,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAE5B,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,OAAO;QACT,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QAEpB,MAAM,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC7B,CAAC;CACF"}

package/dist/cli/watch/sim-watch-supervisor.d.ts

@@ -0,0 +1,52 @@
+import type { SimWatchArguments } from "./sim-watch-arguments.js";
+import { SimWatchReporter } from "./sim-watch-reporter.js";
+interface SimWatchSupervisorProperties {
+    readonly watchArguments: SimWatchArguments;
+    readonly cwd?: string;
+    readonly reporter?: SimWatchReporter;
+}
+/**
+ * Runs a command, and runs it again when something changes.
+ *
+ * The supervisor is a separate process from the one being restarted, and has to
+ * be. A process that respawned itself would leave the shell's job pointing at
+ * the process that exited, so the prompt would come back while an orphan held
+ * the terminal, and Ctrl-C would stop meaning anything.
+ */
+export declare class SimWatchSupervisor {
+    private readonly watchArguments;
+    private readonly cwd;
+    private readonly reporter;
+    private readonly watcher;
+    private readonly restarts;
+    private readonly loopGuard;
+    private child;
+    private stop;
+    private readonly onReportedPath;
+    /**
+     * A path the process watches itself, such as a deployed template it updates
+     * the Stack from in place. Restarting for it would throw away the simulated
+     * state the in-place update exists to keep.
+     */
+    private readonly onHeldPath;
+    /**
+     * A process that stopped on its own is a setup that threw, or a script that
+     * ran to the end. Either way the watching goes on, so the next save tries
+     * again without the watch having to be started over.
+     */
+    private readonly onChildExit;
+    constructor(properties: SimWatchSupervisorProperties);
+    /**
+     * Watch until something stops the watching, and report how it ended.
+     */
+    run(): Promise<number>;
+    /**
+     * Stop watching, for a supervisor that has been interrupted.
+     */
+    interrupt(): void;
+    private start;
+    private restart;
+    private fail;
+}
+export {};
+//# sourceMappingURL=sim-watch-supervisor.d.ts.map

package/dist/cli/watch/sim-watch-supervisor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-supervisor.d.ts","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-supervisor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAIlE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAI3D,UAAU,4BAA4B;IACpC,QAAQ,CAAC,cAAc,EAAE,iBAAiB,CAAC;IAC3C,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;CACtC;AAED;;;;;;;GAOG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAoB;IACnD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;IAC1C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAC5C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2B;IACrD,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,IAAI,CAA2C;IAEvD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAE7B;IAEF;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAEzB;IAEF;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAM1B;IAEF,YAAY,UAAU,EAAE,4BAA4B,EAwBnD;IAED;;OAEG;IACG,GAAG,IAAI,OAAO,CAAC,MAAM,CAAC,CAoB3B;IAED;;OAEG;IACH,SAAS,IAAI,IAAI,CAEhB;YAEa,KAAK;YA0BL,OAAO;IAUrB,OAAO,CAAC,IAAI;CAMb"}

package/dist/cli/watch/sim-watch-supervisor.js

@@ -0,0 +1,128 @@
+import { SimWatchChild } from "./sim-watch-child.js";
+import { SimWatchChildEnvironment } from "./sim-watch-child-environment.js";
+import { SimWatchLoopGuard } from "./sim-watch-loop-guard.js";
+import { SimWatchReporter } from "./sim-watch-reporter.js";
+import { SimWatchRestarts } from "./sim-watch-restarts.js";
+import { SimWatchWatcher } from "./sim-watch-watcher.js";
+/**
+ * Runs a command, and runs it again when something changes.
+ *
+ * The supervisor is a separate process from the one being restarted, and has to
+ * be. A process that respawned itself would leave the shell's job pointing at
+ * the process that exited, so the prompt would come back while an orphan held
+ * the terminal, and Ctrl-C would stop meaning anything.
+ */
+export class SimWatchSupervisor {
+    watchArguments;
+    cwd;
+    reporter;
+    watcher;
+    restarts;
+    loopGuard = new SimWatchLoopGuard();
+    child;
+    stop;
+    onReportedPath = (reportedPath) => {
+        this.watcher.addReported(reportedPath);
+    };
+    /**
+     * A path the process watches itself, such as a deployed template it updates
+     * the Stack from in place. Restarting for it would throw away the simulated
+     * state the in-place update exists to keep.
+     */
+    onHeldPath = (heldPath) => {
+        this.watcher.addHeld(heldPath);
+    };
+    /**
+     * A process that stopped on its own is a setup that threw, or a script that
+     * ran to the end. Either way the watching goes on, so the next save tries
+     * again without the watch having to be started over.
+     */
+    onChildExit = (code, signal) => {
+        this.watcher.clearHeld();
+        this.reporter.exited(code, signal);
+    };
+    constructor(properties) {
+        const { watchArguments, cwd = process.cwd(), reporter = new SimWatchReporter({ cwd }), } = properties;
+        this.watchArguments = watchArguments;
+        this.cwd = cwd;
+        this.reporter = reporter;
+        this.restarts = new SimWatchRestarts({
+            restart: async (changedPath) => {
+                await this.restart(changedPath);
+            },
+            onFailure: (error) => {
+                this.fail(error);
+            },
+        });
+        this.watcher = new SimWatchWatcher({
+            cwd,
+            settleMs: watchArguments.settleMs,
+            onChange: (changedPath) => {
+                this.restarts.request(changedPath);
+            },
+        });
+    }
+    /**
+     * Watch until something stops the watching, and report how it ended.
+     */
+    async run() {
+        this.reporter.started(this.watchArguments.describe());
+        this.watcher.start();
+        // Taken before the first start, so an interrupt during startup is heard,
+        // and released in `finally`, so a command that could not be run at all
+        // leaves nothing watching. Open watchers would keep the process alive after
+        // the error had been reported, which reads as a hang rather than a mistake.
+        const stopped = new Promise((resolve) => {
+            this.stop = resolve;
+        });
+        try {
+            await this.start();
+            return await stopped;
+        }
+        finally {
+            this.watcher.stop();
+            await this.child?.stop();
+        }
+    }
+    /**
+     * Stop watching, for a supervisor that has been interrupted.
+     */
+    interrupt() {
+        this.stop?.(0);
+    }
+    async start() {
+        // The run that held a path has gone, and the one replacing it says what it
+        // holds as it registers it. Keeping the old list would leave a file the new
+        // run is not watching neither restarted for nor answered in place.
+        this.watcher.clearHeld();
+        const child = new SimWatchChild({
+            command: this.watchArguments.command,
+            args: this.watchArguments.commandArguments,
+            cwd: this.cwd,
+            env: new SimWatchChildEnvironment({
+                cwd: this.cwd,
+                inspect: this.watchArguments.inspect,
+            }).build(),
+            onPath: this.onReportedPath,
+            onHeldPath: this.onHeldPath,
+            onExit: this.onChildExit,
+        });
+        // Kept only once it is running. A command that could not be run has no
+        // process to stop, and waiting for one to exit that never started is a wait
+        // that never ends.
+        await child.started();
+        this.child = child;
+    }
+    async restart(changedPath) {
+        const startedAt = Date.now();
+        this.loopGuard.check(changedPath, this.child?.ranForMs() ?? 0);
+        await this.child?.stop();
+        await this.start();
+        this.reporter.restarted(changedPath, Date.now() - startedAt);
+    }
+    fail(error) {
+        this.reporter.failed(error instanceof Error ? error : new Error(String(error)));
+        this.stop?.(1);
+    }
+}
+//# sourceMappingURL=sim-watch-supervisor.js.map

package/dist/cli/watch/sim-watch-supervisor.js.map

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

package/dist/cli/watch/sim-watch-watcher.d.ts

@@ -0,0 +1,69 @@
+interface SimWatchWatcherProperties {
+    readonly cwd: string;
+    readonly onChange: (changedPath: string) => void;
+    readonly settleMs?: number | undefined;
+}
+/**
+ * Watches the working directory, and whatever else the process says it is
+ * reading.
+ *
+ * The working directory is watched whole and filtered down, rather than a list
+ * of interesting paths being assembled up front, because the interesting paths
+ * are whatever the project happens to import. What the process reports on top
+ * of that is the paths Yulin holds but Node's module graph never mentions: a
+ * directory mounted into a Bucket, and a synthesized template.
+ *
+ * A reported path is watched whether or not the ignore rules would have passed
+ * over it. Being told about a path is more specific than a default list of
+ * directories worth skipping.
+ */
+export declare class SimWatchWatcher {
+    private readonly cwd;
+    private readonly ignore;
+    private readonly settle;
+    private readonly watchers;
+    private readonly reportedRoots;
+    private readonly heldRoots;
+    constructor(properties: SimWatchWatcherProperties);
+    /**
+     * Start watching the working directory.
+     */
+    start(): void;
+    /**
+     * Also watch a path the supervised process reported.
+     *
+     * A path inside the working directory is already covered by the recursive
+     * watch, so it only needs recording as reported. One outside needs a watcher
+     * of its own.
+     */
+    addReported(reportedPath: string): void;
+    /**
+     * Leave a path to the process that reported it.
+     *
+     * A process watching a path itself answers a change to it without being
+     * restarted, so restarting for it would throw away the simulated state that
+     * answering in place exists to keep. This beats having reported the same path
+     * for watching: being told a path is handled there is more specific than
+     * being told it is worth watching here.
+     */
+    addHeld(heldPath: string): void;
+    /**
+     * Take back every held path, for a process that is no longer running.
+     *
+     * Held paths belong to the run that reported them, unlike reported paths,
+     * which are only ever more to watch. A run that stopped holding a path, or
+     * stopped altogether, would otherwise leave a file nothing is watching and
+     * nothing restarts for.
+     */
+    clearHeld(): void;
+    /**
+     * Stop watching and drop any change that was still settling.
+     */
+    stop(): void;
+    private watch;
+    private changed;
+    private ignored;
+    private within;
+}
+export {};
+//# sourceMappingURL=sim-watch-watcher.d.ts.map

package/dist/cli/watch/sim-watch-watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-watch-watcher.d.ts","sourceRoot":"","sources":["../../../src/cli/watch/sim-watch-watcher.ts"],"names":[],"mappings":"AAOA,UAAU,yBAAyB;IACjC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwB;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgC;IACzD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;IACnD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqB;IAE/C,YAAY,UAAU,EAAE,yBAAyB,EAQhD;IAED;;OAEG;IACH,KAAK,IAAI,IAAI,CAEZ;IAED;;;;;;OAMG;IACH,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CActC;IAED;;;;;;;;OAQG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAE9B;IAED;;;;;;;OAOG;IACH,SAAS,IAAI,IAAI,CAEhB;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,CAQX;IAED,OAAO,CAAC,KAAK;IA8Bb,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,OAAO;IAgBf,OAAO,CAAC,MAAM;CASf"}

package/dist/cli/watch/sim-watch-watcher.js

@@ -0,0 +1,148 @@
+import fs, {} from "node:fs";
+import path from "node:path";
+import { simWatchConfig } from "../../watch/sim-watch.config.js";
+import { SimWatchEventPath } from "./sim-watch-event-path.js";
+import { SimWatchIgnore } from "./sim-watch-ignore.js";
+import { SimWatchSettle } from "../../watch/sim-watch-settle.js";
+/**
+ * Watches the working directory, and whatever else the process says it is
+ * reading.
+ *
+ * The working directory is watched whole and filtered down, rather than a list
+ * of interesting paths being assembled up front, because the interesting paths
+ * are whatever the project happens to import. What the process reports on top
+ * of that is the paths Yulin holds but Node's module graph never mentions: a
+ * directory mounted into a Bucket, and a synthesized template.
+ *
+ * A reported path is watched whether or not the ignore rules would have passed
+ * over it. Being told about a path is more specific than a default list of
+ * directories worth skipping.
+ */
+export class SimWatchWatcher {
+    cwd;
+    ignore = new SimWatchIgnore();
+    settle;
+    watchers = new Map();
+    reportedRoots = new Set();
+    heldRoots = new Set();
+    constructor(properties) {
+        const { cwd, onChange, settleMs = simWatchConfig.settleMs } = properties;
+        this.cwd = path.resolve(cwd);
+        this.settle = new SimWatchSettle({
+            settleMs,
+            maxWaitMs: simWatchConfig.settleMaxWaitMs,
+            onSettled: onChange,
+        });
+    }
+    /**
+     * Start watching the working directory.
+     */
+    start() {
+        this.watch(this.cwd, true);
+    }
+    /**
+     * Also watch a path the supervised process reported.
+     *
+     * A path inside the working directory is already covered by the recursive
+     * watch, so it only needs recording as reported. One outside needs a watcher
+     * of its own.
+     */
+    addReported(reportedPath) {
+        const resolved = path.resolve(reportedPath);
+        if (this.reportedRoots.has(resolved)) {
+            return;
+        }
+        this.reportedRoots.add(resolved);
+        if (this.within(this.cwd, resolved)) {
+            return;
+        }
+        this.watch(resolved, isDirectory(resolved));
+    }
+    /**
+     * Leave a path to the process that reported it.
+     *
+     * A process watching a path itself answers a change to it without being
+     * restarted, so restarting for it would throw away the simulated state that
+     * answering in place exists to keep. This beats having reported the same path
+     * for watching: being told a path is handled there is more specific than
+     * being told it is worth watching here.
+     */
+    addHeld(heldPath) {
+        this.heldRoots.add(path.resolve(heldPath));
+    }
+    /**
+     * Take back every held path, for a process that is no longer running.
+     *
+     * Held paths belong to the run that reported them, unlike reported paths,
+     * which are only ever more to watch. A run that stopped holding a path, or
+     * stopped altogether, would otherwise leave a file nothing is watching and
+     * nothing restarts for.
+     */
+    clearHeld() {
+        this.heldRoots.clear();
+    }
+    /**
+     * Stop watching and drop any change that was still settling.
+     */
+    stop() {
+        this.settle.cancel();
+        for (const watcher of this.watchers.values()) {
+            watcher.close();
+        }
+        this.watchers.clear();
+    }
+    watch(target, recursive) {
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
+        if (this.watchers.has(target) || !fs.existsSync(target)) {
+            return;
+        }
+        const eventPath = new SimWatchEventPath(target, recursive);
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
+        const watcher = fs.watch(target, { recursive }, (_event, fileName) => {
+            const changedPath = eventPath.of(fileName);
+            if (changedPath !== undefined) {
+                this.changed(changedPath);
+            }
+        });
+        // A watched path can be deleted or replaced. Nothing useful can be done
+        // about that from here, and a watcher with no error listener throws.
+        /* v8 ignore next 4 -- raised where the platform reports a watch going away,
+         * which macOS does not do for a deleted directory, so nothing here can make
+         * it happen on the machine this suite runs on. */
+        watcher.on("error", () => {
+            watcher.close();
+            this.watchers.delete(target);
+        });
+        this.watchers.set(target, watcher);
+    }
+    changed(changedPath) {
+        if (this.ignored(changedPath)) {
+            return;
+        }
+        this.settle.record(changedPath);
+    }
+    ignored(changedPath) {
+        for (const root of this.heldRoots) {
+            if (root === changedPath || this.within(root, changedPath)) {
+                return true;
+            }
+        }
+        for (const root of this.reportedRoots) {
+            if (root === changedPath || this.within(root, changedPath)) {
+                return false;
+            }
+        }
+        return this.ignore.ignores(path.relative(this.cwd, changedPath));
+    }
+    within(root, target) {
+        const relative = path.relative(root, target);
+        return (relative.length > 0 &&
+            !relative.startsWith("..") &&
+            !path.isAbsolute(relative));
+    }
+}
+function isDirectory(target) {
+    // eslint-disable-next-line security/detect-non-literal-fs-filename
+    return fs.statSync(target, { throwIfNoEntry: false })?.isDirectory() === true;
+}
+//# sourceMappingURL=sim-watch-watcher.js.map

package/dist/cli/watch/sim-watch-watcher.js.map

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

package/dist/cli/yulin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=yulin.d.ts.map

package/dist/cli/yulin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yulin.d.ts","sourceRoot":"","sources":["../../src/cli/yulin.ts"],"names":[],"mappings":""}

package/dist/cli/yulin.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/* v8 ignore start -- the entry point runs as its own process, so coverage of
+ * this repository's test run never sees it. What it does is covered through
+ * `SimCli`, and that it works as a command is covered by running it. */
+import { SimCli } from "./sim-cli.js";
+try {
+    process.exitCode = await new SimCli().run(process.argv.slice(2));
+}
+catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+}
+/* v8 ignore stop */
+//# sourceMappingURL=yulin.js.map

package/dist/cli/yulin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yulin.js","sourceRoot":"","sources":["../../src/cli/yulin.ts"],"names":[],"mappings":";AAEA;;wEAEwE;AAExE,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,IAAI,CAAC;IACH,OAAO,CAAC,QAAQ,GAAG,MAAM,IAAI,MAAM,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACnE,CAAC;AAAC,OAAO,KAAK,EAAE,CAAC;IACf,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAC9D,CAAC;IACF,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;AACvB,CAAC;AAED,oBAAoB"}

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export { SimAws } from "./service/aws/sim-aws.js";
+export type { SimAwsClosing } from "./service/aws/sim-aws-closing.js";
+export type { SimCloseOnSignalOptions } from "./util/process/close-on-signal.js";
 export type { AwsRegionName } from "./service/aws/sim-aws-region.js";
-export type { SimAwsAccountId } from "./service/aws/sim-aws-account.js";
+export { isSimAwsAccountId, makeSimAwsAccountId, type SimAwsAccountId, simAwsAccountId, SimInvalidAwsAccountId, } from "./service/aws/sim-aws-account-id.js";
 export { type SimClock, SimFixedClock, SimRealClock, } from "./util/clock/sim-clock.js";
 export { SimControllableClock } from "./util/clock/sim-controllable-clock.js";
 export { SimClockControl } from "./util/clock/sim-clock-control.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAClD,YAAY,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACrE,YAAY,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EACL,KAAK,QAAQ,EACb,aAAa,EACb,YAAY,GACb,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EACL,WAAW,EACX,KAAK,gBAAgB,EACrB,kBAAkB,GACnB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAClD,YAAY,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACtE,YAAY,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AACjF,YAAY,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,KAAK,eAAe,EACpB,eAAe,EACf,sBAAsB,GACvB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,KAAK,QAAQ,EACb,aAAa,EACb,YAAY,GACb,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EACL,WAAW,EACX,KAAK,gBAAgB,EACrB,kBAAkB,GACnB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC"}

package/dist/index.js

@@ -1,4 +1,5 @@
 export { SimAws } from "./service/aws/sim-aws.js";
+export { isSimAwsAccountId, makeSimAwsAccountId, simAwsAccountId, SimInvalidAwsAccountId, } from "./service/aws/sim-aws-account-id.js";
 export { SimFixedClock, SimRealClock, } from "./util/clock/sim-clock.js";
 export { SimControllableClock } from "./util/clock/sim-controllable-clock.js";
 export { SimClockControl } from "./util/clock/sim-clock-control.js";

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAGlD,OAAO,EAEL,aAAa,EACb,YAAY,GACb,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EACL,WAAW,EAEX,kBAAkB,GACnB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAIlD,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EAEnB,eAAe,EACf,sBAAsB,GACvB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAEL,aAAa,EACb,YAAY,GACb,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EACL,WAAW,EAEX,kBAAkB,GACnB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC"}

package/dist/serve/http/live-reload/sim-live-reload-client.d.ts

@@ -0,0 +1,44 @@
+import type { ServerResponse } from "node:http";
+/**
+ * One browser holding a live reload connection open.
+ *
+ * Server-Sent Events rather than a WebSocket, because the browser reconnects on
+ * its own. That is what lets a reload survive the process restarting: the
+ * outgoing process has nothing to hand over, and the incoming one has nothing
+ * to pick up.
+ */
+export declare class SimLiveReloadClient {
+    private readonly response;
+    constructor(response: ServerResponse);
+    /**
+     * Start the event stream, telling the browser how soon to come back.
+     */
+    open(): void;
+    /**
+     * Send one named event.
+     */
+    send(event: string, data: string): void;
+    /**
+     * Finish the stream and see its connection out, so the browser reconnects
+     * rather than waiting on a connection nothing is going to answer on.
+     *
+     * Waiting is what makes the last event readable. A socket destroyed with
+     * bytes still in flight is reset rather than closed, and a reset tells the
+     * peer to throw away what it has received but not yet handed to the page,
+     * which is the event that was just written. Ending the socket puts a normal
+     * close after the bytes instead, and resolving once it has gone leaves the
+     * server nothing left to destroy.
+     */
+    end(): Promise<void>;
+    /**
+     * Run something when the browser goes away.
+     */
+    onClose(listener: () => void): void;
+    /**
+     * Wait for a connection to go, giving up on a browser that is no longer
+     * answering rather than holding the process open for it.
+     */
+    private closed;
+    private write;
+}
+//# sourceMappingURL=sim-live-reload-client.d.ts.map

package/dist/serve/http/live-reload/sim-live-reload-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-live-reload-client.d.ts","sourceRoot":"","sources":["../../../../src/serve/http/live-reload/sim-live-reload-client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAIhD;;;;;;;GAOG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;IAE1C,YAAY,QAAQ,EAAE,cAAc,EAEnC;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,CAOX;IAED;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAEtC;IAED;;;;;;;;;;OAUG;IACG,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAElC;IAED;;;OAGG;YACW,MAAM;IAYpB,OAAO,CAAC,KAAK;CAOd"}