@farthershore/cli 0.3.9 → 0.3.10

package/node_modules/thread-stream/test/thread-management.test.js

@@ -0,0 +1,138 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { fork } = require('child_process')
+const { join } = require('path')
+const { readFile } = require('fs').promises
+const { file } = require('./helper')
+const { once } = require('events')
+const ThreadStream = require('..')
+
+test('exits with 0', async function (t) {
+  const dest = file()
+  const child = fork(join(__dirname, 'create-and-exit.js'), [dest])
+
+  const [code] = await once(child, 'exit')
+  assert.strictEqual(code, 0)
+
+  const data = await readFile(dest, 'utf8')
+  assert.strictEqual(data, 'hello world\n')
+})
+
+test('emit error if thread exits', async function (t) {
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'exit.js'),
+    sync: true
+  })
+
+  const closed = once(stream, 'close').catch(() => {})
+
+  stream.on('ready', () => {
+    stream.write('hello world\n')
+  })
+
+  let [err] = await once(stream, 'error')
+  assert.strictEqual(err.message, 'the worker thread exited')
+
+  stream.write('noop');
+  [err] = await once(stream, 'error')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  stream.write('noop');
+  [err] = await once(stream, 'error')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  await closed
+})
+
+test('emit error if thread have unhandledRejection', async function (t) {
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'unhandledRejection.js'),
+    sync: true
+  })
+
+  const closed = once(stream, 'close').catch(() => {})
+
+  stream.on('ready', () => {
+    stream.write('hello world\n')
+  })
+
+  let [err] = await once(stream, 'error')
+  assert.strictEqual(err.message, 'kaboom')
+
+  stream.write('noop');
+  [err] = await once(stream, 'error')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  stream.write('noop');
+  [err] = await once(stream, 'error')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  await closed
+})
+
+test('emit error if worker stream emit error', async function (t) {
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'error.js'),
+    sync: true
+  })
+
+  const closed = once(stream, 'close').catch(() => {})
+
+  stream.on('ready', () => {
+    stream.write('hello world\n')
+  })
+
+  let [err] = await once(stream, 'error')
+  assert.strictEqual(err.message, 'kaboom')
+
+  stream.write('noop');
+  [err] = await once(stream, 'error')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  stream.write('noop');
+  [err] = await once(stream, 'error')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  await closed
+})
+
+test('emit error if thread have uncaughtException', async function (t) {
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'uncaughtException.js'),
+    sync: true
+  })
+
+  const closed = once(stream, 'close').catch(() => {})
+
+  stream.on('ready', () => {
+    stream.write('hello world\n')
+  })
+
+  let [err] = await once(stream, 'error')
+  assert.strictEqual(err.message, 'kaboom')
+
+  stream.write('noop');
+  [err] = await once(stream, 'error')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  stream.write('noop');
+  [err] = await once(stream, 'error')
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  await closed
+})
+
+test('close the work if out of scope on gc', { skip: !global.WeakRef }, async function (t) {
+  const dest = file()
+  const child = fork(join(__dirname, 'close-on-gc.js'), [dest], {
+    execArgv: ['--expose-gc']
+  })
+
+  const [code] = await once(child, 'exit')
+  assert.strictEqual(code, 0)
+
+  const data = await readFile(dest, 'utf8')
+  assert.strictEqual(data, 'hello world\n')
+})

package/node_modules/thread-stream/test/to-file-on-destroy.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const fs = require('fs')
+const { Writable } = require('stream')
+
+function run (opts) {
+  let data = ''
+  return new Writable({
+    autoDestroy: true,
+    write (chunk, enc, cb) {
+      data += chunk.toString()
+      cb()
+    },
+    destroy (err, cb) {
+      // process._rawDebug('destroy called')
+      fs.writeFile(opts.dest, data, function (err2) {
+        cb(err2 || err)
+      })
+    }
+  })
+}
+
+module.exports = run

package/node_modules/thread-stream/test/to-file-on-final.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const fs = require('fs')
+const { Writable } = require('stream')
+
+function run (opts) {
+  let data = ''
+  return new Writable({
+    autoDestroy: true,
+    write (chunk, enc, cb) {
+      data += chunk.toString()
+      cb()
+    },
+    final (cb) {
+      setTimeout(function () {
+        fs.writeFile(opts.dest, data, function (err) {
+          cb(err)
+        })
+      }, 100)
+    }
+  })
+}
+
+module.exports = run

package/node_modules/thread-stream/test/to-file.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const fs = require('fs')
+const { once } = require('events')
+
+async function run (opts) {
+  const stream = fs.createWriteStream(opts.dest)
+  await once(stream, 'open')
+  return stream
+}
+
+module.exports = run

package/node_modules/thread-stream/test/to-file.mjs

