goke 6.7.0 → 6.9.0

package/dist/just-bash.js

@@ -8,14 +8,78 @@
 import { Buffer } from 'node:buffer';
 import { fileURLToPath } from 'node:url';
 import { GokeProcessExit } from './goke.js';
-function createTextCaptureStream() {
-    const chunks = [];
-    return {
-        get text() {
-            return chunks.join('');
-        },
+const TRUNCATION_MESSAGE = '\n[output truncated]\n';
+function createTextCaptureStreams(maxLength) {
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    const limit = maxLength != null && maxLength > 0 ? maxLength : Number.POSITIVE_INFINITY;
+    let totalLength = 0;
+    let stdoutTruncated = false;
+    let stderrTruncated = false;
+    const createStream = (stream) => ({
         write(data) {
-            chunks.push(data);
+            if (totalLength >= limit) {
+                if (stream === 'stdout') {
+                    stdoutTruncated = true;
+                }
+                else {
+                    stderrTruncated = true;
+                }
+                return;
+            }
+            const remaining = limit - totalLength;
+            const text = data.length <= remaining ? data : data.slice(0, remaining);
+            if (stream === 'stdout') {
+                stdoutChunks.push(text);
+                stdoutTruncated ||= text.length !== data.length;
+            }
+            else {
+                stderrChunks.push(text);
+                stderrTruncated ||= text.length !== data.length;
+            }
+            totalLength += text.length;
+        },
+    });
+    const trimEnd = (value, count) => value.slice(0, Math.max(0, value.length - count));
+    return {
+        stdout: createStream('stdout'),
+        stderr: createStream('stderr'),
+        getResult() {
+            let stdout = stdoutChunks.join('');
+            let stderr = stderrChunks.join('');
+            if (!stdoutTruncated && !stderrTruncated) {
+                return { stdout, stderr };
+            }
+            const target = stderrTruncated ? 'stderr' : 'stdout';
+            const message = limit === Number.POSITIVE_INFINITY
+                ? TRUNCATION_MESSAGE
+                : TRUNCATION_MESSAGE.slice(0, Math.min(TRUNCATION_MESSAGE.length, limit));
+            let overflow = stdout.length + stderr.length + message.length - limit;
+            if (Number.isFinite(limit) && overflow > 0) {
+                if (target === 'stderr') {
+                    const stderrTrim = Math.min(overflow, stderr.length);
+                    stderr = trimEnd(stderr, stderrTrim);
+                    overflow -= stderrTrim;
+                    if (overflow > 0) {
+                        stdout = trimEnd(stdout, overflow);
+                    }
+                }
+                else {
+                    const stdoutTrim = Math.min(overflow, stdout.length);
+                    stdout = trimEnd(stdout, stdoutTrim);
+                    overflow -= stdoutTrim;
+                    if (overflow > 0) {
+                        stderr = trimEnd(stderr, overflow);
+                    }
+                }
+            }
+            if (target === 'stderr') {
+                stderr += message;
+            }
+            else {
+                stdout += message;
+            }
+            return { stdout, stderr };
         },
     };
 }
@@ -187,16 +251,15 @@ export function createJustBashCommand(cli, options) {
         name,
         trusted: true,
         async execute(args, context) {
-            const stdout = createTextCaptureStream();
-            const stderr = createTextCaptureStream();
+            const output = createTextCaptureStreams(context?.limits?.maxOutputSize);
             const argv = ['node', name, ...args];
             const cloned = cli.clone({
                 cwd: context?.cwd,
                 env: context ? createJustBashEnvProxy(context.env) : cli.env,
                 fs: context ? createJustBashFs(context.fs, context.cwd) : cli.fs,
                 stdin: context?.stdin,
-                stdout,
-                stderr,
+                stdout: output.stdout,
+                stderr: output.stderr,
                 argv,
                 exit: (code) => {
                     throw new GokeProcessExit(code);
@@ -206,17 +269,19 @@ export function createJustBashCommand(cli, options) {
             try {
                 cloned.parse(argv, { run: false });
                 await cloned.runMatchedCommand();
+                const result = output.getResult();
                 return {
-                    stdout: stdout.text,
-                    stderr: stderr.text,
+                    stdout: result.stdout,
+                    stderr: result.stderr,
                     exitCode: 0,
                 };
             }
             catch (error) {
                 if (error instanceof GokeProcessExit) {
+                    const result = output.getResult();
                     return {
-                        stdout: stdout.text,
-                        stderr: stderr.text,
+                        stdout: result.stdout,
+                        stderr: result.stderr,
                         exitCode: error.code,
                     };
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goke",
-  "version": "6.7.0",
+  "version": "6.9.0",
   "type": "module",
   "description": "Simple yet powerful framework for building command-line apps. Inspired by cac.",
   "repository": {

package/src/__test__/index.test.ts

@@ -2336,3 +2336,169 @@ describe('middleware', () => {
     expect(order).toEqual(['sync1', 'async', 'sync2', 'action'])
   })
 })
+
+describe('use() with sub-CLI composition', () => {
+  test('basic composition: sub-CLI command runs via parent', () => {
+    const parent = goke('mycli')
+    const sub = goke()
+    let matched = ''
+
+    sub
+      .command('deploy', 'Deploy the app')
+      .action(() => { matched = 'deploy' })
+
+    parent.use(sub)
+    parent.parse(['node', 'bin', 'deploy'], { run: true })
+    expect(matched).toBe('deploy')
+  })
+
+  test('multiple sub-CLIs composed together', () => {
+    const parent = goke('mycli')
+    const subA = goke()
+    const subB = goke()
+    let matched = ''
+
+    subA.command('login', 'Login').action(() => { matched = 'login' })
+    subB.command('deploy', 'Deploy').action(() => { matched = 'deploy' })
+
+    parent.use(subA).use(subB)
+
+    parent.parse(['node', 'bin', 'login'], { run: true })
+    expect(matched).toBe('login')
+
+    matched = ''
+    parent.parse(['node', 'bin', 'deploy'], { run: true })
+    expect(matched).toBe('deploy')
+  })
+
+  test('sub-CLI command with options and schema coercion', () => {
+    const parent = goke('mycli')
+    const sub = goke()
+    let result: any = {}
+
+    sub
+      .command('serve', 'Start server')
+      .option('--port <port>', z.number().describe('Port'))
+      .option('--host <host>', z.string().describe('Host'))
+      .action((options) => { result = options })
+
+    parent.use(sub)
+    parent.parse('node bin serve --port 3000 --host localhost'.split(' '), { run: true })
+
+    expect(result.port).toBe(3000)
+    expect(typeof result.port).toBe('number')
+    expect(result.host).toBe('localhost')
+  })
+
+  test('sub-CLI command with positional args', () => {
+    const parent = goke('mycli')
+    const sub = goke()
+    let receivedId = ''
+
+    sub
+      .command('get <id>', 'Get a resource')
+      .action((id) => { receivedId = id })
+
+    parent.use(sub)
+    parent.parse(['node', 'bin', 'get', 'abc123'], { run: true })
+
+    expect(receivedId).toBe('abc123')
+  })
+
+  test('sub-CLI with multi-word commands', () => {
+    const parent = goke('mycli')
+    const sub = goke()
+    let matched = ''
+
+    sub.command('mcp login', 'Login to MCP').action(() => { matched = 'mcp login' })
+    sub.command('mcp logout', 'Logout from MCP').action(() => { matched = 'mcp logout' })
+
+    parent.use(sub)
+
+    parent.parse(['node', 'bin', 'mcp', 'login'], { run: true })
+    expect(matched).toBe('mcp login')
+
+    matched = ''
+    parent.parse(['node', 'bin', 'mcp', 'logout'], { run: true })
+    expect(matched).toBe('mcp logout')
+  })
+
+  test('help output includes composed commands', () => {
+    const stdout = createTestOutputStream()
+    const parent = goke('mycli', { stdout })
+    const sub = goke()
+
+    sub.command('selfhost', 'Set up on your own workspace')
+      .option('-t, --token [token]', 'Admin token')
+
+    parent.command('init', 'Initialize project')
+    parent.use(sub)
+    parent.help()
+    parent.parse(['node', 'bin', '--help'], { run: false })
+
+    expect(stdout.text).toContain('init')
+    expect(stdout.text).toContain('selfhost')
+    expect(stdout.text).toContain('Set up on your own workspace')
+  })
+
+  test('sub-CLI middlewares are NOT copied to parent', () => {
+    const parent = goke('mycli')
+    const sub = goke()
+    let subMiddlewareCalled = false
+    const order: string[] = []
+
+    sub.use(() => { subMiddlewareCalled = true })
+    sub.command('deploy', 'Deploy').action(() => { order.push('deploy') })
+
+    parent.use(() => { order.push('parent-mw') })
+    parent.use(sub)
+
+    parent.parse(['node', 'bin', 'deploy'], { run: true })
+
+    expect(subMiddlewareCalled).toBe(false)
+    expect(order).toEqual(['parent-mw', 'deploy'])
+  })
+
+  test('parent global options are available to composed commands', () => {
+    const parent = goke('mycli')
+    const sub = goke()
+    let result: any = {}
+
+    parent.option('--verbose', 'Verbose output')
+
+    sub
+      .command('build', 'Build')
+      .option('--target <target>', 'Build target')
+      .action((options) => { result = options })
+
+    parent.use(sub)
+    parent.parse('node bin build --verbose --target production'.split(' '), { run: true })
+
+    expect(result.verbose).toBe(true)
+    expect(result.target).toBe('production')
+  })
+
+  test('composed commands coexist with inline commands', () => {
+    const parent = goke('mycli')
+    const sub = goke()
+    let matched = ''
+
+    parent.command('init', 'Initialize').action(() => { matched = 'init' })
+
+    sub.command('deploy', 'Deploy').action(() => { matched = 'deploy' })
+    sub.command('rollback', 'Rollback').action(() => { matched = 'rollback' })
+
+    parent.use(sub)
+
+    parent.parse(['node', 'bin', 'init'], { run: true })
+    expect(matched).toBe('init')
+
+    matched = ''
+    parent.parse(['node', 'bin', 'deploy'], { run: true })
+    expect(matched).toBe('deploy')
+
+    matched = ''
+    parent.parse(['node', 'bin', 'rollback'], { run: true })
+    expect(matched).toBe('rollback')
+  })
+})

package/src/__test__/just-bash.test.ts

@@ -5,7 +5,33 @@
 import { describe, expect, test } from 'vitest'
 import { z } from 'zod'
 import goke from '../index.js'
-import type { GokeOutputStream, GokeOptions } from '../index.js'
+import type { GokeOutputStream, GokeOptions, GokeFs } from '../index.js'
+
+/**
+ * Build a minimal `GokeFs` stub where every method throws unless the
+ * caller overrides it. Used by `createExecutionContext` tests that
+ * only care about a single method (e.g. `readFile`) but still need
+ * an object that satisfies the full `GokeFs` interface.
+ */
+function stubGokeFs(overrides: Partial<GokeFs>): GokeFs {
+  const notImplemented = () => { throw new Error('not implemented in stub') }
+  return {
+    appendFile: notImplemented,
+    chmod: notImplemented,
+    copyFile: notImplemented,
+    link: notImplemented,
+    mkdir: notImplemented,
+    readFile: notImplemented,
+    readlink: notImplemented,
+    realpath: notImplemented,
+    rename: notImplemented,
+    rm: notImplemented,
+    symlink: notImplemented,
+    utimes: notImplemented,
+    writeFile: notImplemented,
+    ...overrides,
+  }
+}
 
 const ANSI_RE = /\x1B\[[0-9;]*m/g
 
@@ -82,6 +108,80 @@ describe('clone', () => {
   })
 })
 
+describe('createExecutionContext', () => {
+  test('returns a context that mirrors the cli defaults when called with no override', () => {
+    const stdout = createTestOutputStream()
+    const stderr = createTestOutputStream()
+    const cli = gokeTestable('mycli', {
+      cwd: '/workspace',
+      env: { TOKEN: 'abc' },
+      stdin: 'stdin-text',
+      stdout,
+      stderr,
+    })
+
+    const ctx = cli.createExecutionContext()
+
+    expect(ctx.process.cwd).toBe('/workspace')
+    expect(ctx.process.env.TOKEN).toBe('abc')
+    expect(ctx.process.stdin).toBe('stdin-text')
+    expect(ctx.process.stdout).toBe(stdout)
+    expect(ctx.process.stderr).toBe(stderr)
+
+    ctx.console.log('hi')
+    expect(stdout.text).toBe('hi\n')
+  })
+
+  test('honors per-call overrides for stdout, cwd, env, stdin, fs, and exit', async () => {
+    const defaultStdout = createTestOutputStream()
+    const defaultFs = stubGokeFs({ readFile: async () => 'default' })
+    const cli = gokeTestable('mycli', {
+      cwd: '/default',
+      env: { DEFAULT: '1' },
+      stdin: 'default-stdin',
+      stdout: defaultStdout,
+      fs: defaultFs,
+    })
+
+    const overrideStdout = createTestOutputStream()
+    const overrideStderr = createTestOutputStream()
+    const overrideFs = stubGokeFs({ readFile: async () => 'override' })
+    let receivedExitCode: number | undefined
+    const ctx = cli.createExecutionContext({
+      cwd: '/tenant',
+      env: { TOKEN: 'xyz' },
+      stdin: 'tenant-stdin',
+      stdout: overrideStdout,
+      stderr: overrideStderr,
+      fs: overrideFs,
+      exit: (code) => {
+        receivedExitCode = code
+      },
+    })
+
+    expect(ctx.process.cwd).toBe('/tenant')
+    expect(ctx.process.env.TOKEN).toBe('xyz')
+    expect(ctx.process.env.DEFAULT).toBeUndefined()
+    expect(ctx.process.stdin).toBe('tenant-stdin')
+    expect(ctx.process.stdout).toBe(overrideStdout)
+    expect(ctx.process.stderr).toBe(overrideStderr)
+    expect(ctx.fs).toBe(overrideFs)
+    expect(await ctx.fs.readFile('unused')).toBe('override')
+
+    // The cli's own stdout must NOT receive writes made through the
+    // override. This is what makes per-request capturing safe.
+    ctx.console.log('per-tenant')
+    expect(defaultStdout.text).toBe('')
+    expect(overrideStdout.text).toBe('per-tenant\n')
+
+    // Custom exit callback runs, then the wrapper throws GokeProcessExit
+    // so the action's code path stops at the exit site.
+    const { GokeProcessExit } = await import('../goke.js')
+    expect(() => ctx.process.exit(7)).toThrow(GokeProcessExit)
+    expect(receivedExitCode).toBe(7)
+  })
+})
+
 describe('createJustBashCommand', () => {
   test('runs multi-word goke subcommands through one just-bash command', async () => {
     const cli = gokeTestable('parent')
@@ -289,4 +389,28 @@ describe('createJustBashCommand', () => {
       exitCode: 7,
     })
   })
+
+  test('truncates captured output to just-bash maxOutputSize and appends a notice', async () => {
+    const { Bash } = await import('just-bash')
+    const cli = gokeTestable('parent')
+
+    cli
+      .command('spam-stderr', 'Write too much stderr')
+      .action((options, { console }) => {
+        console.error('x'.repeat(60))
+        console.error('y'.repeat(60))
+      })
+
+    const bash = new Bash({
+      executionLimits: { maxOutputSize: 80 },
+      customCommands: [await cli.createJustBashCommand()],
+    })
+
+    const result = await bash.exec('parent spam-stderr')
+
+    expect(result.exitCode).toBe(0)
+    expect(result.stdout).toBe('')
+    expect(result.stderr.length).toBeLessThanOrEqual(80)
+    expect(result.stderr).toBe(`${'x'.repeat(60)}\n[output truncated]\n`)
+  })
 })

package/src/__test__/types.test-d.ts

@@ -481,6 +481,47 @@ describe('type-level: README TypeScript examples', () => {
       })
   })
 
+  test('use() with sub-CLI preserves parent middleware typing', () => {
+    const sub = goke()
+    sub
+      .command('deploy', 'Deploy the app')
+      .option('--force', z.boolean())
+      .action((options) => {
+        // Sub-CLI command's action sees its own options
+        expectTypeOf(options.force).toEqualTypeOf<boolean | undefined>()
+      })
+
+    goke('test')
+      .option('--verbose', z.boolean().default(false).describe('Verbose'))
+      .use(sub)
+      .use((options) => {
+        // Parent middleware still sees parent's accumulated options after .use(subCli)
+        expectTypeOf(options.verbose).toEqualTypeOf<boolean>()
+      })
+      .command('build', 'Build')
+      .option('--target <target>', z.string())
+      .action((options) => {
+        // Parent's inline command still sees global options
+        expectTypeOf(options.verbose).toEqualTypeOf<boolean>()
+        expectTypeOf(options.target).toEqualTypeOf<string>()
+      })
+  })
+
+  test('use() with sub-CLI does not leak sub-CLI types to parent', () => {
+    const sub = goke()
+      .option('--sub-only <val>', z.string())
+    sub.command('sub-cmd', 'Sub command').action(() => {})
+
+    goke('test')
+      .option('--parent-only <val>', z.number())
+      .use(sub)
+      .use((options) => {
+        expectTypeOf(options.parentOnly).toEqualTypeOf<number>()
+        // @ts-expect-error subOnly is not declared on the parent
+        options.subOnly
+      })
+  })
+
   test('README global options and middleware example stays typed end-to-end', () => {
     // `z.boolean().default(false)` and `z.string().default(...)` are
     // effectively required at runtime: the default applies when the flag is

package/src/goke.ts

@@ -1000,6 +1000,45 @@ interface GokeExecutionContext {
   process: GokeProcess
 }
 
+/**
+ * Per-request overrides accepted by `Goke#createExecutionContext()`.
+ *
+ * Any field left `undefined` falls back to the `Goke` instance's
+ * defaults (set via `GokeOptions`), which themselves fall back to the
+ * real Node.js `process.*`. Use this to construct an execution context
+ * with tenant-specific values — e.g. a per-user `cwd`/`env`/`fs` pair
+ * for a remote MCP server, or capture streams for stdout/stderr.
+ *
+ * Passing a custom `exit` replaces the default behavior of calling
+ * `this.exit(code)`. The returned `process.exit` still throws
+ * `GokeProcessExit` after the user-provided `exit` returns, so callers
+ * can catch the exit without the outer code needing to know about it.
+ */
+interface GokeExecutionContextOverride {
+  /** Override the argv array exposed as `process.argv`. Defaults to the cli's raw parsed argv. */
+  argv?: string[]
+  /** Override the working directory exposed as `process.cwd`. */
+  cwd?: string
+  /** Override the environment exposed as `process.env`. */
+  env?: Record<string, string | undefined>
+  /** Override the filesystem exposed as `ctx.fs`. */
+  fs?: GokeFs
+  /** Override the stdin content exposed as `process.stdin`. */
+  stdin?: string
+  /** Override the stdout stream used by `ctx.console.log` and exposed as `process.stdout`. */
+  stdout?: GokeOutputStream
+  /** Override the stderr stream used by `ctx.console.error` and exposed as `process.stderr`. */
+  stderr?: GokeOutputStream
+  /**
+   * Override the exit function called by `process.exit(code)`.
+   *
+   * The returned context still throws `GokeProcessExit` after this
+   * callback returns, so callers that want to capture the exit
+   * without killing the host process can pass `() => {}`.
+   */
+  exit?: (code: number) => void
+}
+
 class GokeProcessExit extends Error {
   code: number
 
@@ -1193,19 +1232,63 @@ class Goke<Opts = {}> extends EventEmitter {
     return cloned
   }
 
-  private createExecutionContext(argv = this.rawArgs): GokeExecutionContext {
+  /**
+   * Build a `GokeExecutionContext` using this cli's defaults, optionally
+   * overridden per-request.
+   *
+   * `runMatchedCommand()` calls this internally with no arguments to
+   * construct the context passed to command actions and middlewares.
+   *
+   * The method is also public so adapters (MCP, remote RPC, batch
+   * runners, etc.) can build a context for a single invocation with
+   * tenant-specific values — e.g. capture streams for stdout/stderr,
+   * a per-user `cwd`/`env`/`fs`, or an `exit` that throws instead of
+   * killing the host process. See {@link GokeExecutionContextOverride}.
+   *
+   * @example
+   * ```ts
+   * // Build an execution context that captures output into strings and
+   * // treats `ctx.process.exit(code)` as a `GokeProcessExit` throw
+   * // instead of terminating the host process.
+   * const stdout = createTextCaptureStream()
+   * const stderr = createTextCaptureStream()
+   * const ctx = cli.createExecutionContext({
+   *   stdout,
+   *   stderr,
+   *   exit: () => {},
+   * })
+   * try {
+   *   await action(...args, options, ctx)
+   * } catch (err) {
+   *   if (err instanceof GokeProcessExit) {
+   *     // handle exit code
+   *   } else {
+   *     throw err
+   *   }
+   * }
+   * ```
+   */
+  createExecutionContext(override?: GokeExecutionContextOverride): GokeExecutionContext {
+    const stdout = override?.stdout ?? this.stdout
+    const stderr = override?.stderr ?? this.stderr
+    // Reuse the cached console when streams aren't overridden; otherwise
+    // build a new one so ctx.console.log writes to the overridden streams.
+    const contextConsole = (override?.stdout !== undefined || override?.stderr !== undefined)
+      ? createConsole(stdout, stderr)
+      : this.console
+    const exitFn = override?.exit ?? this.exit
     return {
-      console: this.console,
-      fs: this.fs,
+      console: contextConsole,
+      fs: override?.fs ?? this.fs,
       process: {
-        argv,
-        cwd: this.cwd ?? process.cwd(),
-        env: this.env ?? process.env,
-        stdin: this.stdin ?? '',
-        stdout: this.stdout,
-        stderr: this.stderr,
-        exit: (code: number) => {
-          this.exit(code)
+        argv: override?.argv ?? this.rawArgs,
+        cwd: override?.cwd ?? this.cwd ?? process.cwd(),
+        env: override?.env ?? this.env ?? process.env,
+        stdin: override?.stdin ?? this.stdin ?? '',
+        stdout,
+        stderr,
+        exit: (code) => {
+          exitFn(code)
           throw new GokeProcessExit(code)
         },
       },
@@ -1298,14 +1381,48 @@ class Goke<Opts = {}> extends EventEmitter {
    *     }
    *   })
    * ```
+   *
+   * Alternatively, pass another `Goke` instance to compose commands from
+   * separate files. All commands defined on the sub-CLI are merged into
+   * this CLI. Middlewares and global options from the sub-CLI are NOT
+   * copied; only commands are composed.
+   *
+   * @example
+   * ```ts
+   * // selfhost.ts
+   * export const selfhostCli = goke()
+   * selfhostCli
+   *   .command('selfhost', 'Set up on your own workspace')
+   *   .option('-t, --token [token]', 'Admin token')
+   *   .action((options) => { ... })
+   *
+   * // main.ts
+   * import { selfhostCli } from './selfhost.js'
+   * goke('mycli')
+   *   .use(selfhostCli)
+   *   .help()
+   *   .parse(process.argv)
+   * ```
    */
+  use(subCli: Goke<any>): this
   use(
     callback: (
       options: Opts & DoubleDashOptions,
       context: GokeExecutionContext,
     ) => void | Promise<void>,
+  ): this
+  use(
+    callbackOrCli:
+      | Goke<any>
+      | ((options: Opts & DoubleDashOptions, context: GokeExecutionContext) => void | Promise<void>),
   ): this {
-    this.middlewares.push({ action: callback })
+    if (callbackOrCli instanceof Goke) {
+      for (const command of callbackOrCli.commands) {
+        this.commands.push(cloneCommandInto(command, this))
+      }
+      return this
+    }
+    this.middlewares.push({ action: callbackOrCli })
     return this
   }
 
@@ -1828,6 +1945,6 @@ class Goke<Opts = {}> extends EventEmitter {
 
 // ─── Exports ───
 
-export type { GokeOutputStream, GokeConsole, GokeOptions, GokeProcess, GokeExecutionContext, GokeFs }
+export type { GokeOutputStream, GokeConsole, GokeOptions, GokeProcess, GokeExecutionContext, GokeExecutionContextOverride, GokeFs }
 export { createConsole, Command, GokeProcessExit, openInBrowser }
 export default Goke

package/src/index.ts

@@ -11,6 +11,6 @@ const goke = (name = '', options?: GokeOptions) => new Goke(name, options)
 export default goke
 export { goke, Goke, Command }
 export { createConsole, GokeProcessExit, openInBrowser } from "./goke.js"
-export type { GokeOutputStream, GokeConsole, GokeExecutionContext, GokeFs, GokeOptions, GokeProcess } from "./goke.js"
+export type { GokeOutputStream, GokeConsole, GokeExecutionContext, GokeExecutionContextOverride, GokeFs, GokeOptions, GokeProcess } from "./goke.js"
 export type { StandardTypedV1, StandardJSONSchemaV1, JsonSchema } from "./coerce.js"
 export { GokeError, coerceBySchema, extractJsonSchema, wrapJsonSchema, isStandardSchema, extractSchemaMetadata } from "./coerce.js"