@zenera/faker 1.1.0

package/dist/command.js

@@ -0,0 +1,339 @@
+import { rmSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative, resolve } from 'node:path';
+import { bold, CliError, cyan, dim, EXIT, green, json, note, ownedContainers, parse, paths, red, removeContainers, table, usageError, write, writeAll, yellow, } from '@zenera/cli/lib';
+import { GENERATORS } from "./box.js";
+import { reason } from "./generate.js";
+import { listen } from "./server.js";
+import { open } from "./setup.js";
+import {} from "./spec.js";
+// ---------------------------------------------------------------------------
+// zen faker — a mock API from a specification
+//
+// A command in another package rather than a binary of its own: one thing to
+// install, one keyring, one name to remember. `zen` loads this module only when
+// somebody types `zen faker`, so nothing here is on the path of `zen list`.
+//
+// That it stays up is not a problem for the frame — `run` simply does not
+// resolve until a signal arrives, and the process lives as long as the answer
+// takes, which is what every other command already means.
+// ---------------------------------------------------------------------------
+const USAGE = 'zen faker <serve|build|cache> [spec...]';
+// `--json` is the frame's, lifted out of the arguments before they arrive; it
+// reaches us as `ctx.json` and must not be declared again or `strict` rejects it.
+const OPTIONS = {
+    port: { type: 'string' },
+    host: { type: 'string' },
+    model: { type: 'string' },
+    image: { type: 'string' },
+    cache: { type: 'string' },
+    attempts: { type: 'string' },
+    concurrency: { type: 'string' },
+    seed: { type: 'string' },
+    timeout: { type: 'string' },
+    'max-body': { type: 'string' },
+    rebuild: { type: 'boolean' },
+    'no-cache': { type: 'boolean' },
+    quiet: { type: 'boolean' },
+};
+export const command = {
+    summary: 'A mock API from an openapi/swagger document.',
+    usage: USAGE,
+    details: [
+        'Commands',
+        ...table([
+            ['  serve <spec...>', dim('Serve the documents. Generators are written on demand.')],
+            ['  build <spec...>', dim('Write every generator now and exit.')],
+            ['  cache ls|clear', dim('What has been generated, or throw it away.')],
+        ]),
+        '',
+        'Options',
+        ...table([
+            ['  --port <n>', dim('Default 8787.')],
+            ['  --host <h>', dim('Default 127.0.0.1. Anything else is reachable off-machine.')],
+            ['  --model <ref>', dim('Which model writes the generators.')],
+            ['  --image <ref>', dim('Skip the baked image and use this one.')],
+            ['  --cache <dir>', dim('Where generators live. Default ~/.zenera/neo/faker.')],
+            ['  --seed <n>', dim('Answer the same request the same way every time.')],
+            ['  --attempts <n>', dim('Tries per generator before giving up. Default 3.')],
+            ['  --concurrency <n>', dim('Generators written at once. Default 4.')],
+            ['  --timeout <s>', dim('Seconds one generator may take. Default 30.')],
+            ['  --max-body <n>', dim('Largest request body accepted, in bytes.')],
+            ['  --rebuild', dim('Ignore what is cached and write it again.')],
+            ['  --no-cache', dim('Do not record what is written.')],
+            ['  --quiet', dim('No narration.')],
+        ]),
+        '',
+        dim(`Credentials come from the ${cyan('zen')} keyring — try ${cyan('zen key ls')}.`),
+    ],
+    async run(ctx) {
+        const [name, ...rest] = ctx.args;
+        switch (name) {
+            case 'serve':
+                return await serve(rest, ctx);
+            case 'build':
+                return await warm(rest, ctx);
+            case 'cache':
+                return await cache(rest, ctx);
+            default:
+                throw usageError(name ? `unknown command "${name}"` : 'no command given', USAGE);
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// serve
+// ---------------------------------------------------------------------------
+async function serve(args, ctx) {
+    const { values, positionals } = parse(args, OPTIONS, 'zen faker serve <spec...>');
+    const loud = !values.quiet && !ctx.json;
+    const setup = await start(values, positionals, ctx, 'serve');
+    if (loud) {
+        printSpecs(setup.router.operations, ctx.cwd);
+    }
+    const host = values.host ?? '127.0.0.1';
+    const listener = await listen({
+        router: setup.router,
+        cache: setup.cache,
+        checks: setup.checks,
+        box: setup.box,
+        seed: number(values.seed, 'seed'),
+        maxBody: number(values['max-body'], 'max-body'),
+        onRequest: values.quiet ? undefined : (line) => note(dim(line)),
+    }, host, number(values.port, 'port') ?? 8787);
+    if (!values.quiet) {
+        note(`${green('listening')} ${cyan(`http://${host}:${listener.port}`)} ` +
+            dim(`${setup.router.operations.length} operations`));
+        if (host !== '127.0.0.1' && host !== 'localhost') {
+            note(yellow(`bound to ${host} — this mock is reachable from the network`));
+        }
+        note(dim(`generators: ${setup.root}/${GENERATORS}`));
+    }
+    // The address is the answer; the rest was narration.
+    write(`http://${host}:${listener.port}`);
+    await until(['SIGINT', 'SIGTERM']);
+    if (!values.quiet) {
+        note(dim('stopping'));
+    }
+    await listener.close();
+    await setup.close();
+}
+/** Resolves when one of the signals arrives, and stops listening for them. */
+function until(signals) {
+    return new Promise((settle) => {
+        const done = () => {
+            for (const s of signals) {
+                process.off(s, done);
+            }
+            settle();
+        };
+        for (const s of signals) {
+            process.once(s, done);
+        }
+    });
+}
+// ---------------------------------------------------------------------------
+// build — every generator, up front
+// ---------------------------------------------------------------------------
+async function warm(args, ctx) {
+    const { values, positionals } = parse(args, OPTIONS, 'zen faker build <spec...>');
+    const loud = !values.quiet && !ctx.json;
+    const setup = await start(values, positionals, ctx, 'build');
+    if (loud) {
+        printSpecs(setup.router.operations, ctx.cwd);
+    }
+    const results = [];
+    try {
+        for (const operation of setup.router.operations) {
+            const id = `${operation.method.toUpperCase()} ${operation.path}`;
+            if (!operation.success.schema) {
+                results.push({ operation: id, status: 'skipped', detail: 'no response body' });
+                continue;
+            }
+            try {
+                const generator = await setup.cache.ensure(operation);
+                results.push({ operation: id, status: generator.cached ? 'cached' : 'built' });
+            }
+            catch (err) {
+                results.push({
+                    operation: id,
+                    status: 'failed',
+                    detail: reason(err),
+                });
+            }
+        }
+    }
+    finally {
+        await setup.close();
+    }
+    if (ctx.json) {
+        json(results);
+    }
+    else {
+        writeAll(table(results.map((r) => [
+            `  ${mark(r.status)}`,
+            r.operation,
+            dim(r.detail?.slice(0, 100) ?? ''),
+        ])));
+    }
+    // Reported first, then failed: the table is the answer either way.
+    const failed = results.filter((r) => r.status === 'failed').length;
+    if (failed > 0) {
+        throw new CliError(`${failed} of ${results.length} generators failed`, EXIT.failed, 'run again to retry, or raise --attempts');
+    }
+}
+const mark = (status) => status === 'failed' ? red('failed') : status === 'skipped' ? dim('skipped') : green(status);
+// ---------------------------------------------------------------------------
+// cache
+// ---------------------------------------------------------------------------
+async function cache(args, ctx) {
+    const { values, positionals } = parse(args, OPTIONS, 'zen faker cache <ls|clear>');
+    const root = values.cache ? resolve(ctx.cwd, values.cache) : paths.faker();
+    const sub = positionals[0] ?? 'ls';
+    if (sub === 'ls') {
+        const entries = await listGenerators(root);
+        if (ctx.json) {
+            json(entries);
+            return;
+        }
+        if (entries.length === 0) {
+            note('nothing cached yet');
+            return;
+        }
+        writeAll(table([
+            [bold('KEY'), bold('OPERATION'), bold('MODEL'), bold('TRIES')],
+            ...entries.map((e) => [
+                e.key,
+                `${e.method?.toUpperCase() ?? '?'} ${e.path ?? ''}`,
+                dim(e.model ?? '—'),
+                dim(String(e.attempts ?? '—')),
+            ]),
+        ]));
+        return;
+    }
+    if (sub === 'clear') {
+        rmSync(join(root, GENERATORS), { recursive: true, force: true });
+        // The container is named after its configuration, so a stale one would
+        // otherwise sit there stopped forever with nothing pointing at it.
+        // `zn-<key>-<digest>` is the shape, and this one's key is `faker`.
+        const mine = (await ownedContainers()).filter((c) => c.name.startsWith('zn-faker-'));
+        if (mine.length > 0) {
+            await removeContainers(mine.map((c) => c.name));
+        }
+        note(`${green('cleared')} ${dim(root)}`);
+        return;
+    }
+    throw usageError(`unknown cache command "${sub}"`, 'zen faker cache <ls|clear>');
+}
+async function listGenerators(root) {
+    let keys;
+    try {
+        keys = await readdir(join(root, GENERATORS));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const key of keys.sort()) {
+        try {
+            const meta = JSON.parse(await readFile(join(root, GENERATORS, key, 'meta.json'), 'utf8'));
+            out.push({ key, ...meta });
+        }
+        catch {
+            out.push({ key });
+        }
+    }
+    return out;
+}
+function summarize(operations) {
+    const by = new Map();
+    for (const op of operations) {
+        let stat = by.get(op.source);
+        if (!stat) {
+            stat = { source: op.source, paths: new Set(), methods: 0, functions: 0 };
+            by.set(op.source, stat);
+        }
+        stat.paths.add(op.path);
+        stat.methods += 1;
+        if (op.success.schema) {
+            stat.functions += 1;
+        }
+    }
+    return [...by.values()];
+}
+const HEADERS = ['PATHS', 'METHODS', 'FUNCTIONS'];
+function printSpecs(operations, cwd) {
+    const stats = summarize(operations);
+    const rows = stats.map((s) => ({
+        name: relative(cwd, s.source) || s.source,
+        cells: [s.paths.size, s.methods, s.functions],
+    }));
+    if (rows.length > 1) {
+        rows.push({
+            name: 'total',
+            cells: HEADERS.map((_, i) => rows.reduce((n, r) => n + r.cells[i], 0)),
+        });
+    }
+    // Numbers are padded before they are styled: a colour code has no width,
+    // and `table` cannot know that.
+    const widths = HEADERS.map((h, i) => Math.max(h.length, ...rows.map((r) => String(r.cells[i]).length)));
+    const lines = table([
+        [bold('SPEC'), ...HEADERS.map((h, i) => bold(h.padStart(widths[i])))],
+        ...rows.map((r) => [
+            r.name === 'total' ? dim(r.name) : r.name,
+            ...r.cells.map((c, i) => String(c).padStart(widths[i])),
+        ]),
+    ]);
+    note('');
+    for (const line of lines) {
+        note(`  ${line}`);
+    }
+    note('');
+}
+// ---------------------------------------------------------------------------
+// Shared
+// ---------------------------------------------------------------------------
+async function start(values, specs, ctx, what) {
+    const loud = !values.quiet && !ctx.json;
+    return open({
+        specs,
+        cwd: ctx.cwd,
+        cache: values.cache,
+        model: values.model,
+        image: values.image,
+        attempts: number(values.attempts, 'attempts'),
+        concurrency: number(values.concurrency, 'concurrency'),
+        timeout: number(values.timeout, 'timeout'),
+        rebuild: values.rebuild,
+        ephemeral: values['no-cache'],
+        onImageBuild: loud
+            ? (tag) => note(`${dim('building')} ${tag} ${dim('— once, then cached')}`)
+            : undefined,
+        events: {
+            onStart: loud
+                ? ({ operation }) => note(`${dim('writing a generator for')} ${operation.method.toUpperCase()} ${operation.path}`)
+                : undefined,
+            onAttempt: loud
+                ? ({ operation, attempt, diagnostics }) => note(`  ${yellow(`attempt ${attempt} failed`)} ${dim(`${operation.operationId}: ${(diagnostics ?? []).join(' ').slice(0, 160)}`)}`)
+                : undefined,
+            onReady: loud && what === 'serve'
+                ? ({ operation, cached }) => cached
+                    ? undefined
+                    : note(`  ${green('ready')} ${dim(operation.operationId)}`)
+                : undefined,
+            onFail: loud
+                ? ({ operation, error }) => note(`  ${red('gave up')} ${dim(operation.operationId)} ${reason(error)}`)
+                : undefined,
+        },
+    });
+}
+function number(raw, what) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+        throw usageError(`--${what} must be a number, got "${raw}"`);
+    }
+    return value;
+}
+//# sourceMappingURL=command.js.map

package/dist/envelope.d.ts

@@ -0,0 +1,13 @@
+export interface GeneratorInput {
+    operationId: string;
+    method: string;
+    /** the template, not the resolved path — `/users/{user_id}` */
+    path: string;
+    pathParams: Record<string, unknown>;
+    query: Record<string, unknown>;
+    headers: Record<string, string>;
+    body: unknown;
+    /** seeds `random` and `Faker` inside the generator */
+    seed: number;
+}
+//# sourceMappingURL=envelope.d.ts.map

package/dist/envelope.js

@@ -0,0 +1,9 @@
+// ---------------------------------------------------------------------------
+// What a generator is handed
+//
+// One shape, written by the server for a real request and by the build loop for
+// a synthetic probe. That they are the same shape is the whole reason a
+// generator that satisfies its probes also satisfies traffic.
+// ---------------------------------------------------------------------------
+export {};
+//# sourceMappingURL=envelope.js.map

package/dist/generate.d.ts

@@ -0,0 +1,38 @@
+import type { Model } from '@zenera/neo';
+import type { Box } from './box.ts';
+import type { Operation } from './spec.ts';
+import { type Checks } from './validate.ts';
+export interface BuildOptions {
+    model: Model;
+    box: Box;
+    checks: Checks;
+    /** how many times the model may be asked before giving up */
+    attempts?: number;
+    onAttempt?: (attempt: number, diagnostics: readonly string[]) => void;
+    signal?: AbortSignal;
+}
+export interface Built {
+    source: string;
+    attempts: number;
+}
+export declare class BuildFailed extends Error {
+    readonly operation: Operation;
+    readonly diagnostics: readonly string[];
+    constructor(operation: Operation, diagnostics: readonly string[]);
+}
+/**
+ * Why something failed, in one line, including the part that is usually hidden.
+ *
+ * `fetch failed` is undici's word for a dozen different problems — a DNS
+ * miss, a refused connection, a TLS error, a timeout — and which one it was is
+ * only ever in `cause`. Reporting the top-level message alone turns every
+ * network fault into the same useless sentence.
+ */
+export declare function reason(err: unknown): string;
+export declare function build(operation: Operation, opts: BuildOptions): Promise<Built>;
+/**
+ * Models fence code even when told not to, and a stray ```python line is a
+ * syntax error rather than a bad answer — not worth a round trip.
+ */
+export declare function unfence(text: string): string;
+//# sourceMappingURL=generate.d.ts.map

package/dist/generate.js

@@ -0,0 +1,125 @@
+import { echoIssues, probesFor } from "./probe.js";
+import { instruction, retry, SYSTEM } from "./prompt.js";
+import { describeIssues, issues } from "./validate.js";
+export class BuildFailed extends Error {
+    operation;
+    diagnostics;
+    constructor(operation, diagnostics) {
+        super(`could not write a generator for ${operation.method.toUpperCase()} ${operation.path}`);
+        this.name = 'BuildFailed';
+        this.operation = operation;
+        this.diagnostics = diagnostics;
+    }
+}
+/**
+ * Why something failed, in one line, including the part that is usually hidden.
+ *
+ * `fetch failed` is undici's word for a dozen different problems — a DNS
+ * miss, a refused connection, a TLS error, a timeout — and which one it was is
+ * only ever in `cause`. Reporting the top-level message alone turns every
+ * network fault into the same useless sentence.
+ */
+export function reason(err) {
+    if (err instanceof BuildFailed && err.diagnostics.length > 0) {
+        return `${err.message}: ${err.diagnostics.join(' ')}`;
+    }
+    const parts = [];
+    const seen = new Set();
+    let at = err;
+    while (at instanceof Error && !seen.has(at)) {
+        seen.add(at);
+        const e = at;
+        const head = [e.status ?? e.statusCode, e.code].filter(Boolean).join(' ');
+        const line = `${head} ${e.message.split('\n')[0].trim()}`.trim();
+        if (line && !parts.includes(line)) {
+            parts.push(line);
+        }
+        at = e.cause;
+    }
+    return parts.join(' — ') || String(err);
+}
+export async function build(operation, opts) {
+    const limit = Math.max(1, opts.attempts ?? 3);
+    const probes = probesFor(operation);
+    const response = opts.checks.for(operation).response;
+    const messages = [
+        { role: 'user', content: [{ type: 'text', text: instruction(operation) }] },
+    ];
+    let last = [];
+    for (let attempt = 1; attempt <= limit; attempt++) {
+        const answer = await ask(opts, {
+            system: SYSTEM,
+            messages,
+            tools: [],
+            signal: opts.signal,
+        });
+        const source = unfence(answer.text);
+        if (!source.trim()) {
+            last = ['the answer was empty'];
+        }
+        else {
+            await opts.box.write(operation.key, source);
+            last = await judge(operation, probes, response, opts.box);
+            if (last.length === 0) {
+                return { source, attempts: attempt };
+            }
+        }
+        opts.onAttempt?.(attempt, last);
+        messages.push({ role: 'assistant', content: source }, { role: 'user', content: [{ type: 'text', text: retry(last) }] });
+    }
+    throw new BuildFailed(operation, last);
+}
+/**
+ * Streamed when the adapter can, and every delta is dropped: nothing here
+ * renders progress. It is the *socket* that needs them.
+ *
+ * A generator is a few hundred lines, and a model asked for one in a single
+ * non-streaming call sends nothing at all while it thinks. Something upstream
+ * closes a connection that has been idle for a minute, and the whole attempt
+ * dies with `UND_ERR_SOCKET other side closed` at ~61 s — not a timeout anyone
+ * here set, and not the SDK's, which is ten minutes. Tokens on the wire keep
+ * it open.
+ */
+function ask(opts, request) {
+    return opts.model.stream ? opts.model.stream(request, discard) : opts.model.generate(request);
+}
+const discard = () => { };
+/** Every probe, run and checked. Empty means the generator is good. */
+async function judge(operation, probes, response, box) {
+    const out = [];
+    for (const probe of probes) {
+        const outcome = await box.run(operation.key, probe);
+        const called = `input ${JSON.stringify({ pathParams: probe.pathParams, query: probe.query })}`;
+        if (!outcome.ok) {
+            out.push(`- ${called}: the file ${outcome.fault}.`);
+            if (outcome.stderr) {
+                out.push(`  stderr: ${tail(outcome.stderr)}`);
+            }
+            // A file that will not run says nothing about the next probe.
+            break;
+        }
+        if (response && !response(outcome.value)) {
+            out.push(`- ${called}: the output does not match the response schema — ${describeIssues(issues('', response.errors))}.`);
+        }
+        const echo = echoIssues(probe, outcome.value, operation.success.schema);
+        if (echo.length > 0) {
+            out.push(`- ${called}: ${describeIssues(echo)}.`);
+        }
+    }
+    return out;
+}
+/**
+ * Models fence code even when told not to, and a stray ```python line is a
+ * syntax error rather than a bad answer — not worth a round trip.
+ */
+export function unfence(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('```')) {
+        return trimmed;
+    }
+    const body = trimmed.slice(trimmed.indexOf('\n') + 1);
+    const close = body.lastIndexOf('```');
+    return (close === -1 ? body : body.slice(0, close)).trimEnd();
+}
+const tail = (s) => s.trim().split('\n').slice(-6).join('\n  ');
+//# sourceMappingURL=generate.js.map

