@asermax/pi-tentacles 0.1.0 → 1.1.0

package/extension/index.js

@@ -3037,6 +3037,38 @@ var fail$4 = fail$5;
 */
 var isResult = isResult$1;
 /**
+* Checks whether a `Result` is a `Failure`.
+*
+* **When to use**
+*
+* Use to narrow a known `Result` to the `Failure` variant.
+*
+* **Details**
+*
+* - Acts as a TypeScript type guard, narrowing to `Failure<A, E>`
+* - After narrowing, you can access `.failure` to read the error value
+*
+* **Example** (Narrowing to failure)
+*
+* ```ts import.meta.vitest
+* import { Result } from "effect"
+*
+* const result = Result.fail("oops")
+*
+* if (Result.isFailure(result)) {
+*   result.failure // => "oops"
+* }
+* ```
+*
+* @see {@link isSuccess} for the opposite check
+* @see {@link isResult} to check if a value is any Result
+*
+* @stability stable
+* @category guards
+* @since 4.0.0
+*/
+var isFailure = isFailure$1;
+/**
 * Checks whether a `Result` is a `Success`.
 *
 * **When to use**
@@ -3069,6 +3101,43 @@ var isResult = isResult$1;
 */
 var isSuccess$1 = isSuccess$2;
 /**
+* Folds a `Result` into a single value by applying one of two functions.
+*
+* **When to use**
+*
+* Use when a `Result`'s success and failure branches should be collapsed into
+* one plain output type.
+*
+* **Details**
+*
+* - Applies `onSuccess` if the result is a `Success`
+* - Applies `onFailure` if the result is a `Failure`
+* - Both branches must return the same type (or a common supertype)
+*
+* **Example** (Folding to a string)
+*
+* ```ts import.meta.vitest
+* import { pipe, Result } from "effect"
+*
+* const format = Result.match({
+*   onSuccess: (n: number) => `Got ${n}`,
+*   onFailure: (e: string) => `Err: ${e}`
+* })
+*
+* format(Result.succeed(42)) // => "Got 42"
+*
+* format(Result.fail("timeout")) // => "Err: timeout"
+* ```
+*
+* @see {@link merge} to extract `A | E` without mapping
+* @see {@link getOrElse} to unwrap only the success with a fallback
+*
+* @stability stable
+* @category pattern matching
+* @since 2.0.0
+*/
+var match$1 = /*#__PURE__*/ dual(2, (self, { onFailure, onSuccess }) => isFailure(self) ? onFailure(self.failure) : onSuccess(self.success));
+/**
 * Maps a record into another record by applying a transformation function to each of its values.
 *
 * **Example** (Mapping record values)
@@ -5013,6 +5082,66 @@ function taggedMatch() {
 * @since 2.0.0
 */
 var TaggedError$1 = TaggedError$2;
+// ../../node_modules/.pnpm/effect@4.1.3/node_modules/effect/dist/encoding/EncodingError.js
+/**
+* Shared error type for encoding and decoding operations.
+*
+* @stability stable
+* @since 4.0.0
+*/
+/**
+* Type identifier stored on `EncodingError` values and used by
+* `isEncodingError`.
+*
+* **When to use**
+*
+* Use when implementing low-level `EncodingError`-compatible values that need
+* to carry the runtime marker.
+*
+* **Details**
+*
+* This marker is part of the runtime representation of `EncodingError`. Prefer
+* `isEncodingError` when narrowing unknown values.
+*
+* @see {@link isEncodingError} for the public guard that checks this marker
+*
+* @stability stable
+* @category type IDs
+* @since 4.0.0
+*/
+var EncodingErrorTypeId = "~effect/encoding/EncodingError";
+/**
+* Error returned when an encoding or decoding operation cannot process its input.
+*
+* **When to use**
+*
+* Use when you need to handle or inspect failures from encoding or decoding
+* operations.
+*
+* **Details**
+*
+* The error records whether the failure happened during encoding or decoding,
+* which encoding module reported it, the original input, and a human-readable
+* message.
+*
+* @see {@link isEncodingError} for checking whether a value is an EncodingError
+*
+* @stability stable
+* @category errors
+* @since 4.0.0
+*/
+var EncodingError = class extends (/*#__PURE__*/ TaggedError$1("EncodingError")) {
+	/**
+	* Marks this value as an encoding or decoding error for runtime guards.
+	*
+	* **When to use**
+	*
+	* Use to identify `EncodingError` instances through `isEncodingError`.
+	*
+	* @since 4.0.0
+	*/
+	[EncodingErrorTypeId] = EncodingErrorTypeId;
+};
 var hexCodes = /*#__PURE__*/ (/* @__PURE__ */ new Uint8Array(256)).fill(255);
 for (let i = 0; i < 16; i++) {
 	hexCodes[/*#__PURE__*/ "0123456789abcdef".charCodeAt(i)] = i;
@@ -5443,6 +5572,11 @@ var suspend$1 = /*#__PURE__*/ makePrimitive({
 	}
 });
 /** @internal */
