flingit 0.0.63 → 0.0.66

package/node_modules/determined/dist/index.d.cts

@@ -0,0 +1,110 @@
+import { Result } from 'neverthrow';
+import { BrandedString } from '@glideapps/ts-necessities';
+
+interface EntropySource {
+    random(reason: string): number;
+}
+declare class SimpleEntropySource implements EntropySource {
+    random(): number;
+}
+interface EntropyRecord {
+    readonly name: string;
+    readonly value: number;
+}
+declare class RecordingEntropySource implements EntropySource {
+    private readonly underlying;
+    private readonly records;
+    constructor(underlying: EntropySource);
+    random(name: string): number;
+    getRecords(): readonly EntropyRecord[];
+}
+declare class ReplayingEntropySource implements EntropySource {
+    private readonly records;
+    private position;
+    constructor(records: readonly EntropyRecord[]);
+    random(name: string): number;
+}
+declare function sample<T>(entropy: EntropySource, name: string, items: readonly T[]): T | undefined;
+
+interface Logger {
+    log(...log: readonly unknown[]): void;
+    error(...log: readonly unknown[]): void;
+}
+interface SimulationTask extends Logger, EntropySource {
+    checkpoint(...log: readonly unknown[]): Promise<void>;
+    failpoint(...log: readonly unknown[]): Promise<void>;
+    blockpoint(...log: readonly unknown[]): void;
+    abortSimulation(e: unknown): never;
+}
+interface TaskSpec<T> {
+    readonly name: string;
+    readonly f: (task: SimulationTask) => Promise<T>;
+}
+interface Simulation {
+    runTasks<TSpecs extends readonly TaskSpec<any>[]>(specs: TSpecs): Promise<Result<{
+        [K in keyof TSpecs]: TSpecs[K] extends TaskSpec<infer R> ? R : never;
+    }, Error>>;
+}
+declare class NoSimulationTask implements SimulationTask {
+    private readonly taskName;
+    private readonly shouldLog;
+    constructor(taskName: string, shouldLog: boolean);
+    log(...log: readonly unknown[]): void;
+    error(...log: readonly unknown[]): void;
+    random(): number;
+    checkpoint(...log: readonly unknown[]): Promise<void>;
+    failpoint(...log: readonly unknown[]): Promise<void>;
+    blockpoint(...log: readonly unknown[]): void;
+    abortSimulation(e: unknown): never;
+}
+declare class NoSimulation implements Simulation {
+    private readonly log;
+    constructor(log: boolean);
+    runTasks<TSpecs extends readonly TaskSpec<any>[]>(specs: TSpecs): Promise<Result<{
+        [K in keyof TSpecs]: TSpecs[K] extends TaskSpec<infer R> ? R : never;
+    }, Error>>;
+}
+declare const noSimulation: NoSimulation;
+declare class SimulationImpl implements Simulation {
+    private readonly logger;
+    private readonly entropy;
+    private readonly failureProbability;
+    private readonly taskInfos;
+    private abortedWithError;
+    constructor(logger: Logger, entropy: EntropySource, failureProbability: number);
+    private abort;
+    private pickTask;
+    private unlockIfNecessary;
+    runTasks<TSpecs extends readonly TaskSpec<any>[]>(specs: TSpecs): Promise<Result<{
+        [K in keyof TSpecs]: TSpecs[K] extends TaskSpec<infer R> ? R : never;
+    }, Error>>;
+}
+
+type ErrorType = BrandedString<"ErrorType">;
+declare const makeErrorType: (s: string) => ErrorType;
+declare class ApplicationFailure extends Error {
+    readonly type: ErrorType | undefined;
+    readonly nonRetryable: boolean;
+    constructor(message: string, type?: ErrorType, nonRetryable?: boolean);
+}
+declare function isApplicationFailure(error: unknown): error is ApplicationFailure;
+
+declare class Mutex {
+    /** This is `undefined` iff the mutex is unlocked.  Otherwise it's an array of resolve functions, one for each waiter. */
+    private waiters;
+    private readonly name;
+    constructor(name: string);
+    get isLocked(): boolean;
+    lock(task: SimulationTask, reason: string): Promise<void>;
+    unlock(task: SimulationTask, reason: string): void;
+}
+
+declare class ConditionVariable {
+    private readonly waiters;
+    private readonly name;
+    constructor(name: string);
+    wait(task: SimulationTask, reason: string): Promise<void>;
+    notifyAll(task: SimulationTask, reason: string): void;
+}
+
+export { ApplicationFailure, ConditionVariable, type EntropySource, type ErrorType, type Logger, Mutex, NoSimulationTask, RecordingEntropySource, ReplayingEntropySource, SimpleEntropySource, type Simulation, SimulationImpl, type SimulationTask, type TaskSpec, isApplicationFailure, makeErrorType, noSimulation, sample };