package/dist/image.d.ts

@@ -0,0 +1,25 @@
+import { type Runner } from '@zenera/neo';
+/**
+ * Lower bounds rather than exact pins: the tag is a function of this list, so
+ * an edit here yields a new image and a new container either way, and pinning a
+ * patch release would only mean a rebuild every time one is published.
+ */
+export declare const REQUIREMENTS: readonly ["Faker>=37", "exrex>=0.11", "jsonschema>=4.23", "python-dateutil>=2.9"];
+/** What the generator may import. Quoted verbatim in the prompt. */
+export declare const AVAILABLE: readonly ["faker", "exrex", "jsonschema", "dateutil"];
+export declare const BASE_IMAGE = "docker.io/library/python:3.14-slim-bookworm";
+export declare function imageTag(base?: string): string;
+export interface ImageOptions {
+    /** where the empty build context is created */
+    root: string;
+    base?: string;
+    engine?: string;
+    exec?: Runner;
+    onBuild?: (tag: string) => void;
+}
+/**
+ * The tag to run, built if it is not there yet. Returns without touching podman
+ * when the image already exists, which is every start after the first.
+ */
+export declare function ensureImage(opts: ImageOptions): Promise<string>;
+//# sourceMappingURL=image.d.ts.map

package/dist/image.js

