@orkestrel/tool 0.0.1 → 0.0.2

package/dist/src/core/index.js

@@ -1,4 +1,5 @@
 import { arrayShape, booleanShape, createContract, integerShape, literalShape, objectShape, optionalShape, schemaToParameters, stringShape, unionShape } from "@orkestrel/contract";
+import { isTerminalError } from "@orkestrel/terminal";
 import { WorkspaceError, createTool, createWorkspaceManager, isText, rangeOf } from "@orkestrel/agent";
 import { WorkflowError, createWorkflowContract } from "@orkestrel/workflow";
 //#region src/core/constants.ts
@@ -236,13 +237,74 @@ var DESCRIBE_TOOL_SUMMARY = "Return the full description of a named registered t
 * schema or multi-step protocol to teach.
 */
 var DESCRIBE_TOOL_DESCRIPTION = "Return the full description of a registered tool by its name. Required: name - the registered tool name (see another tool listing for available names).";
+/**
+* The name {@link import('./factories.js').createPromptTool} advertises by default — the key a
+* model calls and the `ToolManagerInterface` (`@orkestrel/agent`) registers under.
+*/
+var PROMPT_TOOL_NAME = "ask";
+/**
+* The lean {@link import('@orkestrel/agent').ToolInterface.summary} {@link import('./factories.js').createPromptTool}
+* advertises in place of {@link PROMPT_TOOL_DESCRIPTION} — a `ToolManagerInterface.definitions()`
+* (`@orkestrel/agent`) advertises `summary ?? description`, so this one-sentence text stands in
+* for the full teaching description; the full text stays retrievable via
+* {@link import('./factories.js').createDescribeTool}.
+*/
+var PROMPT_TOOL_SUMMARY = "Ask another terminal a question and BLOCK until it answers; the call resolves with the answered value. Call describe('ask') for the required fields.";
+var PROMPT_TOOL_DESCRIPTION = [
+	"Ask another terminal a question and block until it answers. This call does not return until the addressed terminal answers, or the prompt fails.",
+	"",
+	"Required:",
+	"  to      - the terminal name to ask.",
+	"  form    - the prompt kind: one of \"input\", \"password\", \"confirm\", \"select\", \"checkbox\", \"editor\".",
+	"  message - the question shown to the answering terminal.",
+	"Optional:",
+	"  options - form-specific options (e.g. choices for \"select\"/\"checkbox\").",
+	"A cycle (two terminals asking each other) or an expired prompt fails the call with a typed error.",
+	"Example:",
+	JSON.stringify({
+		to: "reviewer",
+		form: "confirm",
+		message: "Approve the release?"
+	})
+].join("\n");
+/**
+* The name {@link import('./factories.js').createAnswerTool} advertises by default — the key a
+* model calls and the `ToolManagerInterface` (`@orkestrel/agent`) registers under.
+*/
+var ANSWER_TOOL_NAME = "answer";
+/**
+* The lean {@link import('@orkestrel/agent').ToolInterface.summary} {@link import('./factories.js').createAnswerTool}
+* advertises in place of {@link ANSWER_TOOL_DESCRIPTION} — a `ToolManagerInterface.definitions()`
+* (`@orkestrel/agent`) advertises `summary ?? description`, so this one-sentence text stands in
+* for the full teaching description; the full text stays retrievable via
+* {@link import('./factories.js').createDescribeTool}.
+*/
+var ANSWER_TOOL_SUMMARY = "List prompts addressed to this terminal, or answer one by id. Call describe('answer') for the required fields.";
+var ANSWER_TOOL_DESCRIPTION = [
+	"List the prompts currently addressed to this terminal, or answer one of them by id. Every call is ONE operation, chosen by the \"operation\" field.",
+	"",
+	"Operations:",
+	"- pending { \"operation\": \"pending\" } — list every prompt currently addressed to this terminal (id, form, message, options, time).",
+	"- answer  { \"operation\": \"answer\", \"id\": \"<prompt id>\", \"value\": <answer value> } — answer the prompt with that id; \"value\" must match the prompt's form (a string for \"input\"/\"password\"/\"editor\", a boolean for \"confirm\", a choice for \"select\", an array of choices for \"checkbox\").",
+	"Example — list pending prompts:",
+	JSON.stringify({ operation: "pending" }),
+	"Example — answer one:",
+	JSON.stringify({
+		operation: "answer",
+		id: "abc123",
+		value: true
+	})
+].join("\n");
 //#endregion
 //#region src/core/errors.ts
 /**
 * Thrown by {@link import('./factories.js').createAgentTool}'s and
 * {@link import('./factories.js').createDescribeTool}'s handlers on every failure path — a
-* malformed / unresolvable call or an unknown tool name (`TOOL`), or a delegation that would
-* exceed the configured depth bound or re-enter an ancestor (`DEPTH`).
+* malformed / unresolvable call or an unknown tool name (`TOOL`), a delegation that would
+* exceed the configured depth bound or re-enter an ancestor (`DEPTH`), a prompt cycle
+* (`DEADLOCK`), a prompt that expired before it was answered (`EXPIRE`), or an answer that
+* failed to apply (`ANSWER`) — the last three thrown by
+* {@link import('./factories.js').createPromptTool} / {@link import('./factories.js').createAnswerTool}.
 *
 * @remarks
 * Carries a machine-readable `code` (see {@link import('./types.js').AgentToolErrorCode}) and
@@ -294,6 +356,106 @@ function isAgentToolError(value) {
 //#endregion
 //#region src/core/shapers.ts
 /**
+* The shape of {@link import('./factories.js').createPromptTool}'s call arguments — `to` (the
+* terminal identity to address), `form` (which of the six {@link import('@orkestrel/terminal').PromptType}
+* forms to ask), `message`, an optional `timeout` override, and every per-form optional field
+* FLATTENED onto one object (mirrors `workspaceToolShape`'s flat-arm style, but a single shared
+* shape rather than a discriminated union — `form` alone does not vary the REQUIRED fields, only
+* which of the optional ones apply, so a flat shape stays faithful without duplicating `to` /
+* `message` / `timeout` across six near-identical arms).
+*
+* @remarks
+* `choices` backs `'select'` / `'checkbox'`; `default` backs `'input'` / `'confirm'` / `'select'`
+* (a string for the first two forms' text default, `'true'`/`'false'` string for confirm — the
+* contract layer cannot vary a field's type by a sibling field's value, so `default` stays a
+* string and the handler coerces per form); `mask` backs `'password'`; `min` / `max` backs
+* `'checkbox'`; `validate` (declarative only) backs the four text-shaped forms
+* (`'input'` / `'password'` / `'confirm'` / `'editor'`).
+*/
+var promptToolShape = objectShape({
+	to: stringShape({
+		min: 1,
+		description: "The terminal identity to address the prompt to."
+	}),
+	form: literalShape([
+		"input",
+		"password",
+		"confirm",
+		"select",
+		"checkbox",
+		"editor"
+	], { description: "Which prompt form to ask." }),
+	message: stringShape({
+		min: 1,
+		description: "The prompt's question."
+	}),
+	default: optionalShape(stringShape({ description: "The default answer if the responder submits blank — 'input' / 'editor' text, 'confirm' 'true'/'false', or a 'select' choice value." })),
+	choices: optionalShape(arrayShape(objectShape({
+		name: stringShape({
+			min: 1,
+			description: "The choice label shown to the answering party."
+		}),
+		value: stringShape({
+			min: 1,
+			description: "The value submitted when this choice is picked."
+		}),
+		description: optionalShape(stringShape({ description: "An optional one-line elaboration." }))
+	}), { description: "The selectable choices for 'select' / 'checkbox'." })),
+	mask: optionalShape(stringShape({
+		min: 1,
+		description: "The mask character 'password' renders in place of input."
+	})),
+	min: optionalShape(integerShape({
+		min: 0,
+		description: "The minimum number of 'checkbox' selections required."
+	})),
+	max: optionalShape(integerShape({
+		min: 0,
+		description: "The maximum number of 'checkbox' selections allowed."
+	})),
+	validate: optionalShape(objectShape({
+		required: optionalShape(booleanShape({ description: "Reject an empty (trimmed) input." })),
+		minimum: optionalShape(integerShape({
+			min: 0,
+			description: "Reject an input shorter than this many characters."
+		})),
+		maximum: optionalShape(integerShape({
+			min: 0,
+			description: "Reject an input longer than this many characters."
+		})),
+		pattern: optionalShape(stringShape({ description: "Reject an input that fails this regular-expression source." })),
+		email: optionalShape(booleanShape({ description: "Require a valid email-address shape." })),
+		url: optionalShape(booleanShape({ description: "Require a valid URL shape." })),
+		numeric: optionalShape(booleanShape({ description: "Require a numeric value." })),
+		integer: optionalShape(booleanShape({ description: "Require an integer value." })),
+		alphanumeric: optionalShape(booleanShape({ description: "Require letters and digits only." }))
+	})),
+	timeout: optionalShape(integerShape({
+		min: 0,
+		description: "Milliseconds to wait before the prompt expires."
+	}))
+});
+/**
+* The shape of {@link import('./factories.js').createAnswerTool}'s call arguments — discriminated
+* by `operation`: `'pending'` lists the prompts addressed to this tool's terminal, `'answer'`
+* resolves one by `id` with a `value`.
+*
+* @remarks
+* `value`'s type varies by the ORIGINAL prompt's form (`string` for `'input'` / `'password'` /
+* `'select'` / `'editor'`, `boolean` for `'confirm'`, `readonly string[]` for `'checkbox'`) —
+* `unionShape(stringShape(), booleanShape(), arrayShape(stringShape()))` expresses that
+* union directly, so `value` is typed as the full `string | boolean | readonly string[]` union
+* here (no lossy string-only fallback needed).
+*/
+var answerToolShape = unionShape(objectShape({ operation: literalShape(["pending"], { description: "List the prompts currently addressed to this terminal." }) }), objectShape({
+	operation: literalShape(["answer"], { description: "Answer one pending prompt by id." }),
+	id: stringShape({
+		min: 1,
+		description: "The id of the pending prompt to answer."
+	}),
+	value: unionShape(stringShape({ description: "A text / select / editor answer." }), booleanShape({ description: "A confirm answer." }), arrayShape(stringShape(), { description: "A checkbox answer — the checked values." }))
+}));
+/**
 * The shape of {@link import('./types.js').AgentToolArguments} —
 * {@link import('./factories.js').createAgentTool}'s advertised `parameters`.
 *
@@ -655,6 +817,69 @@ function expandSteps(flat) {
 		phases: flat.steps.map((step) => ({ tasks: [{ run: step.name }] }))
 	});
 }
+/**
+* Normalize an LLM-supplied answer `value` to the type {@link PromptType} `form` expects, so a
+* caller that only ever emits strings can still answer a typed prompt.
+*
+* @remarks
+* `'confirm'` coerces to a `boolean` — a `boolean` passes through, and the strings `'true'` /
+* `'false'` (case-insensitively) map to it; any other string is truthy-coerced via
+* `Boolean(value)`. `'checkbox'` coerces to `readonly string[]` — an array passes through
+* (stringifying each entry), a comma-separated string splits + trims into one, and any other
+* single (non-comma) string becomes a one-item array. Every other form (`'input'` / `'password'`
+* / `'select'` / `'editor'`) coerces to a plain `string` — a string passes through verbatim; a
+* non-string, non-object scalar (`number` / `boolean`) stringifies via `String(value)`; an
+* object or array (no lossless string form) falls back to `''` rather than serializing garbage.
+* Pure and total — never throws.
+*
+* @param form - The {@link PromptType} the answer is being coerced FOR
+* @param value - The raw, LLM-supplied answer value
+* @returns The coerced answer — `boolean` for `'confirm'`, `readonly string[]` for `'checkbox'`,
+*   `string` otherwise
+*/
+function coerceAnswer(form, value) {
+	if (form === "confirm") {
+		if (typeof value === "boolean") return value;
+		if (typeof value === "string") {
+			const lower = value.trim().toLowerCase();
+			if (lower === "true") return true;
+			if (lower === "false") return false;
+		}
+		return Boolean(value);
+	}
+	if (form === "checkbox") {
+		if (Array.isArray(value)) return value.map((entry) => String(entry));
+		if (typeof value === "string") {
+			if (value.includes(",")) return value.split(",").map((entry) => entry.trim());
+			return [value];
+		}
+		return [String(value)];
+	}
+	if (typeof value === "string") return value;
+	if (typeof value === "object" && value !== null) return "";
+	return String(value);
+}
+/**
+* Map a caught error to the {@link AgentToolErrorCode} the terminal-tool factory should throw
+* with — the pure classification step of that factory's error handling.
+*
+* @remarks
+* Narrows `error` with {@link isTerminalError} (`@orkestrel/terminal`) first: a non-`TerminalError`
+* value returns `undefined`, telling the caller this mapper does not apply (rethrow / handle
+* otherwise). For a genuine `TerminalError`, `'DEADLOCK'` maps to `'DEADLOCK'`, `'EXPIRE'` maps
+* to `'EXPIRE'`, and every other {@link import('@orkestrel/terminal').TerminalErrorCode}
+* (`'TARGET'`, `'CANCEL'`, `'DRIVER'`) maps to the generic `'TOOL'` code. The mapper only
+* classifies — the factory performs the actual throw.
+*
+* @param error - The value caught from a terminal-manager operation (`ask` / `answer` / …)
+* @returns The mapped {@link AgentToolErrorCode}, or `undefined` if `error` is not a `TerminalError`
+*/
+function terminalToolCode(error) {
+	if (!isTerminalError(error)) return void 0;
+	if (error.code === "DEADLOCK") return "DEADLOCK";
+	if (error.code === "EXPIRE") return "EXPIRE";
+	return "TOOL";
+}
 //#endregion
 //#region src/core/factories.ts
 /**
@@ -1193,7 +1418,175 @@ function createDescribeTool(tools) {
 		}
 	});
 }
+/**
+* Build an LLM-callable prompt tool — the ASK side of the terminal seam. Asks
+* {@link import('./types.js').PromptToolOptions.to} a question and BLOCKS until it answers,
+* returning the resolved answer value.
+*
+* @remarks
+* The universal tool-handler contract (AGENTS §14): validates the call args against
+* {@link import('./shapers.js').promptToolShape}, dispatches to the matching
+* `TerminalManagerInterface.ask` overload (`@orkestrel/terminal`) for the call's `form`, and
+* RETURNS the resolved answer on success. `from` is FIXED at construction
+* ({@link import('./types.js').PromptToolOptions.from}) — never read from the model-supplied
+* args — so a model cannot spoof which terminal is asking. A prompt CYCLE rejects with
+* `TerminalError('DEADLOCK')`, re-surfaced as a typed `DEADLOCK`
+* {@link import('./errors.js').AgentToolError}; an expired prompt re-surfaces as `EXPIRE`; an
+* unknown `to` (or any other `TerminalError`) re-surfaces as `TOOL`, naming the unknown terminal
+* plus the known ones (`manager.terminals()`).
+*
+* @param options - The live manager, the fixed `from` identity, and advertised overrides (see
+*   {@link import('./types.js').PromptToolOptions})
+* @returns A `ToolInterface` (named {@link import('./constants.js').PROMPT_TOOL_NAME} by default)
+*
+* @example
+* ```ts
+* import { createPromptTool } from '@src/core'
+* import { createTerminalManager, createToolManager } from '@orkestrel/terminal'
+*
+* const manager = createTerminalManager()
+* manager.add('agent')
+* manager.add('reviewer')
+* const tool = createPromptTool({ manager, from: 'agent' })
+* const tools = createToolManager()
+* tools.add(tool) // the agent can now ask 'reviewer' and block for the answer
+* ```
+*/
+function createPromptTool(options) {
+	const contract = createContract(promptToolShape);
+	const parameters = schemaToParameters(contract.schema);
+	return createTool({
+		name: options.name ?? "ask",
+		description: options.description ?? PROMPT_TOOL_DESCRIPTION,
+		summary: PROMPT_TOOL_SUMMARY,
+		parameters,
+		execute: async (args) => {
+			const call = contract.parse(args);
+			if (call === void 0) throw new AgentToolError("TOOL", "malformed ask call", { args });
+			if ((call.form === "select" || call.form === "checkbox") && (call.choices ?? []).length === 0) throw new AgentToolError("TOOL", "select/checkbox requires at least one choice", {
+				to: call.to,
+				form: call.form
+			});
+			try {
+				switch (call.form) {
+					case "input": return await options.manager.ask(options.from, call.to, call.form, {
+						message: call.message,
+						...call.default === void 0 ? {} : { default: call.default },
+						...call.validate === void 0 ? {} : { validate: call.validate }
+					});
+					case "editor": return await options.manager.ask(options.from, call.to, call.form, {
+						message: call.message,
+						...call.default === void 0 ? {} : { default: call.default },
+						...call.validate === void 0 ? {} : { validate: call.validate }
+					});
+					case "password": return await options.manager.ask(options.from, call.to, call.form, {
+						message: call.message,
+						...call.mask === void 0 ? {} : { mask: call.mask },
+						...call.validate === void 0 ? {} : { validate: call.validate }
+					});
+					case "confirm": return await options.manager.ask(options.from, call.to, call.form, {
+						message: call.message,
+						...call.default === void 0 ? {} : { default: call.default === "true" }
+					});
+					case "select": return await options.manager.ask(options.from, call.to, call.form, {
+						message: call.message,
+						choices: call.choices ?? [],
+						...call.default === void 0 ? {} : { default: call.default }
+					});
+					case "checkbox": return await options.manager.ask(options.from, call.to, call.form, {
+						message: call.message,
+						choices: call.choices ?? [],
+						...call.min === void 0 ? {} : { min: call.min },
+						...call.max === void 0 ? {} : { max: call.max }
+					});
+				}
+			} catch (error) {
+				const code = terminalToolCode(error);
+				if (code === void 0) throw error;
+				if (code === "DEADLOCK") throw new AgentToolError("DEADLOCK", `asking '${call.to}' would form a prompt cycle`, isTerminalError(error) ? error.context : {
+					from: options.from,
+					to: call.to
+				});
+				if (code === "EXPIRE") throw new AgentToolError("EXPIRE", `prompt to '${call.to}' expired before it was answered`, { to: call.to });
+				if (isTerminalError(error) && error.code === "TARGET") throw new AgentToolError("TOOL", `unknown terminal '${call.to}'`, {
+					to: call.to,
+					known: options.manager.terminals()
+				});
+				throw new AgentToolError("TOOL", `asking '${call.to}' failed`, { to: call.to });
+			}
+		}
+	});
+}
+/**
+* Build an LLM-callable answer tool — the ANSWER side of the terminal seam. Lists the prompts
+* currently addressed to {@link import('./types.js').AnswerToolOptions.to}, or answers one of
+* them by id.
+*
+* @remarks
+* The universal tool-handler contract (AGENTS §14): validates the call args against
+* {@link import('./shapers.js').answerToolShape} (discriminated by `operation`). `'pending'`
+* returns a compact list (`{ id, from, form, message }`) of every prompt currently addressed to
+* `to` (`TerminalManagerInterface.pending`, `@orkestrel/terminal`). `'answer'` looks the prompt
+* up by `id` (an unknown id throws a typed `ANSWER` {@link import('./errors.js').AgentToolError}),
+* normalizes the model-supplied `value` to the prompt's own form
+* ({@link import('./helpers.js').coerceAnswer}), and applies it via
+* `TerminalManagerInterface.answer` — a rejected / unknown / unresolvable outcome
+* (`TerminalAnswerResult.error`) re-surfaces as a typed `ANSWER` `AgentToolError`; success returns
+* `{ answered: id }`. `to` is FIXED at construction
+* ({@link import('./types.js').AnswerToolOptions.to}) — never read from the model-supplied args —
+* so a model cannot spoof which terminal it is answering for. Concurrent answerers racing on one
+* endpoint are FIRST-WRITE-WINS — a late answer to an already-settled prompt returns a typed
+* `ANSWER` `AgentToolError` (surfaced as a 422 over HTTP).
+*
+* @param options - The live manager, the fixed `to` identity, and advertised overrides (see
+*   {@link import('./types.js').AnswerToolOptions})
+* @returns A `ToolInterface` (named {@link import('./constants.js').ANSWER_TOOL_NAME} by default)
+*
+* @example
+* ```ts
+* import { createAnswerTool } from '@src/core'
+* import { createTerminalManager, createToolManager } from '@orkestrel/terminal'
+*
+* const manager = createTerminalManager()
+* manager.add('reviewer')
+* const tool = createAnswerTool({ manager, to: 'reviewer' })
+* const tools = createToolManager()
+* tools.add(tool) // the reviewer terminal can now list/answer prompts addressed to it
+* ```
+*/
+function createAnswerTool(options) {
+	const contract = createContract(answerToolShape);
+	const parameters = schemaToParameters(contract.schema);
+	return createTool({
+		name: options.name ?? "answer",
+		description: options.description ?? ANSWER_TOOL_DESCRIPTION,
+		summary: ANSWER_TOOL_SUMMARY,
+		parameters,
+		execute: async (args) => {
+			const call = contract.parse(args);
+			if (call === void 0) throw new AgentToolError("TOOL", "malformed answer call", { args });
+			if (call.operation === "pending") return options.manager.pending(options.to).map((prompt) => ({
+				id: prompt.id,
+				from: prompt.from,
+				form: prompt.form,
+				message: prompt.message
+			}));
+			const prompt = options.manager.pending(options.to).find((entry) => entry.id === call.id);
+			if (prompt === void 0) throw new AgentToolError("ANSWER", `unknown prompt '${call.id}'`, {
+				id: call.id,
+				reason: "unknown"
+			});
+			const coerced = coerceAnswer(prompt.form, call.value);
+			const result = options.manager.answer(options.to, call.id, coerced);
+			if (!result.success) throw new AgentToolError("ANSWER", `failed to answer prompt '${call.id}': ${result.error}`, {
+				id: call.id,
+				reason: result.error
+			});
+			return { answered: call.id };
+		}
+	});
+}
 //#endregion
