fleetfizz 0.1.0 → 0.2.0

package/dist/fleetfizz.mjs

@@ -9379,7 +9379,19 @@ const Proto$7 = {
 		return toDateUtc$1(this).toJSON();
 	}
 };
-({ ...Proto$7 });
+const ProtoUtc = {
+	...Proto$7,
+	_tag: "Utc",
+	[symbol$1]() {
+		return number$1(this.epochMilliseconds);
+	},
+	[symbol](that) {
+		return isDateTime$1(that) && that._tag === "Utc" && this.epochMilliseconds === that.epochMilliseconds;
+	},
+	toString() {
+		return `DateTime.Utc(${toDateUtc$1(this).toJSON()})`;
+	}
+};
 ({ ...Proto$7 });
 const ProtoTimeZone = {
 	[TimeZoneTypeId]: TimeZoneTypeId,
@@ -9390,7 +9402,23 @@ const ProtoTimeZone = {
 ({ ...ProtoTimeZone });
 ({ ...ProtoTimeZone });
 /** @internal */
+const isDateTime$1 = (u) => hasProperty(u, TypeId$27);
+const makeUtc = (epochMillis) => {
+	const self = Object.create(ProtoUtc);
+	self.epochMilliseconds = epochMillis;
+	Object.defineProperty(self, "partsUtc", {
+		value: void 0,
+		enumerable: false,
+		writable: true
+	});
+	return self;
+};
+/** @internal */
+const now$1 = /*#__PURE__*/ map$7(currentTimeMillis, makeUtc);
+/** @internal */
 const toDateUtc$1 = (self) => new Date(self.epochMilliseconds);
+/** @internal */
+const formatIso$1 = (self) => toDateUtc$1(self).toISOString();
 globalThis.Number;
 /**
 * Returns the number rounded with the given precision.
@@ -16538,17 +16566,56 @@ function resolve$1(ast) {
 	return ast.checks ? ast.checks[ast.checks.length - 1].annotations : ast.annotations;
 }
 /** @internal */
+function resolveAt(key) {
+	return (ast) => resolve$1(ast)?.[key];
+}
+/** @internal */
 const STRUCTURAL_ANNOTATION_KEY = "~structural";
 /** @internal */
+const IDENTIFIER_FALLBACK_KEY = "~identifier";
+/** @internal */
 const SENTINELS_ANNOTATION_KEY = "~sentinels";
 /** @internal */
 const CONSTRUCTOR_ANNOTATION_KEY = "~constructor";
 /** @internal */
+const jsonSchemaAnnotationKeys = [
+	"title",
+	"description",
+	"default",
+	"examples",
+	"readOnly",
+	"writeOnly",
+	"format",
+	"contentEncoding",
+	"contentMediaType",
+	"contentSchema"
+];
+/** @internal */
+const resolveIdentifier = /*#__PURE__*/ resolveAt("identifier");
+/** @internal */
+const resolveIdentifierFallback = /*#__PURE__*/ resolveAt(IDENTIFIER_FALLBACK_KEY);
+/** @internal */
 const getExpected = /*#__PURE__*/ memoize((ast) => {
 	const identifier = resolve$1(ast)?.identifier;
 	if (typeof identifier === "string") return identifier;
 	return ast.getExpected(getExpected);
 });
+/** @internal */
+const annotationExcludedKeys = /*#__PURE__*/ new Set([
+	SENTINELS_ANNOTATION_KEY,
+	STRUCTURAL_ANNOTATION_KEY,
+	"representation",
+	"arbitraryConstraint",
+	"toJsonSchema",
+	"toCode",
+	"toEquivalence",
+	"toFormatter",
+	"toCodec",
+	"toCodecJson",
+	"toCodecStringTree",
+	"toCodecIso",
+	"toCodecArbitrary"
+]);
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/internal/schema/parser.js
 /** @internal */
@@ -17077,6 +17144,48 @@ function getSchemaIssueOrThrow(cause, message) {
 	if (issue === void 0) throw new Error(message, { cause });
 	return issue;
 }
+/**
+* Gets the current time using the `Clock` service and converts it to a `DateTime`.
+*
+* **Example** (Getting the current DateTime)
+*
+* ```ts import.meta.vitest
+* import { DateTime, Effect } from "effect"
+* import { TestClock } from "effect/testing"
+*
+* await Effect.runPromise(Effect.map(DateTime.now, DateTime.isDateTime)) // => true
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 3.6.0
+*/
+const now = now$1;
+/**
+* Formats a `DateTime` as a UTC ISO string.
+*
+* **Details**
+*
+* Always returns the UTC representation in ISO 8601 format, ignoring any time zone.
+*
+* **Example** (Formatting DateTime values as ISO strings)
+*
+* ```ts import.meta.vitest
+* import { DateTime } from "effect"
+*
+* DateTime.formatIso(DateTime.makeUnsafe("2024-01-01T12:30:45.123Z")) // => "2024-01-01T12:30:45.123Z"
+*
+* const zoned = DateTime.makeZonedUnsafe("2024-01-01T12:30:45.123Z", {
+*   timeZone: "Europe/London"
+* })
+* DateTime.formatIso(zoned) // => "2024-01-01T12:30:45.123Z"
+* ```
+*
+* @stability stable
+* @category formatting
+* @since 3.6.0
+*/
+const formatIso = formatIso$1;
 const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 const codes = /*#__PURE__*/ (/* @__PURE__ */ new Uint8Array(123)).fill(255);
 for (let i = 0; i < 64; i++) codes[/*#__PURE__*/ alphabet.charCodeAt(i)] = i;
@@ -19470,6 +19579,10 @@ function record(key, value) {
 function isOptional(ast) {
 	return ast.context?.isOptional ?? false;
 }
+/** @internal */
+function isMutable(ast) {
+	return ast.context?.isMutable ?? false;
+}
 function isStructuralCheck(check) {
 	return check.annotations?.["~structural"] === true || check._tag === "FilterGroup" && check.checks.every(isStructuralCheck);
 }
@@ -19640,6 +19753,11 @@ const parameterFromString = /*#__PURE__*/ applyToSelfOrLastLinkEncodingIdempoten
 		case "Union": return ast.recur(parameterFromString);
 	}
 });
+/**
+* any string, including newlines
+* @internal
+*/
+const STRING_PATTERN = "[\\s\\S]*?";
 const isStringFiniteRegExp = /*#__PURE__*/ new globalThis.RegExp(`^${FINITE_PATTERN}$`);
 const isStringNumberRegExp = /*#__PURE__*/ new globalThis.RegExp(`^(?:${FINITE_PATTERN}|Infinity|-Infinity|NaN)$`);
 /** @internal */
@@ -19750,6 +19868,10 @@ const Json$1 = /*#__PURE__*/ new Declaration([], () => (input, ast, options) =>
 	toCodecJson: () => void 0,
 	toCodecStringTree: () => unknownToStringTree
 });
+/** @internal */
+const unknownToJson = /*#__PURE__*/ new Link(Json$1, /*#__PURE__*/ passthrough());
+/** @internal */
+const objectKeywordToJson = /*#__PURE__*/ new Link(/*#__PURE__*/ new Union$1([/*#__PURE__*/ new Arrays(false, [], [Json$1]), /*#__PURE__*/ new Objects([], [/*#__PURE__*/ new IndexSignature(string, Json$1)])]), /*#__PURE__*/ passthrough());
 /**
 * Returns true if the value is a StringTree value.
 *
@@ -22226,7 +22348,223 @@ function make$5(ast, options) {
 	return self;
 }
 //#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.2/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 formatUriFragmentToken(token) {
+	return encodeURI(escapeToken(token)).replace(/#/g, "%23");
+}
+/** @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;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/JsonSchema.js
+/**
+* Helpers for normalizing and converting JSON Schema and OpenAPI schema
+* documents. Supported inputs include JSON Schema Draft-07, Draft 2020-12,
+* OpenAPI 3.0, and OpenAPI 3.1; conversions normalize through
+* `Document<"draft-2020-12">` before emitting another dialect, including
+* JSON Schema Draft-04. The module also defines document types, meta-schema
+* constants, and OpenAPI component-key helpers.
+*
+* @stability stable
+* @since 4.0.0
+*/
+/**
+* Represents the `$schema` meta-schema URI for JSON Schema Draft 2020-12.
+*
+* **When to use**
+*
+* Use when you need to populate the `$schema` field while emitting a JSON
+* Schema document that should declare JSON Schema Draft 2020-12.
+*
+* **Details**
+*
+* The exported value is the literal string
+* `https://json-schema.org/draft/2020-12/schema`.
+*
+* @see {@link META_SCHEMA_URI_DRAFT_07} for the Draft-07 `$schema` URI
+*
+* @stability stable
+* @category constants
+* @since 4.0.0
+*/
+const META_SCHEMA_URI_DRAFT_2020_12 = "https://json-schema.org/draft/2020-12/schema";
+function transformSchema(node, transform) {
+	return walk(node, false, true);
+	function walk(node, inheritedResource, isRoot = false) {
+		if (!isObject(node)) return node;
+		const inEmbeddedResource = inheritedResource || !isRoot && createsResource(node.$id);
+		const out = {};
+		for (const key of Object.keys(node)) {
+			const value = node[key];
+			let transformed = value;
+			switch (key) {
+				case "$defs":
+				case "properties":
+				case "patternProperties":
+				case "dependentSchemas":
+					transformed = mapObject(value, (value) => walk(value, inEmbeddedResource)) ?? value;
+					break;
+				case "allOf":
+				case "anyOf":
+				case "oneOf":
+				case "prefixItems":
+					transformed = Array.isArray(value) ? value.map((value) => walk(value, inEmbeddedResource)) : value;
+					break;
+				case "not":
+				case "additionalProperties":
+				case "propertyNames":
+				case "unevaluatedProperties":
+				case "items":
+				case "contains":
+				case "unevaluatedItems":
+				case "if":
+				case "then":
+				case "else":
+				case "contentSchema": transformed = walk(value, inEmbeddedResource);
+			}
+			assignProperty(out, key, transformed);
+		}
+		transform(out, inEmbeddedResource);
+		return out;
+	}
+}
+/** @internal */
+function rewriteRefs(schema, rewrite) {
+	return transformSchema(schema, (schema) => {
+		rewriteSchemaRef(schema, rewrite);
+	});
+}
+function rewriteSchemaRef(schema, rewrite) {
+	if (typeof schema.$ref === "string") assignProperty(schema, "$ref", rewrite(schema.$ref, "$ref"));
+	if (typeof schema.$dynamicRef === "string") assignProperty(schema, "$dynamicRef", rewrite(schema.$dynamicRef, "$dynamicRef"));
+}
+function mapObject(value, f) {
+	if (!isObject(value)) return void 0;
+	const out = {};
+	for (const key of Object.keys(value)) assignProperty(out, key, f(value[key], key));
+	return out;
+}
+function createsResource(id) {
+	return typeof id === "string" && id.length > 0 && id[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];
+//#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/internal/schema/toCodec.js
+/** @internal */
+const toCodecJsonAST = /*#__PURE__*/ applyToSelfOrLastLinkEncodingIdempotent((ast) => {
+	const out = toCodecJsonASTStep(ast, toCodecJsonAST);
+	const context = ast.context;
+	if (out === ast || context === void 0) return out;
+	return replaceContextLastLink(out, withoutConstructorDefault(context));
+});
 function withoutConstructorDefault(context) {
 	return context.constructorDefault === void 0 ? context : new Context(context.isOptional, context.isMutable, void 0, context.annotations);
 }
@@ -22240,6 +22578,44 @@ function makeReorder(getPriority) {
 		return sortedTypes;
 	};
 }
