@stringsync/splates 0.0.60 → 1.13.3

package/vendor/core/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jared Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/core/abort/aborts.d.ts

@@ -0,0 +1,10 @@
+/** Ways of bringing an `AbortSignal` to bear on work that does not take one. */
+export declare class aborts {
+    private constructor();
+    /**
+     * Settles with `promise`, or rejects with the signal's reason if that comes
+     * first. The underlying work is not cancelled, since a promise cannot be:
+     * this stops the caller waiting on it.
+     */
+    static race<T>(signal: AbortSignal, promise: Promise<T>): Promise<T>;
+}

package/vendor/core/abort/index.d.ts

@@ -0,0 +1 @@
+export { aborts } from "./aborts";

package/vendor/core/abort/index.js

@@ -0,0 +1,24 @@
+// abort/aborts.ts
+class aborts {
+  constructor() {}
+  static race(signal, promise) {
+    if (signal.aborted) {
+      return Promise.reject(signal.reason);
+    }
+    return new Promise((resolve, reject) => {
+      const onAbort = () => reject(signal.reason);
+      signal.addEventListener("abort", onAbort, { once: true });
+      const settled = () => signal.removeEventListener("abort", onAbort);
+      promise.then((value) => {
+        settled();
+        resolve(value);
+      }, (error) => {
+        settled();
+        reject(error);
+      });
+    });
+  }
+}
+export {
+  aborts
+};

package/vendor/core/assert/assert-error.d.ts

@@ -0,0 +1,4 @@
+/** What every `assert` and `ensure` check throws when it does not hold. */
+export declare class AssertError extends Error {
+    constructor(message?: string);
+}

package/vendor/core/assert/assert.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Assertions that narrow the type of what they are given, for the invariants a
+ * type cannot state. Each throws an `AssertError` when it does not hold.
+ *
+ * ```ts
+ * assert.present(user, "no user on the session");
+ * user.name; // narrowed
+ * ```
+ *
+ * Use `ensure` instead when you want the value back rather than a narrowing.
+ */
+export declare class assert {
+    private constructor();
+    static that(condition: unknown, message?: string): asserts condition;
+    static number(value: unknown, message?: string): asserts value is number;
+    static integer(value: unknown, message?: string): asserts value is number;
+    /** Inclusive of both bounds. */
+    static inRange(value: unknown, min: number, max: number, message?: string): asserts value is number;
+    static notNull<T>(value: T, message?: string): asserts value is Exclude<T, null>;
+    static defined<T>(value: T, message?: string): asserts value is Exclude<T, undefined>;
+    static present<T>(value: T, message?: string): asserts value is Exclude<T, null | undefined>;
+    /** States that control cannot reach here, e.g. the default of an exhaustive switch. */
+    static unreachable(message?: string): never;
+}

package/vendor/core/assert/ensure.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The assertions of `assert`, each returning the value it checked, so they can
+ * be used where a value is expected rather than as a statement of their own.
+ *
+ * ```ts
+ * const port = ensure.integer(raw, "PORT must be a whole number");
+ * ```
+ */
+export declare class ensure {
+    private constructor();
+    static number(value: unknown, message?: string): number;
+    static integer(value: unknown, message?: string): number;
+    /** Inclusive of both bounds. */
+    static inRange(value: unknown, min: number, max: number, message?: string): number;
+    static notNull<T>(value: T, message?: string): Exclude<T, null>;
+    static defined<T>(value: T, message?: string): Exclude<T, undefined>;
+    static present<T>(value: T, message?: string): Exclude<T, null | undefined>;
+}

package/vendor/core/assert/index.d.ts

@@ -0,0 +1,3 @@
+export { assert } from "./assert";
+export { AssertError } from "./assert-error";
+export { ensure } from "./ensure";

package/vendor/core/assert/index.js

@@ -0,0 +1,75 @@
+// assert/assert-error.ts
+class AssertError extends Error {
+  constructor(message) {
+    super(message ?? "assertion failed");
+    this.name = "AssertError";
+  }
+}
+
+// assert/assert.ts
+class assert {
+  constructor() {}
+  static that(condition, message) {
+    if (!condition) {
+      throw new AssertError(message);
+    }
+  }
+  static number(value, message) {
+    assert.that(typeof value === "number", message ?? `expected a number, got: ${value}`);
+    assert.that(!Number.isNaN(value), message ?? "expected a number, got NaN");
+  }
+  static integer(value, message) {
+    assert.number(value, message);
+    assert.that(Number.isInteger(value), message ?? `expected an integer, got: ${value}`);
+  }
+  static inRange(value, min, max, message) {
+    assert.number(value, message);
+    assert.that(value >= min && value <= max, message ?? `expected a value within [${min}, ${max}], got: ${value}`);
+  }
+  static notNull(value, message) {
+    assert.that(value !== null, message ?? "expected a value, got null");
+  }
+  static defined(value, message) {
+    assert.that(value !== undefined, message ?? "expected a value, got undefined");
+  }
+  static present(value, message) {
+    assert.notNull(value, message);
+    assert.defined(value, message);
+  }
+  static unreachable(message) {
+    throw new AssertError(message ?? "expected to be unreachable");
+  }
+}
+// assert/ensure.ts
+class ensure {
+  constructor() {}
+  static number(value, message) {
+    assert.number(value, message);
+    return value;
+  }
+  static integer(value, message) {
+    assert.integer(value, message);
+    return value;
+  }
+  static inRange(value, min, max, message) {
+    assert.inRange(value, min, max, message);
+    return value;
+  }
+  static notNull(value, message) {
+    assert.notNull(value, message);
+    return value;
+  }
+  static defined(value, message) {
+    assert.defined(value, message);
+    return value;
+  }
+  static present(value, message) {
+    assert.present(value, message);
+    return value;
+  }
+}
+export {
+  AssertError,
+  assert,
+  ensure
+};

