@hyperdrive.bot/paseo-cli 0.2.6

package/dist/commands/worktree/index.js

@@ -0,0 +1,25 @@
+import { Command } from "commander";
+import { runLsCommand } from "./ls.js";
+import { runArchiveCommand } from "./archive.js";
+import { runCreateCommand } from "./create.js";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+export function createWorktreeCommand() {
+    const worktree = new Command("worktree").description("Manage Paseo-managed git worktrees");
+    addJsonAndDaemonHostOptions(worktree.command("ls").description("List Paseo-managed git worktrees")).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(worktree
+        .command("create")
+        .description("Create a Paseo-managed git worktree")
+        .option("--mode <mode>", "Creation mode: branch-off, checkout-branch, or checkout-pr")
+        .option("--new-branch <name>", "New branch name (--mode branch-off)")
+        .option("--base <ref>", "Base ref for new branch (--mode branch-off, defaults to repo default)")
+        .option("--branch <name>", "Existing branch to check out (--mode checkout-branch)")
+        .option("--pr-number <n>", "Pull request number (--mode checkout-pr)")
+        .option("--cwd <path>", "Repository directory (default: current)")).action(withOutput(runCreateCommand));
+    addJsonAndDaemonHostOptions(worktree
+        .command("archive")
+        .description("Archive a worktree (removes worktree and associated branch)")
+        .argument("<name>", "Worktree name or branch name")).action(withOutput(runArchiveCommand));
+    return worktree;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/worktree/ls.d.ts

@@ -0,0 +1,19 @@
+import type { Command } from "commander";
+import type { CommandOptions, ListResult, OutputSchema } from "../../output/index.js";
+/** Worktree list item for display */
+export interface WorktreeListItem {
+    name: string;
+    branch: string;
+    cwd: string;
+    agent: string;
+}
+export declare function resolvePaseoHomePath(): string;
+export declare function resolvePaseoWorktreesDir(): string;
+/** Schema for worktree ls output */
+export declare const worktreeLsSchema: OutputSchema<WorktreeListItem>;
+export type WorktreeLsResult = ListResult<WorktreeListItem>;
+export interface WorktreeLsOptions extends CommandOptions {
+    host?: string;
+}
+export declare function runLsCommand(options: WorktreeLsOptions, _command: Command): Promise<WorktreeLsResult>;
+//# sourceMappingURL=ls.d.ts.map

package/dist/commands/worktree/ls.js

@@ -0,0 +1,97 @@
+import { homedir } from "node:os";
+import { basename, join, sep } from "node:path";
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+/** Shorten home directory in path */
+function shortenPath(path) {
+    const home = process.env.HOME;
+    if (home && path.startsWith(home)) {
+        return "~" + path.slice(home.length);
+    }
+    return path;
+}
+/** Extract worktree name from path */
+function extractWorktreeName(path) {
+    return basename(path);
+}
+export function resolvePaseoHomePath() {
+    return process.env.PASEO_HOME ?? join(homedir(), ".paseo");
+}
+export function resolvePaseoWorktreesDir() {
+    return join(resolvePaseoHomePath(), "worktrees");
+}
+function isAgentInManagedWorktree(agentCwd) {
+    const worktreesDir = resolvePaseoWorktreesDir();
+    return agentCwd === worktreesDir || agentCwd.startsWith(worktreesDir + sep);
+}
+/** Schema for worktree ls output */
+export const worktreeLsSchema = {
+    idField: "name",
+    columns: [
+        { header: "NAME", field: "name", width: 20 },
+        { header: "BRANCH", field: "branch", width: 25 },
+        { header: "CWD", field: "cwd", width: 45 },
+        { header: "AGENT", field: "agent", width: 10 },
+    ],
+};
+export async function runLsCommand(options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: paseo daemon start",
+        };
+        throw error;
+    }
+    try {
+        const agentsPayload = await client.fetchAgents({ filter: { includeArchived: true } });
+        const agents = agentsPayload.entries.map((entry) => entry.agent);
+        // Get worktree list from daemon
+        const response = await client.getPaseoWorktreeList({});
+        await client.close();
+        if (response.error) {
+            const error = {
+                code: "WORKTREE_LIST_FAILED",
+                message: `Failed to list worktrees: ${response.error.message}`,
+            };
+            throw error;
+        }
+        // Build a map of worktree paths to agent IDs
+        const worktreeAgentMap = new Map();
+        for (const agent of agents) {
+            if (isAgentInManagedWorktree(agent.cwd)) {
+                worktreeAgentMap.set(agent.cwd, agent.id.slice(0, 7));
+            }
+        }
+        const items = response.worktrees.map((wt) => ({
+            name: extractWorktreeName(wt.worktreePath),
+            branch: wt.branchName ?? "-",
+            cwd: shortenPath(wt.worktreePath),
+            agent: worktreeAgentMap.get(wt.worktreePath) ?? "-",
+        }));
+        return {
+            type: "list",
+            data: items,
+            schema: worktreeLsSchema,
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        // Re-throw CommandError as-is
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "WORKTREE_LIST_FAILED",
+            message: `Failed to list worktrees: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=ls.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,6 @@
+import { runCli } from "./run.js";
+const exitCode = await runCli(process.argv.slice(2), {
+    nodeArgv: [process.argv[0] ?? "node", process.argv[1] ?? "paseo"],
+});
+process.exitCode = exitCode;
+//# sourceMappingURL=index.js.map

package/dist/output/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Output abstraction layer for the Paseo CLI.
+ *
+ * This module provides structured output rendering with support for multiple formats:
+ * - table: Human-readable aligned tables (default)
+ * - json: Machine-readable JSON
+ * - yaml: Machine-readable YAML
+ * - quiet: Minimal output (IDs only)
+ *
+ * @example
+ * ```typescript
+ * import { withOutput, render, type ListResult, type OutputSchema } from './output/index.js'
+ *
+ * // Define your data type
+ * interface Agent { id: string; title: string; status: string }
+ *
+ * // Define how to render it
+ * const schema: OutputSchema<Agent> = {
+ *   idField: 'id',
+ *   columns: [
+ *     { header: 'ID', field: 'id' },
+ *     { header: 'TITLE', field: 'title' },
+ *     { header: 'STATUS', field: 'status', color: (v) => v === 'running' ? 'green' : undefined },
+ *   ],
+ * }
+ *
+ * // Return structured data from commands
+ * const result: ListResult<Agent> = {
+ *   type: 'list',
+ *   data: agents,
+ *   schema,
+ * }
+ *
+ * // Render with options
+ * const output = render(result, { format: 'json' })
+ * ```
+ */
+export type { OutputFormat, OutputOptions, ColumnDef, OutputSchema, CommandResult, SingleResult, ListResult, AnyCommandResult, CommandError, } from "./types.js";
+export { renderTable, renderTableHeader, renderTableRow } from "./table.js";
+export { renderJson, renderJsonLine } from "./json.js";
+export { renderYaml, renderYamlDoc } from "./yaml.js";
+export { renderQuiet } from "./quiet.js";
+export { render, renderError, toCommandError, defaultOutputOptions } from "./render.js";
+export { withOutput, createOutputOptions, type CommandOptions } from "./with-output.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/output/index.js

@@ -0,0 +1,47 @@
+/**
+ * Output abstraction layer for the Paseo CLI.
+ *
+ * This module provides structured output rendering with support for multiple formats:
+ * - table: Human-readable aligned tables (default)
+ * - json: Machine-readable JSON
+ * - yaml: Machine-readable YAML
+ * - quiet: Minimal output (IDs only)
+ *
+ * @example
+ * ```typescript
+ * import { withOutput, render, type ListResult, type OutputSchema } from './output/index.js'
+ *
+ * // Define your data type
+ * interface Agent { id: string; title: string; status: string }
+ *
+ * // Define how to render it
+ * const schema: OutputSchema<Agent> = {
+ *   idField: 'id',
+ *   columns: [
+ *     { header: 'ID', field: 'id' },
+ *     { header: 'TITLE', field: 'title' },
+ *     { header: 'STATUS', field: 'status', color: (v) => v === 'running' ? 'green' : undefined },
+ *   ],
+ * }
+ *
+ * // Return structured data from commands
+ * const result: ListResult<Agent> = {
+ *   type: 'list',
+ *   data: agents,
+ *   schema,
+ * }
+ *
+ * // Render with options
+ * const output = render(result, { format: 'json' })
+ * ```
+ */
+// Renderers
+export { renderTable, renderTableHeader, renderTableRow } from "./table.js";
+export { renderJson, renderJsonLine } from "./json.js";
+export { renderYaml, renderYamlDoc } from "./yaml.js";
+export { renderQuiet } from "./quiet.js";
+// Main render function
+export { render, renderError, toCommandError, defaultOutputOptions } from "./render.js";
+// Command wrapper
+export { withOutput, createOutputOptions } from "./with-output.js";
+//# sourceMappingURL=index.js.map

package/dist/output/json.d.ts

@@ -0,0 +1,11 @@
+/**
+ * JSON renderer for CLI output.
+ *
+ * Renders structured data as formatted JSON for machine consumption.
+ */
+import type { AnyCommandResult, OutputOptions } from "./types.js";
+/** Render command result as JSON */
+export declare function renderJson<T>(result: AnyCommandResult<T>, _options: OutputOptions): string;
+/** Render a single item as JSON line (for NDJSON streaming) */
+export declare function renderJsonLine<T>(item: T, serialize?: (data: T) => unknown): string;
+//# sourceMappingURL=json.d.ts.map

package/dist/output/json.js

@@ -0,0 +1,37 @@
+/**
+ * JSON renderer for CLI output.
+ *
+ * Renders structured data as formatted JSON for machine consumption.
+ */
+/** Render command result as JSON */
+export function renderJson(result, _options) {
+    const { schema } = result;
+    // Apply custom serializer if provided
+    if (schema.serialize) {
+        if (result.type === "list") {
+            // If all items serialize to the same object, return just one
+            // This handles the case where a list of key-value rows should serialize
+            // to a single structured object
+            const serialized = result.data.map((item) => schema.serialize(item));
+            if (serialized.length > 0) {
+                const first = JSON.stringify(serialized[0]);
+                const allSame = serialized.every((s) => JSON.stringify(s) === first);
+                if (allSame) {
+                    return JSON.stringify(serialized[0], null, 2);
+                }
+            }
+            return JSON.stringify(serialized, null, 2);
+        }
+        else {
+            const serialized = schema.serialize(result.data);
+            return JSON.stringify(serialized, null, 2);
+        }
+    }
+    return JSON.stringify(result.data, null, 2);
+}
+/** Render a single item as JSON line (for NDJSON streaming) */
+export function renderJsonLine(item, serialize) {
+    const output = serialize ? serialize(item) : item;
+    return JSON.stringify(output);
+}
+//# sourceMappingURL=json.js.map

package/dist/output/quiet.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Quiet renderer for CLI output.
+ *
+ * Outputs only ID fields, one per line. Useful for scripting and pipelines.
+ */
+import type { AnyCommandResult, OutputOptions } from "./types.js";
+/** Render command result in quiet mode (IDs only) */
+export declare function renderQuiet<T>(result: AnyCommandResult<T>, _options: OutputOptions): string;
+//# sourceMappingURL=quiet.d.ts.map

package/dist/output/quiet.js

@@ -0,0 +1,22 @@
+/**
+ * Quiet renderer for CLI output.
+ *
+ * Outputs only ID fields, one per line. Useful for scripting and pipelines.
+ */
+/** Extract ID from item using schema definition */
+function getId(item, idField) {
+    if (typeof idField === "function") {
+        return idField(item);
+    }
+    return String(item[idField]);
+}
+/** Render command result in quiet mode (IDs only) */
+export function renderQuiet(result, _options) {
+    if (result.type === "single") {
+        return getId(result.data, result.schema.idField);
+    }
+    else {
+        return result.data.map((item) => getId(item, result.schema.idField)).join("\n");
+    }
+}
+//# sourceMappingURL=quiet.js.map

package/dist/output/render.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Main render dispatcher for CLI output.
+ *
+ * Selects the appropriate renderer based on output options.
+ */
+import type { AnyCommandResult, CommandError, OutputOptions } from "./types.js";
+/** Default output options */
+export declare const defaultOutputOptions: OutputOptions;
+/** Render command result to string based on output options */
+export declare function render<T>(result: AnyCommandResult<T>, options?: Partial<OutputOptions>): string;
+/** Convert an unknown error to a CommandError */
+export declare function toCommandError(error: unknown): CommandError;
+/** Render an error to string based on output options */
+export declare function renderError(error: CommandError, options?: Partial<OutputOptions>): string;
+//# sourceMappingURL=render.d.ts.map

package/dist/output/render.js

@@ -0,0 +1,83 @@
+/**
+ * Main render dispatcher for CLI output.
+ *
+ * Selects the appropriate renderer based on output options.
+ */
+import chalk from "chalk";
+import YAML from "yaml";
+import { renderTable } from "./table.js";
+import { renderJson } from "./json.js";
+import { renderYaml } from "./yaml.js";
+import { renderQuiet } from "./quiet.js";
+/** Default output options */
+export const defaultOutputOptions = {
+    format: "table",
+    quiet: false,
+    noHeaders: false,
+    noColor: false,
+};
+/** Render command result to string based on output options */
+export function render(result, options = {}) {
+    const opts = { ...defaultOutputOptions, ...options };
+    // Quiet mode takes precedence
+    if (opts.quiet) {
+        return renderQuiet(result, opts);
+    }
+    // Dispatch to format-specific renderer
+    switch (opts.format) {
+        case "json":
+            return renderJson(result, opts);
+        case "yaml":
+            return renderYaml(result, opts);
+        case "table":
+        default:
+            if (result.schema.renderHuman) {
+                return result.schema.renderHuman(result, opts);
+            }
+            return renderTable(result, opts);
+    }
+}
+/** Convert an unknown error to a CommandError */
+export function toCommandError(error) {
+    if (isCommandError(error)) {
+        return error;
+    }
+    if (error instanceof Error) {
+        return {
+            code: "UNKNOWN_ERROR",
+            message: error.message,
+            details: error.stack,
+        };
+    }
+    return {
+        code: "UNKNOWN_ERROR",
+        message: String(error),
+    };
+}
+/** Type guard for CommandError */
+function isCommandError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        "message" in error &&
+        typeof error.code === "string" &&
+        typeof error.message === "string");
+}
+/** Render an error to string based on output options */
+export function renderError(error, options = {}) {
+    const opts = { ...defaultOutputOptions, ...options };
+    if (opts.format === "json") {
+        return JSON.stringify({ error }, null, 2);
+    }
+    if (opts.format === "yaml") {
+        return YAML.stringify({ error });
+    }
+    // Table/default format: human-readable error
+    const prefix = opts.noColor ? "Error: " : chalk.red("Error: ");
+    const message = error.message;
+    if (error.details && typeof error.details === "string") {
+        return `${prefix}${message}\n${error.details}`;
+    }
+    return `${prefix}${message}`;
+}
+//# sourceMappingURL=render.js.map

package/dist/output/table.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Table renderer for CLI output.
+ *
+ * Renders structured data as aligned ASCII tables with optional color support.
+ */
+import type { AnyCommandResult, OutputOptions, OutputSchema } from "./types.js";
+/** Render a list result as a table */
+export declare function renderTable<T>(result: AnyCommandResult<T>, options: OutputOptions): string;
+/** Render just a table header (for streaming) */
+export declare function renderTableHeader<T>(schema: OutputSchema<T>, options: OutputOptions, widths?: number[]): string;
+/** Render just a table row (for streaming) */
+export declare function renderTableRow<T>(item: T, schema: OutputSchema<T>, options: OutputOptions, widths?: number[]): string;
+//# sourceMappingURL=table.d.ts.map

package/dist/output/table.js

@@ -0,0 +1,135 @@
+/**
+ * Table renderer for CLI output.
+ *
+ * Renders structured data as aligned ASCII tables with optional color support.
+ */
+import chalk from "chalk";
+// ANSI escape code regex for stripping colors when measuring width
+const ANSI_REGEX = 
+// eslint-disable-next-line no-control-regex
+/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+/** Strip ANSI escape codes from a string */
+function stripAnsi(str) {
+    return str.replace(ANSI_REGEX, "");
+}
+/** Get visible string length (excluding ANSI codes) */
+function visibleLength(str) {
+    return stripAnsi(str).length;
+}
+/** Pad a cell to the specified width with alignment */
+function padCell(cell, width, align) {
+    const visible = visibleLength(cell);
+    const padding = Math.max(0, width - visible);
+    switch (align) {
+        case "right":
+            return " ".repeat(padding) + cell;
+        case "center": {
+            const left = Math.floor(padding / 2);
+            const right = padding - left;
+            return " ".repeat(left) + cell + " ".repeat(right);
+        }
+        case "left":
+        default:
+            return cell + " ".repeat(padding);
+    }
+}
+/** Apply a chalk color to a string */
+function applyColor(str, colorName) {
+    // Map color names to chalk methods
+    const colorMap = {
+        red: chalk.red,
+        green: chalk.green,
+        blue: chalk.blue,
+        yellow: chalk.yellow,
+        cyan: chalk.cyan,
+        magenta: chalk.magenta,
+        white: chalk.white,
+        gray: chalk.gray,
+        grey: chalk.grey,
+        dim: chalk.dim,
+        bold: chalk.bold,
+    };
+    const colorFn = colorMap[colorName];
+    return colorFn ? colorFn(str) : str;
+}
+/** Extract value from item using field definition */
+function getValue(item, field) {
+    return typeof field === "function" ? field(item) : item[field];
+}
+/** Render a single table row */
+function renderRow(item, columns, widths, options) {
+    return columns
+        .map((col, colIndex) => {
+        const value = getValue(item, col.field);
+        let cell = String(value ?? "");
+        const width = widths[colIndex];
+        // Apply color if enabled
+        if (col.color && !options.noColor) {
+            const colorName = col.color(value, item);
+            if (colorName) {
+                cell = applyColor(cell, colorName);
+            }
+        }
+        return padCell(cell, width ?? 0, col.align ?? "left");
+    })
+        .join("  ");
+}
+/** Render header row */
+function renderHeader(columns, widths, options) {
+    const headerRow = columns
+        .map((col, i) => padCell(col.header, widths[i] ?? 0, col.align ?? "left"))
+        .join("  ");
+    return options.noColor ? headerRow : chalk.bold(headerRow);
+}
+/** Calculate column widths based on content and hints */
+function calculateWidths(data, columns, includeHeaders) {
+    return columns.map((col) => {
+        // Start with header width if including headers
+        let maxWidth = includeHeaders ? col.header.length : 0;
+        // Check all data values
+        for (const item of data) {
+            const value = getValue(item, col.field);
+            const str = String(value ?? "");
+            maxWidth = Math.max(maxWidth, visibleLength(str));
+        }
+        // Apply width hint if specified (minimum width)
+        if (col.width) {
+            maxWidth = Math.max(maxWidth, col.width);
+        }
+        return maxWidth;
+    });
+}
+/** Render a list result as a table */
+export function renderTable(result, options) {
+    const { schema } = result;
+    const data = result.type === "list" ? result.data : [result.data];
+    if (data.length === 0) {
+        return "";
+    }
+    const columns = schema.columns;
+    const includeHeaders = !options.noHeaders;
+    const widths = calculateWidths(data, columns, includeHeaders);
+    const lines = [];
+    // Add header row
+    if (includeHeaders) {
+        lines.push(renderHeader(columns, widths, options));
+    }
+    // Add data rows
+    for (const item of data) {
+        lines.push(renderRow(item, columns, widths, options));
+    }
+    return lines.join("\n");
+}
+/** Render just a table header (for streaming) */
+export function renderTableHeader(schema, options, widths) {
+    const columns = schema.columns;
+    const actualWidths = widths ?? columns.map((col) => col.width ?? col.header.length);
+    return renderHeader(columns, actualWidths, options);
+}
+/** Render just a table row (for streaming) */
+export function renderTableRow(item, schema, options, widths) {
+    const columns = schema.columns;
+    const actualWidths = widths ?? columns.map((col) => col.width ?? col.header.length);
+    return renderRow(item, columns, actualWidths, options);
+}
+//# sourceMappingURL=table.js.map

package/dist/output/types.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Output format types for the Paseo CLI.
+ *
+ * This module defines the structured data types used by the output abstraction layer.
+ * Commands return CommandResult<T> which contains both data and rendering metadata.
+ */
+/** Supported output formats */
+export type OutputFormat = "table" | "json" | "yaml";
+/** Options controlling output rendering */
+export interface OutputOptions {
+    /** Output format (table, json, yaml) */
+    format: OutputFormat;
+    /** Minimal output - IDs only */
+    quiet: boolean;
+    /** Omit table headers */
+    noHeaders: boolean;
+    /** Disable color output */
+    noColor: boolean;
+}
+/** Column definition for table output */
+export interface ColumnDef<T> {
+    /** Header text for the column */
+    header: string;
+    /** Field key or accessor function */
+    field: keyof T | ((item: T) => unknown);
+    /** Optional width hint (characters) */
+    width?: number;
+    /** Optional alignment */
+    align?: "left" | "right" | "center";
+    /** Optional color function - returns chalk color name */
+    color?: (value: unknown, item: T) => string | undefined;
+}
+/** Schema describing how to render command output */
+export interface OutputSchema<T> {
+    /** Field to use for quiet mode (--quiet outputs just this) */
+    idField: keyof T | ((item: T) => string);
+    /** Column definitions for table output */
+    columns: ColumnDef<T>[];
+    /** Optional: custom renderer for human/table output */
+    renderHuman?: (result: AnyCommandResult<T>, options: OutputOptions) => string;
+    /** Optional: transform data before JSON/YAML output */
+    serialize?: (data: T) => unknown;
+}
+/** Result type for commands returning a single item */
+export interface SingleResult<T> {
+    type: "single";
+    /** The structured data to render */
+    data: T;
+    /** Schema describing how to render this data (for item type T) */
+    schema: OutputSchema<T>;
+}
+/** Result type for commands returning a list */
+export interface ListResult<T> {
+    type: "list";
+    /** The structured data to render */
+    data: T[];
+    /** Schema describing how to render this data (for item type T) */
+    schema: OutputSchema<T>;
+}
+/** Union type for all command results */
+export type AnyCommandResult<T> = SingleResult<T> | ListResult<T>;
+/** Base interface for command results (deprecated, use SingleResult or ListResult) */
+export type CommandResult<T> = SingleResult<T> | ListResult<T>;
+/** Structured error for command failures */
+export interface CommandError {
+    /** Machine-readable error code */
+    code: string;
+    /** Human-readable message */
+    message: string;
+    /** Additional context */
+    details?: unknown;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/output/types.js

@@ -0,0 +1,8 @@
+/**
+ * Output format types for the Paseo CLI.
+ *
+ * This module defines the structured data types used by the output abstraction layer.
+ * Commands return CommandResult<T> which contains both data and rendering metadata.
+ */
+export {};
+//# sourceMappingURL=types.js.map