-export { AGENT_TOOL_DEPTH, AGENT_TOOL_DESCRIPTION, AGENT_TOOL_NAME, AGENT_TOOL_SUMMARY, AgentToolError, DESCRIBE_TOOL_DESCRIPTION, DESCRIBE_TOOL_NAME, DESCRIBE_TOOL_SUMMARY, MAX_WORKFLOW_DEPTH, WORKFLOW_TOOL_DESCRIPTION, WORKFLOW_TOOL_FLAT_EXAMPLE, WORKFLOW_TOOL_NAME, WORKFLOW_TOOL_NESTED_EXAMPLE, WORKFLOW_TOOL_SUMMARY, WORKSPACE_TOOL_DESCRIPTION, WORKSPACE_TOOL_EXAMPLE, WORKSPACE_TOOL_NAME, WORKSPACE_TOOL_SUMMARY, agentTag, agentToolShape, completeDraft, completePhaseDraft, completeTaskDraft, createAgentFunction, createAgentTool, createDescribeTool, createToolFunction, createWorkflowDraftContract, createWorkflowTool, createWorkspaceTool, describeToolShape, expandSteps, isAgentToolError, phaseDraftShape, stepShape, taskDraftShape, workflowDraftShape, workflowStepsShape, workflowTag, workflowToolSummary, workspaceToolShape };
+export { AGENT_TOOL_DEPTH, AGENT_TOOL_DESCRIPTION, AGENT_TOOL_NAME, AGENT_TOOL_SUMMARY, ANSWER_TOOL_DESCRIPTION, ANSWER_TOOL_NAME, ANSWER_TOOL_SUMMARY, AgentToolError, DESCRIBE_TOOL_DESCRIPTION, DESCRIBE_TOOL_NAME, DESCRIBE_TOOL_SUMMARY, MAX_WORKFLOW_DEPTH, PROMPT_TOOL_DESCRIPTION, PROMPT_TOOL_NAME, PROMPT_TOOL_SUMMARY, WORKFLOW_TOOL_DESCRIPTION, WORKFLOW_TOOL_FLAT_EXAMPLE, WORKFLOW_TOOL_NAME, WORKFLOW_TOOL_NESTED_EXAMPLE, WORKFLOW_TOOL_SUMMARY, WORKSPACE_TOOL_DESCRIPTION, WORKSPACE_TOOL_EXAMPLE, WORKSPACE_TOOL_NAME, WORKSPACE_TOOL_SUMMARY, agentTag, agentToolShape, answerToolShape, coerceAnswer, completeDraft, completePhaseDraft, completeTaskDraft, createAgentFunction, createAgentTool, createAnswerTool, createDescribeTool, createPromptTool, createToolFunction, createWorkflowDraftContract, createWorkflowTool, createWorkspaceTool, describeToolShape, expandSteps, isAgentToolError, phaseDraftShape, promptToolShape, stepShape, taskDraftShape, terminalToolCode, workflowDraftShape, workflowStepsShape, workflowTag, workflowToolSummary, workspaceToolShape };
 
 //# sourceMappingURL=index.js.map