@@ -0,0 +1,77 @@
+import { createHash } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { DEFAULT_SANDBOX_IMAGE, runProcess } from '@zenera/neo';
+// ---------------------------------------------------------------------------
+// The image
+//
+// The generators are Python, and Python that has to invent a plausible name out
+// of `random.choice` writes output that looks like test data because it is. So
+// the container gets real libraries.
+//
+// They cannot be installed into the *running* box. `containerName()` in
+// @zenera/neo hashes the image and the network, so "start online, install, then
+// switch to `network: none`" resolves to two different containers and the
+// install goes with the first one. Baking them into an image instead is one
+// build, cached by podman's own layers, and leaves the serving container
+// offline — which is the property that matters, because the code it runs was
+// written by a model.
+// ---------------------------------------------------------------------------
+/**
+ * Lower bounds rather than exact pins: the tag is a function of this list, so
+ * an edit here yields a new image and a new container either way, and pinning a
+ * patch release would only mean a rebuild every time one is published.
+ */
+export const REQUIREMENTS = [
+    'Faker>=37',
+    'exrex>=0.11',
+    'jsonschema>=4.23',
+    'python-dateutil>=2.9',
+];
+/** What the generator may import. Quoted verbatim in the prompt. */
+export const AVAILABLE = ['faker', 'exrex', 'jsonschema', 'dateutil'];
+export const BASE_IMAGE = DEFAULT_SANDBOX_IMAGE;
+export function imageTag(base = BASE_IMAGE) {
+    const digest = createHash('sha256')
+        .update(JSON.stringify([base, [...REQUIREMENTS].sort()]))
+        .digest('hex')
+        .slice(0, 12);
+    return `localhost/zenera-faker:${digest}`;
+}
+function containerfile(base) {
+    return [
+        `FROM ${base}`,
+        `RUN pip install --no-cache-dir --disable-pip-version-check ${REQUIREMENTS.join(' ')}`,
+        '',
+    ].join('\n');
+}
+/**
+ * The tag to run, built if it is not there yet. Returns without touching podman
+ * when the image already exists, which is every start after the first.
+ */
+export async function ensureImage(opts) {
+    const base = opts.base ?? BASE_IMAGE;
+    const tag = imageTag(base);
+    const engine = opts.engine ?? 'podman';
+    const run = opts.exec ?? runProcess;
+    const exists = await run(engine, ['image', 'exists', tag], { timeoutMs: 60_000 });
+    if (exists.code === 0) {
+        return tag;
+    }
+    opts.onBuild?.(tag);
+    // An empty directory, because the Containerfile arrives on stdin and there
+    // is nothing to COPY: handing podman the working directory instead would
+    // tar up whatever happened to be in it.
+    const context = join(opts.root, 'build');
+    mkdirSync(context, { recursive: true });
+    const built = await run(engine, ['build', '--tag', tag, '--file', '-', context], {
+        input: containerfile(base),
+        timeoutMs: 900_000,
+        maxBytes: 256 * 1024,
+    });
+    if (built.code !== 0) {
+        throw new Error(`could not build ${tag}: ${(built.stderr.trim() || built.stdout.trim()).split('\n').slice(-3).join(' ')}`);
+    }
+    return tag;
+}
+//# sourceMappingURL=image.js.map

package/dist/main.d.ts

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