package/node_modules/determined/dist/index.d.ts

@@ -0,0 +1,110 @@
+import { Result } from 'neverthrow';
+import { BrandedString } from '@glideapps/ts-necessities';
+
+interface EntropySource {
+    random(reason: string): number;
+}
+declare class SimpleEntropySource implements EntropySource {
+    random(): number;
+}
+interface EntropyRecord {
+    readonly name: string;
+    readonly value: number;
+}
+declare class RecordingEntropySource implements EntropySource {
+    private readonly underlying;
+    private readonly records;
+    constructor(underlying: EntropySource);
+    random(name: string): number;
+    getRecords(): readonly EntropyRecord[];
+}
+declare class ReplayingEntropySource implements EntropySource {
+    private readonly records;
+    private position;
+    constructor(records: readonly EntropyRecord[]);
+    random(name: string): number;
+}
+declare function sample<T>(entropy: EntropySource, name: string, items: readonly T[]): T | undefined;
+
+interface Logger {
+    log(...log: readonly unknown[]): void;
+    error(...log: readonly unknown[]): void;
+}
+interface SimulationTask extends Logger, EntropySource {
+    checkpoint(...log: readonly unknown[]): Promise<void>;
+    failpoint(...log: readonly unknown[]): Promise<void>;
+    blockpoint(...log: readonly unknown[]): void;
+    abortSimulation(e: unknown): never;
+}
+interface TaskSpec<T> {
+    readonly name: string;
+    readonly f: (task: SimulationTask) => Promise<T>;
+}
+interface Simulation {
+    runTasks<TSpecs extends readonly TaskSpec<any>[]>(specs: TSpecs): Promise<Result<{
+        [K in keyof TSpecs]: TSpecs[K] extends TaskSpec<infer R> ? R : never;
+    }, Error>>;
+}
+declare class NoSimulationTask implements SimulationTask {
+    private readonly taskName;
+    private readonly shouldLog;
+    constructor(taskName: string, shouldLog: boolean);
+    log(...log: readonly unknown[]): void;
+    error(...log: readonly unknown[]): void;
+    random(): number;
+    checkpoint(...log: readonly unknown[]): Promise<void>;
+    failpoint(...log: readonly unknown[]): Promise<void>;
+    blockpoint(...log: readonly unknown[]): void;
+    abortSimulation(e: unknown): never;
+}
+declare class NoSimulation implements Simulation {
+    private readonly log;
+    constructor(log: boolean);
+    runTasks<TSpecs extends readonly TaskSpec<any>[]>(specs: TSpecs): Promise<Result<{
+        [K in keyof TSpecs]: TSpecs[K] extends TaskSpec<infer R> ? R : never;
+    }, Error>>;
+}
+declare const noSimulation: NoSimulation;
+declare class SimulationImpl implements Simulation {
+    private readonly logger;
+    private readonly entropy;
+    private readonly failureProbability;
+    private readonly taskInfos;
+    private abortedWithError;
+    constructor(logger: Logger, entropy: EntropySource, failureProbability: number);
+    private abort;
+    private pickTask;
+    private unlockIfNecessary;
+    runTasks<TSpecs extends readonly TaskSpec<any>[]>(specs: TSpecs): Promise<Result<{
+        [K in keyof TSpecs]: TSpecs[K] extends TaskSpec<infer R> ? R : never;
+    }, Error>>;
+}
+
+type ErrorType = BrandedString<"ErrorType">;
+declare const makeErrorType: (s: string) => ErrorType;
+declare class ApplicationFailure extends Error {
+    readonly type: ErrorType | undefined;
+    readonly nonRetryable: boolean;
+    constructor(message: string, type?: ErrorType, nonRetryable?: boolean);
+}
+declare function isApplicationFailure(error: unknown): error is ApplicationFailure;
+
+declare class Mutex {
+    /** This is `undefined` iff the mutex is unlocked.  Otherwise it's an array of resolve functions, one for each waiter. */
+    private waiters;
+    private readonly name;
+    constructor(name: string);
+    get isLocked(): boolean;
+    lock(task: SimulationTask, reason: string): Promise<void>;
+    unlock(task: SimulationTask, reason: string): void;
+}
+
+declare class ConditionVariable {
+    private readonly waiters;
+    private readonly name;
+    constructor(name: string);
+    wait(task: SimulationTask, reason: string): Promise<void>;
+    notifyAll(task: SimulationTask, reason: string): void;
+}
+
+export { ApplicationFailure, ConditionVariable, type EntropySource, type ErrorType, type Logger, Mutex, NoSimulationTask, RecordingEntropySource, ReplayingEntropySource, SimpleEntropySource, type Simulation, SimulationImpl, type SimulationTask, type TaskSpec, isApplicationFailure, makeErrorType, noSimulation, sample };

