@fuzdev/fuz_gitops 0.78.0 → 0.79.0

package/dist/operations_defaults.js

@@ -1,20 +1,20 @@
 /**
  * Production implementations of operations interfaces.
  *
- * Provides real git, npm, fs, and build operations for production use.
+ * Provides real git, npm, fs, build, and `repos` operations for production use.
  * For interface definitions and dependency injection pattern, see `operations.ts`.
  *
  * @module
  */
-import { spawn_out } from '@fuzdev/fuz_util/process.ts';
+import { spawn_out, spawn_process, spawn_result_to_message } from '@fuzdev/fuz_util/process.ts';
 import { readFile, writeFile, mkdir, stat } from 'node:fs/promises';
-import { git_checkout } from '@fuzdev/fuz_util/git.ts';
+import { stripVTControlCharacters } from 'node:util';
 import { fs_classify_error } from '@fuzdev/fuz_util/fs.ts';
 import { EMPTY_OBJECT } from '@fuzdev/fuz_util/object.ts';
 import { has_changesets, read_changesets, predict_next_version } from './changeset_reader.js';
 import { wait_for_package } from './npm_registry.js';
 import { run_preflight_checks } from './preflight_checks.js';
-import { git_add, git_commit, git_add_and_commit, git_tag, git_push_tag, git_has_changes, git_list_uncommitted_files, git_has_file_changed, git_stash, git_stash_pop, git_switch_branch, git_current_branch_name_required, git_current_commit_hash_required, git_check_clean_workspace_as_boolean, git_has_remote, } from './git_operations.js';
+import { git_add, git_commit, git_current_commit_hash_required } from './git_operations.js';
 /** Wrap an async function that returns a value */
 const wrap_with_value = async (fn) => {
     try {
@@ -56,121 +56,115 @@ export const default_changeset_operations = {
         catch (error) {
             return { ok: false, message: String(error) };
         }
-    },
+    }
 };
 export const default_git_operations = {
-    // Core git info
-    current_branch_name: async (options) => {
-        const { cwd } = options ?? EMPTY_OBJECT;
-        return wrap_with_value(() => git_current_branch_name_required(cwd ? { cwd } : undefined));
-    },
     current_commit_hash: async (options) => {
-        const { branch, cwd } = options ?? EMPTY_OBJECT;
-        return wrap_with_value(() => git_current_commit_hash_required(branch, cwd ? { cwd } : undefined));
-    },
-    check_clean_workspace: async (options) => {
         const { cwd } = options ?? EMPTY_OBJECT;
-        return wrap_with_value(() => git_check_clean_workspace_as_boolean(cwd ? { cwd } : undefined));
-    },
-    // Branch operations
-    checkout: async (options) => {
-        const { branch, cwd } = options;
-        return wrap_void(() => git_checkout(branch, cwd ? { cwd } : undefined));
-    },
-    pull: async (options) => {
-        const { origin, branch, cwd } = options ?? EMPTY_OBJECT;
-        try {
-            // Omit the branch arg when absent: a trailing `''` makes git pull the remote's
-            // default branch (origin/HEAD) instead of the current branch's upstream.
-            const spawned = await spawn_out('git', ['pull', origin || 'origin', ...(branch ? [branch] : [])], cwd ? { cwd } : undefined);
-            if (spawned.result.ok) {
-                return { ok: true };
-            }
-            else {
-                return { ok: false, message: spawned.stderr || 'Pull failed' };
-            }
-        }
-        catch (error) {
-            return { ok: false, message: String(error) };
-        }
-    },
-    switch_branch: async (options) => {
-        const { branch, pull, cwd } = options;
-        return wrap_void(() => git_switch_branch(branch, pull, cwd ? { cwd } : undefined));
+        return wrap_with_value(() => git_current_commit_hash_required(cwd ? { cwd } : undefined));
     },
-    has_remote: async (options) => {
-        const { remote, cwd } = options ?? EMPTY_OBJECT;
-        return wrap_with_value(() => git_has_remote(remote, cwd ? { cwd } : undefined));
-    },
-    // Staging and committing
     add: async (options) => {
         const { files, cwd } = options;
         return wrap_void(() => git_add(files, cwd ? { cwd } : undefined));
     },
     commit: async (options) => {
-        const { message, cwd } = options;
-        return wrap_void(() => git_commit(message, cwd ? { cwd } : undefined));
-    },
-    add_and_commit: async (options) => {
-        const { files, message, cwd } = options;
-        return wrap_void(() => git_add_and_commit(files, message, cwd ? { cwd } : undefined));
-    },
-    has_changes: async (options) => {
-        const { cwd } = options ?? EMPTY_OBJECT;
-        return wrap_with_value(() => git_has_changes(cwd ? { cwd } : undefined));
-    },
-    list_uncommitted_files: async (options) => {
-        const { cwd } = options ?? EMPTY_OBJECT;
-        return wrap_with_value(() => git_list_uncommitted_files(cwd ? { cwd } : undefined));
-    },
-    // Tagging
-    tag: async (options) => {
-        const { tag_name, message, cwd } = options;
-        return wrap_void(() => git_tag(tag_name, message, cwd ? { cwd } : undefined));
-    },
-    push_tag: async (options) => {
-        const { tag_name, origin, cwd } = options;
-        return wrap_void(() => git_push_tag(tag_name, origin, cwd ? { cwd } : undefined));
-    },
-    // Stashing
-    stash: async (options) => {
-        const { message, cwd } = options ?? EMPTY_OBJECT;
-        return wrap_void(() => git_stash(message, cwd ? { cwd } : undefined));
-    },
-    stash_pop: async (options) => {
-        const { cwd } = options ?? EMPTY_OBJECT;
-        return wrap_void(() => git_stash_pop(cwd ? { cwd } : undefined));
-    },
-    // File change detection
-    has_file_changed: async (options) => {
-        const { from_commit, to_commit, file_path, cwd } = options;
-        return wrap_with_value(() => git_has_file_changed(from_commit, to_commit, file_path, cwd ? { cwd } : undefined));
-    },
+        const { message, files, cwd } = options;
+        return wrap_void(() => git_commit(message, files, cwd ? { cwd } : undefined));
+    }
 };
