@sjcx/vorma 0.0.0-pre.2 → 0.0.0-pre.3

package/dist/value-transport-Bst4Hk-n.js

@@ -1,864 +0,0 @@
-import { Result } from "effect";
-import { compileFlatPattern, compileNestedPattern } from "@vorma/primitives/matcher";
-//#region src/universal/protocol.ts
-/** Process-environment names consumed as part of a deployment integration. */
-const PROCESS_ENVIRONMENT_PROTOCOL = {
-	vercelSkewProtectionEnabledVariable: "VERCEL_SKEW_PROTECTION_ENABLED",
-	vercelDeploymentIdVariable: "VERCEL_DEPLOYMENT_ID"
-};
-/** Private development coordination between the launcher and mounted runtime. */
-const DEVELOPMENT_PROTOCOL = {
-	serverPortEnvironmentVariable: "PORT",
-	readinessPath: "/.vorma/healthz"
-};
-/** Request and response vocabulary shared by the browser and runtime server. */
-const HTTP_PROTOCOL = {
-	queryKeys: {
-		viewPayload: "vorma-json",
-		deployment: "dpl",
-		streamResume: "vorma_resume"
-	},
-	requestHeaders: {
-		clientBuildId: "x-vorma-client-build-id",
-		clientAcceptsRedirect: "x-accepts-client-redirect",
-		vercelDeploymentId: "x-deployment-id"
-	},
-	responseHeaders: {
-		clientBuildId: "x-vorma-client-build-id",
-		buildSkew: "x-vorma-build-skew",
-		clientRedirect: "x-client-redirect",
-		clientRedirectStatus: "x-client-redirect-status"
-	},
-	buildSkewBody: "{\"ok\":true}"
-};
-/** Reserved markup names shared by server rendering and browser reconciliation. */
-const DOCUMENT_PROTOCOL = {
-	elementIds: {
-		root: "vorma-root",
-		data: "vorma-data-json",
-		criticalCss: "vorma-critical-css"
-	},
-	attributes: {
-		cssBundle: "data-vorma-css-bundle",
-		cssPreload: "data-vorma-css-preload",
-		staticAsset: "data-vorma-static-asset",
-		linkActiveExact: "data-vorma-active-exact",
-		linkActiveAncestor: "data-vorma-active-ancestor",
-		linkPendingExact: "data-vorma-pending-exact",
-		linkPendingAncestor: "data-vorma-pending-ancestor"
-	},
-	headComments: {
-		title: "vorma-head:title",
-		meta: "vorma-head:meta",
-		rest: "vorma-head:rest",
-		assets: "vorma-head:assets"
-	}
-};
-/** Persistent names owned by the browser client. */
-const BROWSER_STATE_PROTOCOL = {
-	historyStateFields: {
-		userState: "vorma-user-state",
-		entryKey: "vorma-entry-key"
-	},
-	/** Session storage key holding saved scroll positions by history entry key. */
-	scrollStorageKey: "vorma-scroll",
-	apiIdentityArrayPrefix: "vorma-api"
-};
-/** URL-search escaping and marker vocabulary shared by both runtimes. */
-const SEARCH_PARAMETER_PROTOCOL = {
-	escapePrefix: "~",
-	keySeparator: ".",
-	keySegmentEscapes: {
-		tilde: "~0",
-		separator: "~1",
-		empty: "~2"
-	},
-	valueMarkers: {
-		null: "~n",
-		emptyArray: "~a",
-		emptyObject: "~o",
-		escapedScalarPrefix: "~s"
-	}
-};
-const PUBLIC_OUTPUT_FILE_NAME_PREFIX = "vorma_out_";
-/** Vorma-owned output layout and stable generated names. */
-const ARTIFACT_PROTOCOL = {
-	/**
-	* The directory Vorma owns beside each configured entry. The name is fixed; applications do not configure it.
-	*/
-	vormaDirectoryName: "_vorma",
-	/** Inside the client entry’s `_vorma`: published public assets. */
-	publicDirectoryName: "public",
-	/** Inside each entry’s `_vorma`: the ignore file covering its output. */
-	ignoreFileName: ".gitignore",
-	ignoreFileSource: "*\n",
-	/** Inside the server entry's `_vorma`: the registered declarations. */
-	generatedBuildFileName: "build.gen.ts",
-	compiledServerEntryFileName: "entry.mjs",
-	compiledRuntimeFileName: "runtime.gen.mjs",
-	productionMetadataFileName: "metadata.gen.json",
-	compiledServerModuleExtension: ".mjs",
-	/** Inside the client entry's `_vorma`. */
-	generatedAssetKeysFileName: "assets.gen.d.ts",
-	/** Inside the client entry's `_vorma`: runtime adapters for contract Effect types. */
-	generatedClientTransportFileName: "transport.gen.ts",
-	/** In both boundaries: the declaration augmenting that boundary's Vorma entry. */
-	generatedClientContractsFileName: "client.gen.d.ts",
-	generatedServerContractsFileName: "server.gen.d.ts",
-	publicOutputFileNamePrefix: PUBLIC_OUTPUT_FILE_NAME_PREFIX,
-	publicModuleFileNamePattern: `${PUBLIC_OUTPUT_FILE_NAME_PREFIX}[name]-[hash].js`,
-	publicAssetFileNamePattern: `${PUBLIC_OUTPUT_FILE_NAME_PREFIX}[name]-[hash][extname]`
-};
-/** Identifiers shared across package entries, discovery, and generated code. */
-const FRAMEWORK_IDENTITY_PROTOCOL = {
-	brands: {},
-	moduleSpecifiers: {
-		build: "vorma/build",
-		server: "vorma/server",
-		client: "vorma/client",
-		clientReact: "vorma/client/react",
-		clientTransportTypes: "virtual:vorma/client-transport-types"
-	}
-};
-/**
-* Tags the framework itself reports in command error channels. A declared
-* domain tag must not collide with one: `Effect.catchTag` could not tell
-* them apart. Declaration compilation rejects collisions.
-*/
-const FRAMEWORK_ERROR_TAGS = [
-	"InputError",
-	"BuildMismatchError",
-	"TransportError",
-	"HandlerError",
-	"QueryRedirected",
-	"StreamResumeUnavailable",
-	"NavigationError",
-	"RevalidationError",
-	"PrefetchError"
-];
-//#endregion
-//#region src/universal/null-prototype-record.ts
-/**
-* A record with no prototype: a key spelled `__proto__` or `constructor` is
-* an own property and nothing else, so a name from the wire can index it
-* without reaching inherited members. `Object.create` is typed as `any`;
-* this function is the one place that typing meets the record's type.
-*/
-function makeNullPrototypeRecord() {
-	return Object.create(null);
-}
-//#endregion
-//#region src/universal/pattern-language.ts
-/** The pattern language: dynamic segments start with a colon, a lone star is a splat, `_index` names a layout's index. */
-const FLAT_PATTERN_LANGUAGE = {
-	kind: "flat",
-	dynamicParamPrefix: ":",
-	splatSegment: "*"
-};
-const NESTED_PATTERN_LANGUAGE = {
-	kind: "nested",
-	dynamicParamPrefix: ":",
-	explicitIndexSegment: "_index",
-	splatSegment: "*"
-};
-//#endregion
-//#region src/universal/path-wire.ts
-/** Converts an absolute request pathname to the canonical spelling used for matching. */
-function canonicalizeRequestPathForMatcher(path) {
-	if (!path.startsWith("/")) return Result.fail({
-		_tag: "PathMustBeAbsolute",
-		path
-	});
-	const wellFormed = checkWellFormedUnicode(path);
-	if (Result.isFailure(wellFormed)) return Result.fail(wellFormed.failure);
-	const encoded = [];
-	for (const segment of path.split("/")) {
-		if (segment === "") {
-			encoded.push("");
-			continue;
-		}
-		const decoded = decodePercentSegment(segment);
-		if (Result.isFailure(decoded)) return Result.fail(decoded.failure);
-		encoded.push(encodeWireText(decoded.success));
-	}
-	return Result.succeed(encoded.join("/"));
-}
-/** Encodes a logical authored route pattern without interpreting static percent escapes. */
-function encodeRoutePatternForMatcher(pattern) {
-	if (!pattern.startsWith("/")) return Result.fail({
-		_tag: "PathMustBeAbsolute",
-		path: pattern
-	});
-	const wellFormed = checkWellFormedUnicode(pattern);
-	if (Result.isFailure(wellFormed)) return Result.fail(wellFormed.failure);
-	const encoded = [];
-	for (const segment of pattern.split("/")) {
-		if (segment === "" || segment === "*" || segment.startsWith(":")) {
-			encoded.push(segment);
-			continue;
-		}
-		if (segment === "." || segment === "..") return Result.fail({
-			_tag: "StaticDotPathSegment",
-			pattern,
-			segment
-		});
-		encoded.push(encodeWireText(segment));
-	}
-	return Result.succeed(encoded.join("/"));
-}
-/**
-* Compiles an authored UI route pattern: wire encoding first, then the
-* nested pattern language. Every UI pattern enters the matcher through this
-* function, in the graph, the build, and the plan.
-*/
-function compileUiPattern(pattern) {
-	const encoded = encodeRoutePatternForMatcher(pattern);
-	if (Result.isFailure(encoded)) return Result.fail(encoded.failure);
-	return compileNestedPattern({
-		pattern: encoded.success,
-		language: NESTED_PATTERN_LANGUAGE
-	});
-}
-/** Compiles an authored endpoint or middleware pattern in the flat pattern language. */
-function compileEndpointPattern(pattern) {
-	const encoded = encodeRoutePatternForMatcher(pattern);
-	if (Result.isFailure(encoded)) return Result.fail(encoded.failure);
-	return compileFlatPattern({
-		pattern: encoded.success,
-		language: FLAT_PATTERN_LANGUAGE
-	});
-}
-/** Decodes a match's wire captures to the logical values supplied to application code. */
-function decodeMatchCaptures(match) {
-	const params = makeNullPrototypeRecord();
-	for (const [name, value] of Object.entries(match.dynamicParams)) {
-		const decoded = decodePathCapture(value);
-		if (Result.isFailure(decoded)) return Result.fail(decoded.failure);
-		params[name] = decoded.success;
-	}
-	const splatValues = [];
-	for (const value of match.splatValues) {
-		const decoded = decodePathCapture(value);
-		if (Result.isFailure(decoded)) return Result.fail(decoded.failure);
-		splatValues.push(decoded.success);
-	}
-	return Result.succeed({
-		params,
-		splatValues
-	});
-}
-/** Encodes one non-empty logical dynamic or splat value as one wire segment. */
-function encodePathCapture(value) {
-	if (value === "") return Result.fail({ _tag: "EmptyPathCapture" });
-	if (value === "." || value === "..") return Result.fail({
-		_tag: "DotPathCapture",
-		value
-	});
-	const wellFormed = checkWellFormedUnicode(value);
-	if (Result.isFailure(wellFormed)) return Result.fail(wellFormed.failure);
-	return Result.succeed(encodeWireText(value));
-}
-/** Decodes one matched wire segment to the logical value supplied to application code. */
-function decodePathCapture(segment) {
-	if (segment === "") return Result.fail({ _tag: "EmptyPathCapture" });
-	if (segment.includes("/")) return Result.fail({
-		_tag: "PathCaptureContainsSeparator",
-		segment
-	});
-	return Result.flatMap(decodePercentSegment(segment), (value) => {
-		return value === "." || value === ".." ? Result.fail({
-			_tag: "DotPathCapture",
-			value
-		}) : Result.succeed(value);
-	});
-}
-function formatPathWireError(error) {
-	switch (error._tag) {
-		case "PathMustBeAbsolute": return `path ${JSON.stringify(error.path)} must begin with /`;
-		case "MalformedPercentEncoding": return `malformed percent encoding at offset ${error.offset} of path segment ${JSON.stringify(error.segment)}`;
-		case "InvalidPercentEncodedUtf8": return `percent-decoded path segment is not UTF-8: ${JSON.stringify(error.segment)}`;
-		case "MalformedUnicode": return `value contains an unpaired Unicode surrogate at offset ${error.offset}`;
-		case "EmptyPathCapture": return "path capture cannot be empty";
-		case "DotPathCapture": return `path parameter ${JSON.stringify(error.value)} cannot be a literal URL segment because URL normalization would erase it`;
-		case "PathCaptureContainsSeparator": return "one path wire segment cannot contain a literal / separator";
-		case "StaticDotPathSegment": return `route pattern ${JSON.stringify(error.pattern)} contains static segment ${JSON.stringify(error.segment)}, which URL normalization would erase`;
-	}
-}
-function checkWellFormedUnicode(value) {
-	for (let offset = 0; offset < value.length; offset++) {
-		const unit = value.charCodeAt(offset);
-		if (unit >= 55296 && unit <= 56319) {
-			const next = value.charCodeAt(offset + 1);
-			if (!(next >= 56320 && next <= 57343)) return Result.fail({
-				_tag: "MalformedUnicode",
-				value,
-				offset
-			});
-			offset += 1;
-		} else if (unit >= 56320 && unit <= 57343) return Result.fail({
-			_tag: "MalformedUnicode",
-			value,
-			offset
-		});
-	}
-	return Result.succeed(void 0);
-}
-function decodePercentSegment(segment) {
-	const wellFormed = checkWellFormedUnicode(segment);
-	if (Result.isFailure(wellFormed)) return Result.fail(wellFormed.failure);
-	for (let offset = 0; offset < segment.length; offset++) if (segment[offset] === "%") {
-		const high = toHexValue(segment.charCodeAt(offset + 1));
-		const low = toHexValue(segment.charCodeAt(offset + 2));
-		if (high === null || low === null) return Result.fail({
-			_tag: "MalformedPercentEncoding",
-			segment,
-			offset
-		});
-		offset += 2;
-	}
-	return Result.try({
-		try: () => decodeURIComponent(segment),
-		catch: () => {
-			return {
-				_tag: "InvalidPercentEncodedUtf8",
-				segment
-			};
-		}
-	});
-}
-function encodeWireText(value) {
-	return encodeURIComponent(value).replaceAll("%2B", "+").replace(/[!'()*]/g, (character) => {
-		return `%${character.charCodeAt(0).toString(16).toUpperCase()}`;
-	});
-}
-function toHexValue(unit) {
-	if (unit >= 48 && unit <= 57) return unit - 48;
-	if (unit >= 65 && unit <= 70) return unit - 65 + 10;
-	if (unit >= 97 && unit <= 102) return unit - 97 + 10;
-	return null;
-}
-//#endregion
-//#region src/universal/value-transport.ts
-const TRANSPORT_MARK_KINDS = /* @__PURE__ */ new Set([
-	"date",
-	"bigint",
-	"number",
-	"undefined",
-	"map",
-	"set",
-	"url",
-	"url-search-params",
-	"regexp",
-	"option",
-	"redacted",
-	"chunk",
-	"duration",
-	"big-decimal",
-	"date-time-utc",
-	"date-time-zoned",
-	"hash-map",
-	"hash-set"
-]);
-const EFFECT_TRANSPORT_TYPES = [
-	{
-		name: "option",
-		representationId: "effect/schema/Option"
-	},
-	{
-		name: "redacted",
-		representationId: "effect/schema/Redacted"
-	},
-	{
-		name: "chunk",
-		representationId: "effect/schema/Chunk"
-	},
-	{
-		name: "duration",
-		representationId: "effect/schema/Duration"
-	},
-	{
-		name: "big-decimal",
-		representationId: "effect/schema/BigDecimal"
-	},
-	{
-		name: "date-time-utc",
-		representationId: "effect/schema/DateTimeUtc"
-	},
-	{
-		name: "date-time-zoned",
-		representationId: "effect/schema/DateTimeZoned"
-	},
-	{
-		name: "hash-map",
-		representationId: "effect/schema/HashMap"
-	},
-	{
-		name: "hash-set",
-		representationId: "effect/schema/HashSet"
-	}
-];
-function encodeTransportedValue(input) {
-	const marks = [];
-	const active = /* @__PURE__ */ new Set();
-	const json = encodeValue({
-		value: input.value,
-		path: [],
-		marks,
-		active,
-		typeEntries: input.typeEntries
-	});
-	return Result.map(json, (encoded) => {
-		return {
-			json: encoded,
-			marks
-		};
-	});
-}
-/** The reader's JSON came from a parser, so its type is only `unknown` here; the marks are what the reader checks. */
-function decodeTransportedValue(input) {
-	const marks = [...input.transported.marks].sort((left, right) => right.path.length - left.path.length);
-	const paths = /* @__PURE__ */ new Set();
-	for (const mark of marks) {
-		const path = JSON.stringify(mark.path);
-		if (paths.has(path)) return Result.fail({
-			_tag: "InvalidTransportMark",
-			path: mark.path,
-			reason: "a value can have only one transport mark"
-		});
-		paths.add(path);
-	}
-	const root = { value: input.transported.json };
-	for (const mark of marks) {
-		const restored = restoreAt({
-			root,
-			mark,
-			typeEntries: input.typeEntries
-		});
-		if (Result.isFailure(restored)) return restored;
-	}
-	return Result.succeed(root.value);
-}
-function encodeValue(input) {
-	const { value, path, marks, active, typeEntries } = input;
-	if (value === null || typeof value === "boolean" || typeof value === "string") return Result.succeed(value);
-	if (typeof value === "number") {
-		if (Number.isFinite(value) && !Object.is(value, -0)) return Result.succeed(value);
-		marks.push({
-			path: [...path],
-			kind: "number"
-		});
-		return Result.succeed(Object.is(value, -0) ? "-0" : String(value));
-	}
-	if (typeof value === "undefined") {
-		marks.push({
-			path: [...path],
-			kind: "undefined"
-		});
-		return Result.succeed(null);
-	}
-	if (typeof value === "bigint") {
-		marks.push({
-			path: [...path],
-			kind: "bigint"
-		});
-		return Result.succeed(value.toString());
-	}
-	if (typeof value !== "object") return Result.fail({
-		_tag: "UntransportableValue",
-		path: [...path],
-		reason: `a ${typeof value} has no wire form`
-	});
-	if (value instanceof Date) {
-		if (Number.isNaN(value.getTime())) return Result.fail({
-			_tag: "UntransportableValue",
-			path: [...path],
-			reason: "an invalid Date has no wire form"
-		});
-		marks.push({
-			path: [...path],
-			kind: "date"
-		});
-		return Result.succeed(value.toISOString());
-	}
-	if (value instanceof URL) {
-		marks.push({
-			path: [...path],
-			kind: "url"
-		});
-		return Result.succeed(value.href);
-	}
-	if (value instanceof URLSearchParams) {
-		marks.push({
-			path: [...path],
-			kind: "url-search-params"
-		});
-		return encodeItems({
-			items: [...value.entries()].map(([key, item]) => [key, item]),
-			path,
-			marks,
-			active,
-			typeEntries
-		});
-	}
-	if (value instanceof RegExp) {
-		marks.push({
-			path: [...path],
-			kind: "regexp"
-		});
-		return Result.succeed({
-			source: value.source,
-			flags: value.flags
-		});
-	}
-	if (active.has(value)) return Result.fail({
-		_tag: "UntransportableValue",
-		path: [...path],
-		reason: "a value cannot contain itself"
-	});
-	for (const entry of typeEntries) {
-		if (!entry.matchesValue(value)) continue;
-		const projected = Result.try({
-			try: () => projectEffectTransportValue(entry, value),
-			catch: (cause) => {
-				return {
-					_tag: "UntransportableValue",
-					path: [...path],
-					reason: `${entry.kind} could not be read: ${String(cause)}`
-				};
-			}
-		});
-		if (Result.isFailure(projected)) return Result.fail(projected.failure);
-		marks.push({
-			path: [...path],
-			kind: entry.kind
-		});
-		active.add(value);
-		const encoded = encodeValue({
-			value: projected.success,
-			path,
-			marks,
-			active,
-			typeEntries
-		});
-		active.delete(value);
-		return encoded;
-	}
-	active.add(value);
-	let encoded;
-	if (value instanceof Map) {
-		marks.push({
-			path: [...path],
-			kind: "map"
-		});
-		encoded = encodeEntries({
-			entries: [...value],
-			path,
-			marks,
-			active,
-			typeEntries
-		});
-	} else if (value instanceof Set) {
-		marks.push({
-			path: [...path],
-			kind: "set"
-		});
-		encoded = encodeItems({
-			items: [...value],
-			path,
-			marks,
-			active,
-			typeEntries
-		});
-	} else if (Array.isArray(value)) encoded = encodeItems({
-		items: value,
-		path,
-		marks,
-		active,
-		typeEntries
-	});
-	else encoded = encodeRecord({
-		value,
-		path,
-		marks,
-		active,
-		typeEntries
-	});
-	active.delete(value);
-	return encoded;
-}
-function projectEffectTransportValue(entry, value) {
-	switch (entry.kind) {
-		case "option": return entry.matchesNone(value) ? [] : [entry.getValue(value)];
-		case "redacted": {
-			const label = entry.getLabel(value);
-			return {
-				value: entry.getValue(value),
-				...label === void 0 ? {} : { label }
-			};
-		}
-		case "chunk":
-		case "hash-set": return entry.getValues(value);
-		case "duration":
-		case "big-decimal":
-		case "date-time-utc":
-		case "date-time-zoned": return entry.format(value);
-		case "hash-map": return entry.getEntries(value);
-	}
-}
-function encodeItems(input) {
-	const out = [];
-	for (const [index, item] of input.items.entries()) {
-		input.path.push(index);
-		const encoded = encodeValue({
-			value: item,
-			path: input.path,
-			marks: input.marks,
-			active: input.active,
-			typeEntries: input.typeEntries
-		});
-		input.path.pop();
-		if (Result.isFailure(encoded)) return encoded;
-		out.push(encoded.success);
-	}
-	return Result.succeed(out);
-}
-/** A Map's entries travel as an array of pairs; a pair's key and value are marked at their own paths inside it. */
-function encodeEntries(input) {
-	return encodeItems({
-		items: input.entries.map(([key, value]) => [key, value]),
-		path: input.path,
-		marks: input.marks,
-		active: input.active,
-		typeEntries: input.typeEntries
-	});
-}
-/** An object's own enumerable string-keyed properties; a class instance, such as a declared error, travels as its fields. */
-function encodeRecord(input) {
-	const out = makeNullPrototypeRecord();
-	for (const key of Object.keys(input.value)) {
-		const descriptor = Object.getOwnPropertyDescriptor(input.value, key);
-		if (descriptor === void 0 || !Object.hasOwn(descriptor, "value")) return Result.fail({
-			_tag: "UntransportableValue",
-			path: [...input.path, key],
-			reason: "an accessor property has no wire form"
-		});
-		input.path.push(key);
-		const encoded = encodeValue({
-			value: descriptor.value,
-			path: input.path,
-			marks: input.marks,
-			active: input.active,
-			typeEntries: input.typeEntries
-		});
-		input.path.pop();
-		if (Result.isFailure(encoded)) return encoded;
-		out[key] = encoded.success;
-	}
-	return Result.succeed(out);
-}
-function restoreAt(input) {
-	const { mark } = input;
-	function fail(reason) {
-		return Result.fail({
-			_tag: "InvalidTransportMark",
-			path: mark.path,
-			reason
-		});
-	}
-	let holder = input.root;
-	let key = "value";
-	for (const step of mark.path) {
-		const container = readOwnDataProperty({
-			holder,
-			key
-		});
-		if (Result.isFailure(container)) return fail(container.failure);
-		if (typeof container.success !== "object" || container.success === null) return fail("the marked path leaves the value");
-		holder = container.success;
-		key = step;
-	}
-	const current = readOwnDataProperty({
-		holder,
-		key
-	});
-	if (Result.isFailure(current)) return fail(current.failure);
-	const restored = restoreValue({
-		kind: mark.kind,
-		value: current.success,
-		typeEntries: input.typeEntries
-	});
-	if (Result.isFailure(restored)) return Result.fail({
-		...restored.failure,
-		path: mark.path
-	});
-	Object.defineProperty(holder, key, {
-		value: restored.success,
-		enumerable: true,
-		configurable: true,
-		writable: true
-	});
-	return Result.succeed(void 0);
-}
-/** A mark traverses JSON data properties, with numbers for array indices and strings for record keys. */
-function readOwnDataProperty(input) {
-	const { holder, key } = input;
-	if (Array.isArray(holder)) {
-		if (typeof key !== "number" || !Number.isInteger(key) || key < 0 || key >= holder.length) return Result.fail("an array mark needs an existing integer index");
-	} else if (typeof key !== "string") return Result.fail("a record mark needs a string key");
-	const descriptor = Object.getOwnPropertyDescriptor(holder, key);
-	return descriptor !== void 0 && descriptor.enumerable && Object.hasOwn(descriptor, "value") ? Result.succeed(descriptor.value) : Result.fail("a mark must address an existing own data property");
-}
-function restoreValue(input) {
-	const { kind, value } = input;
-	function fail(reason) {
-		return Result.fail({
-			_tag: "InvalidTransportMark",
-			path: [],
-			reason
-		});
-	}
-	switch (kind) {
-		case "undefined": return value === null ? Result.succeed(void 0) : fail("an undefined mark needs null");
-		case "date": {
-			if (typeof value !== "string") return fail("a date mark needs a string");
-			const date = new Date(value);
-			return Number.isNaN(date.getTime()) ? fail("a date mark needs an ISO date") : Result.succeed(date);
-		}
-		case "bigint":
-			if (typeof value !== "string") return fail("a bigint mark needs a string");
-			return Result.try({
-				try: () => BigInt(value),
-				catch: () => {
-					return {
-						_tag: "InvalidTransportMark",
-						path: [],
-						reason: "a bigint mark needs an integer string"
-					};
-				}
-			});
-		case "number": switch (value) {
-			case "NaN": return Result.succeed(NaN);
-			case "Infinity": return Result.succeed(Number.POSITIVE_INFINITY);
-			case "-Infinity": return Result.succeed(Number.NEGATIVE_INFINITY);
-			case "-0": return Result.succeed(-0);
-			default: return fail("a number mark names NaN, Infinity, -Infinity, or -0");
-		}
-		case "url":
-			if (typeof value !== "string") return fail("a url mark needs a string");
-			return Result.try({
-				try: () => new URL(value),
-				catch: () => {
-					return {
-						_tag: "InvalidTransportMark",
-						path: [],
-						reason: "a url mark needs an absolute URL"
-					};
-				}
-			});
-		case "url-search-params": {
-			if (!Array.isArray(value)) return fail("a URLSearchParams mark needs an array of pairs");
-			const entries = [];
-			for (const pair of value) {
-				if (!Array.isArray(pair) || pair.length !== 2 || typeof pair[0] !== "string" || typeof pair[1] !== "string") return fail("a URLSearchParams mark needs an array of string pairs");
-				entries.push([pair[0], pair[1]]);
-			}
-			return Result.succeed(new URLSearchParams(entries));
-		}
-		case "regexp": {
-			if (typeof value !== "object" || value === null || !("source" in value) || !("flags" in value) || typeof value.source !== "string" || typeof value.flags !== "string") return fail("a regexp mark needs a source and flags");
-			const { source, flags } = value;
-			return Result.try({
-				try: () => new RegExp(source, flags),
-				catch: () => {
-					return {
-						_tag: "InvalidTransportMark",
-						path: [],
-						reason: "a regexp mark needs a valid pattern"
-					};
-				}
-			});
-		}
-		case "map": {
-			if (!Array.isArray(value)) return fail("a map mark needs an array of pairs");
-			const entries = [];
-			for (const pair of value) {
-				if (!Array.isArray(pair) || pair.length !== 2) return fail("a map mark needs an array of pairs");
-				entries.push([pair[0], pair[1]]);
-			}
-			return Result.succeed(new Map(entries));
-		}
-		case "set":
-			if (!Array.isArray(value)) return fail("a set mark needs an array");
-			return Result.succeed(new Set(value));
-		case "option":
-		case "redacted":
-		case "chunk":
-		case "duration":
-		case "big-decimal":
-		case "date-time-utc":
-		case "date-time-zoned":
-		case "hash-map":
-		case "hash-set": return restoreEffectTransportType({
-			kind,
-			value,
-			typeEntries: input.typeEntries
-		});
-	}
-}
-/** Restores one Effect data type through the boundary-specific adapter list. */
-function restoreEffectTransportType(input) {
-	const entry = input.typeEntries.find((candidate) => {
-		return candidate.kind === input.kind;
-	});
-	if (entry === void 0) return Result.fail({
-		_tag: "InvalidTransportMark",
-		path: [],
-		reason: `${input.kind} is not part of this application's transport`
-	});
-	const restored = Result.try({
-		try: () => restoreEffectTransportValue(entry, input.value),
-		catch: (cause) => {
-			return {
-				_tag: "InvalidTransportMark",
-				path: [],
-				reason: `${input.kind} could not be restored: ${String(cause)}`
-			};
-		}
-	});
-	if (Result.isFailure(restored)) return Result.fail(restored.failure);
-	return restored.success;
-}
-function restoreEffectTransportValue(entry, value) {
-	function fail(reason) {
-		return Result.fail({
-			_tag: "InvalidTransportMark",
-			path: [],
-			reason
-		});
-	}
-	function restoreParsed(parsed, reason) {
-		return parsed._tag === "Some" ? Result.succeed(parsed.value) : fail(reason);
-	}
-	switch (entry.kind) {
-		case "option": return Array.isArray(value) && value.length === 0 ? Result.succeed(entry.none()) : Array.isArray(value) && value.length === 1 ? Result.succeed(entry.some(value[0])) : fail("an option mark needs an empty or one-item array");
-		case "redacted": {
-			if (typeof value !== "object" || value === null || Array.isArray(value)) return fail("a redacted mark needs a value and an optional string label");
-			const record = value;
-			if (!("value" in record) || record["label"] !== void 0 && typeof record["label"] !== "string") return fail("a redacted mark needs a value and an optional string label");
-			return Result.succeed(entry.make(record["value"], record["label"]));
-		}
-		case "chunk": return Array.isArray(value) ? Result.succeed(entry.fromValues(value)) : fail("a chunk mark needs an array");
-		case "duration": return typeof value === "string" ? restoreParsed(entry.parse(value), "a duration mark needs valid duration text") : fail("a duration mark needs duration text");
-		case "big-decimal": return typeof value === "string" ? restoreParsed(entry.parse(value), "a BigDecimal mark needs valid decimal text") : fail("a BigDecimal mark needs decimal text");
-		case "date-time-utc": return typeof value === "string" ? restoreParsed(entry.parse(value), "a DateTime.Utc mark needs valid UTC ISO text") : fail("a DateTime.Utc mark needs UTC ISO text");
-		case "date-time-zoned": return typeof value === "string" ? restoreParsed(entry.parse(value), "a DateTime.Zoned mark needs valid zoned ISO text") : fail("a DateTime.Zoned mark needs zoned ISO text");
-		case "hash-map":
-			if (!Array.isArray(value) || !value.every((pair) => {
-				return Array.isArray(pair) && pair.length === 2;
-			})) return fail("a HashMap mark needs an array of pairs");
-			return Result.succeed(entry.fromEntries(value));
-		case "hash-set": return Array.isArray(value) ? Result.succeed(entry.fromValues(value)) : fail("a HashSet mark needs an array");
-	}
-}
-//#endregion
-export { SEARCH_PARAMETER_PROTOCOL as S, DOCUMENT_PROTOCOL as _, restoreEffectTransportType as a, HTTP_PROTOCOL as b, compileUiPattern as c, encodeRoutePatternForMatcher as d, formatPathWireError as f, DEVELOPMENT_PROTOCOL as g, BROWSER_STATE_PROTOCOL as h, encodeTransportedValue as i, decodeMatchCaptures as l, ARTIFACT_PROTOCOL as m, TRANSPORT_MARK_KINDS as n, canonicalizeRequestPathForMatcher as o, makeNullPrototypeRecord as p, decodeTransportedValue as r, compileEndpointPattern as s, EFFECT_TRANSPORT_TYPES as t, encodePathCapture as u, FRAMEWORK_ERROR_TAGS as v, PROCESS_ENVIRONMENT_PROTOCOL as x, FRAMEWORK_IDENTITY_PROTOCOL as y };