@@ -0,0 +1,8 @@
+import { createWriteStream } from 'fs'
+import { once } from 'events'
+
+export default async function run (opts) {
+  const stream = createWriteStream(opts.dest)
+  await once(stream, 'open')
+  return stream
+}

package/node_modules/thread-stream/test/to-next.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const { PassThrough } = require('stream')
+
+async function run (opts) {
+  return new PassThrough({})
+}
+
+module.exports = run

package/node_modules/thread-stream/test/transpiled.test.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { join } = require('path')
+const { file } = require('./helper')
+const ThreadStream = require('..')
+
+function basic (esVersion) {
+  test(`transpiled-ts-to-${esVersion}`, function () {
+    const dest = file()
+    const stream = new ThreadStream({
+      filename: join(__dirname, 'ts', `to-file.${esVersion}.cjs`),
+      workerData: { dest },
+      sync: true
+    })
+
+    // There are arbitrary checks, the important aspect of this test is to ensure
+    // that we can properly load the transpiled file into our worker thread.
+    assert.deepStrictEqual(stream.writableEnded, false)
+    stream.end()
+    assert.deepStrictEqual(stream.writableEnded, true)
+  })
+}
+
+basic('es5')
+basic('es6')
+basic('es2017')
+basic('esnext')

package/node_modules/thread-stream/test/ts/to-file.ts

@@ -0,0 +1,10 @@
+import { type PathLike, type WriteStream, createWriteStream } from 'fs'
+import { once } from 'events'
+
+export default async function run (
+  opts: { dest: PathLike },
+): Promise<WriteStream> {
+  const stream = createWriteStream(opts.dest)
+  await once(stream, 'open')
+  return stream
+}

package/node_modules/thread-stream/test/ts/transpile.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+set -e
+
+cd ./test/ts;
+
+if (echo "${npm_config_user_agent}" | grep "yarn"); then
+  export RUNNER="yarn";
+else
+  export RUNNER="npx";
+fi
+
+test ./to-file.ts -ot ./to-file.es5.cjs    || ("${RUNNER}" tsc --skipLibCheck --target es5                      ./to-file.ts && mv ./to-file.js ./to-file.es5.cjs);
+test ./to-file.ts -ot ./to-file.es6.mjs    || ("${RUNNER}" tsc --skipLibCheck --target es6                      ./to-file.ts && mv ./to-file.js ./to-file.es6.mjs);
+test ./to-file.ts -ot ./to-file.es6.cjs    || ("${RUNNER}" tsc --skipLibCheck --target es6    --module commonjs ./to-file.ts && mv ./to-file.js ./to-file.es6.cjs);
+test ./to-file.ts -ot ./to-file.es2017.mjs || ("${RUNNER}" tsc --skipLibCheck --target es2017                   ./to-file.ts && mv ./to-file.js ./to-file.es2017.mjs);
+test ./to-file.ts -ot ./to-file.es2017.cjs || ("${RUNNER}" tsc --skipLibCheck --target es2017 --module commonjs ./to-file.ts && mv ./to-file.js ./to-file.es2017.cjs);
+test ./to-file.ts -ot ./to-file.esnext.mjs || ("${RUNNER}" tsc --skipLibCheck --target esnext --module esnext   ./to-file.ts && mv ./to-file.js ./to-file.esnext.mjs);
+test ./to-file.ts -ot ./to-file.esnext.cjs || ("${RUNNER}" tsc --skipLibCheck --target esnext --module commonjs ./to-file.ts && mv ./to-file.js ./to-file.esnext.cjs);

package/node_modules/thread-stream/test/ts-native.test.mjs

@@ -0,0 +1,35 @@
+import { test } from 'node:test'
+import assert from 'node:assert'
+import { readFile } from 'fs/promises'
+import ThreadStream from '../index.js'
+import { join } from 'desm'
+import { file } from './helper.js'
+
+const nodeVersion = parseInt(process.versions.node.split('.')[0], 10)
+
+// Native TypeScript stripping (--experimental-strip-types) is only available in Node 22.6+
+test('typescript module with native type stripping', { skip: nodeVersion < 22 }, async function (t) {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(import.meta.url, 'ts', 'to-file.ts'),
+    workerData: { dest },
+    workerOpts: {
+      execArgv: ['--experimental-strip-types', '--disable-warning=ExperimentalWarning']
+    },
+    sync: false
+  })
+
+  t.after(() => stream.end())
+
+  assert.ok(stream.write('hello world\n'))
+  assert.ok(stream.write('something else\n'))
+
+  stream.end()
+
+  await new Promise((resolve) => {
+    stream.on('close', resolve)
+  })
+
+  const data = await readFile(dest, 'utf8')
+  assert.strictEqual(data, 'hello world\nsomething else\n')
+})

