@akterjs/cli 0.0.0-stage → 0.1.1

package/dist/operation-input.pure-CS9iUhqK.mjs

@@ -0,0 +1,1383 @@
+import { L as reduce, T as join, j as map, l as filter, p as flatMap, w as isReadonlyArrayNonEmpty, y as head } from "./Array-B4kuTQeW.mjs";
+import { W as fnUntraced, dt as map$1, ht as mapError, ln as try_ } from "./Effect-CKFpqbmw.mjs";
+import { S as none, T as toArray, Tn as pipe, b as map$2, cn as isString, f as getOrElse, gt as assignProperty, h as isNone, i as filter$1, kt as formatPath, o as flatMap$1, w as some, x as match } from "./Option-DkxSnBhp.mjs";
+import { $t as isUnique, Bt as isMaxProperties, Ct as isFinite, D as Null, Dn as transform, Dt as isGreaterThanOrEqualTo, E as NonEmptyString, En as passthroughSubtype, F as String$1, Fn as jsonSchemaAnnotationKeys, Ft as isLessThanOrEqualTo, Ht as isMinCodePoints, I as Struct, Jt as isPropertyNames, Kt as isMultipleOf, L as StructWithRest, M as Record, Mt as isLessThan, Pn as annotationExcludedKeys, R as Symbol, Rt as isMaxCodePoints, S as Literals, T as NonEmptyArray, U as Tuple, Ut as isMinLength, W as TupleWithRest, Wt as isMinProperties, X as Unknown, Y as Union, a as Boolean, an as optionalKey, b as JsonObject, ct as encodeOption, g as Finite, in as optional, jt as isInt, k as Number, kn as transformOptional, n as ArraySchema, on as suspend, or as fromEntries, ot as decodeUnknownOption, pr as remove, pt as fromJsonString, qt as isPattern, r as BigInt, rn as makeFilterGroup, sn as tag, sr as get, tn as make, tt as decodeEffect, ut as encodeTo, w as Never, wt as isGreaterThan, x as Literal, y as Json, yn as isJson, z as TaggedError, zt as isMaxLength } from "./Schema-MiKt5K1v.mjs";
+import { d as replace } from "./String-q5dcsVe4.mjs";
+import { CliExitError } from "./terminal/cli-exit.errors.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/jsonSchema.js
+/** @internal */
+function getSubschemaKind(keyword) {
+	switch (keyword) {
+		case "$defs":
+		case "properties":
+		case "patternProperties":
+		case "dependentSchemas": return "map";
+		case "allOf":
+		case "anyOf":
+		case "oneOf":
+		case "prefixItems": return "array";
+		case "not":
+		case "additionalProperties":
+		case "propertyNames":
+		case "unevaluatedProperties":
+		case "items":
+		case "contains":
+		case "unevaluatedItems":
+		case "if":
+		case "then":
+		case "else":
+		case "contentSchema": return "schema";
+	}
+}
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/JsonPointer.js
+/**
+* Helpers for escaping JSON Pointer path segments and converting JSON Pointer
+* URI fragments. JSON Pointer uses `/` to separate path tokens inside a JSON
+* document, so token text must encode literal `~` and `/` characters. URI
+* fragments additionally apply percent-encoding after JSON Pointer escaping.
+*
+* @stability stable
+* @since 4.0.0
+*/
+/**
+* Escapes a JSON Pointer reference token according to RFC 6901 by encoding special characters so the token can be safely used as a segment in a JSON Pointer.
+*
+* **When to use**
+*
+* Use when you need to escape a single JSON Pointer path segment.
+*
+* **Details**
+*
+* - Returns a new escaped string
+* - Replaces `~` (tilde) with `~0` and `/` (forward slash) with `~1`
+* - Returns the input unchanged if it contains no special characters
+* - Empty strings are valid and returned unchanged
+*
+* **Gotchas**
+*
+* The replacement order matters: `~` is replaced before `/` to prevent double-escaping.
+*
+* **Example** (Escaping special characters)
+*
+* ```ts import.meta.vitest
+* import { JsonPointer } from "effect"
+*
+* JsonPointer.escapeToken("a/b") // => "a~1b"
+* JsonPointer.escapeToken("c~d") // => "c~0d"
+* JsonPointer.escapeToken("path/to~key") // => "path~1to~0key"
+* ```
+*
+* @see {@link unescapeToken} The inverse operation for decoding escaped tokens
+* @stability stable
+* @category encoding
+* @since 4.0.0
+*/
+function escapeToken(token) {
+	return token.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+/**
+* Decodes a JSON Pointer reference token according to RFC 6901 escaping rules.
+*
+* **When to use**
+*
+* Use when you need to decode a single escaped JSON Pointer path segment.
+*
+* **Details**
+*
+* - Returns a new unescaped string
+* - Replaces `~1` with `/` (forward slash) and `~0` with `~` (tilde)
+* - Returns the input unchanged if it contains no escaped sequences
+* - Empty strings are valid and returned unchanged
+*
+* **Gotchas**
+*
+* The replacement order matters: `~1` is replaced before `~0` to prevent incorrect decoding.
+*
+* **Example** (Unescaping special characters)
+*
+* ```ts import.meta.vitest
+* import { JsonPointer } from "effect"
+*
+* JsonPointer.unescapeToken("a~1b") // => "a/b"
+* JsonPointer.unescapeToken("c~0d") // => "c~d"
+* JsonPointer.unescapeToken("path~1to~0key") // => "path/to~key"
+* ```
+*
+* @see {@link escapeToken} The inverse operation for encoding tokens
+* @stability stable
+* @category decoding
+* @since 4.0.0
+*/
+function unescapeToken(token) {
+	return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+/** @internal */
+function decodeUriFragment(fragment) {
+	if (fragment.length === 0 || fragment === "#") return "";
+	if (!fragment.startsWith("#")) return void 0;
+	const encoded = fragment.slice(1);
+	try {
+		if (encodeURI(encoded).replace(/%25/g, "%").replace(/#/g, "%23") !== encoded) return void 0;
+		const pointer = decodeURIComponent(encoded);
+		return pointer.startsWith("/") && !/~(?:[^01]|$)/.test(pointer) ? pointer : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Parses a JSON Pointer URI fragment into decoded path tokens.
+*
+* **When to use**
+*
+* Use when you need to resolve a URI fragment against a JSON document.
+*
+* **Details**
+*
+* Percent-encoding is decoded before the pointer is split into tokens, then
+* each token is decoded with {@link unescapeToken}. The empty string and `#`
+* both represent the document root.
+*
+* **Gotchas**
+*
+* Returns `undefined` when the input is not a URI fragment, contains characters
+* that require percent-encoding, or contains an invalid JSON Pointer escape
+* sequence.
+*
+* **Example** (Parsing URI fragments)
+*
+* ```ts import.meta.vitest
+* import { JsonPointer } from "effect"
+*
+* JsonPointer.parseUriFragment("#/users/a~1b") // => ["users", "a/b"]
+* JsonPointer.parseUriFragment("#/caf%C3%A9") // => ["café"]
+* JsonPointer.parseUriFragment("#/%") // => undefined
+* JsonPointer.parseUriFragment("#/a#b") // => undefined
+* ```
+*
+* @see {@link formatUriFragment} for the inverse operation
+* @stability stable
+* @category decoding
+* @since 4.0.0
+*/
+function parseUriFragment(fragment) {
+	const pointer = decodeUriFragment(fragment);
+	return pointer === void 0 ? void 0 : pointer.length === 0 ? [] : pointer.slice(1).split("/").map(unescapeToken);
+}
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/JsonSchema.js
+/** @internal */
+function getReferenceKey($ref) {
+	const path = $ref.startsWith("#") ? parseUriFragment($ref) : void 0;
+	return path !== void 0 && path.length === 2 && path[0] === "$defs" ? path[1] : void 0;
+}
+const PRE_2020_TO_2020_COLLISIONS = [
+	"$anchor",
+	"$defs",
+	"$dynamicAnchor",
+	"$dynamicRef",
+	"$vocabulary",
+	"contentSchema",
+	"dependentRequired",
+	"dependentSchemas",
+	"maxContains",
+	"minContains",
+	"prefixItems",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+];
+[...PRE_2020_TO_2020_COLLISIONS];
+[...PRE_2020_TO_2020_COLLISIONS];
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/errors.js
+/** @internal */
+function errorWithPath(message, path) {
+	if (path.length > 0) message += `\n  at ${formatPath(path)}`;
+	return new Error(message);
+}
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/schema/fromRepresentation.js
+/** @internal */
+var ReferenceSlot = class {
+	body;
+	resolving = false;
+	wrapper;
+	constructor(key) {
+		this.wrapper = suspend(() => {
+			if (this.body === void 0) throw new Error(`Reference ${key} was evaluated before it was resolved`);
+			return this.body;
+		});
+	}
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/schema/fromJsonSchemaDocument.js
+const never = {
+	_tag: "Never",
+	checks: []
+};
+const unknown = {
+	_tag: "Unknown",
+	checks: []
+};
+const string = {
+	_tag: "String",
+	checks: []
+};
+const primitiveSchemas = {
+	Never,
+	Null,
+	String: String$1,
+	Number,
+	Boolean
+};
+const unsupportedStructuredValue = "Only primitive values are supported in \"const\" and \"enum\".";
+const jsonSchemaPatternFlags = "u";
+function isObject(input) {
+	return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+function makeJsonLiteral(input, path) {
+	if (input === null) return {
+		_tag: "Null",
+		checks: []
+	};
+	if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") return {
+		_tag: "Literal",
+		literal: input,
+		checks: []
+	};
+	if (typeof input === "object") throw errorWithPath(unsupportedStructuredValue, path);
+}
+const jsonSchemaValueTypes = [
+	"null",
+	"string",
+	"number",
+	"boolean",
+	"object",
+	"array"
+];
+const jsonSchemaTypeSpecificKeys = [
+	"minLength",
+	"maxLength",
+	"pattern",
+	"minimum",
+	"maximum",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"multipleOf",
+	"properties",
+	"required",
+	"additionalProperties",
+	"patternProperties",
+	"propertyNames",
+	"minProperties",
+	"maxProperties",
+	"items",
+	"prefixItems",
+	"minItems",
+	"maxItems",
+	"uniqueItems"
+];
+const jsonSchemaAnnotationExcludedKeys = /*#__PURE__*/ new Set([
+	...jsonSchemaTypeSpecificKeys,
+	...jsonSchemaAnnotationKeys,
+	...annotationExcludedKeys,
+	"$schema",
+	"$id",
+	"$ref",
+	"$defs",
+	"$anchor",
+	"$dynamicRef",
+	"$dynamicAnchor",
+	"$vocabulary",
+	"$comment",
+	"type",
+	"const",
+	"enum",
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"not",
+	"if",
+	"then",
+	"else",
+	"contains",
+	"minContains",
+	"maxContains",
+	"dependentRequired",
+	"dependentSchemas",
+	"unevaluatedItems",
+	"unevaluatedProperties",
+	"definitions",
+	"dependencies",
+	"additionalItems",
+	"identifier",
+	"expected",
+	"message",
+	"messageMissingKey",
+	"messageUnexpectedKey"
+]);
+function isImportedJsonSchemaType(input) {
+	return input === "integer" || typeof input === "string" && jsonSchemaValueTypes.some((type) => type === input);
+}
+function hasTypeSpecificKeywords(schema) {
+	return jsonSchemaTypeSpecificKeys.some((key) => schema[key] !== void 0);
+}
+function makeFilter(filter) {
+	return {
+		_tag: "Filter",
+		filter
+	};
+}
+function addNumberCheck(checks, value, make) {
+	if (typeof value === "number") checks.push(makeFilter(make(value)));
+}
+function jsonSchemaAnnotations(schema, options) {
+	const annotations = {};
+	if (typeof schema.title === "string") annotations.title = schema.title;
+	if (typeof schema.description === "string") annotations.description = schema.description;
+	if (Object.hasOwn(schema, "default")) annotations.default = schema.default;
+	if (Array.isArray(schema.examples)) annotations.examples = schema.examples;
+	if (typeof schema.readOnly === "boolean") annotations.readOnly = schema.readOnly;
+	if (typeof schema.writeOnly === "boolean") annotations.writeOnly = schema.writeOnly;
+	if (typeof schema.format === "string") annotations.format = schema.format;
+	if (typeof schema.contentEncoding === "string") annotations.contentEncoding = schema.contentEncoding;
+	if (typeof schema.contentMediaType === "string") annotations.contentMediaType = schema.contentMediaType;
+	if (isJson(schema.contentSchema)) annotations.contentSchema = schema.contentSchema;
+	let customAnnotations;
+	if (options?.includeAnnotationKey !== void 0) for (const key of Object.keys(schema)) {
+		if (key.startsWith("~") || jsonSchemaAnnotationExcludedKeys.has(key) || !options.includeAnnotationKey(key)) continue;
+		const value = schema[key];
+		if (isJson(value)) assignProperty(customAnnotations ??= {}, key, value);
+	}
+	return {
+		annotations: Object.keys(annotations).length === 0 ? void 0 : annotations,
+		customAnnotations
+	};
+}
+/** @internal */
+function fromJsonSchemaMultiDocument(document, options, singleRoot = false) {
+	const definitionCache = /* @__PURE__ */ new Map();
+	const validatedAliases = /* @__PURE__ */ new Set();
+	const resolvingChoices = /* @__PURE__ */ new Set();
+	const references = /* @__PURE__ */ new Map();
+	let inNestedResource = false;
+	function finalize(input) {
+		const annotations = mergeAnnotations(input.annotations, input.customAnnotations);
+		if (input._tag === "Reference") {
+			if (annotations !== void 0) resolveReference(input, input.path);
+			let slot = references.get(input.$ref);
+			if (slot === void 0) {
+				slot = new ReferenceSlot(input.$ref);
+				references.set(input.$ref, slot);
+				slot.body = finalize(translateDefinition(input.$ref, input.path)).annotate({ identifier: input.$ref });
+			}
+			return annotations === void 0 ? slot.body ?? slot.wrapper : slot.wrapper.annotate(annotations);
+		}
+		let schema;
+		switch (input._tag) {
+			case "Unknown": return Json.annotate({
+				...annotations,
+				expected: "JSON value"
+			});
+			case "Never":
+			case "Null":
+			case "String":
+			case "Number":
+			case "Boolean":
+				schema = primitiveSchemas[input._tag];
+				break;
+			case "Literal":
+				schema = Literal(input.literal);
+				break;
+			case "Arrays": {
+				const elements = input.elements.map((element) => {
+					const type = finalize(element.type);
+					return element.isOptional ? optionalKey(type) : type;
+				});
+				const rest = input.rest[0] === void 0 ? void 0 : finalize(input.rest[0]);
+				schema = rest !== void 0 ? elements.length === 0 ? ArraySchema(rest) : TupleWithRest(Tuple(elements), [rest]) : Tuple(elements);
+				break;
+			}
+			case "Objects": {
+				if (input.indexSignatures[0]?.parameter === string && input.scopes.some((scope) => scope.patterns.length > 0)) throw errorWithPath("Cannot import open \"patternProperties\": unmatched keys cannot be typed correctly.", input.path);
+				const fields = {};
+				for (const property of input.propertySignatures) {
+					const type = finalize(property.type);
+					assignProperty(fields, property.name, property.isOptional ? optionalKey(type) : type);
+				}
+				const index = input.indexSignatures[0];
+				const record = index === void 0 ? void 0 : Record(finalize(index.parameter), finalize(index.type));
+				schema = record !== void 0 ? input.propertySignatures.length === 0 ? record : StructWithRest(Struct(fields), [record]) : Struct(fields);
+				break;
+			}
+			case "Union": schema = Union(input.types.map(finalize), input.options);
+		}
+		if (annotations !== void 0) schema = schema.annotate(annotations);
+		const checks = input.checks.map(finalizeCheck);
+		return checks.length > 0 ? schema.check(...checks) : schema;
+	}
+	function finalizeCheck(check) {
+		if (check._tag === "FilterGroup") return makeFilterGroup(check.checks.map(finalizeCheck), check.annotations);
+		const filter = check._tag === "PropertyNames" ? isPropertyNames(finalize(check.type)) : check.filter;
+		return check.annotations === void 0 ? filter : filter.annotate(check.annotations);
+	}
+	function annotate(representation, source) {
+		if (source.annotations === void 0 && source.customAnnotations === void 0) return representation;
+		return {
+			...representation,
+			annotations: mergeAnnotations(representation.annotations, source.annotations),
+			customAnnotations: mergeAnnotations(representation.customAnnotations, source.customAnnotations)
+		};
+	}
+	function translateDefinition(key, path, recursiveReferenceError) {
+		const cached = definitionCache.get(key);
+		if (cached !== void 0) {
+			if (cached === null) throw errorWithPath(recursiveReferenceError ?? `Definition ${JSON.stringify(key)} is a circular alias.`, [...path, "$ref"]);
+			return cached;
+		}
+		definitionCache.set(key, null);
+		const pointer = pointers.get(key);
+		const wasInNestedResource = inNestedResource;
+		if (pointer !== void 0) inNestedResource = pointer.crossesResource;
+		const representation = pointer === void 0 ? translateSchema(document.definitions[key], ["definitions", key]) : translateSchema(pointer.target, ["definitions", ...pointer.tokens]);
+		inNestedResource = wasInNestedResource;
+		definitionCache.set(key, representation);
+		if (pointer !== void 0) validatePointerAliases(representation, path, recursiveReferenceError);
+		return representation;
+	}
+	function validatePointerAliases(representation, path, recursiveReferenceError, visiting = /* @__PURE__ */ new Set()) {
+		if (representation._tag === "Reference") {
+			const key = representation.$ref;
+			if (validatedAliases.has(key)) return;
+			if (visiting.has(key)) throw errorWithPath(`Definition ${JSON.stringify(key)} is a circular alias.`, [...path, "$ref"]);
+			visiting.add(key);
+			validatePointerAliases(translateDefinition(key, path, recursiveReferenceError), path, recursiveReferenceError, visiting);
+			visiting.delete(key);
+			validatedAliases.add(key);
+		} else if (representation._tag === "Union") for (const type of representation.types) validatePointerAliases(type, path, recursiveReferenceError, visiting);
+	}
+	function resolveReference(reference, path, recursiveReferenceError, seen = /* @__PURE__ */ new Set()) {
+		if (seen.has(reference.$ref)) throw errorWithPath(`Definition ${JSON.stringify(reference.$ref)} is a circular alias.`, [...path, "$ref"]);
+		seen.add(reference.$ref);
+		const representation = translateDefinition(reference.$ref, path, recursiveReferenceError);
+		if (representation._tag === "Reference") return annotate(resolveReference(representation, path, recursiveReferenceError, seen), representation);
+		return representation;
+	}
+	const pointers = /* @__PURE__ */ new Map();
+	function resolvePointer($ref, path) {
+		const pointer = $ref.startsWith("#") ? parseUriFragment($ref) : void 0;
+		if (pointer === void 0 || pointer.length < 3 || pointer[0] !== "$defs") throw errorWithPath(`Unsupported $ref ${JSON.stringify($ref)}. Use "#/$defs/Name".`, [...path, "$ref"]);
+		const tokens = pointer.slice(1);
+		const key = tokens.map(escapeToken).join("/");
+		if (Object.hasOwn(document.definitions, key)) throw errorWithPath(`Pointer $ref ${JSON.stringify($ref)} conflicts with definition ${JSON.stringify(key)}.`, [...path, "$ref"]);
+		if (pointers.has(key)) return key;
+		let node = document.definitions;
+		let position = "container";
+		let crossesResource = false;
+		for (const token of tokens) {
+			if (position === "container") position = "schema";
+			else if (position === "schema" && isObject(node)) {
+				if (options?.onEnter !== void 0) node = options.onEnter(node);
+				crossesResource ||= isObject(node) && typeof node.$id === "string";
+				const kind = getSubschemaKind(token);
+				position = kind === "schema" ? "schema" : kind === void 0 ? "value" : "container";
+			} else position = "value";
+			node = typeof node === "object" && node !== null && Object.hasOwn(node, token) ? node[token] : void 0;
+		}
+		if (!isObject(node) && typeof node !== "boolean") throw errorWithPath(`Unresolvable $ref ${JSON.stringify($ref)}. Nothing exists at that location.`, [...path, "$ref"]);
+		pointers.set(key, {
+			target: node,
+			tokens,
+			crossesResource
+		});
+		return key;
+	}
+	function mergeAnnotations(left, right) {
+		if (left === void 0) return right;
+		if (right === void 0) return left;
+		return {
+			...left,
+			...right
+		};
+	}
+	function annotateIntersection(representation, left, right) {
+		return annotate(annotate(representation, left), right);
+	}
+	function intersectChecks(left, right, deduplicate = []) {
+		let checks = right.checks;
+		for (const id of deduplicate) if (left.checks.some((check) => check._tag === "Filter" && check.filter.annotations?.representation?.id === id)) checks = checks.filter((check) => check._tag !== "Filter" || check.filter.annotations?.representation?.id !== id);
+		const annotations = checks.length === 0 ? mergeAnnotations(left.annotations, right.annotations) : left.annotations;
+		if (checks.length > 0 && right.annotations !== void 0) checks = checks.length === 1 && checks[0].annotations === void 0 ? [{
+			...checks[0],
+			annotations: right.annotations
+		}] : [{
+			_tag: "FilterGroup",
+			checks,
+			annotations: right.annotations
+		}];
+		return {
+			checks: [...left.checks, ...checks],
+			annotations,
+			customAnnotations: mergeAnnotations(left.customAnnotations, right.customAnnotations)
+		};
+	}
+	function satisfiesPrimitiveCheck(check, value) {
+		if (check._tag === "FilterGroup") return check.checks.every((check) => satisfiesPrimitiveCheck(check, value));
+		return check._tag === "Filter" && check.filter.run(value, Unknown.ast, {}) === void 0;
+	}
+	function satisfiesLiteral(representation, literal) {
+		const value = literal.literal;
+		if (representation._tag === "String" ? typeof value !== "string" : typeof value !== "number") return false;
+		return representation.checks.every((check) => satisfiesPrimitiveCheck(check, value));
+	}
+	function intersectPrimitiveWithLiteral(primitive, literal) {
+		return (primitive._tag === "Boolean" ? typeof literal.literal === "boolean" : satisfiesLiteral(primitive, literal)) ? annotateIntersection(literal, primitive, literal) : never;
+	}
+	function intersectArrays(left, right, path) {
+		const elements = [];
+		const length = Math.max(left.elements.length, right.elements.length);
+		for (let index = 0; index < length; index++) {
+			const leftElement = left.elements[index];
+			const rightElement = right.elements[index];
+			const isOptional = leftElement?.isOptional !== false && rightElement?.isOptional !== false;
+			const leftType = leftElement?.type ?? left.rest[0];
+			const rightType = rightElement?.type ?? right.rest[0];
+			if (leftType === void 0 || rightType === void 0) return isOptional ? {
+				elements,
+				rest: []
+			} : void 0;
+			const type = intersect(leftType, rightType, [
+				...path,
+				"elements",
+				index,
+				"type"
+			]);
+			if (type._tag === "Never") return isOptional ? {
+				elements,
+				rest: []
+			} : void 0;
+			elements.push({
+				isOptional,
+				type
+			});
+		}
+		const leftRest = left.rest[0];
+		const rightRest = right.rest[0];
+		if (leftRest === void 0 || rightRest === void 0) return {
+			elements,
+			rest: []
+		};
+		const rest = intersect(leftRest, rightRest, [
+			...path,
+			"rest",
+			0
+		]);
+		return {
+			elements,
+			rest: rest._tag === "Never" ? [] : [rest]
+		};
+	}
+	function intersectAll(types, path) {
+		let out = types[0] ?? unknown;
+		for (let index = 1; index < types.length; index++) out = intersect(out, types[index], [...path, index]);
+		return out;
+	}
+	function lowerObject(scopes, checked, path) {
+		const names = /* @__PURE__ */ new Set();
+		let hasFiniteKeyDomain = false;
+		let requiresFiniteKeyDomain = false;
+		for (const scope of scopes) {
+			for (const name of scope.properties.keys()) names.add(name);
+			hasFiniteKeyDomain ||= scope.additionalProperties._tag === "Never" && scope.patterns.length === 0;
+			requiresFiniteKeyDomain ||= scope.additionalProperties._tag === "Never" || scope.additionalProperties._tag !== "Unknown" && (scope.hasProperties || scope.patterns.length > 0);
+		}
+		const closedPattern = scopes.length === 1 && names.size === 0 && scopes[0].additionalProperties._tag === "Never" && scopes[0].patterns.length === 1 ? scopes[0].patterns[0] : void 0;
+		if (!hasFiniteKeyDomain && requiresFiniteKeyDomain && closedPattern === void 0) throw errorWithPath(scopes.some((scope) => scope.additionalProperties._tag === "Never") ? "Cannot import this closed patterned object: only one pattern without properties is supported." : "Cannot combine typed \"additionalProperties\" with other property schemas: Effect index signatures also check excluded keys.", path);
+		const properties = [];
+		for (const name of names) {
+			let isOptional = true;
+			const types = [];
+			for (const scope of scopes) {
+				const property = scope.properties.get(name);
+				if (property !== void 0) {
+					if (!property.isOptional) isOptional = false;
+					if (property.type !== void 0) types.push(property.type);
+				}
+				let matches = false;
+				for (const pattern of scope.patterns) if (globalThis.RegExp(pattern.source, jsonSchemaPatternFlags).test(name)) {
+					types.push(pattern.type);
+					matches = true;
+				}
+				if (property?.type === void 0 && !matches) types.push(scope.additionalProperties);
+			}
+			const type = intersectAll(types, [
+				...path,
+				"properties",
+				name
+			]);
+			if (!isOptional && type._tag === "Never") return never;
+			properties.push({
+				name,
+				type,
+				isOptional
+			});
+		}
+		return {
+			_tag: "Objects",
+			propertySignatures: properties,
+			indexSignatures: closedPattern !== void 0 ? [{
+				parameter: closedPattern.parameter,
+				type: closedPattern.type
+			}] : !hasFiniteKeyDomain ? [{
+				parameter: string,
+				type: intersectAll(scopes.map((scope) => scope.additionalProperties), [...path, "additionalProperties"])
+			}] : properties.length === 0 ? [{
+				parameter: string,
+				type: never
+			}] : [],
+			scopes,
+			path,
+			...checked
+		};
+	}
+	const jsonRootTags = [
+		"Null",
+		"String",
+		"Number",
+		"Boolean",
+		"Objects",
+		"Arrays"
+	];
+	const allMasks = (1 << jsonRootTags.length) - 1;
+	function rootMask(representation) {
+		switch (representation._tag) {
+			case "Never": return 0;
+			case "Unknown":
+			case "Reference": return allMasks;
+			case "Literal": switch (typeof representation.literal) {
+				case "string": return 2;
+				case "number": return 4;
+				case "boolean": return 8;
+				default: return 0;
+			}
+			case "Union": {
+				let out = 0;
+				for (const type of representation.types) out |= rootMask(type);
+				return out;
+			}
+			default: return 1 << jsonRootTags.indexOf(representation._tag);
+		}
+	}
+	function hasChoices(representation) {
+		switch (representation._tag) {
+			case "Reference": {
+				const key = representation.$ref;
+				const cached = definitionCache.get(key);
+				if (cached === null || resolvingChoices.has(key)) return true;
+				resolvingChoices.add(key);
+				const out = hasChoices(cached ?? translateDefinition(key, representation.path));
+				resolvingChoices.delete(key);
+				return out;
+			}
+			case "Union": return !isLiteralSet(representation) && (representation.types.length > 1 || representation.types.some(hasChoices));
+			case "Arrays": return representation.elements.some((element) => hasChoices(element.type)) || representation.rest.some(hasChoices);
+			case "Objects": return representation.propertySignatures.some((property) => hasChoices(property.type)) || representation.indexSignatures.some((indexSignature) => hasChoices(indexSignature.parameter) || hasChoices(indexSignature.type)) || representation.scopes.some((scope) => scope.patterns.some((pattern) => hasChoices(pattern.type))) || representation.checks.some(checkHasChoices);
+			default: return false;
+		}
+	}
+	function checkHasChoices(check) {
+		return check._tag === "FilterGroup" ? check.checks.some(checkHasChoices) : check._tag === "PropertyNames" && hasChoices(check.type);
+	}
+	function makeUnion(source, types) {
+		if (types.length === 0) return never;
+		if (types.length === 1 && source.checks.length === 0) return annotate(types[0], source);
+		return {
+			...source,
+			types
+		};
+	}
+	function literalValue(representation) {
+		if (representation._tag === "Null") return null;
+		if (representation._tag !== "Literal") return void 0;
+		return representation.literal;
+	}
+	function isLiteralSet(union) {
+		return (union.options?.mode ?? "anyOf") === "anyOf" && union.types.every((type) => literalValue(type) !== void 0);
+	}
+	function intersectLiteralUnions(left, right, path) {
+		if (!isLiteralSet(left) || !isLiteralSet(right)) return void 0;
+		const rightByValue = /* @__PURE__ */ new Map();
+		for (const representation of right.types) {
+			const value = literalValue(representation);
+			const previous = rightByValue.get(value);
+			rightByValue.set(value, {
+				...representation,
+				customAnnotations: mergeAnnotations(previous?.customAnnotations, representation.customAnnotations)
+			});
+		}
+		const types = [];
+		for (const representation of left.types) {
+			const match = rightByValue.get(literalValue(representation));
+			if (match !== void 0) types.push(intersect(representation, annotate(match, right), path));
+		}
+		return makeUnion(left, types);
+	}
+	function intersectUnionWithType(union, type, path, unionOnLeft) {
+		const mask = rootMask(type);
+		const members = union.types.map((member, index) => ({
+			index,
+			type: member
+		})).filter((member) => (rootMask(member.type) & mask) !== 0);
+		if (members.length > 1 && hasChoices(type)) return unsupportedIntersection(path);
+		if (members.length === 1 && union.checks.length === 0) {
+			const member = annotate(members[0].type, union);
+			return unionOnLeft ? intersect(member, type, [
+				...path,
+				"types",
+				members[0].index
+			]) : intersect(type, member, [
+				...path,
+				"types",
+				members[0].index
+			]);
+		}
+		return makeUnion(union, members.map((member) => unionOnLeft ? intersect(member.type, type, [
+			...path,
+			"types",
+			member.index
+		]) : intersect(type, member.type, [
+			...path,
+			"types",
+			member.index
+		])).filter((type) => type._tag !== "Never"));
+	}
+	function isTypePartition(union) {
+		let mask = 0;
+		for (const type of union.types) {
+			const memberMask = rootMask(type);
+			if ((mask & memberMask) !== 0) return false;
+			mask |= memberMask;
+		}
+		return true;
+	}
+	function unsupportedIntersection(path) {
+		throw errorWithPath("Cannot intersect these \"anyOf\" or \"oneOf\" alternatives without expanding their branches.", path);
+	}
+	function intersectPartition(partition, other, path, partitionOnLeft) {
+		const partitionTypes = partition.types;
+		const otherTypes = other.types;
+		for (const type of otherTypes) {
+			const mask = rootMask(type);
+			if (partitionTypes.filter((member) => (rootMask(member) & mask) !== 0).length > 1 && hasChoices(type)) return unsupportedIntersection(path);
+		}
+		const types = [];
+		for (let index = 0; index < partitionTypes.length; index++) {
+			const member = partitionTypes[index];
+			const type = intersectUnionWithType(other, member, [
+				...path,
+				"types",
+				index
+			], !partitionOnLeft);
+			if (type._tag !== "Never") types.push(type);
+		}
+		return makeUnion(partition, types);
+	}
+	function intersectUnions(left, right, path) {
+		const literals = intersectLiteralUnions(left, right, path);
+		if (literals !== void 0) return literals;
+		if (isTypePartition(left)) return intersectPartition(left, right, path, true);
+		if (isTypePartition(right)) return intersectPartition(right, left, path, false);
+		return unsupportedIntersection(path);
+	}
+	function intersect(left, right, path) {
+		if (left._tag === "Never") return left;
+		if (right._tag === "Never") return right;
+		if (left._tag === "Unknown") return annotateIntersection(right, left, right);
+		if (right._tag === "Unknown") return annotateIntersection(left, left, right);
+		if (left._tag === "Reference") {
+			if ((left.annotations !== void 0 || left.customAnnotations !== void 0) && right._tag === "Reference" && right.annotations === void 0 && right.customAnnotations === void 0) return intersect(left, resolveReference(right, path), path);
+			return annotate(intersect(resolveReference(left, path), right, path), left);
+		}
+		if (right._tag === "Reference") return annotate(intersect(left, resolveReference(right, path), path), right);
+		if (left._tag === "Union" && right._tag === "Union") return intersectUnions(left, right, path);
+		if (left._tag === "Union") return intersectUnionWithType(left, right, path, true);
+		if (right._tag === "Union") return intersectUnionWithType(right, left, path, false);
+		switch (left._tag) {
+			case "Null": return right._tag === "Null" ? annotateIntersection({
+				_tag: "Null",
+				checks: [...left.checks, ...right.checks]
+			}, left, right) : never;
+			case "String":
+				if (right._tag === "Literal") return intersectPrimitiveWithLiteral(left, right);
+				if (right._tag !== "String") return never;
+				return {
+					_tag: "String",
+					...intersectChecks(left, right)
+				};
+			case "Number":
+				if (right._tag === "Literal") return intersectPrimitiveWithLiteral(left, right);
+				if (right._tag !== "Number") return never;
+				return {
+					_tag: "Number",
+					...intersectChecks(left, right, ["effect/schema/isFinite", "effect/schema/isInt"])
+				};
+			case "Boolean":
+				if (right._tag === "Literal") return intersectPrimitiveWithLiteral(left, right);
+				return right._tag === "Boolean" ? annotateIntersection({
+					_tag: "Boolean",
+					checks: [...left.checks, ...right.checks]
+				}, left, right) : never;
+			case "Literal":
+				if (right._tag === "Literal") return left.literal === right.literal ? annotateIntersection({
+					...left,
+					checks: [...left.checks, ...right.checks]
+				}, left, right) : never;
+				if ((right._tag === "String" || right._tag === "Number") && satisfiesLiteral(right, left) || right._tag === "Boolean" && typeof left.literal === "boolean") return annotateIntersection(left, left, right);
+				return never;
+			case "Arrays": {
+				if (right._tag !== "Arrays") return never;
+				const arrays = intersectArrays(left, right, path);
+				if (arrays === void 0) return never;
+				return {
+					_tag: "Arrays",
+					...arrays,
+					...intersectChecks(left, right, ["effect/schema/isUnique"])
+				};
+			}
+			case "Objects":
+				if (right._tag !== "Objects") return never;
+				return lowerObject([...left.scopes, ...right.scopes], intersectChecks(left, right), path);
+		}
+	}
+	function translateSchema(input, path, isRoot = false) {
+		if (input === false) return never;
+		if (!isObject(input)) return unknown;
+		const schema = options?.onEnter === void 0 ? input : options.onEnter(input);
+		if (schema === void 0) return unknown;
+		if (isObject(schema.not) && Object.keys(schema.not).length === 0) return annotate(never, jsonSchemaAnnotations(schema, options));
+		const wasInNestedResource = inNestedResource;
+		inNestedResource ||= !isRoot && typeof schema.$id === "string";
+		for (const keyword of Object.keys(schema)) {
+			if (keyword === "if" && !Object.hasOwn(schema, "then") && !Object.hasOwn(schema, "else")) continue;
+			switch (keyword) {
+				case "if":
+				case "$dynamicRef":
+				case "contains":
+				case "dependentRequired":
+				case "dependentSchemas":
+				case "not":
+				case "unevaluatedItems":
+				case "unevaluatedProperties": throw errorWithPath(`Cannot import JSON Schema keyword "${keyword}": Effect has no equivalent constraint.`, [...path, keyword]);
+			}
+		}
+		let representation = translateType(schema, path);
+		if (Object.hasOwn(schema, "const")) {
+			const constPath = [...path, "const"];
+			const literal = makeJsonLiteral(schema.const, constPath);
+			if (literal !== void 0) representation = intersect(representation, literal, constPath);
+		}
+		if (Array.isArray(schema.enum)) {
+			const types = schema.enum.map((value, index) => makeJsonLiteral(value, [
+				...path,
+				"enum",
+				index
+			]) ?? unknown);
+			representation = intersect(representation, types.length === 1 ? types[0] : {
+				_tag: "Union",
+				types,
+				checks: []
+			}, [...path, "enum"]);
+		}
+		if (typeof schema.$ref === "string") {
+			if (inNestedResource) throw errorWithPath("Cannot resolve $ref under a nested \"$id\". Resolve or flatten it first.", [...path, "$ref"]);
+			const key = getReferenceKey(schema.$ref);
+			if (key !== void 0 && !Object.hasOwn(document.definitions, key)) throw errorWithPath(`Missing definition ${JSON.stringify(key)} for $ref ${JSON.stringify(schema.$ref)}.`, [...path, "$ref"]);
+			const reference = {
+				_tag: "Reference",
+				$ref: key ?? resolvePointer(schema.$ref, path),
+				path
+			};
+			representation = representation._tag === "Unknown" ? reference : representation._tag === "Never" ? never : intersect(resolveReference(reference, path, `Recursive $ref ${JSON.stringify(reference.$ref)} cannot have sibling constraints.`), representation, path);
+		}
+		representation = annotate(representation, jsonSchemaAnnotations(schema, options));
+		if (Array.isArray(schema.allOf)) for (let index = 0; index < schema.allOf.length; index++) representation = intersect(representation, translateSchema(schema.allOf[index], [
+			...path,
+			"allOf",
+			index
+		]), [
+			...path,
+			"allOf",
+			index
+		]);
+		for (const mode of ["anyOf", "oneOf"]) {
+			const members = schema[mode];
+			if (Array.isArray(members)) representation = intersect({
+				_tag: "Union",
+				types: members.map((member, index) => translateSchema(member, [
+					...path,
+					mode,
+					index
+				])),
+				...mode === "oneOf" ? { options: { mode } } : {},
+				checks: []
+			}, representation, [...path, mode]);
+		}
+		inNestedResource = wasInNestedResource;
+		return representation;
+	}
+	function translateType(schema, path) {
+		const types = Array.isArray(schema.type) && schema.type.every(isImportedJsonSchemaType) ? schema.type : !isImportedJsonSchemaType(schema.type) && hasTypeSpecificKeywords(schema) ? jsonSchemaValueTypes : void 0;
+		if (types !== void 0) return {
+			_tag: "Union",
+			types: types.map((type) => translateType({
+				...schema,
+				type
+			}, path)),
+			checks: []
+		};
+		const type = isImportedJsonSchemaType(schema.type) ? schema.type : void 0;
+		switch (type) {
+			case "null": return {
+				_tag: "Null",
+				checks: []
+			};
+			case "string": return {
+				_tag: "String",
+				checks: collectStringChecks(schema, path)
+			};
+			case "number":
+			case "integer": return {
+				_tag: "Number",
+				checks: [makeFilter(type === "number" ? isFinite() : isInt()), ...collectNumberChecks(schema)]
+			};
+			case "boolean": return {
+				_tag: "Boolean",
+				checks: []
+			};
+			case "array": {
+				const prefixItems = Array.isArray(schema.prefixItems) ? schema.prefixItems : void 0;
+				const minItems = typeof schema.minItems === "number" ? schema.minItems : 0;
+				const elements = prefixItems?.map((element, index) => ({
+					isOptional: index + 1 > minItems,
+					type: translateSchema(element, [
+						...path,
+						"prefixItems",
+						index
+					])
+				})) ?? [];
+				const isTupleClosed = schema.items === false || schema.items === void 0 && prefixItems !== void 0 && schema.maxItems === prefixItems.length;
+				const isMaxItemsRedundant = isTupleClosed && typeof schema.maxItems === "number" && schema.maxItems >= elements.length;
+				return {
+					_tag: "Arrays",
+					elements,
+					rest: isTupleClosed ? [] : [schema.items === void 0 ? unknown : translateSchema(schema.items, [...path, "items"])],
+					checks: collectArrayChecks(schema, isMaxItemsRedundant)
+				};
+			}
+			case "object": return lowerObject([collectObjectScope(schema, path)], { checks: collectObjectChecks(schema, path) }, path);
+			default: return unknown;
+		}
+	}
+	function importPatternCheck(pattern, path) {
+		switch (options?.patterns ?? "error") {
+			case "error": throw errorWithPath("Patterns may block validation and are disabled. Use patterns: \"apply\" for trusted schemas or \"ignore\" to discard them.", path);
+			case "ignore": return;
+			case "apply": {
+				let regex;
+				try {
+					regex = globalThis.RegExp(pattern, jsonSchemaPatternFlags);
+				} catch {
+					throw errorWithPath("Cannot import pattern using ECMAScript Unicode mode.", path);
+				}
+				return makeFilter(isPattern(regex));
+			}
+		}
+	}
+	function collectStringChecks(schema, path) {
+		const checks = [];
+		if (schema.minLength === 1) addNumberCheck(checks, schema.minLength, isMinLength);
+		else addNumberCheck(checks, schema.minLength, isMinCodePoints);
+		addNumberCheck(checks, schema.maxLength, isMaxCodePoints);
+		if (typeof schema.pattern === "string") {
+			const check = importPatternCheck(schema.pattern, [...path, "pattern"]);
+			if (check !== void 0) checks.push(check);
+		}
+		return checks;
+	}
+	function collectNumberChecks(schema) {
+		const checks = [];
+		addNumberCheck(checks, schema.minimum, isGreaterThanOrEqualTo);
+		addNumberCheck(checks, schema.maximum, isLessThanOrEqualTo);
+		addNumberCheck(checks, schema.exclusiveMinimum, isGreaterThan);
+		addNumberCheck(checks, schema.exclusiveMaximum, isLessThan);
+		addNumberCheck(checks, schema.multipleOf, isMultipleOf);
+		return checks;
+	}
+	function collectArrayChecks(schema, isMaxItemsRedundant) {
+		const checks = [];
+		if (!Array.isArray(schema.prefixItems) || typeof schema.minItems === "number" && schema.minItems > schema.prefixItems.length) addNumberCheck(checks, schema.minItems, isMinLength);
+		if (!isMaxItemsRedundant) addNumberCheck(checks, schema.maxItems, isMaxLength);
+		if (schema.uniqueItems === true) checks.push(makeFilter(isUnique()));
+		return checks;
+	}
+	function collectObjectScope(schema, path) {
+		const sourceProperties = isObject(schema.properties) ? schema.properties : {};
+		const required = new Set(Array.isArray(schema.required) ? schema.required.filter((key) => typeof key === "string") : []);
+		const propertyNames = Object.keys(sourceProperties);
+		const keys = /* @__PURE__ */ new Set([...propertyNames, ...required]);
+		const properties = new Map(Array.from(keys, (name) => [name, {
+			type: Object.hasOwn(sourceProperties, name) ? translateSchema(sourceProperties[name], [
+				...path,
+				"properties",
+				name
+			]) : void 0,
+			isOptional: !required.has(name)
+		}]));
+		const hasProperties = propertyNames.length > 0;
+		const patterns = [];
+		if (isObject(schema.patternProperties)) for (const [pattern, value] of Object.entries(schema.patternProperties)) {
+			const check = importPatternCheck(pattern, [
+				...path,
+				"patternProperties",
+				pattern
+			]);
+			if (check === void 0) return {
+				properties,
+				hasProperties,
+				patterns: [],
+				additionalProperties: unknown
+			};
+			patterns.push({
+				source: pattern,
+				parameter: {
+					_tag: "String",
+					checks: [check]
+				},
+				type: translateSchema(value, [
+					...path,
+					"patternProperties",
+					pattern
+				])
+			});
+		}
+		return {
+			properties,
+			hasProperties,
+			patterns,
+			additionalProperties: schema.additionalProperties === false ? never : isObject(schema.additionalProperties) ? translateSchema(schema.additionalProperties, [...path, "additionalProperties"]) : unknown
+		};
+	}
+	function collectObjectChecks(schema, path) {
+		const checks = [];
+		addNumberCheck(checks, schema.minProperties, isMinProperties);
+		addNumberCheck(checks, schema.maxProperties, isMaxProperties);
+		if (schema.propertyNames !== void 0) {
+			const propertyNamesPath = [...path, "propertyNames"];
+			checks.push({
+				_tag: "PropertyNames",
+				type: intersect(string, translateSchema(schema.propertyNames, propertyNamesPath), propertyNamesPath)
+			});
+		}
+		return checks;
+	}
+	return document.schemas.map((schema, index) => finalize(translateSchema(schema, singleRoot ? ["schema"] : ["schemas", index], true)));
+}
+/** @internal */
+function fromJsonSchemaDocument$1(document, options) {
+	return fromJsonSchemaMultiDocument({
+		dialect: document.dialect,
+		schemas: [document.schema],
+		definitions: document.definitions
+	}, options, true)[0];
+}
+const RepresentationSchema = /*#__PURE__*/ suspend(() => RepresentationUnion);
+const RepresentationsSchema = /*#__PURE__*/ ArraySchema(RepresentationSchema);
+const RepresentationAnnotationSchema = /*#__PURE__*/ Struct({
+	id: NonEmptyString,
+	payload: Json
+});
+const CheckRepresentationAnnotationSchema = /*#__PURE__*/ Struct({
+	...RepresentationAnnotationSchema.fields,
+	schemas: /*#__PURE__*/ optional(RepresentationsSchema)
+});
+function pruneAnnotations(annotations) {
+	const out = {};
+	for (const [key, value] of Object.entries(annotations)) if (isJson(value)) assignProperty(out, key, value);
+	return Object.keys(out).length === 0 ? none() : some(out);
+}
+const AnnotationsSchema = /*#__PURE__*/ optional(Record(String$1, Unknown)).pipe(/*#__PURE__*/ encodeTo(/*#__PURE__*/ optionalKey(JsonObject), {
+	decode: /*#__PURE__*/ passthroughSubtype(),
+	encode: /*#__PURE__*/ transformOptional((annotations) => isNone(annotations) || annotations.value === void 0 ? none() : pruneAnnotations(annotations.value))
+}));
+const CheckSchema = /*#__PURE__*/ suspend(() => CheckUnion);
+const ChecksSchema = /*#__PURE__*/ ArraySchema(CheckSchema);
+const KeywordFields = {
+	annotations: AnnotationsSchema,
+	checks: ChecksSchema
+};
+const CheckUnion = /*#__PURE__*/ Union([/* @__PURE__ */ Struct({
+	_tag: /*#__PURE__*/ tag("Filter"),
+	representation: CheckRepresentationAnnotationSchema,
+	annotations: AnnotationsSchema,
+	aborted: Boolean
+}), /* @__PURE__ */ Struct({
+	_tag: /*#__PURE__*/ tag("FilterGroup"),
+	representation: /*#__PURE__*/ optional(CheckRepresentationAnnotationSchema),
+	annotations: AnnotationsSchema,
+	checks: /*#__PURE__*/ NonEmptyArray(CheckSchema)
+})]);
+function makeKeywordSchema(tag$1) {
+	return Struct({
+		_tag: tag(tag$1),
+		...KeywordFields
+	});
+}
+const DeclarationSchema = /*#__PURE__*/ Struct({
+	_tag: /*#__PURE__*/ tag("Declaration"),
+	representation: RepresentationAnnotationSchema,
+	annotations: AnnotationsSchema,
+	typeParameters: RepresentationsSchema,
+	checks: ChecksSchema
+});
+const SuspendSchema = /*#__PURE__*/ Struct({
+	_tag: /*#__PURE__*/ tag("Suspend"),
+	annotations: AnnotationsSchema,
+	checks: /*#__PURE__*/ Tuple([]),
+	thunk: RepresentationSchema
+});
+function makeValueSchema(type, value) {
+	return value.pipe(encodeTo(Struct({
+		type: tag(type),
+		value
+	}), {
+		decode: transform((encoded) => encoded.value),
+		encode: transform((value) => ({
+			type,
+			value
+		}))
+	}));
+}
+const StringValueCodec = /*#__PURE__*/ makeValueSchema("string", String$1);
+const NumberValueCodec = /*#__PURE__*/ makeValueSchema("number", Number);
+const LiteralSchema = /*#__PURE__*/ Struct({
+	_tag: /*#__PURE__*/ tag("Literal"),
+	...KeywordFields,
+	literal: /*#__PURE__*/ Union([
+		StringValueCodec,
+		/*#__PURE__*/ makeValueSchema("number", Finite),
+		/*#__PURE__*/ makeValueSchema("bigint", BigInt),
+		/*#__PURE__*/ makeValueSchema("boolean", Boolean)
+	])
+});
+const UniqueSymbolSchema = /*#__PURE__*/ Struct({
+	_tag: /*#__PURE__*/ tag("UniqueSymbol"),
+	...KeywordFields,
+	symbol: Symbol
+});
+const EnumSchema = /*#__PURE__*/ Struct({
+	_tag: /*#__PURE__*/ tag("Enum"),
+	...KeywordFields,
+	enums: /*#__PURE__*/ ArraySchema(/*#__PURE__*/ Tuple([String$1, /*#__PURE__*/ Union([StringValueCodec, NumberValueCodec])]))
+});
+const TemplateLiteralSchema = /*#__PURE__*/ Struct({
+	_tag: /*#__PURE__*/ tag("TemplateLiteral"),
+	...KeywordFields,
+	parts: RepresentationsSchema
+});
+const ElementSchema = /*#__PURE__*/ Struct({
+	isOptional: Boolean,
+	type: RepresentationSchema,
+	annotations: AnnotationsSchema
+});
+const ArraysSchema = /*#__PURE__*/ Struct({
+	_tag: /*#__PURE__*/ tag("Arrays"),
+	...KeywordFields,
+	elements: /*#__PURE__*/ ArraySchema(ElementSchema),
+	rest: RepresentationsSchema
+});
+const PropertySignatureSchema = /*#__PURE__*/ Struct({
+	name: /*#__PURE__*/ Union([
+		StringValueCodec,
+		NumberValueCodec,
+		/*#__PURE__*/ makeValueSchema("symbol", Symbol)
+	]),
+	type: RepresentationSchema,
+	isOptional: Boolean,
+	isMutable: Boolean,
+	annotations: AnnotationsSchema
+});
+const IndexSignatureSchema = /*#__PURE__*/ Struct({
+	parameter: RepresentationSchema,
+	type: RepresentationSchema
+});
+const ObjectsSchema = /*#__PURE__*/ Struct({
+	_tag: /*#__PURE__*/ tag("Objects"),
+	...KeywordFields,
+	propertySignatures: /*#__PURE__*/ ArraySchema(PropertySignatureSchema),
+	indexSignatures: /*#__PURE__*/ ArraySchema(IndexSignatureSchema)
+});
+const UnionSchema = /*#__PURE__*/ Struct({
+	_tag: /*#__PURE__*/ tag("Union"),
+	...KeywordFields,
+	types: RepresentationsSchema,
+	options: /*#__PURE__*/ optionalKey(/*#__PURE__*/ Struct({ mode: /*#__PURE__*/ optionalKey(/*#__PURE__*/ Literals(["anyOf", "oneOf"])) }))
+});
+const RepresentationUnion = /*#__PURE__*/ Union([
+	DeclarationSchema,
+	/* @__PURE__ */ Struct({
+		_tag: /*#__PURE__*/ tag("Reference"),
+		$ref: NonEmptyString
+	}),
+	SuspendSchema,
+	/*#__PURE__*/ makeKeywordSchema("Null"),
+	/*#__PURE__*/ makeKeywordSchema("Undefined"),
+	/*#__PURE__*/ makeKeywordSchema("Void"),
+	/*#__PURE__*/ makeKeywordSchema("Never"),
+	/*#__PURE__*/ makeKeywordSchema("Unknown"),
+	/*#__PURE__*/ makeKeywordSchema("Any"),
+	/*#__PURE__*/ Struct({
+		_tag: /*#__PURE__*/ tag("String"),
+		...KeywordFields,
+		content: /*#__PURE__*/ optional(/*#__PURE__*/ Struct({
+			mediaType: String$1,
+			schema: /*#__PURE__*/ optional(RepresentationSchema)
+		}))
+	}),
+	/*#__PURE__*/ makeKeywordSchema("Number"),
+	/*#__PURE__*/ makeKeywordSchema("Boolean"),
+	/*#__PURE__*/ makeKeywordSchema("BigInt"),
+	/*#__PURE__*/ makeKeywordSchema("Symbol"),
+	/*#__PURE__*/ makeKeywordSchema("ObjectKeyword"),
+	LiteralSchema,
+	UniqueSymbolSchema,
+	EnumSchema,
+	TemplateLiteralSchema,
+	ArraysSchema,
+	ObjectsSchema,
+	UnionSchema
+]);
+/**
+* Imports a JSON Schema Draft 2020-12 document as a runtime schema.
+*
+* **When to use**
+*
+* Use when you need to validate or transform values described by an external JSON Schema document.
+*
+* **Details**
+*
+* Translates a Draft 2020-12 subset using Effect schemas and built-in checks. Validation follows those checks and the
+* decoder's parse options, so import and re-export do not guarantee identical accepted values or a lossless round trip.
+* Import errors explain the unsupported constraint or reference and include its source path.
+* The input is assumed to be a valid Draft 2020-12 document; this function does not validate it against the meta-schema.
+* Instance validation semantics assume JSON-compatible JavaScript values produced by `JSON.parse`.
+*
+* **Gotchas**
+*
+* - `{ not: {} }` imports as `Never`. Other uses of `not` are unsupported.
+* - When `additionalProperties` is `true`, `{}`, or omitted, additional values use `Schema.Json` and are retained.
+*   Closed objects normally strip excess properties by default; pass `onExcessProperty: "error"` to reject them.
+*   Closed empty objects instead use `Schema.Record(Schema.String, Schema.Never)` and reject string-keyed entries
+*   regardless of that option.
+*   Object keyword scopes still constrain declared properties in intersections. Combinations requiring index
+*   signatures that exclude explicit properties or patterned keys are rejected with an explanation of the limitation.
+* - Property count and name checks run on the decoded object, after excess properties have been stripped.
+* - String `minLength` and `maxLength` checks count Unicode code points, except that `minLength: 1` uses the equivalent
+*   UTF-16 non-empty check. `integer` uses `Schema.isInt`, which requires safe integers.
+* - Applied patterns use `Schema.isPattern` with the `u` flag. Patterns that cannot be compiled in Unicode mode are
+*   rejected as unsupported translations with their source path.
+* - `$dynamicRef`, `contains`, `dependentRequired`, `dependentSchemas`, active `if` / `then` / `else`,
+*   `unevaluatedItems`, and `unevaluatedProperties` are rejected with an error identifying the unsupported keyword. Inactive
+*   conditional keywords and `minContains` / `maxContains` without `contains` have no validation effect and are ignored.
+* - Objects and arrays used as `const` values or `enum` members are rejected. Only strings, numbers, booleans, and null
+*   are supported.
+* - Intersections of overlapping unions are limited to disjoint root-type partitions and finite primitive `anyOf`
+*   literal sets, which may also be duplicated across branches. Other union intersections, including cases that would
+*   duplicate any other nested choice, are rejected.
+* - Unknown extension keywords are ignored and their semantics are not enforced.
+* - Only local references to top-level definitions in the form `#/$defs/<escaped-token>` are supported, optionally
+*   followed by a pointer below the definition. A pointer target becomes a definition keyed by its escaped tokens, such
+*   as `Name/properties/field`, and is rejected if a top-level definition already uses that key. Root references and
+*   external references are rejected with the supported reference format. Missing definitions are reported by name.
+*   References reached inside nested schema resources introduced by `$id` are rejected instead of resolved against the
+*   top-level definitions.
+* - Imported constraints use built-in schemas and checks.
+* - Pattern constraints reached during translation cause an error by default. Use `patterns: "apply"` only for trusted
+*   documents, or `patterns: "ignore"` to skip them. Ignoring patterns can both admit invalid values and reject valid
+*   values when `oneOf` branches start overlapping.
+* - `onEnter` results replace the corresponding input nodes before translation.
+* - Callback results are used directly, and exceptions raised by a callback pass through unchanged.
+*
+* @see {@link fromJsonSchemaMultiDocument} for multiple roots sharing definitions
+* @see {@link toRepresentation} for converting the result to a representation document
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+function fromJsonSchemaDocument(document, options) {
+	return fromJsonSchemaDocument$1(document, options);
+}
+// ../../node_modules/.pnpm/@akterjs+cloud-api@file+..+akter-cloud+packages+cloud-api_effect@4.1.2_patch_hash=0e611_59e8fdba67d150970876667b4296bdf6/node_modules/@akterjs/cloud-api/src/operations/schema-unsupported.errors.ts
+var SchemaUnsupportedError = class extends TaggedError()("SchemaUnsupportedError", { message: String$1 }) {};
+// ../../node_modules/.pnpm/@akterjs+cloud-api@file+..+akter-cloud+packages+cloud-api_effect@4.1.2_patch_hash=0e611_59e8fdba67d150970876667b4296bdf6/node_modules/@akterjs/cloud-api/src/operations/operation-request.pure.ts
+const Definitions = Record(String$1, JsonObject);
+const imported = (document) => {
+	return fromJsonSchemaDocument({
+		definitions: pipe(get(document, "$defs"), flatMap$1(decodeUnknownOption(Definitions)), getOrElse(() => ({}))),
+		dialect: "draft-2020-12",
+		schema: remove(document, "$defs")
+	}, { patterns: "apply" });
+};
+const schemaOf = (document) => try_({
+	catch: (cause) => SchemaUnsupportedError.make({ message: String(cause) }),
+	try: () => imported(document)
+}).pipe(map$1((schema) => make(schema.ast)));
+const jsonText = encodeOption(fromJsonString(Json));
+const textOf = (value) => {
+	if (isString(value)) return value;
+	return getOrElse(jsonText(value), () => "");
+};
+const valuesIn = (fields, input) => flatMap(fields, (field) => {
+	const value = get(input, field.name);
+	return toArray(map$2(value, (found) => [field.name, found]));
+});
+const fill = (template, [name, value]) => replace(`{${name}}`, globalThis.encodeURIComponent(textOf(value)))(template);
+const requestOf = ({ input, operation }) => {
+	const placed = (place) => filter(operation.fields, (field) => field.in === place);
+	const path = reduce(valuesIn(placed("path"), input), operation.path, fill);
+	const queryValues = valuesIn(placed("query"), input);
+	const query = fromEntries(map(queryValues, ([name, value]) => [name, textOf(value)]));
+	const fields = fromEntries(valuesIn(placed("body"), input));
+	const hasBody = isReadonlyArrayNonEmpty(placed("body"));
+	return {
+		body: match(head(placed("payload")), {
+			onNone: () => filter$1(some(fields), () => hasBody),
+			onSome: (field) => get(input, field.name)
+		}),
+		path,
+		query
+	};
+};
+// src/registry/operation-input.pure.ts
+const InputObject = fromJsonString(JsonObject);
+const invalid = (message) => CliExitError.make({
+	code: CliExitError.codes.usage,
+	message,
+	reason: "InvalidInput"
+});
+const unsupported = (failure) => CliExitError.make({
+	code: CliExitError.codes.failed,
+	message: `This CLI can't read the API's schema: ${failure.message}`,
+	reason: "SchemaUnsupported"
+});
+const checkedSchema = (document) => mapError(schemaOf(document), unsupported);
+const parseInput = (text) => decodeEffect(InputObject)(text).pipe(mapError(() => invalid("--input must be one JSON object.")));
+const targetOf = (operation) => (input) => pipe(filter(operation.fields, (field) => field.in === "path"), flatMap((field) => toArray(get(input, field.name).pipe(map$2((value) => `${field.name} ${textOf(value)}`)))), join(", "));
+const validInput = fnUntraced(function* validInput({ input, operation }) {
+	const schema = yield* checkedSchema(operation.input);
+	const command = join(operation.command, " ");
+	yield* decodeEffect(schema)(input).pipe(mapError((failure) => invalid(`Invalid input for akter ${command}:\n${failure.message}`)));
+	return {
+		input,
+		request: requestOf({
+			input,
+			operation
+		})
+	};
+});
+export { validInput as i, parseInput as n, targetOf as r, checkedSchema as t };