+const toCodecJsonReorder = /*#__PURE__*/ makeReorder((ast) => {
+	switch (ast._tag) {
+		case "BigInt":
+		case "Symbol":
+		case "UniqueSymbol": return 0;
+		default: return 1;
+	}
+});
+function toCodecJsonASTStep(ast, recur) {
+	switch (ast._tag) {
+		case "Declaration": {
+			const getLink = ast.annotations?.toCodecJson ?? ast.annotations?.toCodec;
+			if (!isFunction(getLink)) return replaceEncoding(ast, [unknownToJson]);
+			const link = getLink(ast.typeParameters.map((tp) => make$5(toEncoded(tp))));
+			return link === void 0 ? ast : replaceEncoding(ast, [mapLink(link, recur)]);
+		}
+		case "Unknown": return replaceEncoding(ast, [unknownToJson]);
+		case "ObjectKeyword": return replaceEncoding(ast, [objectKeywordToJson]);
+		case "Undefined":
+		case "Void":
+		case "Literal":
+		case "Number": return ast.toCodecJson();
+		case "UniqueSymbol":
+		case "Symbol":
+		case "BigInt": return ast.toCodecStringTree();
+		case "Objects":
+			validateCanonicalObjectPropertyNames(ast);
+			return ast.recur(recur, parameterFromString);
+		case "Union": {
+			const sortedTypes = toCodecJsonReorder(ast.types);
+			if (sortedTypes !== ast.types) return new Union$1(sortedTypes, ast.options, ast.annotations, ast.checks, ast.encoding, ast.context, ast.encodingChecks).recur(recur);
+			return ast.recur(recur);
+		}
+		case "Arrays":
+		case "Suspend": return ast.recur(recur);
+	}
+	return ast;
+}
 /** @internal */
 function toCodecStringTree$1(schema) {
 	return make$5(toCodecStringTreeAST(schema.ast), { schema });
@@ -22305,6 +22681,849 @@ const toCodecStringTreeAST = /*#__PURE__*/ applyToSelfOrLastLinkEncodingIdempote
 	if (out !== ast && ast.context !== void 0) return replaceContextLastLink(out, withoutConstructorDefault(ast.context));
 	return out;
 }, { stopAt: isCodecArrayFromSingleLink });
