semola 0.5.2 → 0.5.4

package/dist/lib/policy/index.d.mts

@@ -1,6 +1,63 @@
-import { ConditionHelper, and, endsWith, eq, gt, gte, has, hasAny, hasLength, includes, isDefined, isEmpty, isNullish, lt, lte, matches, neq, not, or, startsWith } from "../../policy/helpers.mjs";
-import { Action, AllowParams, ForbidParams } from "../../policy/types.mjs";
-
+//#region src/lib/policy/helpers.d.ts
+declare const _brand: unique symbol;
+type ConditionHelper<V> = {
+  readonly [_brand]: (actual: V) => boolean;
+  operator: string;
+  value: unknown;
+  fn: (actual: V) => boolean;
+};
+declare const eq: <V>(value: V) => ConditionHelper<V>;
+declare const neq: <V>(value: V) => ConditionHelper<V>;
+declare const gt: {
+  (value: Date): ConditionHelper<Date>;
+  (value: number): ConditionHelper<number>;
+  (value: string): ConditionHelper<string>;
+};
+declare const gte: {
+  (value: Date): ConditionHelper<Date>;
+  (value: number): ConditionHelper<number>;
+  (value: string): ConditionHelper<string>;
+};
+declare const lt: {
+  (value: Date): ConditionHelper<Date>;
+  (value: number): ConditionHelper<number>;
+  (value: string): ConditionHelper<string>;
+};
+declare const lte: {
+  (value: Date): ConditionHelper<Date>;
+  (value: number): ConditionHelper<number>;
+  (value: string): ConditionHelper<string>;
+};
+declare const not: <V>(inner: ConditionHelper<V>) => ConditionHelper<V>;
+declare const and: <V>(...helpers: ConditionHelper<V>[]) => ConditionHelper<V>;
+declare const or: <V>(...helpers: ConditionHelper<V>[]) => ConditionHelper<V>;
+declare const startsWith: (prefix: string) => ConditionHelper<string>;
+declare const endsWith: (suffix: string) => ConditionHelper<string>;
+declare const includes: (substring: string) => ConditionHelper<string>;
+declare const matches: (pattern: RegExp) => ConditionHelper<string>;
+declare const has: <V>(items: V | V[]) => ConditionHelper<V[]>;
+declare const hasAny: <V>(items: V | V[]) => ConditionHelper<V[]>;
+type HasLengthArg = number | {
+  min?: number;
+  max?: number;
+};
+declare const hasLength: (length: HasLengthArg) => ConditionHelper<string | unknown[]>;
+declare const isEmpty: () => ConditionHelper<string | unknown[]>;
+declare const isDefined: () => ConditionHelper<unknown>;
+declare const isNullish: () => ConditionHelper<unknown>;
+//#endregion
+//#region src/lib/policy/types.d.ts
+type Action = "read" | "create" | "update" | "delete" | (string & {});
+type ConditionValue<V> = V extends Record<string, unknown> ? ConditionHelper<V> | Conditions<V> : ConditionHelper<V>;
+type Conditions<T = Record<string, unknown>> = { [K in keyof T]?: ConditionValue<T[K]> };
+type PolicyRuleParams<T = Record<string, unknown>> = {
+  action: Action | Action[];
+  conditions?: Conditions<T>;
+  reason?: string;
+};
+type AllowParams<T = Record<string, unknown>> = PolicyRuleParams<T>;
+type ForbidParams<T = Record<string, unknown>> = PolicyRuleParams<T>;
+//#endregion
 //#region src/lib/policy/index.d.ts
 declare class Policy<TEntity extends Record<string, unknown> = Record<string, unknown>> {
   private rules;
@@ -17,5 +74,4 @@ declare class Policy<TEntity extends Record<string, unknown> = Record<string, un
   private matchValue;
 }
 //#endregion
-export { type ConditionHelper, Policy, and, endsWith, eq, gt, gte, has, hasAny, hasLength, includes, isDefined, isEmpty, isNullish, lt, lte, matches, neq, not, or, startsWith };
-//# sourceMappingURL=index.d.mts.map
+export { type ConditionHelper, Policy, and, endsWith, eq, gt, gte, has, hasAny, hasLength, includes, isDefined, isEmpty, isNullish, lt, lte, matches, neq, not, or, startsWith };

package/dist/lib/policy/index.mjs