package/node_modules/thread-stream/test/ts-node-fallback.test.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { readFile } = require('fs/promises')
+const { join } = require('path')
+const { file } = require('./helper')
+const ThreadStream = require('..')
+
+// This test verifies that TypeScript files can be loaded via ts-node
+// when native type stripping is not enabled in the worker thread.
+// Unlike ts.test.ts which passes --experimental-strip-types via execArgv,
+// this test does NOT pass that flag, so the worker will fall back to ts-node.
+test('typescript module with ts-node fallback', async function (t) {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'ts', 'to-file.ts'),
+    workerData: { dest },
+    sync: false
+  })
+
+  t.after(() => stream.end())
+
+  assert.ok(stream.write('hello world\n'))
+  assert.ok(stream.write('something else\n'))
+
+  stream.end()
+
+  await new Promise((resolve) => {
+    stream.on('close', resolve)
+  })
+
+  const data = await readFile(dest, 'utf8')
+  assert.strictEqual(data, 'hello world\nsomething else\n')
+})

package/node_modules/thread-stream/test/uncaughtException.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const { Writable } = require('stream')
+
+// Nop console.error to avoid printing things out
+console.error = () => {}
+
+setImmediate(function () {
+  throw new Error('kaboom')
+})
+
+async function run (opts) {
+  const stream = new Writable({
+    write (chunk, enc, cb) {
+      cb()
+    }
+  })
+  return stream
+}
+
+module.exports = run

package/node_modules/thread-stream/test/unhandledRejection.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const { Writable } = require('stream')
+
+// Nop console.error to avoid printing things out
+console.error = () => {}
+
+setImmediate(function () {
+  Promise.reject(new Error('kaboom'))
+})
+
+async function run (opts) {
+  const stream = new Writable({
+    write (chunk, enc, cb) {
+      cb()
+    }
+  })
+  return stream
+}
+
+module.exports = run

package/node_modules/thread-stream/test/yarnrc.yml

@@ -0,0 +1,7 @@
+nodeLinker: pnp
+pnpMode: loose
+pnpEnableEsmLoader: false
+packageExtensions:
+  debug@*:
+    dependencies:
+      supports-color: '*'

package/node_modules/thread-stream/tsconfig.json

@@ -0,0 +1,8 @@
+{
+    "compilerOptions": {
+        "esModuleInterop": true
+    },
+    "files": [
+        "index.d.ts"
+    ],
+}

package/node_modules/zod/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Colin McDonnell
+
+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/zod/README.md