+var fromResult$1 = /*#__PURE__*/ match$1({
+	onFailure: fail$3,
+	onSuccess: succeed$3
+});
+/** @internal */
 var failCauseSync$1 = (evaluate) => suspend$1(() => failCause$1(evaluate()));
 /** @internal */
 var die$2 = (defect) => exitDie(defect);
@@ -5656,12 +5790,19 @@ var map$3 = /*#__PURE__*/ dual(2, (self, f) => new ContImpl(self, mapCont, f));
 /** @internal */
 var mapEager$1 = /*#__PURE__*/ dual(2, (self, f) => effectIsExit(self) ? exitMap(self, f) : map$3(self, f));
 /** @internal */
+var mapErrorEager$1 = /*#__PURE__*/ dual(2, (self, f) => effectIsExit(self) ? exitMapError(self, f) : mapError(self, f));
+/** @internal */
 var exitIsSuccess = (self) => self._tag === "Success";
 /** @internal */
 var exitVoid = /*#__PURE__*/ exitSucceed(void 0);
 /** @internal */
 var exitMap = /*#__PURE__*/ dual(2, (self, f) => self._tag === "Success" ? exitSucceed(f(self.value)) : self);
 /** @internal */
+var exitMapError = /*#__PURE__*/ dual(2, (self, f) => {
+	if (self._tag === "Success") return self;
+	return exitFailCause(causeMap(self.cause, f));
+});
+/** @internal */
 var exitAsVoidAll = (exits) => {
 	const failures = [];
 	for (const exit of exits) if (exit._tag === "Failure") failures.push(...exit.cause.reasons);
@@ -5703,6 +5844,8 @@ var OnFailureImpl = function(self, f) {
 	this[contE] = f;
 };
 OnFailureImpl.prototype = OnFailureProto;
+/** @internal */
+var mapError = /*#__PURE__*/ dual(2, (self, f) => catchCause$1(self, (cause) => failCause$1(causeMap(cause, f))));
 var OnSuccessAndFailureProto = /*#__PURE__*/ makePrimitiveProto({
 	op: "OnSuccessAndFailure",
 	[evaluate]: evaluateCont
@@ -7666,6 +7809,31 @@ var try_ = try_$1;
 */
 var withFiber = withFiber$1;
 /**
+* Converts a `Result` to an `Effect`.
+*
+* **Example** (Converting a Result into an Effect)
+*
+* ```ts import.meta.vitest
+* import { Effect, Result } from "effect"
+* const output: Array<unknown> = []
+*
+* const success = Result.succeed(42)
+* const failure = Result.fail("Something went wrong")
+*
+* const effect1 = Effect.fromResult(success)
+* const effect2 = Effect.fromResult(failure)
+*
+* void output.push(Effect.runSync(effect1))
+* void output.push(Effect.runSync(Effect.flip(effect2)))
+* output // => [42, "Something went wrong"]
+* ```
+*
+* @stability stable
+* @category converting
+* @since 4.0.0
+*/
+var fromResult = fromResult$1;
+/**
 * Chains effects to produce new `Effect` instances, useful for combining
 * operations that depend on previous results.
 *
@@ -8029,6 +8197,53 @@ var runSyncExit = runSyncExit$1;
 */
 var mapEager = mapEager$1;
 /**
+* Applies `mapError` eagerly when an effect is already resolved.
+*
+* **When to use**
+*
+* Use when an already-resolved failed effect should apply an error
+* transformation immediately while pending effects still use regular error
+* mapping.
+*
+* **Details**
+*
+* Success effects pass through unchanged because there is no error to
+* transform. Failure effects apply the mapping function immediately, and
+* pending effects fall back to regular `mapError` behavior.
+*
+* Maps every typed error in the cause, preserving defects, interrupts and
+* reason order. Unlike typed recovery, mapping does not convert errors to defects.
+*
+* **Example** (Mapping errors eagerly when possible)
+*
+* ```ts import.meta.vitest
+* import { Effect } from "effect"
+* const output: Array<unknown> = []
+*
+* // For resolved failure effects, the error mapping is applied immediately
+* const failed = Effect.fail("original error")
+* const mapped = Effect.mapErrorEager(failed, (err: string) => `mapped: ${err}`) // Applied eagerly
+*
+* // For pending effects, behaves like regular mapError
+* const pending = Effect.delay(Effect.fail("error"), 0)
+* const mappedPending = Effect.mapErrorEager(
+*   pending,
+*   (err: string) => `mapped: ${err}`
+* ) // Uses regular mapError
+*
+* void output.push(await Effect.runPromise(Effect.all([
+*   Effect.flip(mapped),
+*   Effect.flip(mappedPending)
+* ])))
+* output // => [['mapped: original error', 'mapped: error']]
+* ```
+*
+* @stability stable
+* @category error handling
+* @since 4.0.0
+*/
+var mapErrorEager = mapErrorEager$1;
+/**
 * Applies `flatMap` eagerly when an effect is already resolved.
 *
 * **When to use**
@@ -8096,10 +8311,214 @@ var flatMapEager = flatMapEager$1;
 * @since 4.0.0
 */
 var fnUntracedEager = fnUntracedEager$1;
+// ../../node_modules/.pnpm/effect@4.1.3/node_modules/effect/dist/internal/base64.js
+/**
+* Decodes `str` with native `Uint8Array.fromBase64`.
+*
+* Returns `undefined` when native decoding is unavailable or skipped for a
+* short input, and `null` when native decoding rejected the input. In both
+* cases the caller's JS path produces the module's own result or error.
+*
+* Native decoding also skips ASCII whitespace and accepts missing padding, so
+* callers validate the length and padding first and pass the byte length a
+* valid input decodes to. Skipped whitespace always yields fewer bytes, so a
+* result of any other length counts as rejected.
+*
+* @internal
+*/
+var decodeNative = (str, decodedLength, options) => {
+	if (str.length < 128) return void 0;
+	const NativeUint8Array = Uint8Array;
+	if (typeof NativeUint8Array.fromBase64 !== "function") return void 0;
+	try {
+		const bytes = NativeUint8Array.fromBase64(str, options);
+		return bytes.length === decodedLength ? bytes : null;
+	} catch {
+		return null;
+	}
+};
+/** @internal */
+var stripCrlf = (str) => str.indexOf("\n") === -1 && str.indexOf("\r") === -1 ? str : str.replace(/[\n\r]/g, "");
+// ../../node_modules/.pnpm/effect@4.1.3/node_modules/effect/dist/encoding/Base64.js
+/**
+* Base64 encoding and decoding helpers.
+*
+* @stability stable
+* @since 4.0.0
+*/
+/**
+* Encodes the given value into a Base64 (RFC 4648) string.
+*
+* **When to use**
+*
+* Use to encode text or bytes as a standard padded Base64 string for storage or
+* transport.
+*
+* **Details**
+*
+* String inputs are encoded as UTF-8 bytes before Base64 encoding.
+* `Uint8Array` inputs are encoded directly. The output uses the standard
+* RFC 4648 alphabet with `=` padding.
+*
+* **Example** (Encoding Base64 strings and bytes)
+*
+* ```ts import.meta.vitest
+* import { Base64 } from "effect/encoding"
+*
+* Base64.encode("hello") // => "aGVsbG8="
+*
+* const bytes = new Uint8Array([72, 101, 108, 108, 111])
+* Base64.encode(bytes) // => "SGVsbG8="
+* ```
+*
+* @see {@link decode} for decoding standard Base64 to bytes
+* @see {@link decodeString} for decoding standard Base64 to UTF-8 text
+*
+* @stability stable
+* @category encoding
+* @since 4.0.0
+*/
+var encode = (input) => encodeBytes(typeof input === "string" ? encoder$1.encode(input) : input);
+/**
+* Decodes a Base64 (RFC 4648) string into bytes safely.
+*
+* **When to use**
+*
+* Use to decode a standard padded Base64 string into bytes without throwing on
+* invalid input.
+*
+* **Details**
+*
+* Returns `Result.succeed` with a `Uint8Array` when decoding succeeds, or
+* `Result.fail` with an `EncodingError` when the input is not valid Base64.
+*
+* **Example** (Decoding Base64 bytes)
+*
+* ```ts import.meta.vitest
+* import { Result } from "effect"
+* import { Base64 } from "effect/encoding"
+*
+* Base64.decode("SGVsbG8=") // => Result.succeed(new Uint8Array([72, 101, 108, 108, 111]))
+* ```
+*
+* @stability stable
+* @category decoding
+* @since 4.0.0
+*/
+var decode = (str) => {
+	const stripped = stripCrlf(str);
+	const length = stripped.length;
+	if (length % 4 !== 0) return fail$4(new EncodingError({
+		kind: "Decode",
+		module: "Base64",
+		input: stripped,
+		message: `Length must be a multiple of 4, but is ${length}`
+	}));
+	const index = stripped.indexOf("=");
+	if (index !== -1 && (index < length - 2 || index === length - 2 && stripped[length - 1] !== "=")) return fail$4(new EncodingError({
+		kind: "Decode",
+		module: "Base64",
+		input: stripped,
+		message: "Found a '=' character, but it is not at the end"
+	}));
+	const missingOctets = stripped.endsWith("==") ? 2 : stripped.endsWith("=") ? 1 : 0;
+	const decodedLength = 3 * (length / 4) - missingOctets;
+	const native = decodeNative(stripped, decodedLength, void 0);
+	if (native) return succeed$4(native);
+	if (native === null) {
+		const invalid = invalidCharacter.exec(stripped);
+		if (invalid !== null) return fail$4(new EncodingError({
+			kind: "Decode",
+			module: "Base64",
+			input: stripped,
+			message: `Invalid character ${invalid[0]}`
+		}));
+	}
+	try {
+		const result = new Uint8Array(decodedLength);
+		for (let i = 0, j = 0; i < length; i += 4, j += 3) {
+			const buffer = getCode(stripped.charCodeAt(i)) << 18 | getCode(stripped.charCodeAt(i + 1)) << 12 | getCode(stripped.charCodeAt(i + 2)) << 6 | getCode(stripped.charCodeAt(i + 3));
+			result[j] = buffer >> 16;
+			result[j + 1] = buffer >> 8 & 255;
+			result[j + 2] = buffer & 255;
+		}
+		return succeed$4(result);
+	} catch (cause) {
+		return fail$4(new EncodingError({
+			kind: "Decode",
+			module: "Base64",
+			input: stripped,
+			message: cause instanceof Error ? cause.message : "Invalid input"
+		}));
+	}
+};
+var encodeBytes = (bytes) => {
+	const length = bytes.length;
+	const toBase64 = Uint8Array.prototype.toBase64;
+	if (length >= 32 && typeof toBase64 === "function") return toBase64.call(bytes);
+	return length < 128 ? encodeShort(bytes) : encodeLong(bytes);
+};
+var encodeShort = (bytes) => {
+	const length = bytes.length;
+	let result = "";
+	let i = 2;
+	for (; i < length; i += 3) {
+		result += alphabet[bytes[i - 2] >> 2];
+		result += alphabet[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
+		result += alphabet[(bytes[i - 1] & 15) << 2 | bytes[i] >> 6];
+		result += alphabet[bytes[i] & 63];
+	}
+	if (i === length + 1) {
+		result += alphabet[bytes[i - 2] >> 2];
+		result += alphabet[(bytes[i - 2] & 3) << 4];
+		result += "==";
+	}
+	if (i === length) {
+		result += alphabet[bytes[i - 2] >> 2];
+		result += alphabet[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
+		result += alphabet[(bytes[i - 1] & 15) << 2];
+		result += "=";
+	}
+	return result;
+};
+var encodeLong = (bytes) => {
+	const length = bytes.length;
+	const result = new Uint8Array(Math.ceil(length / 3) * 4);
+	let i;
+	let j = 0;
+	for (i = 2; i < length; i += 3, j += 4) {
+		result[j] = alphabetCodes[bytes[i - 2] >> 2];
+		result[j + 1] = alphabetCodes[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
+		result[j + 2] = alphabetCodes[(bytes[i - 1] & 15) << 2 | bytes[i] >> 6];
+		result[j + 3] = alphabetCodes[bytes[i] & 63];
+	}
+	if (i === length + 1) {
+		result[j] = alphabetCodes[bytes[i - 2] >> 2];
+		result[j + 1] = alphabetCodes[(bytes[i - 2] & 3) << 4];
+		result[j + 2] = paddingCode;
+		result[j + 3] = paddingCode;
+	}
+	if (i === length) {
+		result[j] = alphabetCodes[bytes[i - 2] >> 2];
+		result[j + 1] = alphabetCodes[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
+		result[j + 2] = alphabetCodes[(bytes[i - 1] & 15) << 2];
+		result[j + 3] = paddingCode;
+	}
+	return decoder.decode(result);
+};
+var encoder$1 = /*#__PURE__*/ new TextEncoder();
+var decoder = /*#__PURE__*/ new TextDecoder("utf-8", { ignoreBOM: true });
 var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var alphabetCodes = /*#__PURE__*/ encoder$1.encode(alphabet);
+var paddingCode = /*#__PURE__*/ "=".charCodeAt(0);
+var invalidCharacter = /[^A-Za-z0-9+/=]/;
 var codes = /*#__PURE__*/ (/* @__PURE__ */ new Uint8Array(123)).fill(255);
 for (let i = 0; i < 64; i++) codes[/*#__PURE__*/ alphabet.charCodeAt(i)] = i;
 codes[/*#__PURE__*/ "=".charCodeAt(0)] = 0;
+var getCode = (charCode) => {
+	if (charCode >= codes.length || codes[charCode] === 255) throw new TypeError(`Invalid character ${String.fromCharCode(charCode)}`);
+	return codes[charCode];
+};
 ({ ...BaseProto });
 ({ ...BaseProto });
 ({ ...PipeInspectableProto });
@@ -9005,6 +9424,61 @@ function stringifyJson(options) {
 		catch: () => new InvalidValue({ expected: "a JSON-serializable value" }, input, parseOptions)
 	}));
 }
+/**
+* Encodes a `Uint8Array` or string to a Base64 string.
+*
+* **Details**
+*
+* The getter is pure and never fails.
+*
+* **Example** (Encoding to Base64)
+*
+* ```ts import.meta.vitest
+* import { Effect, Option, SchemaGetter } from "effect"
+*
+* const encode = SchemaGetter.encodeBase64<Uint8Array>()
+* const result = Effect.runSync(SchemaGetter.run(encode, Option.some(new Uint8Array([1, 2, 3])), {}))
+* result // => Option.some("AQID")
+* ```
+*
+* @see {@link decodeBase64} for the inverse operation to `Uint8Array`
+* @see {@link decodeBase64String} for the inverse operation to `string`
+* @see {@link encodeBase64Url} for the URL-safe variant
+*
+* @stability stable
+* @category encoding
+* @since 4.0.0
+*/
+function encodeBase64() {
+	return transform$1(encode);
+}
+/**
+* Decodes a Base64 string to a `Uint8Array`.
+*
+* **Details**
+*
+* - Fails with `SchemaIssue.InvalidValue` if the input is not valid Base64.
+*
+* **Example** (Decoding Base64 to bytes)
+*
+* ```ts import.meta.vitest
+* import { Effect, Option, SchemaGetter } from "effect"
+*
+* const decode = SchemaGetter.decodeBase64<string>()
+* const result = await Effect.runPromise(SchemaGetter.run(decode, Option.some("AQID"), {}))
+* Option.map(result, Array.from) // => Option.some([1, 2, 3])
+* ```
+*
+* @see {@link decodeBase64String} to decode to `string` instead
+* @see {@link encodeBase64} for the inverse operation
+*
+* @stability stable
+* @category decoding
+* @since 4.0.0
+*/
+function decodeBase64() {
+	return transformEffect$1((input, options) => mapErrorEager(fromResult(decode(input)), () => new InvalidValue({ expected: "a valid Base64 string" }, input, options)));
+}
 // ../../node_modules/.pnpm/effect@4.1.3/node_modules/effect/dist/internal/schema/content.js
 var ContentTypeId = /*#__PURE__*/ Symbol.for("~effect/Schema/content");
 /** @internal */
@@ -9169,6 +9643,39 @@ function passthrough() {
 */
 var numberFromString = /*#__PURE__*/ new Transformation(/*#__PURE__*/ Number$3(), /*#__PURE__*/ String$3());
 /**
+* Decodes a Base64-encoded `string` into a `Uint8Array` and encodes a
+* `Uint8Array` back to a Base64 string.
+*
+* **When to use**
+*
+* Use when you need a schema transformation for binary data transmitted as
+* Base64 strings (e.g. file uploads, API payloads).
+*
+* **Details**
+*
+* Decoding parses the Base64 string into bytes. Encoding writes the byte array
+* as a Base64 string.
+*
+* **Example** (Converting Base64 to a Uint8Array)
+*
+* ```ts import.meta.vitest
+* import { Schema, SchemaTransformation } from "effect"
+*
+* const schema = Schema.String.pipe(
+*   Schema.decodeTo(Schema.Uint8Array, SchemaTransformation.uint8ArrayFromBase64String)
+* )
+* Array.from(Schema.decodeSync(schema)("AQID")) // => [1, 2, 3]
+* ```
+*
+* @see {@link fromJsonString}
+* @see `Schema.Uint8ArrayFromBase64` - a ready-made schema wrapping this transformation.
+*
+* @stability stable
+* @category encoding
+* @since 4.0.0
+*/
+var uint8ArrayFromBase64String = /*#__PURE__*/ new Transformation(/*#__PURE__*/ decodeBase64(), /*#__PURE__*/ encodeBase64());
+/**
 * Decodes a JSON string with `JSON.parse` and encodes a value with
 * `JSON.stringify`.
 *
@@ -14129,6 +14636,41 @@ function toTaggedUnion(tag) {
 	};
 }
 /**
+* Creates a schema that validates values using `instanceof`.
+* Decoding and encoding pass the value through unchanged.
+*
+* **Example** (Defining a schema for a built-in class)
+*
+* ```ts import.meta.vitest
+* import { Schema } from "effect"
+*
+* const DateSchema = Schema.instanceOf(Date)
+*
+* const decoded = Schema.decodeUnknownSync(DateSchema)(new Date("2024-01-01"))
+* decoded.toISOString() // => "2024-01-01T00:00:00.000Z"
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 3.10.0
+*/
+function instanceOf(constructor, annotations) {
+	return declare((u) => u instanceof constructor, annotations);
+}
+/**
+* Constructs an `SchemaAST.Link` that describes how a value of type `T` encodes to and decodes from a `To` schema.
+* Used when building low-level AST transformations that bridge two schema types.
+*
+* @stability stable
+* @category transforming
+* @since 4.0.0
+*/
+function link() {
+	return (encodeTo, transformation) => {
+		return new Link(encodeTo.ast, makeTransformation(transformation));
+	};
+}
+/**
 * Creates a custom validation filter from a predicate function.
 *
 * **Details**
@@ -14369,6 +14911,51 @@ function isInt(annotations) {
 * @since 3.10.0
 */
 var Int = /*#__PURE__*/ Number$1.check(/*#__PURE__*/ isInt());
+/**
+* Validates that a value has at most the specified length. Works with strings
+* and arrays.
+*
+* **Details**
+*
+* JSON Schema:
+*
+* The bound must be finite; it is rounded down and clamped to zero. This check
+* corresponds to `maxItems` for arrays. Strings use the same bound for
+* `maxLength`, which cannot reject a string accepted by this check because a
+* string has no more code points than UTF-16 code units.
+*
+* Arbitrary:
+*
+* During arbitrary generation, this applies a `maxLength`
+* constraint to ensure generated strings or arrays have at most the required
+* length.
+*
+* @stability stable
+* @category validation
+* @since 4.0.0
+*/
+function isMaxLength(maxLength, annotations) {
+	maxLength = normalizeCardinality(maxLength);
+	return makeFilter((input) => input.length <= maxLength, {
+		expected: `a value with a length of at most ${maxLength}`,
+		representation: {
+			id: "effect/schema/isMaxLength",
+			payload: { maxLength }
+		},
+		toJsonSchema: ({ type }) => type === "string" ? maxLength === 0 ? { maxLength } : [{ maxLength }, true] : type === "array" ? { maxItems: maxLength } : type === void 0 ? [{
+			maxLength,
+			maxItems: maxLength
+		}, true] : [{}, true],
+		toCode: () => ({ runtime: `Schema.isMaxLength(${maxLength})` }),
+		[STRUCTURAL_ANNOTATION_KEY]: true,
+		arbitraryConstraint: { maxLength },
+		...annotations
+	});
+}
+function normalizeCardinality(value) {
+	if (!globalThis.Number.isFinite(value)) throw new globalThis.RangeError(`Expected a finite number, got ${value}`);
+	return Math.max(0, Math.floor(value));
+}
 globalThis.RegExp;
 globalThis.URL;
 var JsonString = /*#__PURE__*/ String$1.annotate({ expected: "a string that will be decoded as JSON" });
@@ -14407,7 +14994,36 @@ function fromJsonString(schema, options) {
 }
 globalThis.File;
 globalThis.URLSearchParams;
-globalThis.Uint8Array;
+var Base64String = /*#__PURE__*/ String$1.annotate({
+	expected: "a base64 encoded string that will be decoded as Uint8Array",
+	format: "byte",
+	contentEncoding: "base64"
+});
+/**
+* Schema for JavaScript `Uint8Array` objects.
+*
+* **Details**
+*
+* Default JSON serializer:
+*
+* The default JSON serializer encodes Uint8Array as a Base64 encoded string.
+*
+* @stability stable
+* @category schemas
+* @since 4.0.0
+*/
+var Uint8Array$1 = /*#__PURE__*/ instanceOf(globalThis.Uint8Array, {
+	representation: {
+		id: "effect/schema/Uint8Array",
+		payload: null
+	},
+	toCode: () => ({
+		runtime: `Schema.Uint8Array`,
+		Type: `globalThis.Uint8Array`
+	}),
+	expected: "Uint8Array",
+	toCodecJson: () => link()(Base64String, uint8ArrayFromBase64String)
+});
 var immerable = /*#__PURE__*/ globalThis.Symbol.for("immer-draftable");
 var payloadToken = {};
 function makeClass(Inherited, identifier, struct$1, annotations, proto) {
@@ -14743,6 +15359,18 @@ var Entry = Union([
 	}),
 	TaggedStruct("subagentResult", { text: String$1 })
 ]).pipe(toTaggedUnion("_tag"));
+var Settings = Struct({
+	provider: String$1,
+	model: String$1,
+	effort: String$1,
+	image: String$1,
+	size: String$1,
+	lifetime: Int,
+	repository: NullOr(Struct({
+		url: String$1.check(isPattern(/^https?:\/\/[^/\s]+/, { message: "repository URL must start with https:// (or http://) and name a host" })),
+		shallow: Boolean$1
+	}))
+});
 // ../../packages/worker-api/src/session-state.ts
 var SessionStatuses = {
 	running: "running",
@@ -14756,12 +15384,26 @@ var Question = Struct({
 	id: QuestionId,
 	text: String$1
 });
+var SessionDetails = Struct({
+	settings: Settings,
+	skills: ArraySchema(String$1),
+	agents: ArraySchema(String$1)
+});
 var SessionState = Union([
-	TaggedStruct(SessionStatuses.running, {}),
-	TaggedStruct(SessionStatuses.waiting, { question: Question }),
-	TaggedStruct(SessionStatuses.idle, { lastEntry: optionalKey(Entry) }),
-	TaggedStruct(SessionStatuses.failed, { failure: String$1 }),
-	TaggedStruct(SessionStatuses.closed, {})
+	TaggedStruct(SessionStatuses.running, SessionDetails.fields),
+	TaggedStruct(SessionStatuses.waiting, {
+		...SessionDetails.fields,
+		question: Question
+	}),
+	TaggedStruct(SessionStatuses.idle, {
+		...SessionDetails.fields,
+		lastEntry: optionalKey(Entry)
+	}),
+	TaggedStruct(SessionStatuses.failed, {
+		...SessionDetails.fields,
+		failure: String$1
+	}),
+	TaggedStruct(SessionStatuses.closed, SessionDetails.fields)
 ]).pipe(toTaggedUnion("_tag"));
 /** The registry's status for a state. */
 var statusOf = (state) => SessionState.match(state, {
@@ -14779,6 +15421,10 @@ var SessionRef = Struct({
 	name: String$1,
 	status: SessionStatus
 });
+var SessionListing = Struct({
+	...SessionRef.fields,
+	...SessionDetails.fields
+});
 // ../../node_modules/.pnpm/effect@4.1.3/node_modules/effect/dist/internal/matcher.js
 /** @internal */
 var TypeId$6 = "~effect/Match/Matcher";
@@ -15136,11 +15782,13 @@ var orElse = orElse$1;
 var SessionNotFound = class extends TaggedError()("SessionNotFound", { sessionId: SessionId }, { httpApiStatus: 404 }) {};
 var QuestionNotWaiting = class extends TaggedError()("QuestionNotWaiting", { questionId: QuestionId }, { httpApiStatus: 409 }) {};
 var Unauthorized = class extends TaggedError()("Unauthorized", {}, { httpApiStatus: 401 }) {};
+var InvalidArchive = class extends TaggedError()("InvalidArchive", { message: String$1 }, { httpApiStatus: 400 }) {};
 /** Every error the API returns; the helper's command result carries it. */
 var TentaclesError = Union([
 	SessionNotFound,
 	QuestionNotWaiting,
-	Unauthorized
+	Unauthorized,
+	InvalidArchive
 ]);
 var WatchLineJson = fromJsonString(Union([Struct({
 	sessionId: SessionId,
@@ -16457,33 +17105,49 @@ var http = (options) => Object.assign(Object.create(Proto), {
 * @since 4.0.0
 */
 var bearer = /*#__PURE__*/ http({ scheme: "Bearer" });
+// ../../packages/worker-api/src/archive-kinds.ts
+/**
+* The kinds of archive a create request carries. `expandsInto` is where the workspace container
+* expands the kind's archive; a null one is read by the Worker only and never reaches the container.
+*/
+var archiveKinds = {
+	skills: {
+		heading: "Skills",
+		expandsInto: "/skills"
+	},
+	agents: {
+		heading: "Agents",
+		expandsInto: null
+	},
+	context: {
+		heading: "Context",
+		expandsInto: "/context"
+	}
+};
+keys(archiveKinds).flatMap((kind) => {
+	const { expandsInto } = archiveKinds[kind];
+	return expandsInto == null ? [] : [{
+		kind,
+		directory: expandsInto
+	}];
+});
 // ../../packages/worker-api/src/middleware.ts
 /** Every request carries the API key as a bearer token; a provider checks it against its secret. */
 var ApiKey = class extends Service()("tentacles/ApiKey", {
 	security: { bearer },
 	error: Unauthorized
 }) {};
-var Settings = Struct({
-	provider: String$1,
-	model: String$1,
-	effort: String$1,
-	image: String$1,
-	size: String$1,
-	lifetime: Int,
-	repository: NullOr(Struct({
-		url: String$1,
-		shallow: Boolean$1
-	}))
-});
 var PromptMode = Enum({
 	followUp: "followUp",
 	steer: "steer"
 });
+var Archive = Uint8Array$1.check(isMaxLength(5242880));
 var CreateSession = Struct({
 	name: String$1,
 	parent: Parent,
 	settings: Settings,
-	prompt: String$1
+	prompt: String$1,
+	...map$5(archiveKinds, () => optionalKey(Archive))
 });
 var Prompt = Struct({
 	text: String$1,
@@ -16497,7 +17161,8 @@ var sessionParams = { sessionId: SessionId };
 var MessageCount = Int.check(isGreaterThanOrEqualTo(1));
 var SessionsGroup = class extends make("sessions").add(post("create", "/sessions", {
 	payload: CreateSession,
-	success: Struct({ sessionId: SessionId })
+	success: Struct({ sessionId: SessionId }),
+	error: InvalidArchive
 }), post("prompt", "/sessions/:sessionId/prompt", {
 	params: sessionParams,
 	payload: Prompt,
@@ -16523,7 +17188,7 @@ var SessionsGroup = class extends make("sessions").add(post("create", "/sessions
 	error: SessionNotFound
 }), get("list", "/sessions", {
 	query: Parent.fields,
-	success: ArraySchema(SessionRef)
+	success: ArraySchema(SessionListing)
 }), get("socket", "/sessions/:sessionId/socket", {
 	params: sessionParams,
 	success: Empty(101),
@@ -16569,8 +17234,15 @@ var endpointArguments = (name) => {
 };
 /** What the agent sends to spawn: the glue fills the parent. */
 var SpawnArguments = CreateSession.mapFields((fields) => ({
-	...fields,
-	settings: optionalKey(Settings.mapFields(map(optionalKey)))
+	...omit(fields, [
+		"skills",
+		"agents",
+		"context"
+	]),
+	settings: optionalKey(Settings.mapFields(map(optionalKey))),
+	skills: optionalKey(ArraySchema(String$1).annotate({ description: "Paths of skill folders on this machine, each holding a SKILL.md." })),
+	agents: optionalKey(ArraySchema(String$1).annotate({ description: "Paths of agent definition files on this machine." })),
+	context: optionalKey(ArraySchema(String$1).annotate({ description: "Paths of files or folders on this machine; the remote agent finds them in /context, each under its own name." }))
 })).mapFields(omit(["parent"]));
 // src/core/tool-table.ts
 var ToolNames = {
@@ -16589,7 +17261,7 @@ var spawnDocument = toJsonSchemaDocument(SpawnArguments);
 var ToolTable = {
 	spawn: ToolEntry.Endpoint({
 		name: ToolNames.spawn,
-		description: "Start a remote agent with a name, a first prompt and optional settings. The settings left out come from the plugin's defaults. Answers with the new session's id.",
+		description: "Start a remote agent with a name, a first prompt and optional settings. The settings left out come from the plugin's defaults. Optionally takes the paths of skill folders and agent definition files, and the paths of context files or folders the remote agent finds in /context, which stay fixed for the session. Answers with the new session's id.",
 		endpoint: "create",
 		harnesses: bothHarnesses,
 		arguments: {
@@ -16667,7 +17339,8 @@ var decodeWatchLine = decodeUnknownOption(WatchLineJson);
 var failureText = type().pipe(tagsExhaustive({
 	SessionNotFound: (error) => `SessionNotFound: session ${error.sessionId} does not exist.`,
 	QuestionNotWaiting: (error) => `QuestionNotWaiting: question ${error.questionId} is no longer waiting.`,
-	Unauthorized: () => "Unauthorized: the Worker refused the API key in TENTACLES_API_KEY."
+	Unauthorized: () => "Unauthorized: the Worker refused the API key in TENTACLES_API_KEY.",
+	InvalidArchive: (error) => error.message
 }));
 var wakeKeyOf = (state) => value(state).pipe(tag(SessionStatuses.waiting, (waiting) => `${SessionStatuses.waiting}:${waiting.question.id}`), orElse(statusOf));
 /** Holds the local-state transitions, which states wake the parent and when the watch restarts; both glues run it. */