@@ -1,4 +1,190 @@
-import { and, endsWith, eq, gt, gte, has, hasAny, hasLength, includes, isDefined, isEmpty, isNullish, lt, lte, matches, neq, not, or, startsWith } from "../../policy/helpers.mjs";
+//#region src/lib/policy/helpers.ts
+const _brand = Symbol("conditionHelper");
+const eq = (value) => {
+	const fn = (actual) => actual === value;
+	return {
+		[_brand]: fn,
+		operator: "eq",
+		value,
+		fn
+	};
+};
+const neq = (value) => {
+	const fn = (actual) => actual !== value;
+	return {
+		[_brand]: fn,
+		operator: "neq",
+		value,
+		fn
+	};
+};
+const gt = (value) => {
+	const fn = (actual) => actual > value;
+	return {
+		[_brand]: fn,
+		operator: "gt",
+		value,
+		fn
+	};
+};
+const gte = (value) => {
+	const fn = (actual) => actual >= value;
+	return {
+		[_brand]: fn,
+		operator: "gte",
+		value,
+		fn
+	};
+};
+const lt = (value) => {
+	const fn = (actual) => actual < value;
+	return {
+		[_brand]: fn,
+		operator: "lt",
+		value,
+		fn
+	};
+};
+const lte = (value) => {
+	const fn = (actual) => actual <= value;
+	return {
+		[_brand]: fn,
+		operator: "lte",
+		value,
+		fn
+	};
+};
+const not = (inner) => {
+	const fn = (actual) => !inner.fn(actual);
+	return {
+		[_brand]: fn,
+		operator: "not",
+		value: inner,
+		fn
+	};
+};
+const and = (...helpers) => {
+	const fn = (actual) => helpers.every((h) => h.fn(actual));
+	return {
+		[_brand]: fn,
+		operator: "and",
+		value: helpers,
+		fn
+	};
+};
+const or = (...helpers) => {
+	const fn = (actual) => helpers.some((h) => h.fn(actual));
+	return {
+		[_brand]: fn,
+		operator: "or",
+		value: helpers,
+		fn
+	};
+};
+const startsWith = (prefix) => {
+	const fn = (actual) => actual.startsWith(prefix);
+	return {
+		[_brand]: fn,
+		operator: "startsWith",
+		value: prefix,
+		fn
+	};
+};
+const endsWith = (suffix) => {
+	const fn = (actual) => actual.endsWith(suffix);
+	return {
+		[_brand]: fn,
+		operator: "endsWith",
+		value: suffix,
+		fn
+	};
+};
+const includes = (substring) => {
+	const fn = (actual) => actual.includes(substring);
+	return {
+		[_brand]: fn,
+		operator: "includes",
+		value: substring,
+		fn
+	};
+};
+const matches = (pattern) => {
+	const fn = (actual) => {
+		pattern.lastIndex = 0;
+		return pattern.test(actual);
+	};
+	return {
+		[_brand]: fn,
+		operator: "matches",
+		value: pattern,
+		fn
+	};
+};
+const has = (items) => {
+	const fn = (actual) => {
+		if (Array.isArray(items)) return items.every((item) => actual.includes(item));
+		return actual.includes(items);
+	};
+	return {
+		[_brand]: fn,
+		operator: "has",
+		value: items,
+		fn
+	};
+};
+const hasAny = (items) => {
+	const normalized = Array.isArray(items) ? items : [items];
+	const fn = (actual) => normalized.some((item) => actual.includes(item));
+	return {
+		[_brand]: fn,
+		operator: "hasAny",
+		value: items,
+		fn
+	};
+};
+const hasLength = (length) => {
+	const fn = (actual) => {
+		const len = actual.length;
+		if (typeof length === "number") return len === length;
+		if (length.min !== void 0 && len < length.min) return false;
+		if (length.max !== void 0 && len > length.max) return false;
+		return true;
+	};
+	return {
+		[_brand]: fn,
+		operator: "hasLength",
+		value: length,
+		fn
+	};
+};
+const isEmpty = () => {
+	const fn = (actual) => actual.length === 0;
+	return {
+		[_brand]: fn,
+		operator: "isEmpty",
+		value: void 0,
+		fn
+	};
+};
+const isDefined = () => {
+	const fn = (actual) => actual !== null && actual !== void 0;
+	return {
+		[_brand]: fn,
+		operator: "isDefined",
+		value: void 0,
+		fn
+	};
+};
+const isNullish = () => {
+	const fn = (actual) => actual === null || actual === void 0;
+	return {
+		[_brand]: fn,
+		operator: "isNullish",
+		value: void 0,
+		fn
+	};
+};
+//#endregion
 //#region src/lib/policy/index.ts
 var Policy = class {
 	rules = [];
@@ -77,5 +263,3 @@ var Policy = class {
 };
 //#endregion
 export { Policy, and, endsWith, eq, gt, gte, has, hasAny, hasLength, includes, isDefined, isEmpty, isNullish, lt, lte, matches, neq, not, or, startsWith };
-
-//# sourceMappingURL=index.mjs.map

package/dist/lib/prompts/index.cjs

@@ -1,7 +1,367 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_runtime = require("../../prompts/core/runtime.cjs");
-const require_session = require("../../prompts/core/session.cjs");
+const require_lib_errors_index = require("../errors/index.cjs");
 let node_util = require("node:util");
+//#region src/lib/prompts/core/keys.ts
+const ESC = "\x1B";
+const CSI = "\x1B[";
+const ESC_BACKSPACE = `${ESC}\u007F`;
+const CHAR_KEY_MAP = new Map(Object.values({
+	enterCr: {
+		value: "\r",
+		name: "enter"
+	},
+	enterLf: {
+		value: "\n",
+		name: "enter"
+	},
+	ctrlA: {
+		value: "
",
+		name: "ctrl_a"
+	},
+	ctrlC: {
+		value: "",
+		name: "ctrl_c"
+	},
+	ctrlBackspace: {
+		value: "",
+		name: "ctrl_backspace"
+	},
+	backspace: {
+		value: "",
+		name: "backspace"
+	},
+	tab: {
+		value: "	",
+		name: "tab"
+	},
+	space: {
+		value: " ",
+		name: "space"
+	}
+}).map((entry) => [entry.value, { name: entry.name }]));
+const KNOWN_SEQUENCES = [
+	{
+		sequence: "\x1B[1;2D",
+		key: { name: "shift_left" }
+	},
+	{
+		sequence: "\x1B[1;2C",
+		key: { name: "shift_right" }
+	},
+	{
+		sequence: "\x1B[1;5D",
+		key: { name: "ctrl_left" }
+	},
+	{
+		sequence: "\x1B[1;5C",
+		key: { name: "ctrl_right" }
+	},
+	{
+		sequence: "\x1B[1;6D",
+		key: { name: "shift_ctrl_left" }
+	},
+	{
+		sequence: "\x1B[1;6C",
+		key: { name: "shift_ctrl_right" }
+	},
+	{
+		sequence: "\x1B[3~",
+		key: { name: "delete" }
+	},
+	{
+		sequence: "\x1B[H",
+		key: { name: "home" }
+	},
+	{
+		sequence: "\x1B[F",
+		key: { name: "end" }
+	},
+	{
+		sequence: "\x1B[A",
+		key: { name: "up" }
+	},
+	{
+		sequence: "\x1B[B",
+		key: { name: "down" }
+	},
+	{
+		sequence: "\x1B[C",
+		key: { name: "right" }
+	},
+	{
+		sequence: "\x1B[D",
+		key: { name: "left" }
+	}
+];
+const isControlChar = (char) => {
+	return char <= "" || char === "";
+};
+const isCsiFinalByte = (char) => {
+	if (!char) return false;
+	if (char >= "A" && char <= "Z") return true;
+	if (char >= "a" && char <= "z") return true;
+	if (char === "~") return true;
+	return false;
+};
+const readCsiLength = (remaining) => {
+	if (!remaining.startsWith(CSI)) return null;
+	let index = 2;
+	while (index < remaining.length) {
+		if (isCsiFinalByte(remaining[index] ?? "")) return {
+			length: index + 1,
+			incomplete: false
+		};
+		index += 1;
+	}
+	return {
+		length: 0,
+		incomplete: true
+	};
+};
+const parseKeys = (chunk) => {
+	const keys = [];
+	let cursor = 0;
+	while (cursor < chunk.length) {
+		const remaining = chunk.slice(cursor);
+		if (remaining.startsWith(ESC_BACKSPACE)) {
+			keys.push({ name: "ctrl_backspace" });
+			cursor += 2;
+			continue;
+		}
+		const knownSequence = KNOWN_SEQUENCES.find((entry) => remaining.startsWith(entry.sequence));
+		if (knownSequence) {
+			keys.push(knownSequence.key);
+			cursor += knownSequence.sequence.length;
+			continue;
+		}
+		const csiLength = readCsiLength(remaining);
+		if (csiLength) {
+			if (csiLength.incomplete) return {
+				keys,
+				remaining: chunk.slice(cursor)
+			};
+			cursor += csiLength.length;
+			continue;
+		}
+		const char = chunk[cursor] ?? "";
+		switch (char) {
+			case ESC:
+				if (cursor === chunk.length - 1) keys.push({ name: "escape" });
+				break;
+			default: {
+				const key = CHAR_KEY_MAP.get(char);
+				if (key) keys.push(key);
+				else if (!isControlChar(char)) keys.push({
+					name: "character",
+					value: char
+				});
+			}
+		}
+		cursor += 1;
+	}
+	return {
+		keys,
+		remaining: ""
+	};
+};
+//#endregion
+//#region src/lib/prompts/core/runtime.ts
+const HIDE_CURSOR = "\x1B[?25l";
+const SHOW_CURSOR = "\x1B[?25h";
+const countLines = (text) => {
+	let count = 1;
+	for (let i = 0; i < text.length; i++) if (text[i] === "\n") count += 1;
+	return count;
+};
+var NodePromptRuntime = class {
+	stdin;
+	stdout;
+	queue = [];
+	waiters = [];
+	initialized = false;
+	previousLines = 0;
+	buffer = "";
+	constructor(stdin = process.stdin, stdout = process.stdout) {
+		this.stdin = stdin;
+		this.stdout = stdout;
+	}
+	isInteractive() {
+		return Boolean(this.stdin.isTTY && this.stdout.isTTY && typeof this.stdin.setRawMode === "function");
+	}
+	init() {
+		if (!this.isInteractive()) return require_lib_errors_index.err("PromptEnvironmentError", "Interactive prompts require a TTY with raw mode support");
+		if (this.initialized) return require_lib_errors_index.ok(void 0);
+		const [initError] = require_lib_errors_index.mightThrowSync(() => {
+			this.stdin.setRawMode(true);
+			this.stdin.setEncoding("utf8");
+			this.stdin.resume();
+			this.stdin.on("data", this.onData);
+			this.stdout.write(HIDE_CURSOR);
+		});
+		if (initError) return require_lib_errors_index.err("PromptIOError", "Unable to initialize prompt runtime");
+		this.initialized = true;
+		return require_lib_errors_index.ok(void 0);
+	}
+	readKey() {
+		const queued = this.queue.shift();
+		if (queued) return Promise.resolve(require_lib_errors_index.ok(queued));
+		return new Promise((resolve) => {
+			this.waiters.push(resolve);
+		});
+	}
+	render(frame) {
+		const [renderError] = require_lib_errors_index.mightThrowSync(() => {
+			if (this.previousLines > 1) this.stdout.write(`\u001B[${this.previousLines - 1}A`);
+			this.stdout.write("\r\x1B[J");
+			this.stdout.write(frame);
+			this.previousLines = countLines(frame);
+		});
+		if (renderError) return require_lib_errors_index.err("PromptIOError", "Unable to render prompt frame");
+		return require_lib_errors_index.ok(void 0);
+	}
+	done(frame) {
+		const [doneError] = require_lib_errors_index.mightThrowSync(() => {
+			if (this.previousLines > 1) this.stdout.write(`\u001B[${this.previousLines - 1}A`);
+			this.stdout.write("\r\x1B[J");
+			this.stdout.write(`${frame}\n`);
+			this.previousLines = 0;
+		});
+		if (doneError) return require_lib_errors_index.err("PromptIOError", "Unable to finalize prompt frame");
+		return require_lib_errors_index.ok(void 0);
+	}
+	close() {
+		if (!this.initialized) return require_lib_errors_index.ok(void 0);
+		this.initialized = false;
+		const [closeError] = require_lib_errors_index.mightThrowSync(() => {
+			this.stdin.off("data", this.onData);
+			this.stdin.setRawMode(false);
+			this.stdin.pause?.();
+			this.stdout.write(SHOW_CURSOR);
+		});
+		if (closeError) return require_lib_errors_index.err("PromptIOError", "Unable to close prompt runtime");
+		return require_lib_errors_index.ok(void 0);
+	}
+	interrupt() {
+		this.close();
+		process.exit(0);
+	}
+	onData = (chunk) => {
+		const value = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+		const combined = `${this.buffer}${value}`;
+		this.buffer = "";
+		const [parseError, result] = require_lib_errors_index.mightThrowSync(() => parseKeys(combined));
+		if (parseError || !result) {
+			for (const waiter of this.waiters.splice(0)) waiter(require_lib_errors_index.err("PromptIOError", "Failed to parse input"));
+			return;
+		}
+		this.buffer = result.remaining;
+		for (const key of result.keys) {
+			const waiter = this.waiters.shift();
+			if (waiter) waiter(require_lib_errors_index.ok(key));
+			else this.queue.push(key);
+		}
+	};
+};
+const createNodePromptRuntime = () => {
+	return new NodePromptRuntime();
+};
+//#endregion
+//#region src/lib/prompts/core/session.ts
+const CANCEL_MESSAGE = "Interrupted, bye!";
+const resolveOutput = async (options, value) => {
+	if (!options.transform) return require_lib_errors_index.ok(value);
+	const [transformError, transformed] = await require_lib_errors_index.mightThrow(Promise.resolve().then(() => options.transform?.(value)));
+	if (transformError || transformed === null || transformed === void 0) return require_lib_errors_index.err("PromptIOError", "Prompt transform callback failed unexpectedly");
+	return require_lib_errors_index.ok(transformed);
+};
+const runValidation = async (options, value) => {
+	if (!options.validate) return require_lib_errors_index.ok(null);
+	const [validationError, validationMessage] = await require_lib_errors_index.mightThrow(Promise.resolve().then(() => options.validate?.(value)));
+	if (validationError) return require_lib_errors_index.err("PromptIOError", "Prompt validate callback failed unexpectedly");
+	if (typeof validationMessage === "string" && validationMessage.length > 0) return require_lib_errors_index.ok(validationMessage);
+	return require_lib_errors_index.ok(null);
+};
+const isCancelKey = (key) => {
+	if (key.name === "ctrl_c") return true;
+	if (key.name === "escape") return true;
+	return false;
+};
+const runPromptSession = async (params) => {
+	const [initError] = params.runtime.init();
+	if (initError) return require_lib_errors_index.err(initError.type, initError.message);
+	let state = params.initialState;
+	let errorMessage = null;
+	const closeAndDone = (message) => {
+		const [closeErr] = params.runtime.close();
+		if (closeErr) return require_lib_errors_index.err(closeErr.type, closeErr.message);
+		const [doneErr] = params.runtime.done(message);
+		if (doneErr) return require_lib_errors_index.err(doneErr.type, doneErr.message);
+		return null;
+	};
+	while (true) {
+		const [renderError] = params.runtime.render(params.render({
+			options: params.options,
+			state,
+			errorMessage
+		}));
+		if (renderError) {
+			params.runtime.close();
+			return require_lib_errors_index.err(renderError.type, renderError.message);
+		}
+		const [readError, key] = await params.runtime.readKey();
+		if (readError || !key) {
+			params.runtime.close();
+			return require_lib_errors_index.err(readError?.type ?? "PromptIOError", readError?.message ?? "Unable to read prompt input");
+		}
+		if (isCancelKey(key)) {
+			const [closeError] = params.runtime.close();
+			if (closeError) return require_lib_errors_index.err(closeError.type, closeError.message);
+			const [doneError] = params.runtime.done(`✖ ${CANCEL_MESSAGE}`);
+			if (doneError) return require_lib_errors_index.err(doneError.type, doneError.message);
+			if (params.runtime.interrupt) {
+				const [interruptError] = params.runtime.interrupt(CANCEL_MESSAGE);
+				if (interruptError) return require_lib_errors_index.err(interruptError.type, interruptError.message);
+			}
+			return require_lib_errors_index.err("PromptCancelledError", CANCEL_MESSAGE);
+		}
+		if (key.name !== "enter") {
+			state = params.onKey(state, key);
+			errorMessage = null;
+			continue;
+		}
+		const submitResult = params.onSubmit(state);
+		if ("errorMessage" in submitResult) {
+			errorMessage = submitResult.errorMessage;
+			continue;
+		}
+		const rawValue = submitResult.value;
+		const [validationRunError, validationErrorMessage] = await runValidation(params.options, rawValue);
+		if (validationRunError) {
+			const closeDoneErr = closeAndDone(`✖ ${params.options.message}`);
+			if (closeDoneErr) return closeDoneErr;
+			return require_lib_errors_index.err(validationRunError.type, validationRunError.message);
+		}
+		if (validationErrorMessage) {
+			errorMessage = validationErrorMessage;
+			continue;
+		}
+		const [transformError, finalValue] = await resolveOutput(params.options, rawValue);
+		if (transformError) {
+			const closeDoneErr = closeAndDone(`✖ ${params.options.message}`);
+			if (closeDoneErr) return closeDoneErr;
+			return require_lib_errors_index.err(transformError.type, transformError.message);
+		}
+		if (finalValue === null) return require_lib_errors_index.err("PromptIOError", "Unable to transform prompt value");
+		const closeDoneErr = closeAndDone(params.complete({
+			options: params.options,
+			state,
+			value: finalValue
+		}));
+		if (closeDoneErr) return closeDoneErr;
+		return require_lib_errors_index.ok(finalValue);
+	}
+};
+//#endregion
 //#region src/lib/prompts/index.ts
 const pointer = (active) => {
 	return active ? paint("cyan", "❯") : " ";
@@ -154,8 +514,8 @@ const textOnKey = (state, key) => {
 	}
 };
 const input = async (options, runtime) => {
-	return require_session.runPromptSession({
-		runtime: runtime ?? require_runtime.createNodePromptRuntime(),
+	return runPromptSession({
+		runtime: runtime ?? createNodePromptRuntime(),
 		options,
 		initialState: createTextState(options.defaultValue ?? ""),
 		render: ({ options: currentOptions, state, errorMessage }) => {
@@ -173,10 +533,10 @@ const input = async (options, runtime) => {
 	});
 };
 const password = async (options, runtime) => {
-	const promptRuntime = runtime ?? require_runtime.createNodePromptRuntime();
+	const promptRuntime = runtime ?? createNodePromptRuntime();
 	const initialValue = options.defaultValue ?? "";
 	const mask = options.mask;
-	return require_session.runPromptSession({
+	return runPromptSession({
 		runtime: promptRuntime,
 		options,
 		initialState: createTextState(initialValue),
@@ -197,8 +557,8 @@ const password = async (options, runtime) => {
 	});
 };
 const confirm = async (options, runtime) => {
-	return require_session.runPromptSession({
-		runtime: runtime ?? require_runtime.createNodePromptRuntime(),
+	return runPromptSession({
+		runtime: runtime ?? createNodePromptRuntime(),
 		options,
 		initialState: { value: options.defaultValue ?? false },
 		render: ({ options: currentOptions, state, errorMessage }) => {
@@ -231,8 +591,8 @@ const confirm = async (options, runtime) => {
 	});
 };
 const number = async (options, runtime) => {
-	return require_session.runPromptSession({
-		runtime: runtime ?? require_runtime.createNodePromptRuntime(),
+	return runPromptSession({
+		runtime: runtime ?? createNodePromptRuntime(),
 		options,
 		initialState: createTextState(options.defaultValue === void 0 ? "" : String(options.defaultValue)),
 		render: ({ options: currentOptions, state, errorMessage }) => {
@@ -290,8 +650,8 @@ const findDefaultIndex = (choices, defaultValue) => {
 	return findFirstEnabledIndex(choices);
 };
 const select = async (options, runtime) => {
-	return require_session.runPromptSession({
-		runtime: runtime ?? require_runtime.createNodePromptRuntime(),
+	return runPromptSession({
+		runtime: runtime ?? createNodePromptRuntime(),
 		options,
 		initialState: { cursor: findDefaultIndex(options.choices, options.defaultValue) },
 		render: ({ options: currentOptions, state, errorMessage }) => {
@@ -327,8 +687,8 @@ const select = async (options, runtime) => {
 	});
 };
 const multiselect = async (options, runtime) => {
-	return require_session.runPromptSession({
-		runtime: runtime ?? require_runtime.createNodePromptRuntime(),
+	return runPromptSession({
+		runtime: runtime ?? createNodePromptRuntime(),
 		options,
 		initialState: {
 			cursor: findFirstEnabledIndex(options.choices),