package/node_modules/determined/dist/index.js

@@ -0,0 +1,332 @@
+// simulation.ts
+import { assert, exceptionToError, exceptionToString } from "@glideapps/ts-necessities";
+
+// entropy.ts
+var SimpleEntropySource = class {
+  random() {
+    return Math.random();
+  }
+};
+var RecordingEntropySource = class {
+  underlying;
+  records = [];
+  constructor(underlying) {
+    this.underlying = underlying;
+  }
+  random(name) {
+    const value = this.underlying.random(name);
+    this.records.push({ name, value });
+    return value;
+  }
+  getRecords() {
+    return this.records;
+  }
+};
+var ReplayingEntropySource = class {
+  records;
+  position = 0;
+  constructor(records) {
+    this.records = records.slice();
+  }
+  random(name) {
+    const record = this.records[this.position];
+    if (record === void 0) {
+      throw new Error(`No more entropy records available when requesting "${name}"`);
+    }
+    if (record.name !== name) {
+      throw new Error(
+        `Entropy record name mismatch at position ${this.position}: expected "${record.name}", got "${name}"`
+      );
+    }
+    this.position++;
+    return record.value;
+  }
+};
+function sample(entropy, name, items) {
+  if (items.length < 2) return items[0];
+  const index = Math.floor(entropy.random(name) * items.length);
+  return items[index];
+}
+
+// errors.ts
+import { makeBrandString } from "@glideapps/ts-necessities";
+var makeErrorType = makeBrandString();
+var ApplicationFailure = class extends Error {
+  type;
+  nonRetryable;
+  constructor(message, type, nonRetryable) {
+    super(message);
+    this.type = type;
+    this.nonRetryable = nonRetryable ?? false;
+  }
+};
+function isApplicationFailure(error) {
+  return error instanceof ApplicationFailure;
+}
+
+// simulation.ts
+import { err, ok } from "neverthrow";
+var NoSimulationTask = class {
+  taskName;
+  shouldLog;
+  constructor(taskName, shouldLog) {
+    this.taskName = taskName;
+    this.shouldLog = shouldLog;
+  }
+  log(...log) {
+    if (this.shouldLog) {
+      console.log(`${this.taskName}: `, ...log);
+    }
+  }
+  error(...log) {
+    console.error(`${this.taskName}: `, ...log);
+  }
+  random() {
+    return Math.random();
+  }
+  checkpoint(...log) {
+    this.log(...log);
+    return Promise.resolve();
+  }
+  failpoint(...log) {
+    this.log(...log);
+    return Promise.resolve();
+  }
+  blockpoint(...log) {
+    this.log(...log);
+  }
+  abortSimulation(e) {
+    throw exceptionToError(e);
+  }
+};
+var NoSimulation = class {
+  log;
+  constructor(log) {
+    this.log = log;
+  }
+  async runTasks(specs) {
+    const shouldLog = this.log;
+    try {
+      const results = await Promise.all(
+        specs.map(({ name: taskName, f }) => {
+          const task = new NoSimulationTask(taskName, shouldLog);
+          return f(task);
+        })
+      );
+      return ok(results);
+    } catch (e) {
+      return err(exceptionToError(e));
+    }
+  }
+};
+var noSimulation = new NoSimulation(false);
+var SimulationImpl = class {
+  logger;
+  entropy;
+  failureProbability;
+  // FIXME: Should this just be a `TaskInfo[]`, since we never look at the task anyway?
+  taskInfos = /* @__PURE__ */ new Map();
+  abortedWithError;
+  constructor(logger, entropy, failureProbability) {
+    this.logger = logger;
+    this.entropy = entropy;
+    this.failureProbability = failureProbability;
+  }
+  abort(e) {
+    if (this.abortedWithError === void 0) {
+      this.abortedWithError = e;
+      this.logger.error(`Aborting simulation: ${exceptionToString(e)}`);
+    }
+    throw e;
+  }
+  pickTask(tasks) {
+    const task = sample(this.entropy, `Picking task out of ${tasks.map((t) => t.name).join(", ")}`, tasks);
+    assert(task !== void 0, "No tasks to pick from");
+    return task;
+  }
+  unlockIfNecessary() {
+    if (this.abortedWithError !== void 0) throw this.abortedWithError;
+    if (this.taskInfos.size === 0) return;
+    const entries = Array.from(this.taskInfos.entries());
+    if (entries.some(([, i]) => i.resolve === void 0)) {
+      return;
+    }
+    const checkpointEntries = entries.filter(([, i]) => i.resolve !== void 0 && i.resolve !== false);
+    assert(checkpointEntries.length > 0, "All tasks are blocked");
+    const info = this.pickTask(checkpointEntries.map(([, i]) => i));
+    this.logger.log(`${info.name} UNBLOCKED from ${entries.map(([, i]) => i.name).join(", ")}`);
+    const { resolve } = info;
+    assert(resolve !== void 0 && resolve !== false);
+    info.resolve = void 0;
+    resolve();
+  }
+  async runTasks(specs) {
+    const simulation = this;
+    const tasksAndInfos = specs.map((s) => {
+      const info = { name: s.name, resolve: void 0 };
+      const task = {
+        random(name) {
+          const r = simulation.entropy.random(`${s.name} random number: ${name}`);
+          simulation.logger.log(`${s.name} RANDOM ${name}: ${r}`);
+          return r;
+        },
+        log(...log) {
+          simulation.logger.log(`${s.name}:`, ...log);
+        },
+        error(...log) {
+          simulation.logger.error(`${s.name}:`, ...log);
+        },
+        checkpoint(...log) {
+          simulation.logger.log(`${s.name} CHECKPOINT:`, ...log);
+          assert(
+            simulation.taskInfos.has(task),
+            `Task ${s.name} wants to checkpoint, but doesn't exist anymore`
+          );
+          const promise = new Promise((resolve) => {
+            assert(info.resolve === void 0 || info.resolve === false);
+            info.resolve = resolve;
+          });
+          simulation.unlockIfNecessary();
+          return promise;
+        },
+        failpoint(...log) {
+          assert(
+            simulation.taskInfos.has(task),
+            `Task ${s.name} wants to failpoint, but doesn't exist anymore`
+          );
+          const shouldFail = simulation.failureProbability > 0 && simulation.entropy.random(`${s.name} failpoint: ${log.join(" ")}`) < simulation.failureProbability;
+          if (shouldFail) {
+            simulation.logger.log(`${s.name} FAILING:`, ...log);
+            return Promise.reject(
+              new ApplicationFailure(`Simulated failure at failpoint: ${log.join(" ")}`)
+            );
+          }
+          simulation.logger.log(`${s.name} FAILPOINT:`, ...log);
+          const promise = new Promise((resolve) => {
+            assert(
+              info.resolve === void 0 || info.resolve === false,
+              `Task ${s.name} already has a resolve`
+            );
+            info.resolve = resolve;
+          });
+          simulation.unlockIfNecessary();
+          return promise;
+        },
+        blockpoint(...log) {
+          simulation.logger.log(`${s.name} BLOCKPOINT:`, ...log);
+          assert(simulation.taskInfos.has(task));
+          assert(info.resolve === void 0, `Task ${s.name} already has a resolve`);
+          info.resolve = false;
+          simulation.unlockIfNecessary();
+        },
+        abortSimulation(e) {
+          return simulation.abort(e);
+        }
+      };
+      return [s, task, info];
+    });
+    for (const [, task, info] of tasksAndInfos) {
+      this.taskInfos.set(task, info);
+    }
+    try {
+      const results = await Promise.all(
+        tasksAndInfos.map(([s, task]) => {
+          return task.checkpoint("START").then(() => s.f(task)).catch((e) => this.abort(e)).finally(() => {
+            this.taskInfos.delete(task);
+            this.logger.log(
+              `FINISHED ${s.name}, still left ${Array.from(this.taskInfos.values()).map((i) => i.name).join(", ")}`
+            );
+            this.unlockIfNecessary();
+          });
+        })
+      );
+      return ok(results);
+    } catch (e) {
+      return err(exceptionToError(e));
+    }
+  }
+};
+
+// mutex.ts
+import { assert as assert2, defined } from "@glideapps/ts-necessities";
+var Mutex = class {
+  /** This is `undefined` iff the mutex is unlocked.  Otherwise it's an array of resolve functions, one for each waiter. */
+  waiters;
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  get isLocked() {
+    return this.waiters !== void 0;
+  }
+  lock(task, reason) {
+    if (this.waiters === void 0) {
+      task.log(`mutex "${this.name}" locked unopposed for "${reason}"`);
+      this.waiters = [];
+      return Promise.resolve();
+    } else {
+      task.blockpoint(`mutex "${this.name}" enqueue for "${reason}", ${this.waiters.length} other waiters`);
+      const p = new Promise((resolve) => {
+        defined(this.waiters, "Promise init function did not run inline").push(async () => {
+          await task.checkpoint(
+            `mutex "${this.name}" acquired by waiter for "${reason}", ${defined(this.waiters).length} other waiters`
+          );
+          resolve();
+        });
+      });
+      return p;
+    }
+  }
+  unlock(task, reason) {
+    assert2(this.waiters !== void 0, "Can't unlock a mutex that's not locked");
+    const resolve = this.waiters.shift();
+    if (resolve !== void 0) {
+      task.log(
+        `mutex "${this.name}" unlocked and passed to next waiter for "${reason}", ${this.waiters.length} waiters left`
+      );
+      resolve();
+    } else {
+      task.log(`mutex "${this.name}" unlocked for "${reason}"`);
+      this.waiters = void 0;
+    }
+  }
+};
+
+// condition-variable.ts
+var ConditionVariable = class {
+  waiters = [];
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  wait(task, reason) {
+    task.blockpoint(`condition "${this.name}" wait for "${reason}", ${this.waiters.length} other waiters`);
+    return new Promise((resolve) => {
+      this.waiters.push(async () => {
+        await task.checkpoint(`condition "${this.name}" woken up for "${reason}"`);
+        resolve();
+      });
+    });
+  }
+  notifyAll(task, reason) {
+    task.log(`condition "${this.name}" notifying ${this.waiters.length} for "${reason}"`);
+    for (const resolve of this.waiters) {
+      resolve();
+    }
+    this.waiters.length = 0;
+  }
+};
+export {
+  ApplicationFailure,
+  ConditionVariable,
+  Mutex,
+  NoSimulationTask,
+  RecordingEntropySource,
+  ReplayingEntropySource,
+  SimpleEntropySource,
+  SimulationImpl,
+  isApplicationFailure,
+  makeErrorType,
+  noSimulation,
+  sample
+};

