@fuzdev/fuz_app 0.1.0

package/dist/runtime/deps.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Shared dependency interfaces for runtime operations.
+ *
+ * Small composable interfaces that functions accept for only the capabilities
+ * they need. Both Deno and Node implementations satisfy all these interfaces
+ * via `RuntimeDeps`.
+ *
+ * @module
+ */
+/**
+ * Result of a stat operation.
+ */
+export interface StatResult {
+    is_file: boolean;
+    is_directory: boolean;
+}
+/**
+ * Result of executing a command.
+ */
+export interface CommandResult {
+    success: boolean;
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+/**
+ * Environment variable access.
+ */
+export interface EnvDeps {
+    /** Get an environment variable value. */
+    env_get: (name: string) => string | undefined;
+    /** Set an environment variable. */
+    env_set: (name: string, value: string) => void;
+}
+/**
+ * File system read operations.
+ */
+export interface FsReadDeps {
+    /** Get file/directory stats, or null if path doesn't exist. */
+    stat: (path: string) => Promise<StatResult | null>;
+    /** Read a file as text. */
+    read_file: (path: string) => Promise<string>;
+}
+/**
+ * File system write operations.
+ */
+export interface FsWriteDeps {
+    /** Create a directory. */
+    mkdir: (path: string, options?: {
+        recursive?: boolean;
+    }) => Promise<void>;
+    /** Write text to a file. */
+    write_file: (path: string, content: string) => Promise<void>;
+    /** Rename (move) a file. */
+    rename: (old_path: string, new_path: string) => Promise<void>;
+}
+/**
+ * File system remove operations.
+ */
+export interface FsRemoveDeps {
+    /** Remove a file or directory. */
+    remove: (path: string, options?: {
+        recursive?: boolean;
+    }) => Promise<void>;
+}
+/**
+ * Command execution.
+ */
+export interface CommandDeps {
+    /** Run a command and return the result. */
+    run_command: (cmd: string, args: Array<string>) => Promise<CommandResult>;
+}
+/**
+ * Warning/diagnostic output.
+ */
+export interface LogDeps {
+    /** Log a warning message. */
+    warn: (...args: Array<unknown>) => void;
+}
+/**
+ * Terminal I/O operations.
+ */
+export interface TerminalDeps {
+    /** Write bytes to stdout. */
+    stdout_write: (data: Uint8Array) => Promise<number>;
+    /** Read bytes from stdin, or null on EOF. */
+    stdin_read: (buffer: Uint8Array) => Promise<number | null>;
+}
+/**
+ * Process lifecycle.
+ */
+export interface ProcessDeps {
+    /** Exit the process with a code. */
+    exit: (code: number) => never;
+}
+/**
+ * Full runtime capabilities returned by `create_deno_runtime` or `create_node_runtime`.
+ *
+ * Extends all `*Deps` interfaces with additional app-level capabilities.
+ * Functions should accept narrow `*Deps` interfaces, not this full type —
+ * this type is for the wiring layer that creates and passes the runtime.
+ */
+export interface RuntimeDeps extends EnvDeps, FsReadDeps, FsWriteDeps, FsRemoveDeps, CommandDeps, TerminalDeps, ProcessDeps, LogDeps {
+    /** Get all environment variables. */
+    env_all: () => Record<string, string>;
+    /** CLI arguments passed to the program. */
+    readonly args: ReadonlyArray<string>;
+    /** Get current working directory. */
+    cwd: () => string;
+    /** Run a command with inherited stdout/stderr (output goes directly to terminal). */
+    run_command_inherit: (cmd: string, args: Array<string>) => Promise<number>;
+}
+//# sourceMappingURL=deps.d.ts.map

package/dist/runtime/deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deps.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/runtime/deps.ts"],"names":[],"mappings":"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"}

package/dist/runtime/deps.js

@@ -0,0 +1,10 @@
+/**
+ * Shared dependency interfaces for runtime operations.
+ *
+ * Small composable interfaces that functions accept for only the capabilities
+ * they need. Both Deno and Node implementations satisfy all these interfaces
+ * via `RuntimeDeps`.
+ *
+ * @module
+ */
+export {};

package/dist/runtime/fs.d.ts

@@ -0,0 +1,15 @@
+/**
+ * File system utilities.
+ *
+ * @module
+ */
+import type { FsWriteDeps } from './deps.js';
+/**
+ * Write a file atomically via temp file + rename.
+ *
+ * @param deps - deps with file write capabilities
+ * @param path - destination file path
+ * @param content - file contents to write
+ */
+export declare const write_file_atomic: (deps: Pick<FsWriteDeps, "write_file" | "rename">, path: string, content: string) => Promise<void>;
+//# sourceMappingURL=fs.d.ts.map

package/dist/runtime/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/runtime/fs.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AAE3C;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC7B,MAAM,IAAI,CAAC,WAAW,EAAE,YAAY,GAAG,QAAQ,CAAC,EAChD,MAAM,MAAM,EACZ,SAAS,MAAM,KACb,OAAO,CAAC,IAAI,CAId,CAAC"}

package/dist/runtime/fs.js

@@ -0,0 +1,17 @@
+/**
+ * File system utilities.
+ *
+ * @module
+ */
+/**
+ * Write a file atomically via temp file + rename.
+ *
+ * @param deps - deps with file write capabilities
+ * @param path - destination file path
+ * @param content - file contents to write
+ */
+export const write_file_atomic = async (deps, path, content) => {
+    const temp_path = path + '.tmp';
+    await deps.write_file(temp_path, content);
+    await deps.rename(temp_path, path);
+};

package/dist/runtime/mock.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Mock `RuntimeDeps` for testing.
+ *
+ * Provides a fully controllable runtime implementation for unit tests.
+ * Consumer projects can extend `MockRuntime` with project-specific helpers
+ * (e.g. `setup_mock_tx_config`) that stay local.
+ *
+ * @module
+ */
+import type { RuntimeDeps, CommandResult } from './deps.js';
+/**
+ * Mock `RuntimeDeps` with observable state for assertions.
+ */
+export interface MockRuntime extends RuntimeDeps {
+    /** Mock environment variables. */
+    mock_env: Map<string, string>;
+    /** Mock file system (path -> content). */
+    mock_fs: Map<string, string>;
+    /** Mock directories that exist. */
+    mock_dirs: Set<string>;
+    /** Exit calls recorded (exit codes). */
+    exit_calls: Array<number>;
+    /** Commands executed. */
+    command_calls: Array<{
+        cmd: string;
+        args: Array<string>;
+    }>;
+    /** Commands executed with inherit. */
+    command_inherit_calls: Array<{
+        cmd: string;
+        args: Array<string>;
+    }>;
+    /** Stdout writes recorded. */
+    stdout_writes: Array<string>;
+    /** Mock command results (cmd -> result). */
+    mock_command_results: Map<string, CommandResult>;
+    /** Stdin buffer for input simulation. */
+    stdin_buffer: Uint8Array | null;
+}
+/**
+ * Create a mock `RuntimeDeps` for testing.
+ *
+ * @param args - CLI arguments
+ * @returns `MockRuntime` with controllable state
+ *
+ * @example
+ * ```ts
+ * const runtime = create_mock_runtime(['apply', 'tx.ts']);
+ * runtime.mock_env.set('HOME', '/home/test');
+ * runtime.mock_fs.set('/home/test/.app/config.json', '{}');
+ *
+ * await some_function(runtime);
+ *
+ * assert.strictEqual(runtime.command_calls.length, 1);
+ * assert.deepStrictEqual(runtime.exit_calls, [0]);
+ * ```
+ */
+export declare const create_mock_runtime: (args?: Array<string>) => MockRuntime;
+/**
+ * Reset a mock runtime to initial state.
+ *
+ * @param runtime - `MockRuntime` to reset
+ */
+export declare const reset_mock_runtime: (runtime: MockRuntime) => void;
+/**
+ * Set stdin buffer for simulating user input.
+ *
+ * @param runtime - `MockRuntime` to configure
+ * @param input - string to provide as stdin input
+ */
+export declare const set_mock_stdin: (runtime: MockRuntime, input: string) => void;
+/**
+ * Error thrown when mock `runtime.exit()` is called.
+ *
+ * Tests can catch this to verify exit behavior.
+ */
+export declare class MockExitError extends Error {
+    readonly code: number;
+    constructor(code: number);
+}
+//# sourceMappingURL=mock.d.ts.map

package/dist/runtime/mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/runtime/mock.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,WAAW,EAAc,aAAa,EAAC,MAAM,WAAW,CAAC;AAItE;;GAEG;AACH,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC/C,kCAAkC;IAClC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,0CAA0C;IAC1C,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,mCAAmC;IACnC,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvB,wCAAwC;IACxC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B,yBAAyB;IACzB,aAAa,EAAE,KAAK,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;KAAC,CAAC,CAAC;IACzD,sCAAsC;IACtC,qBAAqB,EAAE,KAAK,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;KAAC,CAAC,CAAC;IACjE,8BAA8B;IAC9B,aAAa,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC7B,4CAA4C;IAC5C,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACjD,yCAAyC;IACzC,YAAY,EAAE,UAAU,GAAG,IAAI,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAM,KAAK,CAAC,MAAM,CAAM,KAAG,WAyI9D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,WAAW,KAAG,IAUzD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,WAAW,EAAE,OAAO,MAAM,KAAG,IAEpE,CAAC;AAEF;;;;GAIG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,MAAM;CAKxB"}

package/dist/runtime/mock.js

@@ -0,0 +1,195 @@
+/**
+ * Mock `RuntimeDeps` for testing.
+ *
+ * Provides a fully controllable runtime implementation for unit tests.
+ * Consumer projects can extend `MockRuntime` with project-specific helpers
+ * (e.g. `setup_mock_tx_config`) that stay local.
+ *
+ * @module
+ */
+/**
+ * Create a mock `RuntimeDeps` for testing.
+ *
+ * @param args - CLI arguments
+ * @returns `MockRuntime` with controllable state
+ *
+ * @example
+ * ```ts
+ * const runtime = create_mock_runtime(['apply', 'tx.ts']);
+ * runtime.mock_env.set('HOME', '/home/test');
+ * runtime.mock_fs.set('/home/test/.app/config.json', '{}');
+ *
+ * await some_function(runtime);
+ *
+ * assert.strictEqual(runtime.command_calls.length, 1);
+ * assert.deepStrictEqual(runtime.exit_calls, [0]);
+ * ```
+ */
+export const create_mock_runtime = (args = []) => {
+    const mock_env = new Map();
+    const mock_fs = new Map();
+    const mock_dirs = new Set();
+    const exit_calls = [];
+    const command_calls = [];
+    const command_inherit_calls = [];
+    const stdout_writes = [];
+    const mock_command_results = new Map();
+    let stdin_buffer = null;
+    const runtime = {
+        args,
+        mock_env,
+        mock_fs,
+        mock_dirs,
+        exit_calls,
+        command_calls,
+        command_inherit_calls,
+        stdout_writes,
+        mock_command_results,
+        get stdin_buffer() {
+            return stdin_buffer;
+        },
+        set stdin_buffer(value) {
+            stdin_buffer = value;
+        },
+        // === Environment ===
+        env_get: (name) => mock_env.get(name),
+        env_set: (name, value) => {
+            mock_env.set(name, value);
+        },
+        env_all: () => Object.fromEntries(mock_env),
+        // === Process ===
+        cwd: () => '/mock/cwd',
+        exit: (code) => {
+            exit_calls.push(code);
+            throw new MockExitError(code);
+        },
+        // === Local File System ===
+        stat: async (path) => {
+            if (mock_fs.has(path)) {
+                return { is_file: true, is_directory: false };
+            }
+            if (mock_dirs.has(path)) {
+                return { is_file: false, is_directory: true };
+            }
+            return null;
+        },
+        mkdir: async (path, options) => {
+            if (options?.recursive) {
+                const parts = path.split('/').filter(Boolean);
+                let current = '';
+                for (const part of parts) {
+                    current += '/' + part;
+                    mock_dirs.add(current);
+                }
+            }
+            else {
+                mock_dirs.add(path);
+            }
+        },
+        read_file: async (path) => {
+            const content = mock_fs.get(path);
+            if (content === undefined) {
+                const error = new Error(`ENOENT: no such file or directory: ${path}`);
+                error.code = 'ENOENT';
+                throw error;
+            }
+            return content;
+        },
+        write_file: async (path, content) => {
+            mock_fs.set(path, content);
+        },
+        rename: async (old_path, new_path) => {
+            const content = mock_fs.get(old_path);
+            if (content !== undefined) {
+                mock_fs.set(new_path, content);
+                mock_fs.delete(old_path);
+            }
+        },
+        remove: async (path, options) => {
+            mock_fs.delete(path);
+            mock_dirs.delete(path);
+            if (options?.recursive) {
+                const prefix = path.endsWith('/') ? path : path + '/';
+                for (const key of mock_fs.keys()) {
+                    if (key.startsWith(prefix))
+                        mock_fs.delete(key);
+                }
+                for (const key of mock_dirs) {
+                    if (key.startsWith(prefix))
+                        mock_dirs.delete(key);
+                }
+            }
+        },
+        // === Local Commands ===
+        run_command: async (cmd, args) => {
+            command_calls.push({ cmd, args });
+            const key = `${cmd} ${args.join(' ')}`;
+            const mocked = mock_command_results.get(key);
+            if (mocked)
+                return mocked;
+            return { success: true, code: 0, stdout: '', stderr: '' };
+        },
+        run_command_inherit: async (cmd, args) => {
+            command_inherit_calls.push({ cmd, args });
+            const key = `${cmd} ${args.join(' ')}`;
+            const mocked = mock_command_results.get(key);
+            if (mocked)
+                return mocked.code;
+            return 0;
+        },
+        // === Terminal I/O ===
+        stdout_write: async (data) => {
+            stdout_writes.push(new TextDecoder().decode(data));
+            return data.length;
+        },
+        stdin_read: async (buffer) => {
+            if (stdin_buffer === null)
+                return null;
+            const len = Math.min(buffer.length, stdin_buffer.length);
+            buffer.set(stdin_buffer.subarray(0, len));
+            stdin_buffer = null;
+            return len;
+        },
+        // === Logging ===
+        warn: (..._args) => { }, // eslint-disable-line @typescript-eslint/no-empty-function
+    };
+    return runtime;
+};
+/**
+ * Reset a mock runtime to initial state.
+ *
+ * @param runtime - `MockRuntime` to reset
+ */
+export const reset_mock_runtime = (runtime) => {
+    runtime.mock_env.clear();
+    runtime.mock_fs.clear();
+    runtime.mock_dirs.clear();
+    runtime.exit_calls.length = 0;
+    runtime.command_calls.length = 0;
+    runtime.command_inherit_calls.length = 0;
+    runtime.stdout_writes.length = 0;
+    runtime.mock_command_results.clear();
+    runtime.stdin_buffer = null;
+};
+/**
+ * Set stdin buffer for simulating user input.
+ *
+ * @param runtime - `MockRuntime` to configure
+ * @param input - string to provide as stdin input
+ */
+export const set_mock_stdin = (runtime, input) => {
+    runtime.stdin_buffer = new TextEncoder().encode(input);
+};
+/**
+ * Error thrown when mock `runtime.exit()` is called.
+ *
+ * Tests can catch this to verify exit behavior.
+ */
+export class MockExitError extends Error {
+    code;
+    constructor(code) {
+        super(`exit(${code})`);
+        this.name = 'MockExitError';
+        this.code = code;
+    }
+}

package/dist/runtime/node.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Node.js implementation of `RuntimeDeps`.
+ *
+ * Provides the same interface as `deno.ts` but backed by Node.js APIs.
+ * Used for running servers in Node.js and for tests (vitest runs in Node).
+ *
+ * @module
+ */
+import type { RuntimeDeps } from './deps.js';
+/**
+ * Create a `RuntimeDeps` backed by Node.js APIs.
+ *
+ * @param args - CLI arguments (typically `process.argv.slice(2)`)
+ * @returns `RuntimeDeps` implementation using Node.js runtime
+ */
+export declare const create_node_runtime: (args?: ReadonlyArray<string>) => RuntimeDeps;
+//# sourceMappingURL=node.d.ts.map

package/dist/runtime/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/runtime/node.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,OAAO,KAAK,EAAC,WAAW,EAA4B,MAAM,WAAW,CAAC;AAEtE;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAC/B,OAAM,aAAa,CAAC,MAAM,CAAyB,KACjD,WA6GD,CAAC"}

package/dist/runtime/node.js

@@ -0,0 +1,117 @@
+/**
+ * Node.js implementation of `RuntimeDeps`.
+ *
+ * Provides the same interface as `deno.ts` but backed by Node.js APIs.
+ * Used for running servers in Node.js and for tests (vitest runs in Node).
+ *
+ * @module
+ */
+import { Buffer } from 'node:buffer';
+import { spawn } from 'node:child_process';
+import { stat, mkdir, readFile, writeFile, rename, rm } from 'node:fs/promises';
+import process from 'node:process';
+/**
+ * Create a `RuntimeDeps` backed by Node.js APIs.
+ *
+ * @param args - CLI arguments (typically `process.argv.slice(2)`)
+ * @returns `RuntimeDeps` implementation using Node.js runtime
+ */
+export const create_node_runtime = (args = process.argv.slice(2)) => ({
+    // === Environment ===
+    env_get: (name) => process.env[name],
+    env_set: (name, value) => {
+        process.env[name] = value;
+    },
+    env_all: () => ({ ...process.env }),
+    // === Process ===
+    args,
+    cwd: () => process.cwd(),
+    exit: (code) => process.exit(code),
+    // === Local File System ===
+    stat: async (path) => {
+        try {
+            const s = await stat(path);
+            return { is_file: s.isFile(), is_directory: s.isDirectory() };
+        }
+        catch {
+            return null;
+        }
+    },
+    mkdir: async (path, options) => {
+        await mkdir(path, options);
+    },
+    read_file: (path) => readFile(path, 'utf-8'),
+    write_file: (path, content) => writeFile(path, content, 'utf-8'),
+    rename: (old_path, new_path) => rename(old_path, new_path),
+    remove: (path, options) => rm(path, options),
+    // === Local Commands ===
+    run_command: (cmd, args) => {
+        return new Promise((resolve) => {
+            const proc = spawn(cmd, args, {
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            const stdout_chunks = [];
+            const stderr_chunks = [];
+            proc.stdout.on('data', (chunk) => stdout_chunks.push(chunk));
+            proc.stderr.on('data', (chunk) => stderr_chunks.push(chunk));
+            proc.on('error', (error) => {
+                resolve({
+                    success: false,
+                    code: 1,
+                    stdout: '',
+                    stderr: `Failed to execute command: ${error.message}`,
+                });
+            });
+            proc.on('close', (code) => {
+                resolve({
+                    success: code === 0,
+                    code: code ?? 1,
+                    stdout: Buffer.concat(stdout_chunks).toString('utf-8').trim(),
+                    stderr: Buffer.concat(stderr_chunks).toString('utf-8').trim(),
+                });
+            });
+        });
+    },
+    run_command_inherit: (cmd, args) => {
+        return new Promise((resolve) => {
+            const proc = spawn(cmd, args, {
+                stdio: 'inherit',
+            });
+            proc.on('error', () => resolve(1));
+            proc.on('close', (code) => resolve(code ?? 1));
+        });
+    },
+    // === Terminal I/O ===
+    stdout_write: async (data) => {
+        return new Promise((resolve, reject) => {
+            process.stdout.write(data, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(data.length);
+            });
+        });
+    },
+    // === Logging ===
+    warn: (...args) => console.warn(...args),
+    stdin_read: async (buffer) => {
+        // TODO: Implement proper stdin reading for interactive prompts in Node
+        return new Promise((resolve) => {
+            const onData = (chunk) => {
+                const bytes = Math.min(chunk.length, buffer.length);
+                chunk.copy(buffer, 0, 0, bytes);
+                process.stdin.off('data', onData);
+                process.stdin.pause();
+                resolve(bytes);
+            };
+            const onEnd = () => {
+                process.stdin.off('data', onData);
+                process.stdin.off('end', onEnd);
+                resolve(null);
+            };
+            process.stdin.resume();
+            process.stdin.once('data', onData);
+            process.stdin.once('end', onEnd);
+        });
+    },
+});

package/dist/schema_meta.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared Zod `.meta()` conventions for fuz_app schemas.
+ *
+ * Cross-cutting metadata shape used by env schemas, auth input schemas,
+ * surface generation, and test helpers.
+ *
+ * @module
+ */
+import type { Sensitivity } from './sensitivity.js';
+/** Zod `.meta()` shape for fuz_app schema metadata conventions. */
+export interface SchemaFieldMeta {
+    description?: string;
+    /** Sensitivity level for masking/redaction. `'secret'` masks the value. */
+    sensitivity?: Sensitivity;
+}
+//# sourceMappingURL=schema_meta.d.ts.map

package/dist/schema_meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema_meta.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/schema_meta.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,kBAAkB,CAAC;AAElD,mEAAmE;AACnE,MAAM,WAAW,eAAe;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,WAAW,CAAC;CAC1B"}

package/dist/schema_meta.js

@@ -0,0 +1,9 @@
+/**
+ * Shared Zod `.meta()` conventions for fuz_app schemas.
+ *
+ * Cross-cutting metadata shape used by env schemas, auth input schemas,
+ * surface generation, and test helpers.
+ *
+ * @module
+ */
+export {};

package/dist/sensitivity.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Sensitivity levels for schema metadata.
+ *
+ * Used by env schemas and auth input schemas to control masking/redaction
+ * in startup logs, surface explorers, and test output.
+ *
+ * @module
+ */
+/**
+ * Sensitivity level for a schema field.
+ *
+ * - `'secret'` — value is masked in logs and UI (e.g. passwords, API keys, signing keys)
+ */
+export type Sensitivity = 'secret';
+//# sourceMappingURL=sensitivity.d.ts.map

package/dist/sensitivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sensitivity.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/sensitivity.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC"}

package/dist/sensitivity.js

@@ -0,0 +1,9 @@
+/**
+ * Sensitivity levels for schema metadata.
+ *
+ * Used by env schemas and auth input schemas to control masking/redaction
+ * in startup logs, surface explorers, and test output.
+ *
+ * @module
+ */
+export {};