package/vendor/core/cmd/cli.d.ts

@@ -0,0 +1,70 @@
+import { Command } from "./command";
+import type { Deps } from "./deps";
+import type { AnyMiddleware, Middleware } from "./middleware";
+/**
+ * What a `Cli` dispatches to: a command, or a group that dispatches again.
+ * `Command` satisfies it as it is, which is what lets the two nest freely.
+ */
+interface Node<D> {
+    /** What it does, beside the name it registered under in the parent's help. */
+    summary(): string;
+    exec(argv: string[], deps: D, outer: AnyMiddleware[], path: string): unknown;
+}
+/**
+ * `D` is what `run` is handed and what the actions start from; `C` is what the
+ * middleware has made of it by the time an action runs. Declaring a cli
+ * therefore takes no dependencies at all, which is what makes the declaration
+ * itself testable: build it once at module scope, run it with fakes.
+ */
+export declare class Cli<D extends Deps = Deps, C extends object = D> implements Node<D> {
+    readonly name: string;
+    private cmds;
+    private middleware;
+    private _description;
+    private _fallback;
+    constructor(name: string);
+    /** Only shown when this is a group, on its line in the parent's help. */
+    description(description: string): this;
+    /** Wraps every command's action. Call it before any `command()`. */
+    use<Out extends object>(middleware: Middleware<C, Out>): Cli<D, Out>;
+    command(name: string): Command<unknown, C>;
+    /**
+     * A subcommand that is itself a set of subcommands: `skills add`, `skills
+     * update`. The group is a `Cli` too, so it groups, takes middleware and
+     * prints help exactly the way the root does; only its name is longer.
+     */
+    group(name: string): Cli<D, C>;
+    /**
+     * The subcommand that runs when the first argument names none of the
+     * others, or there is none: `scry` runs `scry check`, and so do
+     * `scry ./app` and `scry --since main`, while `scry add` still adds. It
+     * gets the whole argument list. `--help` still prints this cli's help.
+     */
+    fallback(name: string): this;
+    /**
+     * Mounts another cli's commands under `name`. The mounted cli is built
+     * standalone, as its own program; here it becomes a group, and help names
+     * every command by the path it was reached through, not the name the
+     * mounted cli was built with.
+     */
+    mount<Sub extends object>(name: string, sub: Cli<D, Sub>): this;
+    /**
+     * The program's own dependencies; `log` and `ps` are filled in with the real
+     * ones when left out, and `argv` with the process's own arguments, so a bin
+     * only names what is its own. A test that wants fakes passes them.
+     */
+    run(deps: Omit<D, keyof Deps> & Partial<Deps>, argv?: string[]): unknown;
+    /**
+     * Dispatch, with whatever middleware the levels above contribute. Errors are
+     * left to propagate: only the root's `run` ends the process, so a group
+     * nested three deep still fails once, at the top. `path` is the spelling
+     * that reached this cli, which only the caller knows: a mounted cli is
+     * named one way on its own and another under the program that mounts it.
+     */
+    exec(argv: string[], deps: D, outer?: AnyMiddleware[], path?: string): unknown;
+    summary(): string;
+    private fail;
+    private help;
+}
+export declare function cli<D extends Deps = Deps>(name: string): Cli<D>;
+export {};

package/vendor/core/cmd/command.d.ts

