ignotum 0.0.13 → 0.0.15

package/dist/runtime/routes-Ce8TVP-T.js

@@ -0,0 +1,690 @@
+import { G as InvocationId, H as AppId, U as GeneratedId, X as defineId, Y as VersionId, m as upgrade, p as initial } from "./id--1m0NuUL.js";
+import { a as ActivationGeneration, c as ClientApiVersion, d as PlatformGeneration, f as PlatformReleaseId, h as VersionNumber, l as DataHistoryId, m as ServerApiVersion, p as ProtocolVersion, s as CapabilityId, t as FunctionAddress } from "./sync-DzUwA8W9.js";
+import { t as ValueDescriptor } from "./descriptor-CTY4mtwS-cS43EbwS.js";
+import { Schema } from "effect";
+//#region ../contracts/dist/runtime/functions.js
+const FunctionKind = Schema.Literals(["Mutation", "Query"]);
+Schema.TaggedError()("UnknownFunction", {
+	function: FunctionAddress,
+	message: Schema.String
+});
+Schema.TaggedError()("WrongFunctionKind", {
+	actual: FunctionKind,
+	expected: FunctionKind,
+	function: FunctionAddress,
+	message: Schema.String
+});
+Schema.TaggedError()("InvalidArguments", {
+	function: FunctionAddress,
+	message: Schema.String
+});
+Schema.TaggedError()("FunctionUnavailable", {
+	cause: Schema.Defect(),
+	function: FunctionAddress,
+	message: Schema.String
+});
+//#endregion
+//#region ../contracts/dist/version.js
+const ArtifactPath = Schema.String.check(Schema.isPattern(/^(?!\/)(?![A-Za-z]:\/)(?!.*(?:^|\/)\.\.(?:\/|$))(?!.*(?:^|\/)\.(?:\/|$))(?!.*\/\/)[^\\\0]+$/)).pipe(Schema.brand("ignotum/version/ArtifactPath"));
+const ClientPath = Schema.String.check(Schema.isPattern(/^\/(?!_ignotum(?:\/|$))(?:(?:[A-Za-z0-9._~-]+\/)*[A-Za-z0-9._~-]+\/?)?$/)).pipe(Schema.brand("ignotum/version/ClientPath"));
+const Sha256 = Schema.String.check(Schema.isPattern(/^[0-9a-f]{64}$/)).pipe(Schema.brand("ignotum/version/Sha256"));
+const ArtifactKind = Schema.Literals([
+	"ClientAsset",
+	"ClientDocument",
+	"ClientManifest",
+	"ClientPublicFile",
+	"ClientShell",
+	"FunctionBundle",
+	"ServerManifest",
+	"ServerEnvironment",
+	"SourceMap",
+	"SchemaSnapshot"
+]);
+const ArtifactReference = Schema.Struct({
+	path: ArtifactPath,
+	size: Schema.Natural,
+	sha256: Sha256
+});
+const ArtifactFile = Schema.Struct({
+	path: ArtifactPath,
+	size: Schema.Natural,
+	sha256: Sha256,
+	kind: ArtifactKind,
+	contentType: Schema.String,
+	contentEncoding: Schema.optional(Schema.String)
+});
+const ClientRoute = Schema.Struct({
+	pathname: ClientPath,
+	artifact: ArtifactReference
+});
+const VersionInventoryV1 = Schema.Struct({
+	formatVersion: Schema.Literal(1),
+	files: Schema.Array(ArtifactFile)
+});
+const VersionInventoryV2 = Schema.Struct({
+	formatVersion: Schema.Literal(2),
+	files: Schema.Array(ArtifactFile)
+});
+upgrade(initial(VersionInventoryV1), VersionInventoryV2, (inventory) => ({
+	formatVersion: 2,
+	files: inventory.files
+}));
+const ClientManifestV1 = Schema.Struct({
+	formatVersion: Schema.Literal(1),
+	shell: ArtifactReference,
+	routes: Schema.Array(ClientRoute)
+});
+initial(ClientManifestV1);
+const ClientRoutingRoute = Schema.Struct({
+	pathname: ClientPath,
+	artifact: ArtifactPath
+});
+const ClientRoutingV1 = Schema.Struct({
+	formatVersion: Schema.Literal(1),
+	shell: ArtifactPath,
+	routes: Schema.Array(ClientRoutingRoute)
+});
+initial(ClientRoutingV1);
+const SchemaSnapshotField = Schema.Struct({
+	name: Schema.String,
+	value: ValueDescriptor
+});
+const EnvironmentArtifactV1 = Schema.Struct({
+	formatVersion: Schema.Literal(1),
+	nonce: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{43}$/)),
+	values: Schema.Record(Schema.String, Schema.String)
+});
+initial(EnvironmentArtifactV1);
+const ServerEnvironmentArtifact = Schema.Struct({
+	artifact: ArtifactReference,
+	fields: Schema.Array(SchemaSnapshotField)
+});
+const SchemaSnapshotIndex = Schema.Struct({
+	name: Schema.String,
+	fields: Schema.Array(Schema.String)
+});
+const SchemaSnapshotTableV1 = Schema.Struct({
+	name: Schema.String,
+	fields: Schema.Array(SchemaSnapshotField)
+});
+const SchemaSnapshotV1 = Schema.Struct({
+	formatVersion: Schema.Literal(1),
+	tables: Schema.Array(SchemaSnapshotTableV1)
+});
+const SchemaSnapshotTable = Schema.Struct({
+	name: Schema.String,
+	fields: Schema.Array(SchemaSnapshotField),
+	indexes: Schema.Array(SchemaSnapshotIndex)
+});
+const SchemaSnapshotV2 = Schema.Struct({
+	formatVersion: Schema.Literal(2),
+	tables: Schema.Array(SchemaSnapshotTable)
+});
+const SchemaSnapshot = upgrade(initial(SchemaSnapshotV1), SchemaSnapshotV2, (snapshot) => ({
+	formatVersion: 2,
+	tables: snapshot.tables.map((table) => ({
+		...table,
+		indexes: []
+	}))
+}));
+const ServerFunctionArtifactV1 = Schema.Struct({
+	address: FunctionAddress,
+	kind: FunctionKind,
+	bundle: ArtifactReference,
+	sourceMap: ArtifactReference
+});
+const ServerFunctionArtifact = Schema.Struct({
+	address: FunctionAddress,
+	kind: FunctionKind,
+	args: Schema.optional(ValueDescriptor),
+	returns: Schema.optional(ValueDescriptor),
+	errors: Schema.optional(ValueDescriptor),
+	bundle: ArtifactReference,
+	sourceMap: ArtifactReference
+});
+const ServerBuildManifestV1 = Schema.Struct({
+	formatVersion: Schema.Literal(1),
+	schema: ArtifactReference,
+	functions: Schema.Array(ServerFunctionArtifactV1)
+});
+const ServerBuildManifestV2 = Schema.Struct({
+	formatVersion: Schema.Literal(2),
+	schema: ArtifactReference,
+	functions: Schema.Array(ServerFunctionArtifact)
+});
+const ServerBuildManifestThroughV2 = upgrade(initial(ServerBuildManifestV1), ServerBuildManifestV2, (manifest) => ({
+	formatVersion: 2,
+	schema: manifest.schema,
+	functions: manifest.functions
+}));
+const ServerBuildManifestV3 = Schema.Struct({
+	formatVersion: Schema.Literal(3),
+	schema: ArtifactReference,
+	environment: Schema.optional(ServerEnvironmentArtifact),
+	functions: Schema.Array(ServerFunctionArtifact)
+});
+const ServerBuildManifestThroughV3 = upgrade(ServerBuildManifestThroughV2, ServerBuildManifestV3, (manifest) => ({
+	formatVersion: 3,
+	schema: manifest.schema,
+	functions: manifest.functions
+}));
+const ServerBuildManifestV4 = Schema.Struct({
+	formatVersion: Schema.Literal(4),
+	schema: ArtifactReference,
+	environment: Schema.optional(ServerEnvironmentArtifact),
+	functions: Schema.Array(ServerFunctionArtifact),
+	schemaEvolution: Schema.optional(Schema.Struct({
+		bundle: ArtifactReference,
+		sourceMap: ArtifactReference
+	}))
+});
+upgrade(ServerBuildManifestThroughV3, ServerBuildManifestV4, (manifest) => ({
+	...manifest,
+	formatVersion: 4
+}));
+ArtifactPath.make("inventory.json");
+ArtifactPath.make("client/manifest.json");
+ArtifactPath.make("client/shell.html");
+`${ArtifactPath.make("client/assets")}`;
+`${ArtifactPath.make("client/routes")}`;
+ArtifactPath.make("server/manifest.json");
+ArtifactPath.make("server/schema.json");
+ArtifactPath.make("server/environment.json");
+//#endregion
+//#region ../contracts/dist/platform.js
+const strict$1 = (fields) => Schema.Struct(fields).annotate({ parseOptions: { onExcessProperty: "error" } });
+const Capabilities = Schema.UniqueArray(CapabilityId).check(Schema.isMaxLength(256));
+const RuntimeRequirements = strict$1({
+	clientApiVersion: ClientApiVersion,
+	serverApiVersion: ServerApiVersion,
+	capabilities: Capabilities
+});
+const BrowserGraphReference = strict$1({
+	sha256: Sha256,
+	entry: Schema.String.check(Schema.isTrimmed(), Schema.isPattern(/^ignotum\/platform\/browser\/[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*\.js$/), Schema.isMaxLength(512))
+});
+const GuestGraphReference = strict$1({
+	sha256: Sha256,
+	entry: Schema.String.check(Schema.isTrimmed(), Schema.isPattern(/^ignotum\/platform\/guest\/[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*\.js$/), Schema.isMaxLength(512))
+});
+const PersistentStateFormatId = Schema.String.check(Schema.isTrimmed(), Schema.isPattern(/^[a-z][a-z0-9]*(?:[./-][a-z0-9]+)*$/), Schema.isMaxLength(128)).pipe(Schema.brand("ignotum/platform/PersistentStateFormatId"));
+const PersistentStateFormatVersion = Schema.Int.check(Schema.isGreaterThan(0)).pipe(Schema.brand("ignotum/platform/PersistentStateFormatVersion"));
+const PersistentStateCompatibility = strict$1({
+	format: PersistentStateFormatId,
+	readableVersions: Schema.UniqueArray(PersistentStateFormatVersion).check(Schema.isMinLength(1), Schema.isMaxLength(256)),
+	writeVersion: PersistentStateFormatVersion
+}).check(Schema.makeFilter((value) => value.readableVersions.includes(value.writeVersion) ? void 0 : "A release must read the persistent state version it writes")).annotate({ parseOptions: { onExcessProperty: "error" } });
+Schema.Array(strict$1({
+	format: PersistentStateFormatId,
+	version: PersistentStateFormatVersion
+})).check(Schema.isMaxLength(256), Schema.makeFilter((states) => new Set(states.map((state) => state.format)).size === states.length ? void 0 : "Persistent state format identifiers must be unique"));
+const ReleasePublication = Schema.Union([
+	strict$1({
+		state: Schema.Literal("Staging"),
+		eligible: Schema.Literal(false)
+	}),
+	strict$1({
+		state: Schema.Literal("Ready"),
+		eligible: Schema.Literal(true)
+	}),
+	strict$1({
+		state: Schema.Literal("Failed"),
+		eligible: Schema.Literal(false),
+		reason: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(4096))
+	}),
+	strict$1({
+		state: Schema.Literal("Retired"),
+		eligible: Schema.Literal(false)
+	})
+]);
+const SupportedProtocols = Schema.UniqueArray(ProtocolVersion).check(Schema.isMinLength(1), Schema.isMaxLength(32));
+const PlatformReleaseV1 = strict$1({
+	formatVersion: Schema.Literal(1),
+	id: PlatformReleaseId,
+	browser: strict$1({
+		graph: BrowserGraphReference,
+		clientApiVersion: ClientApiVersion,
+		protocolVersion: ProtocolVersion
+	}),
+	guest: strict$1({
+		graph: GuestGraphReference,
+		serverApiVersion: ServerApiVersion,
+		protocolVersion: ProtocolVersion
+	}),
+	gateway: strict$1({
+		implementation: Sha256,
+		browserProtocols: SupportedProtocols
+	}),
+	host: strict$1({
+		implementation: Sha256,
+		guestProtocols: SupportedProtocols
+	}),
+	capabilities: Capabilities,
+	persistentState: Schema.Array(PersistentStateCompatibility).check(Schema.isMaxLength(256)),
+	publication: ReleasePublication
+}).check(Schema.makeFilter((release) => {
+	const issues = [];
+	if (!release.gateway.browserProtocols.includes(release.browser.protocolVersion)) issues.push({
+		path: ["gateway"],
+		issue: "Gateway must support the selected browser protocol"
+	});
+	if (!release.host.guestProtocols.includes(release.guest.protocolVersion)) issues.push({
+		path: ["host"],
+		issue: "Host must support the selected guest protocol"
+	});
+	if (new Set(release.persistentState.map((state) => state.format)).size !== release.persistentState.length) issues.push({
+		path: ["persistentState"],
+		issue: "Persistent state format identifiers must be unique"
+	});
+	return issues;
+})).annotate({ parseOptions: { onExcessProperty: "error" } });
+initial(PlatformReleaseV1);
+const ExecutionSelectionV1 = strict$1({
+	formatVersion: Schema.Literal(1),
+	appId: AppId,
+	versionId: VersionId,
+	activationGeneration: ActivationGeneration,
+	platformReleaseId: PlatformReleaseId,
+	platformGeneration: PlatformGeneration,
+	dataHistoryId: DataHistoryId
+});
+const ExecutionSelection = initial(ExecutionSelectionV1);
+/** Compare trusted admission and commit selections, including the database history fence. */
+const sameExecutionSelection = (left, right) => left.appId === right.appId && left.versionId === right.versionId && left.activationGeneration === right.activationGeneration && left.platformReleaseId === right.platformReleaseId && left.platformGeneration === right.platformGeneration && left.dataHistoryId === right.dataHistoryId;
+/** Browser recovery scope only; reconciliation must verify the owning session separately. */
+const RecoverySessionId = defineId("rec", "ignotum/platform/RecoverySessionId");
+const RecoveryIdentity = strict$1({
+	invocationId: InvocationId,
+	originalSelection: ExecutionSelection
+});
+const RecoveryLimits = {
+	maxOperations: 1024,
+	maxRetentionMs: 6048e5
+};
+const RecoveryRecordV1 = strict$1({
+	formatVersion: Schema.Literal(1),
+	appId: AppId,
+	clientSessionId: RecoverySessionId,
+	recordedAt: Schema.Natural,
+	expiresAt: Schema.Natural,
+	operations: Schema.Array(RecoveryIdentity).check(Schema.isMaxLength(RecoveryLimits.maxOperations))
+}).check(Schema.makeFilter((record) => {
+	const issues = [];
+	if (record.expiresAt <= record.recordedAt || record.expiresAt - record.recordedAt > RecoveryLimits.maxRetentionMs) issues.push({
+		path: ["expiresAt"],
+		issue: "Recovery retention must be positive and bounded"
+	});
+	if (record.operations.some((operation) => operation.originalSelection.appId !== record.appId)) issues.push({
+		path: ["operations"],
+		issue: "Recovery operations must belong to the record's app"
+	});
+	const identities = record.operations.map((operation) => `${operation.originalSelection.dataHistoryId}/${operation.invocationId}`);
+	if (new Set(identities).size !== identities.length) issues.push({
+		path: ["operations"],
+		issue: "Recovery operation identities must be unique within a data history"
+	});
+	return issues;
+})).annotate({ parseOptions: { onExcessProperty: "error" } });
+initial(RecoveryRecordV1);
+const RetentionTarget = Schema.Union([
+	strict$1({
+		kind: Schema.Literal("Version"),
+		appId: AppId,
+		versionId: VersionId
+	}),
+	strict$1({
+		kind: Schema.Literal("PlatformRelease"),
+		platformReleaseId: PlatformReleaseId
+	}),
+	strict$1({
+		kind: Schema.Literal("AppArtifact"),
+		appId: AppId,
+		versionId: VersionId,
+		sha256: Sha256
+	}),
+	strict$1({
+		kind: Schema.Literal("PlatformArtifact"),
+		platformReleaseId: PlatformReleaseId,
+		sha256: Sha256
+	})
+]);
+const RetentionOwnerV1 = Schema.Union([
+	strict$1({
+		reason: Schema.Literal("Rollback"),
+		appId: AppId
+	}),
+	strict$1({
+		reason: Schema.Literal("Recovery"),
+		appId: AppId,
+		clientSessionId: RecoverySessionId
+	}),
+	strict$1({
+		reason: Schema.Literal("DataHistory"),
+		appId: AppId,
+		dataHistoryId: DataHistoryId
+	})
+]);
+const RetentionOwner = Schema.Union([RetentionOwnerV1, strict$1({
+	reason: Schema.Literal("Lifecycle"),
+	appId: AppId,
+	key: Schema.String.check(Schema.isPattern(/^[a-zA-Z0-9][a-zA-Z0-9._:/-]{0,127}$/))
+})]);
+const RetentionReferenceV1 = strict$1({
+	formatVersion: Schema.Literal(1),
+	owner: RetentionOwnerV1,
+	target: RetentionTarget
+}).check(Schema.makeFilter((reference) => (reference.target.kind === "Version" || reference.target.kind === "AppArtifact") && reference.target.appId !== reference.owner.appId ? "Retention references must belong to the owner's app" : void 0)).annotate({ parseOptions: { onExcessProperty: "error" } });
+const RetentionReferenceV2 = strict$1({
+	formatVersion: Schema.Literal(2),
+	owner: RetentionOwner,
+	target: RetentionTarget
+}).check(Schema.makeFilter((reference) => (reference.target.kind === "Version" || reference.target.kind === "AppArtifact") && reference.target.appId !== reference.owner.appId ? "Retention references must belong to the owner's app" : void 0));
+upgrade(initial(RetentionReferenceV1), RetentionReferenceV2, (previous) => ({
+	...previous,
+	formatVersion: 2
+}));
+//#endregion
+//#region ../contracts/dist/app-definition.js
+const appDefinitionLimits = {
+	declarationBytes: 1048576,
+	artifactBytes: 16777216,
+	totalArtifactBytes: 134217728,
+	serverArtifactBytes: 67108864,
+	artifacts: 512,
+	modules: 512,
+	importsPerModule: 256,
+	routes: 512,
+	layouts: 128,
+	functions: 512,
+	conversions: 512,
+	urlFields: 64,
+	literalValues: 64,
+	textLength: 4096,
+	configurationDepth: 96,
+	configurationNodes: 65536,
+	descriptorDepth: 32,
+	descriptorNodes: 8192,
+	graphDepth: 64,
+	moduleTokens: 1e5
+};
+const strict = (fields) => Schema.Struct(fields).annotate({ parseOptions: { onExcessProperty: "error" } });
+const Name = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256));
+const Text = Schema.String.check(Schema.isMaxLength(appDefinitionLimits.textLength));
+const ExportName = Schema.String.check(Schema.isPattern(/^[A-Za-z_$][A-Za-z0-9_$]*$/), Schema.isTrimmed());
+const AppArtifactPath = ArtifactPath.check(Schema.isTrimmed(), Schema.isMaxLength(512), Schema.isPattern(/^(?:[A-Za-z0-9_-][A-Za-z0-9_.-]*\/)*[A-Za-z0-9_-][A-Za-z0-9_.-]*$/));
+const AppModuleId = Schema.String.check(Schema.isTrimmed(), Schema.isMaxLength(512), Schema.isPattern(/^app\/(?:client|server)\/(?:[A-Za-z0-9_-][A-Za-z0-9_.-]*\/)*[A-Za-z0-9_-][A-Za-z0-9_.-]*$/)).pipe(Schema.brand("ignotum/app-definition/AppModuleId"));
+const RouteId = Name.pipe(Schema.brand("ignotum/app-definition/RouteId"));
+const LayoutId = Name.pipe(Schema.brand("ignotum/app-definition/LayoutId"));
+const ModuleExportReference = strict({
+	module: AppModuleId,
+	exportName: ExportName
+});
+const ModuleImport = Schema.Union([
+	strict({
+		kind: Schema.Literal("App"),
+		specifier: Name,
+		module: AppModuleId
+	}),
+	strict({
+		kind: Schema.Literal("Runtime"),
+		specifier: Schema.Literals([
+			"ignotum/client",
+			"ignotum/client/jsx-runtime",
+			"ignotum/client/jsx-dev-runtime",
+			"ignotum/server"
+		])
+	}),
+	strict({
+		kind: Schema.Literal("Compiler"),
+		specifier: Schema.Literals([
+			"ignotum/internal/api",
+			"ignotum/internal/client",
+			"ignotum/internal/routes",
+			"ignotum/internal/bootstrap",
+			"ignotum/internal/server"
+		])
+	}),
+	strict({
+		kind: Schema.Literal("RenderingPeer"),
+		specifier: Schema.Literals([
+			"preact",
+			"preact/hooks",
+			"preact/jsx-runtime",
+			"preact/jsx-dev-runtime"
+		])
+	}),
+	strict({
+		kind: Schema.Literal("HostBridge"),
+		specifier: Schema.Literal("ignotum:host")
+	})
+]);
+const AppModule = strict({
+	id: AppModuleId,
+	artifact: AppArtifactPath,
+	imports: Schema.Array(ModuleImport).check(Schema.isMaxLength(appDefinitionLimits.importsPerModule)),
+	sourceMap: Schema.optional(AppArtifactPath),
+	assets: Schema.optional(Schema.Array(AppArtifactPath).check(Schema.isMaxLength(appDefinitionLimits.artifacts))),
+	styles: Schema.optional(Schema.Array(AppArtifactPath).check(Schema.isMaxLength(appDefinitionLimits.artifacts)))
+});
+const AppModuleGraph = strict({
+	entries: Schema.Array(AppModuleId).check(Schema.isMaxLength(appDefinitionLimits.modules)),
+	modules: Schema.Array(AppModule).check(Schema.isMaxLength(appDefinitionLimits.modules))
+});
+const ArtifactFields = {
+	path: AppArtifactPath,
+	size: Schema.Natural.check(Schema.isLessThanOrEqualTo(appDefinitionLimits.artifactBytes)),
+	sha256: Sha256,
+	contentType: Name,
+	contentEncoding: Schema.optional(Schema.Literal("gzip"))
+};
+const AppArtifact = Schema.Union([
+	strict({
+		...ArtifactFields,
+		kind: Schema.Literals([
+			"ClientModule",
+			"Style",
+			"Image",
+			"Icon"
+		]),
+		visibility: Schema.Literal("public")
+	}),
+	strict({
+		...ArtifactFields,
+		kind: Schema.Literal("ServerModule"),
+		visibility: Schema.Literal("private")
+	}),
+	strict({
+		...ArtifactFields,
+		kind: Schema.Literal("SourceMap"),
+		visibility: Schema.Literal("private"),
+		owner: AppModuleId
+	})
+]);
+const UrlLiteral = Schema.Union([
+	Text,
+	Schema.Finite,
+	Schema.Boolean
+]);
+const UrlScalarDescriptor = Schema.Union([
+	strict({ type: Schema.Literal("string") }),
+	strict({
+		type: Schema.Literal("id"),
+		table: Name
+	}),
+	strict({ type: Schema.Literal("number") }),
+	strict({ type: Schema.Literal("integer") }),
+	strict({ type: Schema.Literal("boolean") }),
+	strict({
+		type: Schema.Literal("literal"),
+		value: UrlLiteral
+	}),
+	strict({
+		type: Schema.Literal("literals"),
+		values: Schema.Array(UrlLiteral).check(Schema.isMinLength(1), Schema.isMaxLength(appDefinitionLimits.literalValues), Schema.makeFilter((values) => new Set(values.map(String)).size === values.length || "URL literal encodings must be unique"))
+	})
+]);
+const urlScalarSchema = (descriptor) => {
+	switch (descriptor.type) {
+		case "string": return Text;
+		case "id": return GeneratedId;
+		case "number": return Schema.Finite;
+		case "integer": return Schema.Int;
+		case "boolean": return Schema.Boolean;
+		case "literal": return Schema.Literal(descriptor.value);
+		case "literals": return Schema.Literals(descriptor.values);
+	}
+};
+const UrlRequiredDescriptor = Schema.Union([UrlScalarDescriptor, strict({
+	type: Schema.Literal("array"),
+	value: UrlScalarDescriptor
+})]);
+const UrlDefault = Schema.Union([UrlLiteral, Schema.Array(UrlLiteral).check(Schema.isMaxLength(256))]);
+const UrlValueDescriptor = Schema.Union([
+	UrlRequiredDescriptor,
+	strict({
+		type: Schema.Literal("optional"),
+		value: UrlRequiredDescriptor
+	}),
+	strict({
+		type: Schema.Literal("default"),
+		value: UrlRequiredDescriptor,
+		default: UrlDefault
+	}).check(Schema.makeFilter((descriptor) => {
+		const valueSchema = descriptor.value.type === "array" ? Schema.Array(urlScalarSchema(descriptor.value.value)) : urlScalarSchema(descriptor.value);
+		return Schema.is(valueSchema)(descriptor.default) || "The URL default must satisfy its value descriptor";
+	})).annotate({ parseOptions: { onExcessProperty: "error" } })
+]);
+const UrlField = strict({
+	name: Name,
+	value: UrlValueDescriptor
+});
+const PathUrlField = strict({
+	name: Name,
+	value: Schema.Union([UrlScalarDescriptor, strict({
+		type: Schema.Literal("array"),
+		value: strict({ type: Schema.Literal("string") })
+	})])
+});
+const Meta = strict({
+	description: Schema.optional(Text),
+	robots: Schema.optional(Text)
+});
+const StaticMetadata = strict({
+	title: Schema.optional(Text),
+	meta: Schema.optional(Meta)
+});
+const LayoutMetadata = strict({
+	title: Schema.optional(Text),
+	titleTemplate: Schema.optional(Text.check(Schema.makeFilter((template) => template.split("%s").length === 2 || "A title template must contain exactly one %s placeholder"))),
+	meta: Schema.optional(Meta)
+});
+const RoutePattern = Schema.String.check(Schema.isMaxLength(2048), Schema.isPattern(/^\/(?!_ignotum(?:\/|$))[^?#\\\0]*$/));
+const RouteDefinition = strict({
+	id: RouteId,
+	pattern: RoutePattern,
+	directoryScope: Schema.optional(RoutePattern),
+	precedence: Schema.Array(Schema.Natural).check(Schema.isMaxLength(128)),
+	params: Schema.Array(PathUrlField).check(Schema.isMaxLength(appDefinitionLimits.urlFields)),
+	searchParams: Schema.Array(UrlField).check(Schema.isMaxLength(appDefinitionLimits.urlFields)),
+	page: ModuleExportReference,
+	layouts: Schema.Array(LayoutId).check(Schema.isMaxLength(appDefinitionLimits.layouts)),
+	metadata: StaticMetadata,
+	boundaries: strict({
+		error: Schema.Boolean,
+		invalid: Schema.Boolean
+	})
+});
+const LayoutDefinition = strict({
+	id: LayoutId,
+	scope: RoutePattern,
+	parent: Schema.optional(LayoutId),
+	module: ModuleExportReference,
+	metadata: LayoutMetadata,
+	boundaries: strict({
+		error: Schema.Boolean,
+		invalid: Schema.Boolean,
+		notFound: Schema.Boolean
+	})
+});
+const FunctionDefinition = strict({
+	address: FunctionAddress,
+	kind: FunctionKind,
+	entry: ModuleExportReference,
+	args: ValueDescriptor,
+	returns: Schema.optional(ValueDescriptor),
+	errors: ValueDescriptor
+});
+const SchemaConversion = strict({
+	table: Name,
+	field: Name,
+	from: ValueDescriptor,
+	to: ValueDescriptor,
+	entry: ModuleExportReference
+});
+const AppDefinitionV1 = strict({
+	formatVersion: Schema.Literal(1),
+	appName: Name,
+	requirements: RuntimeRequirements,
+	client: strict({
+		registration: ModuleExportReference,
+		graph: AppModuleGraph,
+		routes: Schema.Array(RouteDefinition).check(Schema.isMaxLength(appDefinitionLimits.routes)),
+		layouts: Schema.Array(LayoutDefinition).check(Schema.isMaxLength(appDefinitionLimits.layouts)),
+		styles: Schema.Array(AppArtifactPath).check(Schema.isMaxLength(appDefinitionLimits.artifacts)),
+		icon: Schema.optional(AppArtifactPath)
+	}),
+	server: strict({
+		graph: AppModuleGraph,
+		functions: Schema.Array(FunctionDefinition).check(Schema.isMaxLength(appDefinitionLimits.functions)),
+		schema: strict({
+			entry: ModuleExportReference,
+			identity: Sha256,
+			descriptor: SchemaSnapshot,
+			conversions: Schema.Array(SchemaConversion).check(Schema.isMaxLength(appDefinitionLimits.conversions))
+		})
+	}),
+	artifacts: Schema.Array(AppArtifact).check(Schema.isMaxLength(appDefinitionLimits.artifacts))
+}).check(Schema.makeFilter((definition) => definition.artifacts.reduce((sum, artifact) => sum + artifact.size, 0) <= appDefinitionLimits.totalArtifactBytes || "App artifacts exceed the total byte limit"), Schema.makeFilter((definition) => definition.artifacts.filter((artifact) => artifact.visibility === "private").reduce((sum, artifact) => sum + artifact.size, 0) <= appDefinitionLimits.serverArtifactBytes || "Private artifacts exceed the server byte limit"), Schema.makeFilter((definition) => new TextEncoder().encode(JSON.stringify(definition)).byteLength <= appDefinitionLimits.declarationBytes || "App definition exceeds the declaration byte limit"));
+const AppDefinitionThroughV1 = initial(AppDefinitionV1.annotate({ parseOptions: { onExcessProperty: "error" } }));
+AppDefinitionV1.fields.server;
+const AppDefinition = AppDefinitionThroughV1;
+const ProtectedEnvironmentReference = strict({
+	artifact: strict({
+		path: AppArtifactPath,
+		size: ArtifactFields.size,
+		sha256: Sha256
+	}),
+	fields: Schema.Array(SchemaSnapshotField).check(Schema.isMaxLength(256))
+});
+const UploadDeclarationV1 = strict({
+	formatVersion: Schema.Literal(1),
+	definition: AppDefinition,
+	environment: Schema.optional(ProtectedEnvironmentReference)
+}).check(Schema.makeFilter((declaration) => new TextEncoder().encode(JSON.stringify(declaration)).byteLength <= appDefinitionLimits.declarationBytes || "Upload declaration exceeds the declaration byte limit"), Schema.makeFilter((declaration) => declaration.definition.artifacts.reduce((sum, artifact) => sum + artifact.size, declaration.environment?.artifact.size ?? 0) <= appDefinitionLimits.totalArtifactBytes || "Upload artifacts exceed the total byte limit"), Schema.makeFilter((declaration) => declaration.definition.artifacts.filter((artifact) => artifact.visibility === "private").reduce((sum, artifact) => sum + artifact.size, declaration.environment?.artifact.size ?? 0) <= appDefinitionLimits.serverArtifactBytes || "Protected upload artifacts exceed the server byte limit"));
+initial(UploadDeclarationV1.annotate({ parseOptions: { onExcessProperty: "error" } }));
+const VersionAdmissionRecordV1 = Schema.Union([strict({
+	formatVersion: Schema.Literal(1),
+	versionId: VersionId,
+	state: Schema.Literals([
+		"Uploading",
+		"Validating",
+		"Rejected"
+	]),
+	eligible: Schema.Literal(false)
+}), strict({
+	formatVersion: Schema.Literal(1),
+	versionId: VersionId,
+	state: Schema.Literal("Finalized"),
+	number: VersionNumber,
+	eligible: Schema.Boolean
+})]);
+initial(VersionAdmissionRecordV1);
+//#endregion
+//#region src/internal/routes.ts
+const RouteReferenceTypeId = Symbol.for("ignotum/internal/routes/RouteReference");
+const createRouteReference = (definition) => ({ [RouteReferenceTypeId]: Schema.decodeUnknownSync(RouteDefinition)(definition) });
+const getRouteDefinition = (reference) => reference[RouteReferenceTypeId];
+//#endregion
+export { RouteDefinition as a, UrlValueDescriptor as c, RecoveryIdentity as d, RecoverySessionId as f, LayoutMetadata as i, appDefinitionLimits as l, getRouteDefinition as n, StaticMetadata as o, sameExecutionSelection as p, LayoutDefinition as r, UrlScalarDescriptor as s, createRouteReference as t, ExecutionSelection as u };
+
+//# sourceMappingURL=routes-Ce8TVP-T.js.map