+/** The most lines of a child's stderr a failure carries. */
+export const OUTPUT_TAIL_MAX_LINES = 20;
+/** The most characters of a child's stderr a failure carries. */
+export const OUTPUT_TAIL_MAX_CHARS = 4096;
+/**
+ * The end of a process's output, for a failure message: its last lines, then
+ * its last characters, with terminal escape sequences stripped and trailing
+ * whitespace trimmed.
+ *
+ * @param text - the output, or as much of its end as was kept
+ * @param max_lines - the most lines to keep
+ * @param max_chars - the most characters to keep, applied after `max_lines`
+ */
+export const output_tail = (text, max_lines = OUTPUT_TAIL_MAX_LINES, max_chars = OUTPUT_TAIL_MAX_CHARS) => {
+    const lines = stripVTControlCharacters(text).replace(/\r\n?/g, '\n').trimEnd().split('\n');
+    const tail = lines.slice(-max_lines).join('\n');
+    if (tail.length <= max_chars)
+        return drop_leading_blank_lines(tail);
+    // a character cut can split a line, and with it a secret masking would no longer
+    // recognize, so the partial first line goes
+    const cut = tail.slice(-max_chars);
+    if (tail[tail.length - max_chars - 1] === '\n')
+        return drop_leading_blank_lines(cut);
+    const nl = cut.indexOf('\n');
+    return nl === -1 ? '' : drop_leading_blank_lines(cut.slice(nl + 1));
+};
+// not `trimStart`, which would strip the first line's indentation
+const drop_leading_blank_lines = (text) => text.replace(/^\n+/, '');
 export const default_process_operations = {
-    spawn: async (options) => {
-        const { cmd, args, cwd } = options;
+    run_interactive: async (options) => {
+        const { cmd, args, cwd, stdout = 'stdout' } = options;
         try {
-            const spawned = await spawn_out(cmd, args, cwd ? { cwd } : undefined);
-            if (spawned.result.ok) {
-                return {
-                    ok: true,
-                    stdout: spawned.stdout || undefined,
-                    stderr: spawned.stderr || undefined,
-                };
-            }
-            else {
-                return {
-                    ok: false,
-                    message: 'Command failed',
-                    stderr: spawned.stderr || undefined,
-                };
-            }
+            // stdin and stdout go straight to the child (fd 2 for stdout routed to our stderr), so
+            // they stay a TTY when ours are — npm prompts for a one-time password only on a TTY.
+            // Only stderr is piped, to keep its end for the failure message while echoing it live.
+            const { child, closed } = spawn_process(cmd, args, {
+                cwd,
+                stdio: ['inherit', stdout === 'stderr' ? 2 : 'inherit', 'pipe']
+            });
+            // a rolling window over stderr's end, bounded however much the child writes
+            let kept = '';
+            child.stderr?.setEncoding('utf8');
+            child.stderr?.on('data', (chunk) => {
+                process.stderr.write(chunk);
+                kept += chunk;
+                if (kept.length > OUTPUT_TAIL_MAX_CHARS * 4)
+                    kept = kept.slice(-OUTPUT_TAIL_MAX_CHARS * 2);
+            });
+            const result = await closed;
+            if (result.ok)
+                return { ok: true };
+            const stderr_tail = output_tail(kept);
+            return {
+                ok: false,
+                message: `\`${[cmd, ...args].join(' ')}\` failed (${spawn_result_to_message(result)})`,
+                stderr_tail: stderr_tail || undefined
+            };
         }
         catch (error) {
             return { ok: false, message: String(error) };
         }
-    },
+    }
+};
+export const default_repos_operations = {
+    status: async (options) => {
+        const { keys, registry, fetch } = options;
+        const args = [...(registry === undefined ? [] : ['--registry', registry]), 'status'];
+        if (fetch)
+            args.push('--fetch');
+        // `--` so a key can never read as a flag
+        args.push('--json', '--', ...keys);
+        const spawned = await spawn_out('repos', args);
+        const { result } = spawned;
+        if (result.kind === 'error') {
+            const not_found = result.error.code === 'ENOENT';
+            return {
+                ok: false,
+                kind: not_found ? 'not_found' : 'failed',
+                message: result.error.message
+            };
+        }
+        if (result.kind === 'signaled') {
+            return { ok: false, kind: 'failed', message: `repos was killed by ${result.signal}` };
+        }
+        return {
+            ok: true,
+            output: {
+                stdout: spawned.stdout ?? '',
+                stderr: spawned.stderr ?? '',
+                exit_code: result.code
+            }
+        };
+    }
 };
 export const default_npm_operations = {
     wait_for_package: async (options) => {
@@ -180,7 +174,7 @@ export const default_npm_operations = {
             return { ok: true };
         }
         catch (error) {
-            return { ok: false, message: String(error), timeout: true };
+            return { ok: false, message: String(error) };
         }
     },
     check_auth: async () => {
@@ -200,36 +194,25 @@ export const default_npm_operations = {
     },
     check_registry: async () => {
         try {
-            const result = await spawn_out('npm', ['ping']);
-            if (result.stdout) {
-                return { ok: true };
-            }
-            return { ok: false, message: 'Failed to ping npm registry' };
-        }
-        catch (error) {
-            return { ok: false, message: String(error) };
-        }
-    },
-    install: async (options) => {
-        const { cwd } = options ?? EMPTY_OBJECT;
-        try {
-            const spawned = await spawn_out('npm', ['install'], cwd ? { cwd } : undefined);
-            if (spawned.result.ok) {
+            // the exit status alone: `npm ping` reports on stderr, writing nothing to stdout
+            const { result } = await spawn_out('npm', ['ping']);
+            if (result.ok) {
                 return { ok: true };
             }
-            else {
-                return { ok: false, message: 'Install failed', stderr: spawned.stderr || undefined };
-            }
+            return {
+                ok: false,
+                message: `Failed to ping npm registry (${spawn_result_to_message(result)})`
+            };
         }
         catch (error) {
             return { ok: false, message: String(error) };
         }
-    },
+    }
 };
 export const default_preflight_operations = {
     run_preflight_checks: async (options) => {
         return run_preflight_checks(options);
-    },
+    }
 };
 export const default_fs_operations = {
     readFile: async (options) => {
@@ -270,13 +253,12 @@ export const default_fs_operations = {
         catch {
             return false;
         }
-    },
+    }
 };
 export const default_build_operations = {
     build_package: async (options) => {
-        const { repo, log } = options;
+        const { repo } = options;
         try {
-            log?.info(`  Building ${repo.library.name}...`);
             const spawned = await spawn_out('gro', ['build'], { cwd: repo.repo_dir });
             if (spawned.result.ok) {
                 return { ok: true };
@@ -285,14 +267,14 @@ export const default_build_operations = {
                 return {
                     ok: false,
                     message: 'Build failed',
-                    output: spawned.stderr || spawned.stdout || 'Build failed',
+                    output: spawned.stderr || spawned.stdout || 'Build failed'
                 };
             }
         }
         catch (error) {
             return { ok: false, message: String(error) };
         }
-    },
+    }
 };
 /**
  * Combined default operations for all gitops functionality.
@@ -305,4 +287,5 @@ export const default_gitops_operations = {
     preflight: default_preflight_operations,
     fs: default_fs_operations,
     build: default_build_operations,
+    repos: default_repos_operations
 };

package/dist/output_helpers.d.ts

@@ -1,9 +1,22 @@
 import type { Logger } from '@fuzdev/fuz_util/log.ts';
 export type OutputFormat = 'stdout' | 'json' | 'markdown';
+/**
+ * Writes one machine-readable document, or one line of a stream, to stdout,
+ * ending it with a newline.
+ */
+export type WriteStdout = (content: string) => void;
 export interface OutputOptions {
     format: OutputFormat;
     outfile?: string;
     log?: Logger;
+    /**
+     * Where a `json` or `markdown` document goes without `outfile`; the one
+     * `route_human_output` returns, so the document reaches stdout while the
+     * logger's lines go to stderr.
+     *
+     * @default `console.log`
+     */
+    write_stdout?: WriteStdout;
 }
 export interface OutputFormatters<T> {
     json: (data: T) => string;
@@ -13,6 +26,29 @@ export interface OutputFormatters<T> {
      */
     stdout: (data: T, log: Logger) => void;
 }
+/**
+ * Whether a task's stdout carries a machine-readable document: a `json` or
+ * `markdown` report not sent to `--outfile`.
+ *
+ * @param format - the task's `--format`
+ * @param outfile - the task's `--outfile`, if any
+ */
+export declare const output_is_machine: (format: string, outfile: string | undefined) => boolean;
+/**
+ * Keeps a task's stdout for its machine-readable document or stream when
+ * `machine` is set: the logger's `info` and `debug` lines, which it writes with
+ * `console.log`, go where its errors go — stderr — and child loggers inherit
+ * that. Gro hands a task the logger its own lines go through, so gro's lines
+ * after the task runs (`✓`, the timings) follow to stderr; the two it prints
+ * before the task runs (`invoking`, `→ <task>`) stay on stdout, out of the
+ * task's reach.
+ *
+ * @param log - the task's logger
+ * @param machine - whether stdout carries a machine-readable document or stream
+ * @returns writes to the stdout the logger wrote to before, for the document
+ * @mutates log - overrides its `console` when `machine` is set
+ */
+export declare const route_human_output: (log: Logger, machine: boolean) => WriteStdout;
 /**
  * Formats data and outputs to file or stdout based on options.
  *

package/dist/output_helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"output_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/output_helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAGpD,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;AAE1D,MAAM,WAAW,aAAa;IAC7B,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC;IAClC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC;IAC1B,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,KAAK,CAAC,MAAM,CAAC,CAAC;IACrC;;OAEG;IACH,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAAU,CAAC,EACxC,MAAM,CAAC,EACP,YAAY,gBAAgB,CAAC,CAAC,CAAC,EAC/B,SAAS,aAAa,KACpB,OAAO,CAAC,IAAI,CA8Bd,CAAC"}
+{"version":3,"file":"output_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/output_helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAGtD,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;AAE1D;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAEpD,MAAM,WAAW,aAAa;IAC7B,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC;IAClC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC;IAC1B,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,KAAK,CAAC,MAAM,CAAC,CAAC;IACrC;;OAEG;IACH,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,QAAQ,MAAM,EAAE,SAAS,MAAM,GAAG,SAAS,KAAG,OACvB,CAAC;AAE1D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,GAAI,KAAK,MAAM,EAAE,SAAS,OAAO,KAAG,WAUlE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAAU,CAAC,EACxC,MAAM,CAAC,EACP,YAAY,gBAAgB,CAAC,CAAC,CAAC,EAC/B,SAAS,aAAa,KACpB,OAAO,CAAC,IAAI,CA6Bd,CAAC"}

package/dist/output_helpers.js

@@ -1,4 +1,37 @@
 import { writeFile } from 'node:fs/promises';
+/**
+ * Whether a task's stdout carries a machine-readable document: a `json` or
+ * `markdown` report not sent to `--outfile`.
+ *
+ * @param format - the task's `--format`
+ * @param outfile - the task's `--outfile`, if any
+ */
+export const output_is_machine = (format, outfile) => (format === 'json' || format === 'markdown') && !outfile;
+/**
+ * Keeps a task's stdout for its machine-readable document or stream when
+ * `machine` is set: the logger's `info` and `debug` lines, which it writes with
+ * `console.log`, go where its errors go — stderr — and child loggers inherit
+ * that. Gro hands a task the logger its own lines go through, so gro's lines
+ * after the task runs (`✓`, the timings) follow to stderr; the two it prints
+ * before the task runs (`invoking`, `→ <task>`) stay on stdout, out of the
+ * task's reach.
+ *
+ * @param log - the task's logger
+ * @param machine - whether stdout carries a machine-readable document or stream
+ * @returns writes to the stdout the logger wrote to before, for the document
+ * @mutates log - overrides its `console` when `machine` is set
+ */
+export const route_human_output = (log, machine) => {
+    const stdout = log.console;
+    if (machine) {
+        log.console = {
+            log: (...args) => stdout.error(...args),
+            warn: (...args) => stdout.warn(...args),
+            error: (...args) => stdout.error(...args)
+        };
+    }
+    return (content) => stdout.log(content);
+};
 /**
  * Formats data and outputs to file or stdout based on options.
  *
@@ -10,7 +43,7 @@ import { writeFile } from 'node:fs/promises';
  * @throws {Error} if stdout format used with `outfile`, or if logger missing for stdout
  */
 export const format_and_output = async (data, formatters, options) => {
-    const { format, outfile, log } = options;
+    const { format, outfile, log, write_stdout = write_console_log } = options;
     // Handle stdout format (special case - uses logger directly)
     if (format === 'stdout') {
         if (outfile) {
@@ -34,7 +67,8 @@ export const format_and_output = async (data, formatters, options) => {
         // line with `[taskname]`, corrupting JSON and cluttering markdown — keep the
         // machine-readable formats unprefixed and pipeable (use `--outfile` for output
         // fully free of Gro's own preamble).
-        // eslint-disable-next-line no-console
-        console.log(content);
+        write_stdout(content);
     }
 };
+// eslint-disable-next-line no-console
+const write_console_log = (content) => console.log(content);

package/dist/preflight_checks.d.ts

@@ -1,47 +1,40 @@
 import type { Logger } from '@fuzdev/fuz_util/log.ts';
 import type { LocalRepo } from './local_repo.js';
-import type { GitOperations, NpmOperations, BuildOperations, ChangesetOperations } from './operations.js';
-export interface PreflightOptions {
-    skip_changesets?: boolean;
-    skip_build_validation?: boolean;
-    required_branch?: string;
-    check_remote?: boolean;
-    estimate_time?: boolean;
-    log?: Logger;
-}
+import type { VersionChange } from './publishing_plan.js';
+import type { NpmOperations, BuildOperations } from './operations.js';
 export interface PreflightResult {
     ok: boolean;
     warnings: Array<string>;
     errors: Array<string>;
-    repos_with_changesets: Set<string>;
-    repos_without_changesets: Set<string>;
-    estimated_duration?: number;
-    npm_username?: string;
 }
 export interface RunPreflightChecksOptions {
     repos: Array<LocalRepo>;
-    preflight_options?: PreflightOptions;
-    git_ops?: GitOperations;
+    /**
+     * The plan's version changes — every package the run publishes, explicit,
+     * escalated, and auto-generated alike. Preflight builds exactly these.
+     */
+    version_changes: Array<VersionChange>;
+    log?: Logger;
     npm_ops?: NpmOperations;
     build_ops?: BuildOperations;
-    changeset_ops?: ChangesetOperations;
 }
 /**
- * Validates all requirements before publishing can proceed.
+ * Validates the publish-time requirements beyond repo git state:
+ * - every package the plan publishes builds (fail-fast to prevent broken state)
+ * - npm authentication
+ * - npm registry connectivity
  *
- * Performs comprehensive pre-flight validation:
- * - Clean workspaces (100% clean required - no uncommitted changes)
- * - Correct branch (usually main)
- * - Changesets present (unless `skip_changesets`=true)
- * - Builds successful (fail-fast to prevent broken state)
- * - Git remote reachability
- * - NPM authentication with username
- * - NPM registry connectivity
+ * What publishes is the plan's to decide, so preflight reads no changesets: it
+ * builds each package in `version_changes`. Git state — each repo on its
+ * registry branch, clean, idle, in sync with origin or ahead of it, and no live
+ * session in its checkout — is the readiness gate's, which `gitops_publish
+ * --wetrun` runs before the plan's confirmation prompt (`repo_readiness.ts`), so
+ * preflight reads no git.
  *
  * Build validation runs BEFORE any publishing to prevent the scenario where
  * version is bumped but build fails, leaving repo in broken state.
  *
- * @returns result with `ok`=false if any errors, plus warnings and detailed status
+ * @returns result with `ok`=false if any errors, plus warnings
  */
-export declare const run_preflight_checks: ({ repos, preflight_options, git_ops, npm_ops, build_ops, changeset_ops, }: RunPreflightChecksOptions) => Promise<PreflightResult>;
+export declare const run_preflight_checks: ({ repos, version_changes, log, npm_ops, build_ops }: RunPreflightChecksOptions) => Promise<PreflightResult>;
 //# sourceMappingURL=preflight_checks.d.ts.map

package/dist/preflight_checks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preflight_checks.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/preflight_checks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAKpD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EACX,aAAa,EACb,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,MAAM,iBAAiB,CAAC;AAQzB,MAAM,WAAW,gBAAgB;IAChC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,eAAe;IAC/B,EAAE,EAAE,OAAO,CAAC;IACZ,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACtB,qBAAqB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACnC,wBAAwB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,yBAAyB;IACzC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IACxB,iBAAiB,CAAC,EAAE,gBAAgB,CAAC;IACrC,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,aAAa,CAAC,EAAE,mBAAmB,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,oBAAoB,GAAU,2EAOxC,yBAAyB,KAAG,OAAO,CAAC,eAAe,CAwLrD,CAAC"}
+{"version":3,"file":"preflight_checks.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/preflight_checks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAGtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGtE,MAAM,WAAW,eAAe;IAC/B,EAAE,EAAE,OAAO,CAAC;IACZ,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACtB;AAED,MAAM,WAAW,yBAAyB;IACzC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IACxB;;;OAGG;IACH,eAAe,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;IACtC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,SAAS,CAAC,EAAE,eAAe,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,oBAAoB,GAAU,qDAMxC,yBAAyB,KAAG,OAAO,CAAC,eAAe,CAkFrD,CAAC"}