@@ -0,0 +1,208 @@
+<p align="center">
+  <img src="logo.svg" width="200px" align="center" alt="Zod logo" />
+  <h1 align="center">Zod</h1>
+  <p align="center">
+    TypeScript-first schema validation with static type inference
+    <br/>
+    by <a href="https://x.com/colinhacks">@colinhacks</a>
+  </p>
+</p>
+<br/>
+
+<p align="center">
+<a href="https://github.com/colinhacks/zod/actions?query=branch%3Amain"><img src="https://github.com/colinhacks/zod/actions/workflows/test.yml/badge.svg?event=push&branch=main" alt="Zod CI status" /></a>
+<a href="https://opensource.org/licenses/MIT" rel="nofollow"><img src="https://img.shields.io/github/license/colinhacks/zod" alt="License"></a>
+<a href="https://www.npmjs.com/package/zod" rel="nofollow"><img src="https://img.shields.io/npm/dw/zod.svg" alt="npm"></a>
+<a href="https://discord.gg/KaSRdyX2vc" rel="nofollow"><img src="https://img.shields.io/discord/893487829802418277?label=Discord&logo=discord&logoColor=white" alt="discord server"></a>
+<a href="https://github.com/colinhacks/zod" rel="nofollow"><img src="https://img.shields.io/github/stars/colinhacks/zod" alt="stars"></a>
+</p>
+
+<div align="center">
+  <a href="https://zod.dev/api">Docs</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://discord.gg/RcG33DQJdf">Discord</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://twitter.com/colinhacks">𝕏</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://bsky.app/profile/zod.dev">Bluesky</a>
+  <br />
+</div>
+
+<br/>
+<br/>
+
+<h2 align="center">Featured sponsor: Jazz</h2>
+
+<div align="center">
+  <a href="https://jazz.tools/?utm_source=zod">
+    <picture width="85%" >
+      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/garden-co/jazz/938f6767e46cdfded60e50d99bf3b533f4809c68/homepage/homepage/public/Zod%20sponsor%20message.png">
+      <img alt="jazz logo" src="https://raw.githubusercontent.com/garden-co/jazz/938f6767e46cdfded60e50d99bf3b533f4809c68/homepage/homepage/public/Zod%20sponsor%20message.png" width="85%">
+    </picture>
+  </a>
+  <br/>
+  <p><sub>Learn more about <a target="_blank" rel="noopener noreferrer" href="mailto:sponsorship@colinhacks.com">featured sponsorships</a></sub></p>
+</div>
+
+<br/>
+<br/>
+<br/>
+
+### [Read the docs →](https://zod.dev/api)
+
+<br/>
+<br/>
+
+## What is Zod?
+
+Zod is a TypeScript-first validation library. Define a schema and parse some data with it. You'll get back a strongly typed, validated result.
+
+```ts
+import * as z from "zod";
+
+const User = z.object({
+  name: z.string(),
+});
+
+// some untrusted data...
+const input = {
+  /* stuff */
+};
+
+// the parsed result is validated and type safe!
+const data = User.parse(input);
+
+// so you can use it with confidence :)
+console.log(data.name);
+```
+
+<br/>
+
+## Features
+
+- Zero external dependencies
+- Works in Node.js and all modern browsers
+- Tiny: `2kb` core bundle (gzipped)
+- Immutable API: methods return a new instance
+- Concise interface
+- Works with TypeScript and plain JS
+- Built-in JSON Schema conversion
+- Extensive ecosystem
+
+<br/>
+
+## Installation
+
+```sh
+npm install zod
+```
+
+<br/>
+
+## Basic usage
+
+Before you can do anything else, you need to define a schema. For the purposes of this guide, we'll use a simple object schema.
+
+```ts
+import * as z from "zod";
+
+const Player = z.object({
+  username: z.string(),
+  xp: z.number(),
+});
+```
+
+### Parsing data
+
+Given any Zod schema, use `.parse` to validate an input. If it's valid, Zod returns a strongly-typed _deep clone_ of the input.
+
+```ts
+Player.parse({ username: "billie", xp: 100 });
+// => returns { username: "billie", xp: 100 }
+```
+
+**Note** — If your schema uses certain asynchronous APIs like `async` [refinements](https://zod.dev/api#refinements) or [transforms](https://zod.dev/api#transforms), you'll need to use the `.parseAsync()` method instead.
+
+```ts
+const schema = z.string().refine(async (val) => val.length <= 8);
+
+await schema.parseAsync("hello");
+// => "hello"
+```
+
+### Handling errors
+
+When validation fails, the `.parse()` method will throw a `ZodError` instance with granular information about the validation issues.
+
+```ts
+try {
+  Player.parse({ username: 42, xp: "100" });
+} catch (err) {
+  if (err instanceof z.ZodError) {
+    err.issues;
+    /* [
+      {
+        expected: 'string',
+        code: 'invalid_type',
+        path: [ 'username' ],
+        message: 'Invalid input: expected string'
+      },
+      {
+        expected: 'number',
+        code: 'invalid_type',
+        path: [ 'xp' ],
+        message: 'Invalid input: expected number'
+      }
+    ] */
+  }
+}
+```
+
+To avoid a `try/catch` block, you can use the `.safeParse()` method to get back a plain result object containing either the successfully parsed data or a `ZodError`. The result type is a [discriminated union](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions), so you can handle both cases conveniently.
+
+```ts
+const result = Player.safeParse({ username: 42, xp: "100" });
+if (!result.success) {
+  result.error; // ZodError instance
+} else {
+  result.data; // { username: string; xp: number }
+}
+```
+
+**Note** — If your schema uses certain asynchronous APIs like `async` [refinements](#refine) or [transforms](#transform), you'll need to use the `.safeParseAsync()` method instead.
+
+```ts
+const schema = z.string().refine(async (val) => val.length <= 8);
+
+await schema.safeParseAsync("hello");
+// => { success: true; data: "hello" }
+```
+
+### Inferring types
+
+Zod infers a static type from your schema definitions. You can extract this type with the `z.infer<>` utility and use it however you like.
+
+```ts
+const Player = z.object({
+  username: z.string(),
+  xp: z.number(),
+});
+
+// extract the inferred type
+type Player = z.infer<typeof Player>;
+
+// use it in your code
+const player: Player = { username: "billie", xp: 100 };
+```
+
+In some cases, the input & output types of a schema can diverge. For instance, the `.transform()` API can convert the input from one type to another. In these cases, you can extract the input and output types independently:
+
+```ts
+const mySchema = z.string().transform((val) => val.length);
+
+type MySchemaIn = z.input<typeof mySchema>;
+// => string
+
+type MySchemaOut = z.output<typeof mySchema>; // equivalent to z.infer<typeof mySchema>
+// number
+```

package/node_modules/zod/index.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.z = void 0;
+const z = __importStar(require("./v4/classic/external.cjs"));
+exports.z = z;
+__exportStar(require("./v4/classic/external.cjs"), exports);
+exports.default = z;