@@ -0,0 +1,96 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { Deps } from "./deps";
+import { type AnyMiddleware, type Middleware } from "./middleware";
+type Action<O, C> = (parsed: O, ctx: C) => unknown;
+/**
+ * A Standard Schema that accepts command-line strings. Use
+ * `z.coerce.number()` for numeric arguments, for example.
+ */
+export type Arg<T> = StandardSchemaV1<unknown, T>;
+/** What a caller can say about an option or a positional beyond its schema. */
+export type Meta<T> = {
+    /** Supplying one makes the option or argument optional. */
+    default?: T;
+    /** The line the help output prints beside it. */
+    description?: string;
+};
+/**
+ * What a caller can say about a variadic argument. It has no `default`: a
+ * variadic with nothing left to collect is an empty array, never missing.
+ */
+export type RestMeta = Pick<Meta<unknown>, "description">;
+export declare class Command<O, C extends object = object> {
+    readonly name: string;
+    private _description;
+    private options;
+    private args;
+    private variadic;
+    private middleware;
+    private _action;
+    private hasAction;
+    private unknownOptions;
+    private excessArguments;
+    private passThrough;
+    constructor(name: string);
+    description(description: string): this;
+    summary(): string;
+    option<K extends string, T>(name: K, schema: Arg<T>, meta?: Meta<T>): Command<O & {
+        [P in K]: T;
+    }, C>;
+    /**
+     * An option given any number of times, collecting each value in order as
+     * an array. The schema describes one of them, so
+     * `repeated("tag", z.string())` arrives as `string[]`, empty when it was
+     * never given.
+     */
+    repeated<K extends string, T>(name: K, schema: Arg<T>, meta?: RestMeta): Command<O & {
+        [P in K]: T[];
+    }, C>;
+    arg<K extends string, T>(name: K, schema: Arg<T>, meta?: Meta<T>): Command<O & {
+        [P in K]: T;
+    }, C>;
+    /**
+     * The last positional, collecting every argument left over as an array. The
+     * schema describes one of them, so `rest("args", z.string())` arrives as
+     * `string[]`, empty when there was nothing left. Only one is allowed, and
+     * nothing may be declared after it.
+     */
+    rest<K extends string, T>(name: K, schema: Arg<T>, meta?: RestMeta): Command<O & {
+        [P in K]: T[];
+    }, C>;
+    /**
+     * Lets a flag this command never declared through as an ordinary argument,
+     * for a command that forwards what it is given to another program. Declared
+     * options are still read from the same command line.
+     */
+    allowUnknownOption(allow?: boolean): this;
+    /** Lets more arguments arrive than were declared, instead of failing. */
+    allowExcessArguments(allow?: boolean): this;
+    /**
+     * Stops reading options once the first argument has arrived, so everything
+     * past it is an argument however it is spelled. `cmd --port 80 run` reads
+     * `--port`; `cmd run --port 80` passes it on, with no `--` needed.
+     */
+    passThroughOptions(passThrough?: boolean): this;
+    /**
+     * Wraps this command's action, inside whatever the `Cli` already wraps it
+     * with. Has to come before `action`, which is typed against the context the
+     * chain produces.
+     */
+    use<Out extends object>(middleware: Middleware<C, Out>): Command<O, Out>;
+    action(action: Action<O, C>): this;
+    exec(argv: string[], deps: Pick<Deps, "log"> & Partial<Pick<Deps, "ps">>, outer?: AnyMiddleware[], path?: string): unknown;
+    /**
+     * Whether this run is asking for help rather than doing anything. Only what
+     * is still being read as an option counts: past a `--`, or past the first
+     * argument of a pass-through command, `--help` belongs to whatever this
+     * command forwards to.
+     */
+    private wantsHelp;
+    private isValue;
+    private isSwitch;
+    private parse;
+    private optionRow;
+    private help;
+}
+export {};

package/vendor/core/cmd/deps.d.ts

@@ -0,0 +1,12 @@
+import type { Logger } from "../log/index.js";
+import type { Ps } from "../system/index.js";
+/**
+ * The least a cli needs handed to it: somewhere to print help and errors, and
+ * something that can end the process. A program declares its own dependencies
+ * as an extension of this, `cli<MyDeps>(name)` types `run` against them, and
+ * they seed the context every action receives.
+ */
+export interface Deps {
+    log: Logger;
+    ps: Ps;
+}

package/vendor/core/cmd/help.d.ts

@@ -0,0 +1,16 @@
+/** One row of a help section: what to type, and what it does. */
+export type Row = readonly [label: string, text: string];
+/**
+ * Lays out a help section: each label in a column of its own, its text beside
+ * it. On a terminal `width` columns wide, text wraps back to its own column
+ * rather than to the left edge, and once any row wraps a blank line parts
+ * every row from the next, so where one ends is plain. Without a width, as
+ * when piped, each row stays one line, so grep finds it whole.
+ */
+export declare function table(rows: readonly Row[], style: (label: string) => string, width: number | undefined): string[];
+/**
+ * Breaks text at spaces into lines at most `width` columns wide, counting
+ * only what shows, not colour codes; a word wider than that gets a line to
+ * itself. Its own line breaks stay. Without a width it is left whole.
+ */
+export declare function wrap(text: string, width: number | undefined): string[];

package/vendor/core/cmd/index.d.ts

@@ -0,0 +1,6 @@
+export type { Cli } from "./cli";
+export { cli } from "./cli";
+export type { Arg, Meta, RestMeta } from "./command";
+export type { Deps } from "./deps";
+export type { Middleware, Next } from "./middleware";
+export { timed } from "./timed";