+globalThis.RegExp;
+/**
+* Escapes special characters in a regular expression pattern.
+*
+* **When to use**
+*
+* Use to turn literal text into a safe regular expression pattern fragment.
+*
+* **Example** (Escaping a pattern string)
+*
+* ```ts import.meta.vitest
+* import { RegExp } from "effect"
+*
+* RegExp.escape("a*b") // => "a\\*b"
+* ```
+*
+* @stability stable
+* @category transforming
+* @since 2.0.0
+*/
+const escape = (string) => string.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&");
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.2/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);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/internal/schema/toJsonSchemaDocument.js
+function formatDefinitionReference(key) {
+	return `#/$defs/${formatUriFragmentToken(key)}`;
+}
+const jsonSchemaAnnotationExcludedKeys = /*#__PURE__*/ new Set([
+	...annotationExcludedKeys,
+	IDENTIFIER_FALLBACK_KEY,
+	...jsonSchemaAnnotationKeys
+]);
+function collectJsonSchemaAnnotations(annotations, options) {
+	if (annotations === void 0) return void 0;
+	const out = {};
+	const title = annotations.title;
+	if (typeof title === "string") out.title = title;
+	const description = annotations.description;
+	const expected = annotations.expected;
+	if (typeof description === "string") out.description = description;
+	else if (options?.generateDescriptions === true && typeof expected === "string") out.description = expected;
+	const defaultValue = annotations.default;
+	if (isJson(defaultValue)) out.default = defaultValue;
+	const examples = annotations.examples;
+	if (Array.isArray(examples) && isJson(examples)) out.examples = examples;
+	const readOnly = annotations.readOnly;
+	if (typeof readOnly === "boolean") out.readOnly = readOnly;
+	const writeOnly = annotations.writeOnly;
+	if (typeof writeOnly === "boolean") out.writeOnly = writeOnly;
+	const format = annotations.format;
+	if (typeof format === "string") out.format = format;
+	const contentEncoding = annotations.contentEncoding;
+	if (typeof contentEncoding === "string") out.contentEncoding = contentEncoding;
+	const contentMediaType = annotations.contentMediaType;
+	if (typeof contentMediaType === "string") out.contentMediaType = contentMediaType;
+	const contentSchema = annotations.contentSchema;
+	if (isJson(contentSchema)) out.contentSchema = contentSchema;
+	if (options?.includeAnnotationKey !== void 0) for (const [key, value] of Object.entries(annotations)) {
+		if (jsonSchemaAnnotationExcludedKeys.has(key) || !options.includeAnnotationKey(key)) continue;
+		if (isJson(value)) assignProperty(out, key, value);
+	}
+	return Object.keys(out).length === 0 ? void 0 : out;
+}
+function extractJsonSchemaNumberType(schema) {
+	let type = schema.type === "number" || schema.type === "integer" ? schema.type : void 0;
+	let out = schema;
+	if (type !== void 0) {
+		out = { ...schema };
+		delete out.type;
+	}
+	if (Array.isArray(out.allOf)) {
+		const members = [];
+		let changed = false;
+		for (const member of out.allOf) {
+			const extracted = extractJsonSchemaNumberType(member);
+			if (extracted.type !== void 0) {
+				changed = true;
+				if (type === void 0 || extracted.type === "integer") type = extracted.type;
+			}
+			if (Object.keys(extracted.schema).length > 0) members.push(extracted.schema);
+		}
+		if (changed) {
+			const { allOf: _, ...rest } = out;
+			out = members.length === 0 ? rest : {
+				...rest,
+				allOf: members
+			};
+		}
+	}
+	return {
+		type,
+		schema: out
+	};
+}
+function isJsonSchemaNumberEncoding(schema) {
+	if (!Array.isArray(schema.anyOf) || schema.anyOf.length !== 2 || schema.anyOf[0]?.type !== "number") return false;
+	const special = schema.anyOf[1];
+	return special?.type === "string" && Array.isArray(special.enum) && special.enum.length === 3 && special.enum.includes("NaN") && special.enum.includes("Infinity") && special.enum.includes("-Infinity");
+}
+const inlineableCheckKeywords = "|type|format|pattern|multipleOf|minimum|maximum|exclusiveMinimum|exclusiveMaximum|minLength|maxLength|minItems|maxItems|uniqueItems|minProperties|maxProperties|propertyNames|";
+function hasOnlyKeywords(schema, allowed) {
+	return Object.keys(schema).every((key) => allowed.includes(`|${key}|`));
+}
+function hasNoCollisions(left, rightKeys) {
+	return typeof left.$ref !== "string" && rightKeys.every((key) => !Object.hasOwn(left, key));
+}
+const promotableAnnotationKeywords = "|title|description|default|examples|readOnly|writeOnly|";
+const inlineableAnnotatedCheckKeywords = inlineableCheckKeywords + promotableAnnotationKeywords;
+function appendJsonSchema(left, right, inlineCheck) {
+	if (Object.keys(left).length === 0) return right;
+	const rightKeys = Object.keys(right);
+	if (rightKeys.length === 0) return left;
+	const leftType = left.type === "number" || left.type === "integer" ? left.type : void 0;
+	const isNumberEncoding = isJsonSchemaNumberEncoding(left);
+	if (leftType !== void 0 || isNumberEncoding) {
+		const extracted = extractJsonSchemaNumberType(right);
+		if (extracted.type !== void 0) {
+			const type = leftType === "integer" || extracted.type === "integer" ? "integer" : "number";
+			const base = {
+				...left,
+				type
+			};
+			if (isNumberEncoding) delete base.anyOf;
+			const extractedKeys = Object.keys(extracted.schema);
+			if (extractedKeys.length === 0) return base;
+			return hasOnlyKeywords(extracted.schema, promotableAnnotationKeywords) && hasNoCollisions(base, extractedKeys) ? {
+				...base,
+				...extracted.schema
+			} : appendJsonSchema(base, extracted.schema, inlineCheck);
+		}
+	}
+	if (inlineCheck && hasNoCollisions(left, rightKeys)) return {
+		...left,
+		...right
+	};
+	const members = Array.isArray(right.allOf) && rightKeys.length === 1 ? right.allOf : [right];
+	if (Array.isArray(left.allOf)) return {
+		...left,
+		allOf: [...left.allOf, ...members]
+	};
+	if (typeof left.$ref === "string") return { allOf: [left, ...members] };
+	return {
+		...left,
+		allOf: members
+	};
+}
+function isExact(exactness, seen = /* @__PURE__ */ new Set()) {
+	if (typeof exactness === "boolean") return exactness;
+	if (seen.has(exactness)) return true;
+	seen.add(exactness);
+	return exactness.every((dependency) => isExact(dependency, seen));
+}
+function isApproximateCheckOutput(output) {
+	return Array.isArray(output);
+}
+function compileJsonSchema(representations, rootPaths, references, options) {
+	const compiledDefinitions = /* @__PURE__ */ new Map();
+	const definitionAliases = /* @__PURE__ */ new Map();
+	const compiledRepresentations = /* @__PURE__ */ new WeakMap();
+	const pendingOneOf = /* @__PURE__ */ new Map();
+	const fallbackDefinitions = /* @__PURE__ */ new Map();
+	const referenceKeys = Object.keys(references);
+	for (const key of referenceKeys) compileDefinition(key, ["references", key]);
+	const compiledSchemas = map$8(representations, (representation, index) => recur(representation, rootPaths[index], []));
+	for (const [branches, schemas] of pendingOneOf.values()) if (!isExact(branches)) {
+		for (const schema of schemas) if (Array.isArray(schema.oneOf)) {
+			schema.anyOf = schema.oneOf;
+			delete schema.oneOf;
+		}
+	}
+	for (const key of referenceKeys) {
+		const representation = references[key];
+		const fallback = getIdentifierFallback(representation);
+		if (fallback === void 0) continue;
+		const schema = compiledDefinitions.get(key)[0];
+		const candidates = fallbackDefinitions.get(fallback);
+		const match = candidates?.find((candidate) => equals$1(compiledDefinitions.get(candidate)[0], schema));
+		if (match === void 0) {
+			if (candidates === void 0) fallbackDefinitions.set(fallback, [key]);
+			else candidates.push(key);
+		} else definitionAliases.set(key, match);
+	}
+	const schemas = map$8(compiledSchemas, finalizeJsonSchema);
+	const definitions = {};
+	for (const key of referenceKeys) if (!definitionAliases.has(key)) assignProperty(definitions, key, finalizeJsonSchema(compiledDefinitions.get(key)[0]));
+	return {
+		dialect: "draft-2020-12",
+		schemas,
+		definitions
+	};
+	function registerPendingOneOf(schema) {
+		if (Array.isArray(schema.oneOf)) pendingOneOf.get(schema.oneOf)?.[1].push(schema);
+		return schema;
+	}
+	function compileDefinition(key, path) {
+		if (!Object.hasOwn(references, key)) throw errorWithPath(`Invalid reference ${key}`, [...path, "$ref"]);
+		const cached = compiledDefinitions.get(key);
+		if (cached !== void 0) return cached;
+		const result = [{}, []];
+		compiledDefinitions.set(key, result);
+		result[0] = recur(references[key], ["references", key], result[1]);
+		return result;
+	}
+	function finalizeJsonSchema(schema) {
+		return rewriteRefs(schema, ($ref) => {
+			const pointer = decodeUriFragment($ref);
+			if (pointer === void 0) {
+				if (/^#(?:\/|%2f)/i.test($ref)) throw new Error(`Invalid JSON Pointer URI fragment ${JSON.stringify($ref)}`);
+				return $ref;
+			}
+			if (!pointer.startsWith("/$defs/")) return $ref;
+			const separator = pointer.indexOf("/", 7);
+			const canonical = definitionAliases.get(unescapeToken(pointer.slice(7, separator < 0 ? void 0 : separator)));
+			if (canonical === void 0) return $ref;
+			return $ref.replace(/^#(?:\/|%2f).*?(?:\/|%2f).*?(?=\/|%2f|$)/i, formatDefinitionReference(canonical));
+		});
+	}
+	function getIdentifierFallback(representation) {
+		if (representation._tag === "Reference") return void 0;
+		const annotations = representation.checks.length === 0 ? representation.annotations : representation.checks[representation.checks.length - 1].annotations;
+		return typeof annotations?.identifier !== "string" && typeof annotations?.["~identifier"] === "string" ? annotations[IDENTIFIER_FALLBACK_KEY] : void 0;
+	}
+	function compileCheck(check, type, path, dependencies) {
+		const annotations = check.annotations;
+		const callback = annotations?.toJsonSchema;
+		if (callback !== void 0) {
+			const result = callback({
+				type,
+				schemas: check.representation?.schemas?.map((schema, index) => recur(schema, [
+					...path,
+					"representation",
+					"schemas",
+					index
+				], dependencies)) ?? []
+			});
+			const approximate = isApproximateCheckOutput(result);
+			if (approximate) dependencies.push(false);
+			const fragment = approximate ? result[0] : result;
+			const ordinary = collectJsonSchemaAnnotations(annotations, options);
+			const schema = ordinary === void 0 ? fragment : {
+				...fragment,
+				...ordinary
+			};
+			const allowed = ordinary === void 0 ? inlineableCheckKeywords : inlineableAnnotatedCheckKeywords;
+			return [schema, check._tag === "Filter" && hasOnlyKeywords(schema, allowed) && (ordinary === void 0 || hasOnlyKeywords(ordinary, promotableAnnotationKeywords)) ? true : void 0];
+		}
+		if (check._tag === "Filter") {
+			dependencies.push(false);
+			return;
+		}
+		const schemas = check.checks.flatMap((child, index) => {
+			const result = compileCheck(child, type, [
+				...path,
+				"checks",
+				index
+			], dependencies);
+			return result === void 0 ? [] : [result[0]];
+		});
+		if (schemas.length === 0) return void 0;
+		const ordinary = collectJsonSchemaAnnotations(annotations, options);
+		const schema = { allOf: schemas };
+		return [ordinary === void 0 ? schema : {
+			...schema,
+			...ordinary
+		}];
+	}
+	function recur(representation, path, dependencies) {
+		if (representation._tag === "Reference") {
+			dependencies.push(compileDefinition(representation.$ref, path)[1]);
+			return { $ref: formatDefinitionReference(representation.$ref) };
+		}
+		const cached = compiledRepresentations.get(representation);
+		if (cached !== void 0) {
+			dependencies.push(cached[1]);
+			return cached[0];
+		}
+		const local = [];
+		dependencies.push(local);
+		let output = on(representation, path, local);
+		const ordinary = collectJsonSchemaAnnotations(representation.annotations, options);
+		if (ordinary !== void 0) output = {
+			...output,
+			...ordinary
+		};
+		for (let index = 0; index < representation.checks.length; index++) {
+			const type = typeof output.type === "string" && isJsonSchemaType(output.type) ? output.type : void 0;
+			const check = compileCheck(representation.checks[index], type, [
+				...path,
+				"checks",
+				index
+			], local);
+			if (check !== void 0) output = appendJsonSchema(output, ...check);
+		}
+		compiledRepresentations.set(representation, [output, local]);
+		return registerPendingOneOf(output);
+	}
+	function on(representation, path, dependencies) {
+		switch (representation._tag) {
+			case "Any":
+			case "Unknown": return {};
+			case "ObjectKeyword": return { anyOf: [{ type: "object" }, { type: "array" }] };
+			case "Void":
+			case "Undefined":
+			case "Null": return { type: "null" };
+			case "BigInt": return {
+				type: "string",
+				allOf: [{ pattern: "^-?\\d+$" }]
+			};
+			case "Symbol": return {
+				type: "string",
+				allOf: [{ pattern: "^Symbol\\(([\\s\\S]*)\\)$" }]
+			};
+			case "UniqueSymbol": return globalThis.Symbol.keyFor(representation.symbol) === void 0 ? { not: {} } : {
+				type: "string",
+				enum: [globalThis.String(representation.symbol)]
+			};
+			case "Declaration":
+				dependencies.push(false);
+				return {};
+			case "Suspend": return recur(representation.thunk, [...path, "thunk"], dependencies);
+			case "Never": return { not: {} };
+			case "String": return { type: "string" };
+			case "Number": return { anyOf: [{ type: "number" }, {
+				type: "string",
+				enum: [
+					"NaN",
+					"Infinity",
+					"-Infinity"
+				]
+			}] };
+			case "Boolean": return { type: "boolean" };
+			case "Literal": {
+				const literal = representation.literal;
+				return typeof literal === "bigint" ? {
+					type: "string",
+					enum: [globalThis.String(literal)]
+				} : {
+					type: typeof literal,
+					enum: [literal]
+				};
+			}
+			case "Enum": {
+				const types = representation.enums.map(([title, literal], index) => {
+					if (typeof literal === "number" && !globalThis.Number.isFinite(literal)) throw errorWithPath(`Invalid numeric enum value ${globalThis.String(literal)}`, [
+						...path,
+						"enums",
+						index,
+						1
+					]);
+					return {
+						type: typeof literal,
+						enum: [literal],
+						title
+					};
+				});
+				return types.length === 0 ? { not: {} } : { anyOf: types };
+			}
+			case "TemplateLiteral": return {
+				type: "string",
+				pattern: `^${representation.parts.map(getPartPattern).join("")}$`
+			};
+			case "Arrays": {
+				if (representation.rest.length > 1) throw errorWithPath("Invalid schema representation document", [...path, "rest"]);
+				const out = { type: "array" };
+				let minItems = representation.elements.length;
+				const prefixItems = representation.elements.map((element, index) => {
+					if (element.isOptional) minItems--;
+					const schema = recur(element.type, [
+						...path,
+						"elements",
+						index,
+						"type"
+					], dependencies);
+					const annotations = collectJsonSchemaAnnotations(element.annotations, options);
+					return annotations === void 0 ? schema : registerPendingOneOf(appendJsonSchema(schema, annotations));
+				});
+				if (prefixItems.length > 0) {
+					out.prefixItems = prefixItems;
+					out.maxItems = representation.elements.length;
+					if (minItems > 0) out.minItems = minItems;
+				} else out.items = false;
+				if (representation.rest.length === 1) {
+					delete out.maxItems;
+					const rest = recur(representation.rest[0], [
+						...path,
+						"rest",
+						0
+					], dependencies);
+					if (Object.keys(rest).length > 0) out.items = rest;
+					else delete out.items;
+				}
+				return out;
+			}
+			case "Objects": {
+				if (representation.propertySignatures.length === 0 && representation.indexSignatures.length === 0) return { not: { type: "null" } };
+				const out = { type: "object" };
+				const properties = {};
+				const required = [];
+				for (let index = 0; index < representation.propertySignatures.length; index++) {
+					const property = representation.propertySignatures[index];
+					if (typeof property.name !== "string") throw errorWithPath("Invalid schema representation document", [
+						...path,
+						"propertySignatures",
+						index,
+						"name"
+					]);
+					const name = property.name;
+					const schema = recur(property.type, [
+						...path,
+						"propertySignatures",
+						index,
+						"type"
+					], dependencies);
+					const annotations = collectJsonSchemaAnnotations(property.annotations, options);
+					assignProperty(properties, name, annotations === void 0 ? schema : registerPendingOneOf(appendJsonSchema(schema, annotations)));
+					if (!property.isOptional) required.push(name);
+				}
+				if (representation.propertySignatures.length > 0) out.properties = properties;
+				if (required.length > 0) out.required = required;
+				const patternProperties = {};
+				const additionalPropertySchemas = [];
+				const indexValueSchemas = [];
+				let hasUnrepresentableIndexPattern = false;
+				for (let index = 0; index < representation.indexSignatures.length; index++) {
+					const signature = representation.indexSignatures[index];
+					let type = recur(signature.type, [
+						...path,
+						"indexSignatures",
+						index,
+						"type"
+					], dependencies);
+					if (equals$1(type, { not: {} })) type = false;
+					indexValueSchemas.push(type);
+					const patterns = getParameterPatterns(signature.parameter, [
+						...path,
+						"indexSignatures",
+						index,
+						"parameter"
+					], /* @__PURE__ */ new Set());
+					if (patterns === void 0) {
+						hasUnrepresentableIndexPattern = true;
+						dependencies.push(false);
+						continue;
+					}
+					if (patterns.length === 0) additionalPropertySchemas.push(type);
+					else for (const pattern of patterns) {
+						const previous = patternProperties[pattern];
+						assignProperty(patternProperties, pattern, previous === void 0 ? type : previous === false || type === false ? false : registerPendingOneOf(appendJsonSchema(previous, type)));
+					}
+				}
+				const hasPatternProperties = Object.keys(patternProperties).length > 0;
+				if (hasPatternProperties) out.patternProperties = patternProperties;
+				if (hasUnrepresentableIndexPattern && options?.onExcessProperty === "error") {
+					const propertyNames = [];
+					if (representation.propertySignatures.length > 0) propertyNames.push({ enum: Object.keys(properties) });
+					for (let index = 0; index < representation.indexSignatures.length; index++) propertyNames.push(recur(representation.indexSignatures[index].parameter, [
+						...path,
+						"indexSignatures",
+						index,
+						"parameter"
+					], dependencies));
+					out.propertyNames = propertyNames.length === 1 ? propertyNames[0] : { anyOf: propertyNames };
+					out.additionalProperties = indexValueSchemas.length === 1 ? indexValueSchemas[0] : { anyOf: indexValueSchemas };
+					if (additionalPropertySchemas.length > 0) out.allOf = additionalPropertySchemas.map((type) => ({
+						type: "object",
+						additionalProperties: type
+					}));
+				} else if (additionalPropertySchemas.length === 0) out.additionalProperties = hasUnrepresentableIndexPattern || options?.onExcessProperty !== "error";
+				else if (additionalPropertySchemas.length === 1 && representation.propertySignatures.length === 0 && !hasPatternProperties) out.additionalProperties = additionalPropertySchemas[0];
+				else if (additionalPropertySchemas.length > 0) out.allOf = additionalPropertySchemas.map((type) => ({
+					type: "object",
+					additionalProperties: type
+				}));
+				if (typeof out.additionalProperties === "object" && out.additionalProperties !== null && Object.keys(out.additionalProperties).length === 0) delete out.additionalProperties;
+				return out;
+			}
+			case "Union": {
+				const branches = [];
+				const types = representation.types.map((type, index) => recur(type, [
+					...path,
+					"types",
+					index
+				], branches));
+				dependencies.push(branches);
+				if (types.length === 0) return { not: {} };
+				const mode = representation.options?.mode ?? "anyOf";
+				if (mode === "anyOf" && types.length > 1) {
+					const compacted = compactEnums(types);
+					if (compacted !== void 0) return compacted;
+				}
+				if (mode === "oneOf") pendingOneOf.set(types, [branches, []]);
+				return { [mode]: types };
+			}
+		}
+	}
+	function getParameterPatterns(parameter, path, seenReferences) {
+		switch (parameter._tag) {
+			case "Reference": {
+				if (!Object.hasOwn(references, parameter.$ref)) throw errorWithPath(`Invalid reference ${parameter.$ref}`, [...path, "$ref"]);
+				compileDefinition(parameter.$ref, path);
+				if (seenReferences.has(parameter.$ref)) return void 0;
+				const next = new Set(seenReferences).add(parameter.$ref);
+				return getParameterPatterns(references[parameter.$ref], ["references", parameter.$ref], next);
+			}
+			case "String": {
+				if (parameter.checks.length === 0) return [];
+				if (parameter.checks.length !== 1 || parameter.checks[0]._tag !== "Filter" || parameter.checks[0].annotations?.toJsonSchema === void 0) return;
+				const dependencies = [];
+				const schema = recur(parameter, path, dependencies);
+				if (!isExact(dependencies)) return void 0;
+				return schema.type === "string" && typeof schema.pattern === "string" && hasOnlyKeywords(schema, "|type|pattern|title|description|default|examples|readOnly|writeOnly|") ? [schema.pattern] : void 0;
+			}
+			case "TemplateLiteral": return parameter.checks.length === 0 ? [`^${parameter.parts.map(getPartPattern).join("")}$`] : void 0;
+			case "Union": {
+				if (parameter.types.length === 0 || parameter.checks.length > 0 || parameter.options?.mode === "oneOf") return;
+				const patterns = [];
+				for (let index = 0; index < parameter.types.length; index++) {
+					const memberPatterns = getParameterPatterns(parameter.types[index], [
+						...path,
+						"types",
+						index
+					], seenReferences);
+					if (memberPatterns === void 0) return void 0;
+					if (memberPatterns.length === 0) return [];
+					patterns.push(...memberPatterns);
+				}
+				return patterns;
+			}
+			default: throw errorWithPath("Invalid schema representation document", path);
+		}
+	}
+}
+function isJsonSchemaType(input) {
+	return input === "string" || input === "number" || input === "boolean" || input === "array" || input === "object" || input === "null" || input === "integer";
+}
+function compactEnums(schemas) {
+	let sharedType = void 0;
+	const values = [];
+	for (const schema of schemas) {
+		if (Object.keys(schema).length !== 2 || schema.type === void 0 || !Array.isArray(schema.enum) || schema.enum.length === 0) return;
+		if (sharedType === void 0) sharedType = schema.type;
+		else if (schema.type !== sharedType) return void 0;
+		for (const value of schema.enum) {
+			if (values.includes(value)) return void 0;
+			values.push(value);
+		}
+	}
+	return {
+		type: sharedType,
+		enum: values
+	};
+}
+function getPartPattern(part) {
+	switch (part._tag) {
+		case "Literal": return escape(globalThis.String(part.literal));
+		case "String": return STRING_PATTERN;
+		case "Number": return FINITE_PATTERN;
+		case "TemplateLiteral": return part.parts.map(getPartPattern).join("");
+		case "Union": return `(?:${part.types.map(getPartPattern).join("|")})`;
+		default: throw errorWithPath("Invalid schema representation document", []);
+	}
+}
+/** @internal */
+function toJsonSchemaDocument$1(document, options) {
+	const output = compileJsonSchema([document.representation], [["representation"]], document.references, options);
+	return {
+		dialect: output.dialect,
+		schema: output.schemas[0],
+		definitions: output.definitions
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/internal/schema/toRepresentation.js
+const defaultReferencePolicy = ({ identifier }) => identifier;
+function annotationsField(annotations) {
+	return annotations === void 0 ? void 0 : { annotations };
+}
+/** @internal */
+function toRepresentation(ast, options) {
+	const { references, representations } = toRepresentations([ast], options);
+	return {
+		representation: representations[0],
+		references
+	};
+}
+/** @internal */
+function toRepresentations(asts, options) {
+	const references = {};
+	const referenceOwners = /* @__PURE__ */ new Map();
+	const buildingReferences = /* @__PURE__ */ new Set();
+	const candidates = /* @__PURE__ */ new Map();
+	const visitingCandidates = /* @__PURE__ */ new Set();
+	for (const ast of asts) visit(ast);
+	const referencePolicy = options?.referencePolicy ?? defaultReferencePolicy;
+	for (const candidatesByIdentifier of candidates.values()) for (const candidate of candidatesByIdentifier.values()) {
+		const requestedReference = referencePolicy({
+			ast: candidate.ast,
+			occurrences: candidate.occurrences,
+			identifier: candidate.identifier
+		});
+		if (requestedReference !== void 0) candidate.reference = getReference(requestedReference, candidate, requestedReference === candidate.identifier || !requestedReference.endsWith("_") ? "_" : "");
+		else if (candidate.isRecursive) candidate.reference = getReference(`${candidate.ast._tag}_`, candidate, "");
+	}
+	return {
+		representations: map$8(asts, (ast) => recur(ast)),
+		references
+	};
+	function getReference(prefix, owner, separator = "_") {
+		let candidate = prefix;
+		let suffix = 0;
+		while (referenceOwners.has(candidate)) {
+			if (referenceOwners.get(candidate) === owner) return candidate;
+			candidate = `${prefix}${separator}${++suffix}`;
+		}
+		referenceOwners.set(candidate, owner);
+		return candidate;
+	}
+	function annotateReference(ast, candidate, reference) {
+		const fallback = candidate.fallback;
+		if (fallback !== void 0) return resolveIdentifierFallback(ast) === fallback ? ast : annotate$1(ast, { [IDENTIFIER_FALLBACK_KEY]: fallback });
+		return reference === candidate.identifier ? ast : annotate$1(ast, { identifier: reference });
+	}
+	function makeReference(reference, ast) {
+		if (!Object.hasOwn(references, reference) && !buildingReferences.has(reference)) {
+			buildingReferences.add(reference);
+			const representation = on(ast);
+			buildingReferences.delete(reference);
+			assignProperty(references, reference, representation);
+		}
+		return {
+			_tag: "Reference",
+			$ref: reference
+		};
+	}
+	function getCandidate(input) {
+		const ast = getLastEncoding(input);
+		const owner = getContextOwner(ast);
+		let identifier = resolveIdentifier(ast);
+		const fallback = identifier === void 0 ? (ast !== input ? resolveIdentifier(input) : void 0) ?? resolveIdentifierFallback(ast) : void 0;
+		if (fallback !== void 0) identifier = `${fallback}Encoded`;
+		let candidatesByIdentifier = candidates.get(owner);
+		if (candidatesByIdentifier === void 0) {
+			candidatesByIdentifier = /* @__PURE__ */ new Map();
+			candidates.set(owner, candidatesByIdentifier);
+		}
+		let candidate = candidatesByIdentifier.get(identifier);
+		if (candidate === void 0) {
+			candidate = {
+				ast: owner,
+				identifier,
+				fallback,
+				occurrences: 0,
+				isRecursive: false,
+				reference: void 0
+			};
+			candidatesByIdentifier.set(identifier, candidate);
+		}
+		return candidate;
+	}
+	function visit(input) {
+		const candidate = getCandidate(input);
+		const ast = candidate.ast;
+		candidate.occurrences++;
+		if (visitingCandidates.has(candidate)) {
+			candidate.isRecursive = true;
+			return;
+		}
+		if (candidate.occurrences > 1) return;
+		visitingCandidates.add(candidate);
+		visitChecks(ast.checks);
+		switch (ast._tag) {
+			case "Declaration":
+			case "Arrays":
+			case "Objects":
+			case "Union":
+				ast.recur((child) => {
+					visit(child);
+					return child;
+				});
+				break;
+			case "TemplateLiteral":
+				ast.parts.forEach(visit);
+				break;
+			case "Suspend": visit(ast.thunk());
+		}
+		visitingCandidates.delete(candidate);
+	}
+	function visitChecks(checks) {
+		checks?.forEach((check) => {
+			check.annotations?.representation?.schemas?.forEach((schema) => visit(toType(schema)));
+			if (check._tag === "FilterGroup") visitChecks(check.checks);
+		});
+	}
+	function recur(input) {
+		const candidate = getCandidate(input);
+		const ast = candidate.ast;
+		const reference = candidate.reference;
+		if (reference !== void 0) return makeReference(reference, candidate.identifier === void 0 ? ast : annotateReference(ast, candidate, reference));
+		return on(ast);
+	}
+	function on(ast) {
+		const checks = fromChecks(ast.checks);
+		switch (ast._tag) {
+			case "Declaration": return {
+				_tag: "Declaration",
+				typeParameters: ast.typeParameters.map((ast) => recur(ast)),
+				checks,
+				...fromDeclarationAnnotations(ast.annotations)
+			};
+			case "Null":
+			case "Undefined":
+			case "Void":
+			case "Never":
+			case "Unknown":
+			case "Any":
+			case "String":
+			case "Boolean":
+			case "Number":
+			case "BigInt":
+			case "Symbol":
+			case "ObjectKeyword": return {
+				_tag: ast._tag,
+				checks,
+				...annotationsField(ast.annotations)
+			};
+			case "Literal": return {
+				_tag: "Literal",
+				literal: ast.literal,
+				checks,
+				...annotationsField(ast.annotations)
+			};
+			case "UniqueSymbol": return {
+				_tag: "UniqueSymbol",
+				symbol: ast.symbol,
+				checks,
+				...annotationsField(ast.annotations)
+			};
+			case "Enum": return {
+				_tag: "Enum",
+				enums: ast.enums,
+				checks,
+				...annotationsField(ast.annotations)
+			};
+			case "TemplateLiteral": return {
+				_tag: "TemplateLiteral",
+				parts: ast.parts.map((ast) => recur(ast)),
+				checks,
+				...annotationsField(ast.annotations)
+			};
+			case "Arrays": return {
+				_tag: "Arrays",
+				elements: ast.elements.map((element) => {
+					const projected = getLastEncoding(element);
+					const annotations = projected.context?.annotations;
+					return {
+						isOptional: isOptional(projected),
+						type: recur(element),
+						...annotationsField(annotations)
+					};
+				}),
+				rest: ast.rest.map((ast) => recur(ast)),
+				checks,
+				...annotationsField(ast.annotations)
+			};
+			case "Objects": return {
+				_tag: "Objects",
+				propertySignatures: ast.propertySignatures.map((property) => {
+					const projected = getLastEncoding(property.type);
+					const annotations = projected.context?.annotations;
+					return {
+						name: property.name,
+						type: recur(property.type),
+						isOptional: isOptional(projected),
+						isMutable: isMutable(projected),
+						...annotationsField(annotations)
+					};
+				}),
+				indexSignatures: ast.indexSignatures.map((index) => ({
+					parameter: recur(index.parameter),
+					type: recur(index.type)
+				})),
+				checks,
+				...annotationsField(ast.annotations)
+			};
+			case "Union": return {
+				_tag: "Union",
+				types: ast.types.map((ast) => recur(ast)),
+				...ast.options === void 0 ? {} : { options: ast.options },
+				checks,
+				...annotationsField(ast.annotations)
+			};
+			case "Suspend": return {
+				_tag: "Suspend",
+				checks: [],
+				thunk: recur(ast.thunk()),
+				...annotationsField(ast.annotations)
+			};
+		}
+	}
+	function fromChecks(checks) {
+		return checks?.map(fromCheck) ?? [];
+	}
+	function fromCheck(check) {
+		switch (check._tag) {
+			case "Filter": return {
+				_tag: "Filter",
+				aborted: check.aborted,
+				...fromCheckAnnotations(check.annotations)
+			};
+			case "FilterGroup": return {
+				_tag: "FilterGroup",
+				checks: map$8(check.checks, fromCheck),
+				...fromCheckAnnotations(check.annotations)
+			};
+		}
+	}
+	function fromDeclarationAnnotations(annotations) {
+		if (annotations === void 0) return void 0;
+		const { representation, ...ordinary } = annotations;
+		return {
+			...representation === void 0 ? void 0 : { representation },
+			...Object.keys(ordinary).length === 0 ? void 0 : { annotations: ordinary }
+		};
+	}
+	function fromCheckAnnotations(annotations) {
+		if (annotations === void 0) return void 0;
+		const { representation, ...ordinary } = annotations;
+		const projected = representation === void 0 ? void 0 : representation.schemas === void 0 ? representation : {
+			...representation,
+			schemas: representation.schemas.map((schema) => recur(toType(schema)))
+		};
+		return {
+			...projected === void 0 ? void 0 : { representation: projected },
+			...Object.keys(ordinary).length === 0 ? void 0 : { annotations: ordinary }
+		};
+	}
+}
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/Struct.js
 /**
@@ -23599,6 +24818,81 @@ const TaggedError = (identifier) => {
 	};
 };
 /**
+* Returns a JSON Schema document using draft 2020-12.
+*
+* **When to use**
+*
+* Use when you need a draft-2020-12 description of the canonical JSON form of a runtime schema.
+*
+* **Details**
+*
+* The document describes the encoded side of `Schema.toCodecJson(schema)`.
+* Use that codec to decode JSON inputs. For example, it decodes JSON `null`
+* to JavaScript `undefined` for a field defined with `Schema.optional(Schema.String)`.
+* Decoding the same input with the original schema rejects `null`.
+*
+* The `options` parameter controls reference extraction and generation details
+* such as excess properties and synthesized check descriptions; it does not
+* change the draft target. The reference policy receives canonical JSON
+* encoded ASTs. By default, anonymous non-recursive candidates remain inline,
+* while candidates with resolved identifiers become definitions. Declarations
+* are lowered through their `toCodecJson` or `toCodec` annotation when
+* available before the representation document is compiled.
+*
+* The generated document is intended for preliminary validation. JSON Schema
+* and Effect checks do not always have identical semantics, so the Effect
+* decoder remains the final authority. Passing JSON Schema validation does not
+* guarantee that Effect decoding will succeed.
+*
+* **Gotchas**
+*
+* JSON Schema generation is best-effort. String length uses Unicode code points
+* in JSON Schema and UTF-16 code units in Effect. A generated `pattern` cannot
+* retain JavaScript RegExp flags. Object property checks apply to the original
+* input in JSON Schema but to the decoded object in Effect. When a `oneOf`
+* branch contains a known approximation, the compiler emits `anyOf` so that
+* the approximation cannot create a false rejection. Unions with only exact
+* branches retain `oneOf`. Custom `toJsonSchema` callbacks return `[schema, true]` for safe,
+* looser approximations and are responsible for the semantics they declare. When
+* canonical JSON derivation adds an artificial transformation, checks and
+* annotations on its source node are not copied to the JSON target, so they do
+* not appear in the emitted document. Opaque declarations without a structural
+* codec are represented by an unconstrained JSON Schema. The default
+* `onExcessProperty: "ignore"` matches the decoder default and leaves
+* index-signature keys without exact selectors open. In `"error"` mode, the compiler
+* constrains those keys with `propertyNames` and applies a permissive choice of
+* candidate index value schemas. The Effect decoder enforces the exact
+* key-value association.
+*
+* **Example** (Decoding JSON with the matching codec)
+*
+* ```ts import.meta.vitest
+* import { Schema } from "effect"
+*
+* const schema = Schema.Struct({
+*   name: Schema.optional(Schema.String)
+* })
+*
+* const document = Schema.toJsonSchemaDocument(schema)
+* const jsonCodec = Schema.toCodecJson(schema)
+*
+* Schema.decodeUnknownResult(schema)({ name: null })._tag // => "Failure"
+* Schema.decodeUnknownSync(jsonCodec)({ name: null }) // => { name: undefined }
+* Schema.decodeUnknownSync(jsonCodec)({}) // => {}
+* Schema.encodeSync(jsonCodec)({ name: undefined }) // => { name: null }
+* ```
+*
+* @see {@link toCodecJson} for decoding and encoding the canonical JSON representation
+* @see {@link SchemaRepresentation.toJsonSchemaDocument} for compiling an existing live representation document
+*
+* @stability stable
+* @category converting
+* @since 4.0.0
+*/
+function toJsonSchemaDocument(schema, options) {
+	return toJsonSchemaDocument$1(toRepresentation(toCodecJsonAST(schema.ast), options), options);
+}
+/**
 * Converts a schema to the StringTree canonical codec, where every leaf value
 * becomes a string while preserving the original structure.
 *
@@ -30390,7 +31684,7 @@ const runWith = (command, config) => {
 };
 //#endregion
 //#region package.json
-var version = "0.1.0";
+var version = "0.2.0";
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/Ref.js
 /**
@@ -33269,14 +34563,35 @@ const VpSection = Struct({
 const MachineSettings = Struct({ clones: optionalKey(NonEmptyString) });
 const FleetConfig = Struct({
 	$schema: optionalKey(String$5),
-	machines: optionalKey(Record(NonEmptyString, MachineSettings)),
+	shippedAt: optionalKey(String$5),
+	shippedFrom: optionalKey(NonEmptyString),
+	shippedTo: optionalKey(Record(NonEmptyString, String$5)),
+	machines: Record(NonEmptyString, MachineSettings).check(makeFilter((machines) => Object.keys(machines).length > 0, {
+		title: "Fleet",
+		description: "at least one Machine"
+	})),
 	repos: optionalKey(ArraySchema(TrackedRepo)),
 	vp: optionalKey(VpSection)
 });
 const repoName = (repo) => repo.name ?? repo.origin.replace("/", "-");
+const SELF_PACKAGE = "fleetfizz";
+//#endregion
+//#region ../../packages/config/src/jsonSchema.ts
+const fleetConfigJsonSchema = () => {
+	const document = toJsonSchemaDocument(FleetConfig, { onExcessProperty: "error" });
+	return {
+		$schema: META_SCHEMA_URI_DRAFT_2020_12,
+		title: "fleetfizz config",
+		...document.schema,
+		$defs: document.definitions
+	};
+};
 //#endregion
 //#region ../../packages/config/src/load.ts
 const CONFIG_FILE = "fleet.config.jsonc";
+const SCHEMA_FILE = "fleet.schema.json";
+const configDir = (env) => `${env.XDG_CONFIG_HOME || `${env.HOME ?? "~"}/.config`}/fleetfizz`;
+const configPath = (env) => `${configDir(env)}/${CONFIG_FILE}`;
 var ConfigError = class extends TaggedError()("ConfigError", {
 	path: String$5,
 	problems: ArraySchema(String$5)
@@ -33285,23 +34600,11 @@ var ConfigError = class extends TaggedError()("ConfigError", {
 		return [`${this.path}:`, ...this.problems.map((p) => `  ${p}`)].join("\n");
 	}
 };
-var ConfigNotFound = class extends TaggedError()("ConfigNotFound", { start: String$5 }) {
+var ConfigNotFound = class extends TaggedError()("ConfigNotFound", { path: String$5 }) {
 	get message() {
-		return `no ${CONFIG_FILE} found in ${this.start} or any parent directory`;
+		return `no config at ${this.path}; write one there (the README has an example) or pass --config`;
 	}
 };
-const findConfig = fn("findConfig")(function* (start) {
-	const fs = yield* FileSystem;
-	const path = yield* Path$1;
-	let dir = path.resolve(start);
-	for (;;) {
-		const candidate = path.join(dir, CONFIG_FILE);
-		if (yield* fs.exists(candidate)) return candidate;
-		const parent = path.dirname(dir);
-		if (parent === dir) return yield* new ConfigNotFound({ start });
-		dir = parent;
-	}
-});
 const lineOf = (text, offset) => text.slice(0, offset).split("\n").length;
 const semanticProblems = (config) => {
 	const problems = [];
@@ -33311,6 +34614,7 @@ const semanticProblems = (config) => {
 		if (seen.has(name)) problems.push(`repos: duplicate name "${name}"`);
 		seen.add(name);
 	}
+	if (config.vp?.globals?.["fleetfizz"] !== void 0) problems.push(`vp.globals: ${SELF_PACKAGE} is pinned by the running version; remove it`);
 	return problems;
 };
 const parseConfig = fn("parseConfig")(function* (path, text) {
@@ -33333,10 +34637,48 @@ const parseConfig = fn("parseConfig")(function* (path, text) {
 });
 const formatIssue = makeFormatterDefault();
 const loadConfig = fn("loadConfig")(function* (path) {
-	const text = yield* (yield* FileSystem).readFileString(path);
+	const fs = yield* FileSystem;
+	if (!(yield* fs.exists(path))) return yield* new ConfigNotFound({ path });
+	const text = yield* fs.readFileString(path);
 	return yield* parseConfig(path, text);
 });
 //#endregion
+//#region ../../packages/config/src/stamp.ts
+const insertAfter = (before) => (properties) => {
+	return before.map((key) => properties.indexOf(key)).reduce((a, b) => Math.max(a, b), -1) + 1;
+};
+const STAMP_KEYS = [
+	"$schema",
+	"shippedAt",
+	"shippedFrom",
+	"shippedTo"
+];
+const stampText = (text, stamp) => {
+	const options = { formattingOptions: {
+		insertSpaces: true,
+		tabSize: 2
+	} };
+	const set = (current, key, value) => applyEdits(current, modify(current, [key], value, {
+		...options,
+		getInsertionIndex: insertAfter(STAMP_KEYS.slice(0, STAMP_KEYS.indexOf(key)))
+	}));
+	const previous = parse(text, void 0, { allowTrailingComma: true });
+	const shippedTo = {
+		...shippedToOf(previous),
+		...Object.fromEntries(stamp.reached.map((name) => [name, stamp.shippedAt]))
+	};
+	let out = set(text, "shippedAt", stamp.shippedAt);
+	out = set(out, "shippedFrom", stamp.shippedFrom);
+	return set(out, "shippedTo", shippedTo);
+};
+const shippedToOf = (config) => {
+	if (typeof config !== "object" || config === null || !("shippedTo" in config)) return {};
+	const value = config.shippedTo;
+	if (typeof value !== "object" || value === null) return {};
+	return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+};
+const isNewer = (remote, local) => remote !== void 0 && (local === void 0 || remote > local);
+//#endregion
 //#region ../../packages/core/src/range.ts
 const newest$1 = (available) => available.filter((v) => import_semver.prerelease(v) === null).sort(import_semver.rcompare)[0];
 const decideRange = (range, installed, available) => {
@@ -33417,17 +34759,12 @@ const planVp = (input) => {
 		skipped: [],
 		failures: []
 	};
-	const vp = input.config.vp;
-	if (vp === void 0 || !targets(vp, input.machine)) return out;
 	const { state, machine } = input;
-	if (state.vp === void 0 || state.vp.version === null) {
-		out.failures.push({
-			what: "vp",
-			reason: "vp is not installed (not on PATH in a login shell)"
-		});
-		return out;
-	}
-	const installed = state.vp.version;
+	const vp = input.config.vp;
+	const targeted = vp !== void 0 && targets(vp, machine);
+	const missing = state.vp === void 0 || state.vp.version === null;
+	if (missing) out.steps.push({ kind: "bootstrap" });
+	const installed = missing ? void 0 : state.vp?.version ?? void 0;
 	const decide = (pkg, range, current, shown = pkg) => {
 		if (range === void 0) return void 0;
 		const decision = decideRange(range, current, input.versions[pkg] ?? []);
@@ -33468,31 +34805,35 @@ const planVp = (input) => {
 			}
 		}
 	};
-	const vpTarget = decide(VP_PACKAGE, vp.version, installed, "vp");
-	if (vpTarget !== void 0) {
-		if (isHomebrew(state.vp.path)) out.failures.push({
-			what: "vp",
-			reason: `vp ${installed} was installed with Homebrew; run brew upgrade vite-plus to get ${vpTarget}`
-		});
-		else out.steps.push({
-			kind: "vp",
-			from: installed,
-			version: vpTarget
+	const nodeNow = missing ? void 0 : state.node ?? void 0;
+	let nodeTarget;
+	if (targeted) {
+		const vpTarget = decide(VP_PACKAGE, vp.version, installed, "vp");
+		if (vpTarget !== void 0) {
+			if (isHomebrew(state.vp?.path)) out.failures.push({
+				what: "vp",
+				reason: `vp ${installed} was installed with Homebrew; run brew upgrade vite-plus to get ${vpTarget}`
+			});
+			else out.steps.push({
+				kind: "vp",
+				from: installed ?? null,
+				version: vpTarget
+			});
+		}
+		nodeTarget = decide(NODE_PACKAGE, vp.node, nodeNow, "node");
+		if (nodeTarget !== void 0) out.steps.push({
+			kind: "node",
+			from: nodeNow ?? null,
+			version: nodeTarget
 		});
 	}
-	const nodeNow = state.node ?? void 0;
-	const nodeTarget = decide(NODE_PACKAGE, vp.node, nodeNow, "node");
-	if (nodeTarget !== void 0) out.steps.push({
-		kind: "node",
-		from: nodeNow ?? null,
-		version: nodeTarget
-	});
 	const nodeDefault = nodeTarget ?? nodeNow;
-	const byName = new Map(state.globals.map((g) => [g.name, g]));
+	const byName = new Map((missing ? [] : state.globals).map((g) => [g.name, g]));
 	const installs = [];
-	for (const [name, range] of Object.entries(vp.globals ?? {})) {
+	const wanted = Object.entries(targeted ? vp.globals ?? {} : {});
+	for (const [name, range] of [...wanted, [SELF_PACKAGE, input.self]]) {
 		const current = byName.get(name);
-		const version = decide(name, range, current?.version);
+		const version = name === "fleetfizz" ? decideSelf(current?.version, input.self, out) : decide(name, range, current?.version);
 		if (version !== void 0) installs.push(current === void 0 ? {
 			name,
 			version
@@ -33513,6 +34854,13 @@ const planVp = (input) => {
 	});
 	return out;
 };
+const decideSelf = (installed, self, out) => {
+	if (installed === void 0 || import_semver.lt(installed, self)) return self;
+	if (import_semver.gt(installed, self)) out.failures.push({
+		what: SELF_PACKAGE,
+		reason: `runs ${SELF_PACKAGE} ${installed}, newer than this ${self}; upgrade here first`
+	});
+};
 const planRepos = (input) => {
 	const repos = [];
 	const failures = [];
@@ -33631,6 +34979,11 @@ const Fact = Union([
 		name: String$5,
 		record: InstallRecordSchema
 	}),
+	Struct({
+		fact: Literal("config"),
+		present: Boolean$4,
+		base64: optionalKey(String$5)
+	}),
 	Struct({
 		fact: Literal("output"),
 		repo: String$5,
@@ -33645,6 +34998,7 @@ const emptyState = {
 	records: {},
 	outputs: {}
 };
+const decodeBase64 = (base64) => new TextDecoder().decode(Uint8Array.from(atob(base64), (c) => c.charCodeAt(0)));
 const assembleState = (facts) => {
 	let state = emptyState;
 	for (const fact of facts) switch (fact.fact) {
@@ -33714,6 +35068,12 @@ const assembleState = (facts) => {
 				}
 			};
 			break;
+		case "config":
+			if (fact.present && fact.base64 !== void 0) state = {
+				...state,
+				config: decodeBase64(fact.base64)
+			};
+			break;
 		case "output": state = {
 			...state,
 			outputs: {
@@ -33745,6 +35105,7 @@ const fingerprintFn = [
 	"}"
 ].join("\n");
 const RECORDS_DIR = `~/.local/state/fleetfizz/records`;
+const CONFIG_DIR_SH = "\"${XDG_CONFIG_HOME:-$HOME/.config}/fleetfizz\"";
 const gatherScript = (input) => {
 	const lines = [
 		prelude,
@@ -33773,6 +35134,7 @@ const gatherScript = (input) => {
 		const name = quote(repo.name);
 		lines.push(`ff_r=${quotePath(RECORDS_DIR)}/${quote(`${repo.name}.json`)}`, `if [ -f "$ff_r" ]; then ff_state "{\\"fact\\":\\"record\\",\\"name\\":\\"$(ff_json ${name})\\",\\"record\\":$(tr -d '\\n' < "$ff_r")}"; fi`);
 	}
+	lines.push(`ff_c=${CONFIG_DIR_SH}/${quote(CONFIG_FILE)}`, `if [ -f "$ff_c" ]; then ff_state "{\\"fact\\":\\"config\\",\\"present\\":true,\\"base64\\":\\"$(base64 < "$ff_c" | tr -d '\\n')\\"}"; else ff_state '{"fact":"config","present":false}'; fi`);
 	lines.push(`ff_state '{"fact":"end"}'`);
 	return lines.join("\n");
 };
@@ -33823,10 +35185,19 @@ const jsonString = encodeSync(fromJsonString(String$5));
 const jsonRecord = encodeSync(fromJsonString(Record(String$5, String$5)));
 const stepId = (repo, step) => `repo:${repo}:${step}`;
 const vpStepId = (step) => step.kind === "reinstall" ? `vp:reinstall:${step.name}` : step.kind === "globals" ? "vp:globals" : `vp:${step.kind}`;
+const CONFIG_STEP = "config";
+const VP_INSTALL = [
+	"curl -fsSL https://vite.plus | bash",
+	`ff_env="\${XDG_CONFIG_HOME:-$HOME/.config}/vite-plus/env"`,
+	`{ [ ! -f "$ff_env" ] || . "$ff_env"; }`,
+	`export PATH="\${VP_HOME:-$HOME/.vite-plus}/bin:\${XDG_DATA_HOME:-$HOME/.local/share}/vite-plus/bin:$PATH"`,
+	"{ hash -r 2>/dev/null || true; }"
+].join(" && ");
 const vpStep = (step) => {
 	const id = vpStepId(step);
 	const command = (() => {
 		switch (step.kind) {
+			case "bootstrap": return VP_INSTALL;
 			case "vp": return `command vp upgrade ${quote(step.version)}`;
 			case "node": return `command vp env default ${quote(step.version)}`;
 			case "reinstall": return `command vp install -g ${quote(`${step.name}@${step.version}`)}`;
@@ -33835,11 +35206,21 @@ const vpStep = (step) => {
 	})();
 	return [
 		stepLine(id),
-		`( ${command} )`,
+		step.kind === "bootstrap" ? command : `( ${command} )`,
 		`ff_code=$?`,
 		`if [ "$ff_code" -ne 0 ]; then ${doneLine(id, false, "$ff_code")}; else ${doneLine(id, true)}; fi`
 	];
 };
+const configStep = () => {
+	const dir = CONFIG_DIR_SH;
+	const write = (variable, file) => `printf '%s' "$${variable}" | base64 -d > ${dir}/${quote(`${file}.tmp`)} && mv -f ${dir}/${quote(`${file}.tmp`)} ${dir}/${quote(file)}`;
+	return [
+		stepLine(CONFIG_STEP),
+		`( mkdir -p ${dir} && ${write("ff_config", CONFIG_FILE)} && ${write("ff_schema", SCHEMA_FILE)} )`,
+		`ff_code=$?`,
+		`if [ "$ff_code" -ne 0 ]; then ${doneLine(CONFIG_STEP, false, "$ff_code")}; else ${doneLine(CONFIG_STEP, true)}; fi`
+	];
+};
 const writeRecord = (repo) => {
 	return [
 		`ff_outs=""`,
@@ -33892,16 +35273,30 @@ const repoSteps = (repo, input) => {
 		"fi"
 	];
 };
+const applyStdin = (token, config, schema) => [
+	token ?? "",
+	encodeBase64(config),
+	encodeBase64(schema)
+];
+const encodeBase64 = (text) => {
+	const bytes = new TextEncoder().encode(text);
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary);
+};
 const applyScript = (input) => {
 	const lines = [
 		prelude,
 		fingerprintFn,
 		`ff_lit() { printf '%s' "$1"; }`,
 		`IFS= read -r ff_token || ff_token=""`,
+		`IFS= read -r ff_config || ff_config=""`,
+		`IFS= read -r ff_schema || ff_schema=""`,
 		`ff_git() { if [ -n "$ff_token" ]; then FF_TOKEN="$ff_token" git -c credential.helper= -c 'credential.helper=!f() { echo username=x-access-token; echo "password=$FF_TOKEN"; }; f' "$@"; else git "$@"; fi; }`,
 		`ff_root=${quotePath(input.cloneRoot)}`,
 		...input.cloneRoot.startsWith("~") ? [`mkdir -p "$ff_root"`] : []
 	];
+	lines.push(...configStep());
 	for (const step of input.plan.vp) lines.push(...vpStep(step));
 	for (const repo of input.plan.repos) lines.push(...repoSteps(repo, input));
 	lines.push(doneLine("end", true));
@@ -34135,14 +35530,19 @@ const gather = fn("gather")(function* (target, script, ledger) {
 		state
 	};
 });
-const runLabels = (p) => Object.fromEntries([...p.vp.map((step) => {
-	switch (step.kind) {
-		case "vp": return [vpStepId(step), `vp upgrade ${step.version}`];
-		case "node": return [vpStepId(step), `node default ${step.version}`];
-		case "reinstall": return [vpStepId(step), `${step.name} reinstall`];
-		case "globals": return [vpStepId(step), `install ${step.packages.map((g) => `${g.name}@${g.version}`).join(" ")}`];
-	}
-}), ...p.repos.map((r) => [stepId(r.name, "install"), `${r.name} install`])]);
+const runLabels = (p) => Object.fromEntries([
+	[CONFIG_STEP, "config"],
+	...p.vp.map((step) => {
+		switch (step.kind) {
+			case "bootstrap": return [vpStepId(step), "install vp"];
+			case "vp": return [vpStepId(step), `vp upgrade ${step.version}`];
+			case "node": return [vpStepId(step), `node default ${step.version}`];
+			case "reinstall": return [vpStepId(step), `${step.name} reinstall`];
+			case "globals": return [vpStepId(step), `install ${step.packages.map((g) => `${g.name}@${g.version}`).join(" ")}`];
+		}
+	}),
+	...p.repos.map((r) => [stepId(r.name, "install"), `${r.name} install`])
+]);
 const apply = fn("apply")(function* (target, p, script, secrets, ledger) {
 	const labels = runLabels(p);
 	let current;
@@ -34174,16 +35574,20 @@ const apply = fn("apply")(function* (target, p, script, secrets, ledger) {
 			case "text": if (line.text.trim() !== "") (current?.output ?? head).push(line.text.trimEnd());
 		}
 	}), ledger);
-	if (run.kind !== "ran") return run.kind;
+	const applied = (outcome) => ({
+		outcome,
+		done
+	});
+	if (run.kind !== "ran") return applied(run.kind);
 	if (current !== void 0) {
 		yield* ledger.fail(target.name, [`${current.id} did not finish`, ...current.output]);
-		return "failed";
+		return applied("failed");
 	}
 	if (!done.includes("end")) {
 		yield* ledger.fail(target.name, ["apply did not finish", ...head]);
-		return "failed";
+		return applied("failed");
 	}
-	if (failed.length > 0 || p.failures.length > 0) return "failed";
+	if (failed.length > 0 || p.failures.length > 0) return applied("failed");
 	const installed = p.repos.filter((r) => done.includes(stepId(r.name, "install")));
 	const upToDate = p.repos.length - installed.length;
 	const parts = [
@@ -34192,7 +35596,7 @@ const apply = fn("apply")(function* (target, p, script, secrets, ledger) {
 		...upToDate > 0 ? [`${upToDate} repo${upToDate === 1 ? "" : "s"} up to date`] : []
 	];
 	yield* ledger.line(target.name, "OK", parts.length === 0 ? "up to date" : parts.join(" · "));
-	return "ok";
+	return applied("ok");
 });
 //#endregion
 //#region src/questions.ts
@@ -34242,6 +35646,7 @@ const askQuestions = fn("askQuestions")(function* (questions, flags, ledger) {
 const SEP = " · ";
 const vpPart = (step) => {
 	switch (step.kind) {
+		case "bootstrap": return "install vp";
 		case "vp": return `vp ${step.from ?? "none"} -> ${step.version}`;
 		case "node": return `node ${step.from ?? "none"} -> ${step.version}`;
 		case "reinstall": return `${step.name} reinstall on Node`;
@@ -34252,10 +35657,14 @@ const repoPart = (repo) => {
 	if (repo.decision.run) return `${repo.name} install (${repo.decision.reason})`;
 };
 const summarize = (plan) => {
-	const parts = [...plan.vp.map(vpPart), ...plan.repos.map(repoPart).filter((p) => p !== void 0)];
+	const parts = [
+		"config",
+		...plan.vp.map(vpPart),
+		...plan.repos.map(repoPart).filter((p) => p !== void 0)
+	];
 	const upToDate = plan.repos.filter((r) => !r.decision.run).length;
 	if (upToDate > 0) parts.push(`${upToDate} repo${upToDate === 1 ? "" : "s"} up to date`);
-	return parts.length === 0 ? "up to date" : parts.join(SEP);
+	return parts.join(SEP);
 };
 //#endregion
 //#region src/ship.ts
@@ -34265,7 +35674,7 @@ var ShipError = class extends Error {
 const unknownMachines = (config, tailnet, only) => {
 	const known = new Set(tailnet.fleet.map((m) => m.name));
 	const referenced = [
-		...Object.keys(config.machines ?? {}),
+		...Object.keys(config.machines),
 		...(config.repos ?? []).flatMap((r) => r.machines ?? []),
 		...config.vp?.machines ?? [],
 		...only
@@ -34282,14 +35691,33 @@ const packagesToResolve = (config) => {
 	];
 };
 const rebuildOf = (flags) => flags.rebuild.length === 0 ? "none" : flags.rebuild.includes("all") ? "all" : flags.rebuild;
+const staleConfigs = fn("staleConfigs")(function* (local, inputIsLocalFile, gathered, ledger) {
+	const stale = [];
+	for (const { machine, local: isLocal, state } of gathered) {
+		if (isLocal && inputIsLocalFile || state.config === void 0) continue;
+		const parsed = yield* result(parseConfig(machine.name, state.config));
+		if (parsed._tag === "Failure") {
+			yield* ledger.line(machine.name, "INFO", "its config does not parse; it will be overwritten");
+			continue;
+		}
+		const remote = parsed.success;
+		if (isNewer(remote.shippedTo?.[machine.name], local.shippedTo?.[machine.name])) stale.push(`${machine.name} (shipped ${remote.shippedAt} from ${remote.shippedFrom ?? "unknown"})`);
+	}
+	return stale;
+});
+const schemaJson = encodeSync(fromJsonString(Unknown, { space: 2 }));
 const ship = fn("ship")(function* (flags) {
-	const path = yield* Path$1;
-	const configPath = flags.config ?? (yield* findConfig(path.resolve(".")));
-	const config = yield* loadConfig(configPath);
+	const fs = yield* FileSystem;
+	const path = flags.config ?? configPath(process.env);
+	const config = yield* loadConfig(path);
 	const tailnet = yield* readTailnet();
 	const unknown = unknownMachines(config, tailnet, flags.only);
 	if (unknown.length > 0) return yield* fail$1(new ShipError(`unknown Machine: ${unknown.join(", ")} (the tailnet has: ${tailnet.fleet.map((m) => m.name).join(", ")})`));
-	const targetsList = tailnet.fleet.filter((m) => flags.only.length === 0 || flags.only.includes(m.name));
+	const fleet = new Set(Object.keys(config.machines));
+	if (!fleet.has(tailnet.self.name)) return yield* fail$1(new ShipError(`this Machine (${tailnet.self.name}) is not in machines in ${path}`));
+	const outsideFleet = flags.only.filter((name) => !fleet.has(name));
+	if (outsideFleet.length > 0) return yield* fail$1(new ShipError(`not in machines in ${path}: ${outsideFleet.join(", ")}`));
+	const targetsList = tailnet.fleet.filter((m) => fleet.has(m.name) && (flags.only.length === 0 || flags.only.includes(m.name)));
 	const ledger = yield* makeLedger(Math.max(5, ...targetsList.map((m) => m.name.length)));
 	const count = `${targetsList.length} machine${targetsList.length === 1 ? "" : "s"}`;
 	yield* ledger.line("fleet", "INFO", [
@@ -34308,7 +35736,7 @@ const ship = fn("ship")(function* (flags) {
 		yield* ledger.line("fleet", "DONE", `${okWord} ${n("ok")}  skipped ${n("skipped")}  failed ${n("failed")}`);
 		if (n("failed") > 0) process.exitCode = 1;
 	});
-	const cloneRootOf = (machine) => config.machines?.[machine.name]?.clones ?? "~/.local/share/fleetfizz/clones";
+	const cloneRootOf = (machine) => config.machines[machine.name]?.clones ?? "~/.local/share/fleetfizz/clones";
 	const gatherRepos = (config.repos ?? []).map((r) => ({
 		name: repoName(r),
 		outputs: r.outputs ?? []
@@ -34343,6 +35771,17 @@ const ship = fn("ship")(function* (flags) {
 			state: result.state
 		};
 	}), { concurrency: "unbounded" }).pipe(map$5((list) => list.filter((g) => g !== void 0)));
+	const stale = yield* staleConfigs(config, flags.config === void 0, gathered, ledger);
+	if (stale.length > 0) {
+		const what = `newer config on ${stale.join(", ")}`;
+		if (flags.dryRun) yield* ledger.line("fleet", "INFO", `${what}; a Ship would ask before overwriting it`);
+		else if (flags.overwriteConfig) yield* ledger.line("fleet", "INFO", `${what}; overwriting it (--overwrite-config)`);
+		else if (!hasTty()) return yield* fail$1(new ShipError(`${what}; copy it here first, or pass --overwrite-config`));
+		else {
+			yield* ledger.line("fleet", "ASK", what);
+			if (!(yield* run$2(Confirm({ message: "Overwrite it with this Machine's config?" })))) return yield* fail$1(new ShipError("aborted: the config here is older"));
+		}
+	}
 	const versions = yield* resolveVersions(packagesToResolve(config));
 	const planAll = (cfg, answers) => gathered.map((g) => ({
 		...g,
@@ -34353,21 +35792,22 @@ const ship = fn("ship")(function* (flags) {
 				platform: g.machine.platform
 			},
 			state: g.state,
+			self: flags.version,
 			versions,
 			rebuild: rebuildOf(flags),
 			answers
 		})
 	}));
-	let planned = planAll(config, {});
+	let cfg = config;
+	let planned = planAll(cfg, {});
 	const questions = planned.flatMap((g) => g.plan.questions);
 	if (questions.length > 0 && !flags.dryRun) {
 		const decided = yield* askQuestions(questions, flags, ledger);
-		let cfg = config;
 		for (const [pkg, decision] of Object.entries(decided)) if (decision.kind === "bump") {
-			const range = yield* bumpConfig(configPath, pkg, decision.installed);
-			yield* ledger.line("fleet", "INFO", `bumped ${pkg} to ${range} in ${configPath}`);
+			const range = yield* bumpConfig(path, pkg, decision.installed);
+			yield* ledger.line("fleet", "INFO", `bumped ${pkg} to ${range} in ${path}`);
 		}
-		if (Object.values(decided).some((d) => d.kind === "bump")) cfg = yield* loadConfig(configPath);
+		if (Object.values(decided).some((d) => d.kind === "bump")) cfg = yield* loadConfig(path);
 		const answers = Object.fromEntries(Object.entries(decided).flatMap(([pkg, d]) => d.kind === "bump" ? [] : [[pkg, d.kind]]));
 		planned = planAll(cfg, answers);
 	}
@@ -34379,14 +35819,21 @@ const ship = fn("ship")(function* (flags) {
 		yield* record(machine.name, p.failures.length > 0 ? "failed" : "ok");
 	}
 	if (flags.dryRun) return yield* finish("planned");
+	const shippedAt = formatIso(yield* now);
+	const original = yield* fs.readFileString(path);
+	const stampWith = (reached) => stampText(original, {
+		shippedAt,
+		shippedFrom: tailnet.self.name,
+		reached: [...reached, ...flags.config === void 0 ? [tailnet.self.name] : []]
+	});
+	const stamped = stampWith(planned.map((g) => g.machine.name));
+	yield* fs.writeFileString(path, stamped);
+	const schema = `${schemaJson(fleetConfigJsonSchema())}\n`;
 	const lent = planned.some((g) => g.plan.repos.length > 0) ? yield* readLentToken() : { token: void 0 };
 	if (lent.token === void 0 && lent.reason !== void 0) yield* ledger.line("fleet", "INFO", `no gh token (${lent.reason}); private repos will fail`);
-	const machineNames = tailnet.fleet.map((m) => m.name);
-	yield* forEach$1(planned, fn("applyOne")(function* ({ machine, local, plan: p }) {
-		if (p.repos.length === 0 && p.vp.length === 0) {
-			if (p.failures.length === 0) yield* ledger.line(machine.name, "OK", "up to date");
-			return;
-		}
+	const machineNames = [...fleet];
+	const stdin = applyStdin(lent.token, stamped, schema);
+	const delivered = yield* forEach$1(planned, fn("applyOne")(function* ({ machine, local, plan: p }) {
 		const script = applyScript({
 			plan: p,
 			cloneRoot: cloneRootOf(machine),
@@ -34396,12 +35843,14 @@ const ship = fn("ship")(function* (flags) {
 				machines: machineNames
 			}
 		});
-		const result = yield* apply({
+		const applied = yield* apply({
 			name: machine.name,
 			local
-		}, p, script, [lent.token ?? ""], ledger);
-		yield* record(machine.name, result);
-	}), { concurrency: "unbounded" });
+		}, p, script, stdin, ledger);
+		yield* record(machine.name, applied.outcome);
+		return applied.done.includes("config") ? machine.name : void 0;
+	}), { concurrency: "unbounded" }).pipe(map$5((list) => list.filter((name) => name !== void 0)));
+	yield* fs.writeFileString(path, stampWith(delivered));
 	yield* finish("ok");
 });
 //#endregion
@@ -34412,14 +35861,17 @@ const shipCommand = make$1("ship", {
 	rebuild: String$1("rebuild").pipe(atLeast(0), withDescription$1("Run a repo's Install Command even when its record matches; `all` for every repo.")),
 	bump: Boolean$1("bump").pipe(withDefault(false), withDescription$1("Answer every above-range question by bumping the config.")),
 	enforce: Boolean$1("enforce").pipe(withDefault(false), withDescription$1("Answer every above-range question by downgrading into the range.")),
-	config: String$1("config").pipe(optional, withDescription$1("Config file. Default: search upward from cwd for fleet.config.jsonc."))
+	overwriteConfig: Boolean$1("overwrite-config").pipe(withDefault(false), withDescription$1("Ship even when another Machine holds a newer config, overwriting it with this one.")),
+	config: String$1("config").pipe(optional, withDescription$1("Config file. Default: $XDG_CONFIG_HOME/fleetfizz/fleet.config.jsonc."))
 }).pipe(withDescription("Ship the config to every reachable Machine."), withHandler((flags) => ship({
 	dryRun: flags.dryRun,
 	only: flags.only,
 	rebuild: flags.rebuild,
 	bump: flags.bump,
 	enforce: flags.enforce,
-	config: flags.config._tag === "Some" ? flags.config.value : void 0
+	overwriteConfig: flags.overwriteConfig,
+	config: flags.config._tag === "Some" ? flags.config.value : void 0,
+	version
 }).pipe(catch_((e) => gen(function* () {
 	yield* error(e.message);
 	process.exitCode = 1;