package/node_modules/determined/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "determined",
+    "version": "0.1.0",
+    "type": "module",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/glideapps/determined.git"
+    },
+    "main": "./dist/index.cjs",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./dist/index.d.ts",
+                "default": "./dist/index.js"
+            },
+            "require": {
+                "types": "./dist/index.d.cts",
+                "default": "./dist/index.cjs"
+            }
+        }
+    },
+    "files": [
+        "dist",
+        "LICENSE",
+        "README.md"
+    ],
+    "dependencies": {
+        "@glideapps/ts-necessities": "^2.4.0",
+        "neverthrow": "^8.2.0"
+    },
+    "devDependencies": {
+        "@types/node": "^24.10.1",
+        "tsup": "^8.5.1",
+        "typescript": "^5.9.3"
+    },
+    "scripts": {
+        "build": "tsup",
+        "test": "node --experimental-strip-types --test *.test.ts",
+        "typecheck": "tsc",
+        "prepublishOnly": "npm run build"
+    }
+}

package/node_modules/end-of-stream/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mathias Buus
+
+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/node_modules/end-of-stream/README.md

@@ -0,0 +1,54 @@
+# end-of-stream
+
+A node module that calls a callback when a readable/writable/duplex stream has completed or failed.
+
+	npm install end-of-stream
+
+[![Build status](https://travis-ci.org/mafintosh/end-of-stream.svg?branch=master)](https://travis-ci.org/mafintosh/end-of-stream)
+
+## Usage
+
+Simply pass a stream and a callback to the `eos`.
+Both legacy streams, streams2 and stream3 are supported.
+
+``` js
+var eos = require('end-of-stream');
+
+eos(readableStream, function(err) {
+  // this will be set to the stream instance
+	if (err) return console.log('stream had an error or closed early');
+	console.log('stream has ended', this === readableStream);
+});
+
+eos(writableStream, function(err) {
+	if (err) return console.log('stream had an error or closed early');
+	console.log('stream has finished', this === writableStream);
+});
+
+eos(duplexStream, function(err) {
+	if (err) return console.log('stream had an error or closed early');
+	console.log('stream has ended and finished', this === duplexStream);
+});
+
+eos(duplexStream, {readable:false}, function(err) {
+	if (err) return console.log('stream had an error or closed early');
+	console.log('stream has finished but might still be readable');
+});
+
+eos(duplexStream, {writable:false}, function(err) {
+	if (err) return console.log('stream had an error or closed early');
+	console.log('stream has ended but might still be writable');
+});
+
+eos(readableStream, {error:false}, function(err) {
+	// do not treat emit('error', err) as a end-of-stream
+});
+```
+
+## License
+
+MIT
+
+## Related
+
+`end-of-stream` is part of the [mississippi stream utility collection](https://github.com/maxogden/mississippi) which includes more useful stream modules similar to this one.