@sjcx/vorma 0.0.0-pre.0 → 0.0.0-pre.1

package/dist/build/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { C as toContentDigest, S as encodeCanonicalJson, _ as compileServerApplication, a as acquireOutputOwnership, b as getClientViewEntries, c as writeAndCheckApplicationGeneration, d as withTypescriptProjects, f as inspectProjects, g as createClientPublicUrlPlugin, h as createCssPublicAssets, i as publishApplicationArtifacts, l as collectPublicAssets, m as resolveVormaConfig, n as loadApplicationSourceLayout, o as checkOutputPath, p as getGeneratedSourceDirectories, r as preparePublicOutput, s as assembleApplicationGeneration, t as buildApplication, u as readTypescriptProjectRoots, v as containsRelativePath, x as projectBrowserContracts, y as CLIENT_SHARED_PACKAGES } from "../build-JgARonaY.js";
+import { C as encodeCanonicalJson, S as projectBrowserContracts, _ as createClientPublicUrlPlugin, a as acquireOutputOwnership, b as CLIENT_SHARED_PACKAGES, c as writeAndCheckApplicationGeneration, d as readTypescriptProjectRoots, f as runTypescriptOperation, g as createCssPublicAssets, h as resolveVormaConfig, i as publishApplicationArtifacts, l as collectPublicAssets, m as getGeneratedSourceDirectories, n as loadApplicationSourceLayout, o as checkOutputPath, p as withTypescriptProjects, r as preparePublicOutput, s as assembleApplicationGeneration, t as buildApplication, u as inspectProjects, v as compileServerApplication, w as toContentDigest, x as getClientViewEntries, y as containsRelativePath } from "../build-DcP5_DUV.js";
 import { g as DEVELOPMENT_PROTOCOL, y as FRAMEWORK_IDENTITY_PROTOCOL } from "../value-transport-Bst4Hk-n.js";
 import { t as VORMA_BUILD_PLUGIN_NAME } from "../build-invocation-D7Fu8gBK.js";
 import { VormaConfigSchema } from "../server/config/index.js";
@@ -510,22 +510,13 @@ function inspectDevelopmentSources(layout) {
 						projects,
 						layout
 					});
-					const sources = yield* Effect.try({
-						try: () => {
-							return {
-								serverRootFiles: new Set(projects.server.rootFiles.map(normalizePath)),
-								clientRootFiles: new Set(projects.client.rootFiles.map(normalizePath)),
-								serverFiles: new Set(projects.server.program.getSourceFileNames().map(normalizePath)),
-								clientFiles: new Set(projects.client.program.getSourceFileNames().map(normalizePath))
-							};
-						},
-						catch: (cause) => {
-							return {
-								_tag: "TypescriptProjectError",
-								message: "Could not read TypeScript development inputs",
-								cause
-							};
-						}
+					const sources = yield* runTypescriptOperation(async () => {
+						return {
+							serverRootFiles: new Set(projects.server.rootFiles.map(normalizePath)),
+							clientRootFiles: new Set(projects.client.rootFiles.map(normalizePath)),
+							serverFiles: new Set((await projects.server.program.getSourceFileNames()).map(normalizePath)),
+							clientFiles: new Set((await projects.client.program.getSourceFileNames()).map(normalizePath))
+						};
 					});
 					return {
 						inspection,

package/dist/build/development-sources.d.ts

@@ -1,6 +1,5 @@
 import { Effect, Path } from "effect";
 import type { ApplicationSourceLayout } from "./source-layout.ts";
-import { type TypescriptProjectError } from "./typescript-projects.ts";
 export type DevelopmentSourceInputs = {
     readonly serverFiles: ReadonlySet<string>;
     readonly clientFiles: ReadonlySet<string>;
@@ -15,7 +14,7 @@ export type DevelopmentSourceInputs = {
 export declare function inspectDevelopmentSources(layout: ApplicationSourceLayout): Effect.Effect<{
     inspection: import("./inspect-projects.ts").InspectedProjects;
     inputs: DevelopmentSourceInputs;
-}, import("./inspect-projects.ts").InspectionIssue | TypescriptProjectError, Path.Path>;
+}, import("./inspect-projects.ts").InspectionIssue | import("./typescript-projects.ts").TypescriptProjectError, Path.Path>;
 /** Watches native compiler inputs while keeping generated writes out of the event stream. */
 export declare function getDevelopmentSourceWatchPaths(input: {
     readonly layout: ApplicationSourceLayout;

package/dist/build/index.js

@@ -1,2 +1,2 @@
-import { t as buildApplication } from "../build-JgARonaY.js";
+import { t as buildApplication } from "../build-DcP5_DUV.js";
 export { buildApplication };

package/dist/build/inspect-projects.d.ts

@@ -3,7 +3,7 @@ import * as Path from "effect/Path";
 import type { HttpMethod, InputTransport } from "../server/graph/declarations.ts";
 import type { EffectTransportMarkKind } from "../universal/value-transport.ts";
 import type { ApplicationSourceLayout } from "./source-layout.ts";
-import type { TypescriptProjects } from "./typescript-projects.ts";
+import { type TypescriptProjectError, type TypescriptProjects } from "./typescript-projects.ts";
 export type DeclarationSource = {
     readonly filePath: string;
     readonly exportName: string;
@@ -66,4 +66,4 @@ export type InspectionIssue = {
 export declare function inspectProjects(input: {
     readonly projects: TypescriptProjects;
     readonly layout: ApplicationSourceLayout;
-}): Effect.Effect<InspectedProjects, InspectionIssue, Path.Path>;
+}): Effect.Effect<InspectedProjects, InspectionIssue | TypescriptProjectError, Path.Path>;

package/dist/build/render-types.d.ts

@@ -1,5 +1,5 @@
 import { Result } from "effect";
-import { type Checker, type Emitter, type Program, type Symbol as TypeSymbol, type Type } from "typescript/unstable/sync";
+import { type Checker, type Emitter, type Program, type Symbol as TypeSymbol, type Type } from "typescript/unstable/async";
 import type { EffectTransportMarkKind } from "../universal/value-transport.ts";
 export type TypeRenderIssue = {
     readonly _tag: "UnrenderableContractType";
@@ -11,7 +11,7 @@ export type TypeRenderer = {
     readonly renderType: (input: {
         readonly type: Type;
         readonly depth: number;
-    }) => Result.Result<string, TypeRenderIssue>;
+    }) => Promise<Result.Result<string, TypeRenderIssue>>;
     /** The alias declarations that rendering needed, each at depth zero. */
     readonly renderAliases: () => ReadonlyArray<string>;
     /** The Effect modules that rendered text names, for the generated file's type imports. */
@@ -23,9 +23,9 @@ export type TypeRenderer = {
 export declare function matchesLibrarySymbol(input: {
     readonly program: Program;
     readonly symbol: TypeSymbol;
-}): boolean;
+}): Promise<boolean>;
 export declare function createTypeRenderer(input: {
     readonly checker: Checker;
     readonly program: Program;
     readonly emitter: Emitter;
-}): TypeRenderer;
+}): Promise<TypeRenderer>;

package/dist/build/typescript-projects.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { type APIOptions, type Project } from "typescript/unstable/sync";
+import { type APIOptions, type Project } from "typescript/unstable/async";
 export type TypescriptProjectError = {
     readonly _tag: "TypescriptProjectError";
     readonly message: string;
@@ -34,3 +34,5 @@ export declare function withTypescriptProjects<A, E, R>(input: {
     readonly fileSystem?: APIOptions["fs"];
     readonly useFn: (projects: TypescriptProjects) => Effect.Effect<A, E, R>;
 }): Effect.Effect<A, E | TypescriptProjectError, R>;
+/** Native compiler operations have no cancellation API; settle each operation before its session can close. */
+export declare function runTypescriptOperation<Value>(fn: () => Promise<Value>): Effect.Effect<Value, TypescriptProjectError, never>;

package/dist/{build-JgARonaY.js → build-DcP5_DUV.js}

@@ -12,7 +12,7 @@ import { RolldownMagicString, build as build$1 } from "rolldown";
 import { readFile } from "node:fs/promises";
 import * as Path$1 from "effect/Path";
 import { SyntaxKind, TokenFlags, isAsExpression, isCallExpression, isElementAccessExpression, isExportSpecifier, isIdentifier, isImportClause, isImportSpecifier, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNonNullExpression, isParenthesizedExpression, isPropertyAccessExpression, isSatisfiesExpression, isStringLiteral, isTypeAssertion, isTypeNode } from "typescript/unstable/ast";
-import { API, ElementFlags, SignatureKind, SymbolFlags } from "typescript/unstable/sync";
+import { API, ElementFlags, SignatureKind, SymbolFlags } from "typescript/unstable/async";
 import { createTemplateHead, createTemplateMiddle, createTemplateTail } from "typescript/unstable/ast/factory";
 import * as FileSystem$1 from "effect/FileSystem";
 import { pid, platform } from "node:process";
@@ -455,8 +455,8 @@ function toRelativeSpecifier(relativePath) {
 //#endregion
 //#region src/build/render-types.ts
 /** Removes the checker's missing-value marker, which is distinct from the ordinary `undefined` type. */
-function withoutAbsence(input) {
-	const members = input.type.isUnionType() ? input.type.getTypes() : [input.type];
+async function withoutAbsence(input) {
+	const members = input.type.isUnionType() ? await input.type.getTypes() : [input.type];
 	const present = members.filter((member) => {
 		return !(member.isIntrinsicType() && member.intrinsicName === "undefined" && member.id !== input.undefinedType.id);
 	});
@@ -543,26 +543,26 @@ function sortProperties(properties) {
 	});
 }
 /** True when a symbol is declared outside the application: in a default library or an installed package. */
-function matchesLibrarySymbol(input) {
+async function matchesLibrarySymbol(input) {
 	const declaration = input.symbol.declarations[0];
 	if (declaration === void 0) return false;
 	const declarationPath = String(declaration.path);
-	const metadata = input.program.getSourceFileMetadata(declarationPath);
+	const metadata = await input.program.getSourceFileMetadata(declarationPath);
 	return metadata !== void 0 && (metadata.isDefaultLibrary || metadata.isFromExternalLibrary || declarationPath.includes("/node_modules/"));
 }
-function createTypeRenderer(input) {
+async function createTypeRenderer(input) {
 	const { checker, program, emitter } = input;
-	const undefinedType = checker.getUndefinedType();
+	const undefinedType = await checker.getUndefinedType();
 	const aliases = /* @__PURE__ */ new Map();
 	const rendered = [];
 	const visiting = /* @__PURE__ */ new Set();
 	const effectModules = /* @__PURE__ */ new Set();
 	const transportTypeNames = /* @__PURE__ */ new Set();
-	function fail(type, reason) {
+	async function fail(type, reason) {
 		return Result.fail({
 			_tag: "UnrenderableContractType",
 			reason,
-			typeText: checker.typeToString(type)
+			typeText: await checker.typeToString(type)
 		});
 	}
 	function getDeclarationPath(symbol) {
@@ -576,72 +576,72 @@ function createTypeRenderer(input) {
 			return entry.symbolName === symbol.name && declarationPath.endsWith(`/effect/dist/${entry.module}.d.ts`);
 		});
 	}
-	function matchesReadonlyProperty(property) {
+	async function matchesReadonlyProperty(property) {
 		if ((property.checkFlags & CHECK_FLAG_READONLY) !== 0) return true;
-		const declaration = property.valueDeclaration?.resolve();
+		const declaration = await property.valueDeclaration?.resolve();
 		if (declaration === void 0) return false;
 		const modifiers = declaration.modifiers;
 		return modifiers !== void 0 && modifiers.some((modifier) => {
 			return modifier.kind === SyntaxKind.ReadonlyKeyword;
 		});
 	}
-	function renderTypeArguments(type, depth) {
+	async function renderTypeArguments(type, depth) {
 		const parts = [];
-		for (const argument of checker.getTypeArguments(type)) {
-			const text = renderNode(argument, depth);
+		for (const argument of await checker.getTypeArguments(type)) {
+			const text = await renderNode(argument, depth);
 			if (Result.isFailure(text)) return text;
 			parts.push(text.success);
 		}
 		return Result.succeed(parts.length === 0 ? "" : `<${parts.join(", ")}>`);
 	}
-	function renderNamedType(type, depth) {
-		const aliasSymbol = type.getAliasSymbol();
-		const symbol = type.getSymbol();
+	async function renderNamedType(type, depth) {
+		const aliasSymbol = await type.getAliasSymbol();
+		const symbol = await type.getSymbol();
 		for (const candidate of [aliasSymbol, symbol]) {
 			if (candidate === void 0) continue;
 			const effectType = matchesEffectType(candidate);
 			if (effectType !== void 0) {
 				effectModules.add(effectType.module);
 				transportTypeNames.add(effectType.kind);
-				const argumentTypes = candidate === aliasSymbol ? type.getAliasTypeArguments() : type.isTypeReference() ? checker.getTypeArguments(type) : [];
+				const argumentTypes = candidate === aliasSymbol ? await type.getAliasTypeArguments() : type.isTypeReference() ? await checker.getTypeArguments(type) : [];
 				const parts = [];
 				for (const argument of argumentTypes) {
-					const text = renderNode(argument, depth);
+					const text = await renderNode(argument, depth);
 					if (Result.isFailure(text)) return text;
 					parts.push(text.success);
 				}
 				return Result.succeed(parts.length === 0 ? effectType.printedName : `${effectType.printedName}<${parts.join(", ")}>`);
 			}
 		}
-		if (symbol !== void 0 && PLATFORM_TYPE_NAMES.has(symbol.name) && matchesLibrarySymbol({
+		if (symbol !== void 0 && PLATFORM_TYPE_NAMES.has(symbol.name) && await matchesLibrarySymbol({
 			program,
 			symbol
 		})) {
-			const argumentsText = type.isTypeReference() ? renderTypeArguments(type, depth) : Result.succeed("");
+			const argumentsText = type.isTypeReference() ? await renderTypeArguments(type, depth) : Result.succeed("");
 			return Result.map(argumentsText, (text) => `${symbol.name}${text}`);
 		}
 		return Result.succeed(null);
 	}
-	function renderProperty(input) {
-		if (checker.getSignaturesOfType(input.propertyType, SignatureKind.Call).length > 0) return fail(input.propertyType, `the property ${input.property.name} is a function, which cannot cross the wire`);
+	async function renderProperty(input) {
+		if ((await checker.getSignaturesOfType(input.propertyType, SignatureKind.Call)).length > 0) return await fail(input.propertyType, `the property ${input.property.name} is a function, which cannot cross the wire`);
 		const optional = (input.property.flags & SymbolFlags.Optional) !== 0;
-		const text = optional ? renderOptionalType(input.propertyType, input.depth) : renderNode(input.propertyType, input.depth);
+		const text = optional ? await renderOptionalType(input.propertyType, input.depth) : await renderNode(input.propertyType, input.depth);
 		if (Result.isFailure(text)) return text;
-		const readonly = matchesReadonlyProperty(input.property) ? "readonly " : "";
+		const readonly = await matchesReadonlyProperty(input.property) ? "readonly " : "";
 		return Result.succeed(`${toIndent(input.depth)}${readonly}${renderPropertyName(input.property.name)}${optional ? "?" : ""}: ${text.success};`);
 	}
 	/** A class instance crosses the wire as the record of its schema fields; the fields come from the class's static `fields`. */
-	function renderClassInstance(type, classSymbol, depth) {
-		const constructorType = checker.getTypeOfSymbol(classSymbol);
-		const fields = constructorType === void 0 ? void 0 : checker.getPropertyOfType(constructorType, "fields");
-		const fieldsType = fields === void 0 ? void 0 : checker.getTypeOfSymbol(fields);
-		if (fieldsType === void 0) return fail(type, `the class ${classSymbol.name} is not an Effect Schema class, so its wire form is unknown`);
+	async function renderClassInstance(type, classSymbol, depth) {
+		const constructorType = await checker.getTypeOfSymbol(classSymbol);
+		const fields = constructorType === void 0 ? void 0 : await checker.getPropertyOfType(constructorType, "fields");
+		const fieldsType = fields === void 0 ? void 0 : await checker.getTypeOfSymbol(fields);
+		if (fieldsType === void 0) return await fail(type, `the class ${classSymbol.name} is not an Effect Schema class, so its wire form is unknown`);
 		const lines = [];
-		for (const field of sortProperties(checker.getPropertiesOfType(fieldsType))) {
-			const property = checker.getPropertyOfType(type, field.name);
-			const propertyType = property === void 0 ? void 0 : checker.getTypeOfSymbol(property);
-			if (property === void 0 || propertyType === void 0) return fail(type, `the class ${classSymbol.name} declares the field ${field.name} without a property of that name`);
-			const line = renderProperty({
+		for (const field of sortProperties(await checker.getPropertiesOfType(fieldsType))) {
+			const property = await checker.getPropertyOfType(type, field.name);
+			const propertyType = property === void 0 ? void 0 : await checker.getTypeOfSymbol(property);
+			if (property === void 0 || propertyType === void 0) return await fail(type, `the class ${classSymbol.name} declares the field ${field.name} without a property of that name`);
+			const line = await renderProperty({
 				property,
 				propertyType,
 				depth: depth + 1
@@ -655,16 +655,16 @@ function createTypeRenderer(input) {
 			`${toIndent(depth)}}`
 		].join("\n"));
 	}
-	function renderObject(type, depth) {
-		const symbol = type.getSymbol();
-		if (symbol !== void 0 && (symbol.flags & SymbolFlags.Class) !== 0) return renderClassInstance(type, symbol, depth);
-		if (checker.getSignaturesOfType(type, SignatureKind.Call).length > 0 || checker.getSignaturesOfType(type, SignatureKind.Construct).length > 0) return fail(type, "a function cannot cross the wire");
+	async function renderObject(type, depth) {
+		const symbol = await type.getSymbol();
+		if (symbol !== void 0 && (symbol.flags & SymbolFlags.Class) !== 0) return await renderClassInstance(type, symbol, depth);
+		if ((await checker.getSignaturesOfType(type, SignatureKind.Call)).length > 0 || (await checker.getSignaturesOfType(type, SignatureKind.Construct)).length > 0) return await fail(type, "a function cannot cross the wire");
 		const lines = [];
-		for (const property of sortProperties(checker.getPropertiesOfType(type))) {
+		for (const property of sortProperties(await checker.getPropertiesOfType(type))) {
 			if (String(property.escapedName).startsWith("__@")) continue;
-			const propertyType = checker.getTypeOfSymbol(property);
-			if (propertyType === void 0) return fail(type, `the property ${property.name} has no type`);
-			const line = renderProperty({
+			const propertyType = await checker.getTypeOfSymbol(property);
+			if (propertyType === void 0) return await fail(type, `the property ${property.name} has no type`);
+			const line = await renderProperty({
 				property,
 				propertyType,
 				depth: depth + 1
@@ -672,10 +672,10 @@ function createTypeRenderer(input) {
 			if (Result.isFailure(line)) return line;
 			lines.push(line.success);
 		}
-		for (const signature of checker.getIndexInfosOfType(type)) {
-			const keyText = renderNode(signature.keyType, depth + 1);
+		for (const signature of await checker.getIndexInfosOfType(type)) {
+			const keyText = await renderNode(signature.keyType, depth + 1);
 			if (Result.isFailure(keyText)) return keyText;
-			const valueText = renderNode(signature.valueType, depth + 1);
+			const valueText = await renderNode(signature.valueType, depth + 1);
 			if (Result.isFailure(valueText)) return valueText;
 			lines.push(`${toIndent(depth + 1)}${signature.isReadonly ? "readonly " : ""}[key: ${keyText.success}]: ${valueText.success};`);
 		}
@@ -685,19 +685,19 @@ function createTypeRenderer(input) {
 			`${toIndent(depth)}}`
 		].join("\n"));
 	}
-	function renderOptionalType(type, depth) {
-		const present = withoutAbsence({
+	async function renderOptionalType(type, depth) {
+		const present = await withoutAbsence({
 			type,
 			undefinedType
 		});
-		return present === void 0 ? renderNode(type, depth) : present.length === 1 && present[0] !== void 0 ? renderNode(present[0], depth) : renderUnion(present, depth, " | ");
+		return present === void 0 ? await renderNode(type, depth) : present.length === 1 && present[0] !== void 0 ? await renderNode(present[0], depth) : await renderUnion(present, depth, " | ");
 	}
-	function renderTuple(type, depth) {
-		const target = type.getTarget();
+	async function renderTuple(type, depth) {
+		const target = await type.getTarget();
 		const members = [];
-		for (const [index, element] of checker.getTypeArguments(type).entries()) {
+		for (const [index, element] of (await checker.getTypeArguments(type)).entries()) {
 			const flags = target.elementFlags[index] ?? ElementFlags.Required;
-			const text = (flags & ElementFlags.Optional) !== 0 ? renderOptionalType(element, depth) : renderNode(element, depth);
+			const text = (flags & ElementFlags.Optional) !== 0 ? await renderOptionalType(element, depth) : await renderNode(element, depth);
 			if (Result.isFailure(text)) return text;
 			if ((flags & ElementFlags.Rest) !== 0) members.push(`...Array<${text.success}>`);
 			else if ((flags & ElementFlags.Variadic) !== 0) members.push(`...(${text.success})`);
@@ -706,7 +706,7 @@ function createTypeRenderer(input) {
 		}
 		return Result.succeed(`${target.readonly ? "readonly " : ""}[${members.join(", ")}]`);
 	}
-	function renderUnion(members, depth, separator) {
+	async function renderUnion(members, depth, separator) {
 		const parts = [];
 		let sawTrue = false;
 		let sawFalse = false;
@@ -716,7 +716,7 @@ function createTypeRenderer(input) {
 				else sawFalse = true;
 				continue;
 			}
-			const text = renderNode(member, depth);
+			const text = await renderNode(member, depth);
 			if (Result.isFailure(text)) return text;
 			parts.push(separator === " & " && member.isUnionType() ? `(${text.success})` : text.success);
 		}
@@ -732,26 +732,26 @@ function createTypeRenderer(input) {
 		return Result.succeed(parts.length === 0 ? "never" : parts.join(separator));
 	}
 	/** Keeps literal contents independent of indentation in the containing declaration. */
-	function renderTemplateToken(node) {
-		return emitter.printNode(node).replaceAll("\r", "\\r").replaceAll("\n", "\\n");
+	async function renderTemplateToken(node) {
+		return (await emitter.printNode(node)).replaceAll("\r", "\\r").replaceAll("\n", "\\n");
 	}
-	function renderTemplateLiteral(type, depth) {
-		if (!type.isTemplateLiteralType()) return fail(type, "not a template literal type");
+	async function renderTemplateLiteral(type, depth) {
+		if (!type.isTemplateLiteralType()) return await fail(type, "not a template literal type");
 		const spans = [];
-		for (const span of type.getTypes()) {
-			const text = renderNode(span, depth);
+		for (const span of await type.getTypes()) {
+			const text = await renderNode(span, depth);
 			if (Result.isFailure(text)) return text;
 			spans.push(text.success);
 		}
 		const [head, ...tail] = type.texts;
-		let text = renderTemplateToken(createTemplateHead(head ?? "", "", TokenFlags.None));
+		let text = await renderTemplateToken(createTemplateHead(head ?? "", "", TokenFlags.None));
 		for (const [index, span] of spans.entries()) {
 			const createLiteral = index === spans.length - 1 ? createTemplateTail : createTemplateMiddle;
-			text += span + renderTemplateToken(createLiteral(tail[index] ?? "", "", TokenFlags.None));
+			text += span + await renderTemplateToken(createLiteral(tail[index] ?? "", "", TokenFlags.None));
 		}
 		return Result.succeed(text);
 	}
-	function renderNode(type, depth) {
+	async function renderNode(type, depth) {
 		const existingAlias = aliases.get(type.id);
 		if (existingAlias !== void 0) return Result.succeed(existingAlias);
 		if (visiting.has(type.id)) {
@@ -760,41 +760,41 @@ function createTypeRenderer(input) {
 			return Result.succeed(name);
 		}
 		visiting.add(type.id);
-		const text = renderTypeStructure(type, depth);
+		const text = await renderTypeStructure(type, depth);
 		visiting.delete(type.id);
 		if (Result.isFailure(text)) return text;
 		const createdAlias = aliases.get(type.id);
 		if (createdAlias === void 0) return text;
-		const declared = depth === 0 ? text : renderTypeStructure(type, 0);
+		const declared = depth === 0 ? text : await renderTypeStructure(type, 0);
 		if (Result.isFailure(declared)) return declared;
 		rendered.push(`type ${createdAlias} = ${declared.success};`);
 		return Result.succeed(createdAlias);
 	}
-	function renderTypeStructure(type, depth) {
-		if (type.isErrorType()) return fail(type, "the type could not be resolved");
+	async function renderTypeStructure(type, depth) {
+		if (type.isErrorType()) return await fail(type, "the type could not be resolved");
 		if (type.isStringLiteralType()) return Result.succeed(JSON.stringify(type.value));
 		if (type.isNumberLiteralType()) return Result.succeed(String(type.value));
 		if (type.isBigIntLiteralType()) return Result.succeed(`${type.value}n`);
 		if (type.isBooleanLiteralType()) return Result.succeed(type.value ? "true" : "false");
 		if (type.isIntrinsicType()) return Result.succeed(type.intrinsicName);
-		const named = renderNamedType(type, depth);
+		const named = await renderNamedType(type, depth);
 		if (Result.isFailure(named)) return Result.fail(named.failure);
 		if (named.success !== null) return Result.succeed(named.success);
-		if (type.isTemplateLiteralType()) return renderTemplateLiteral(type, depth);
-		if (type.isUnionType()) return renderUnion(type.getTypes(), depth, " | ");
-		if (type.isIntersectionType()) return renderUnion(type.getTypes(), depth, " & ");
-		if (type.isTypeParameter()) return fail(type, "a contract type cannot be generic");
-		if (!type.isObjectType()) return fail(type, "the type has no wire form");
-		if (checker.isArrayType(type) && type.isTypeReference()) {
-			const [element] = checker.getTypeArguments(type);
-			if (element === void 0) return fail(type, "an array type without an element type");
-			const text = renderNode(element, depth);
+		if (type.isTemplateLiteralType()) return await renderTemplateLiteral(type, depth);
+		if (type.isUnionType()) return await renderUnion(await type.getTypes(), depth, " | ");
+		if (type.isIntersectionType()) return await renderUnion(await type.getTypes(), depth, " & ");
+		if (type.isTypeParameter()) return await fail(type, "a contract type cannot be generic");
+		if (!type.isObjectType()) return await fail(type, "the type has no wire form");
+		if (await checker.isArrayType(type) && type.isTypeReference()) {
+			const [element] = await checker.getTypeArguments(type);
+			if (element === void 0) return await fail(type, "an array type without an element type");
+			const text = await renderNode(element, depth);
 			if (Result.isFailure(text)) return text;
-			const wrapper = type.getSymbol()?.name === "ReadonlyArray" ? "ReadonlyArray" : "Array";
+			const wrapper = (await type.getSymbol())?.name === "ReadonlyArray" ? "ReadonlyArray" : "Array";
 			return Result.succeed(`${wrapper}<${text.success}>`);
 		}
-		if (checker.isTupleType(type) && type.isTypeReference()) return renderTuple(type, depth);
-		return renderObject(type, depth);
+		if (await checker.isTupleType(type) && type.isTypeReference()) return await renderTuple(type, depth);
+		return await renderObject(type, depth);
 	}
 	return {
 		renderType: (input) => renderNode(input.type, input.depth),
@@ -923,37 +923,146 @@ function makePublicAssetsBasePathError(cause) {
 	};
 }
 //#endregion
+//#region src/build/typescript-projects.ts
+/** Reads native project membership without loading programs or declaration types. */
+function readTypescriptProjectRoots(input) {
+	return withTypescriptApi({
+		configDirectory: input.configDirectory,
+		useFn: (api) => {
+			return runTypescriptOperation(async () => {
+				return {
+					server: (await api.parseConfigFile(input.serverTsconfigFilePath)).fileNames,
+					client: (await api.parseConfigFile(input.clientTsconfigFilePath)).fileNames
+				};
+			});
+		}
+	});
+}
+/** Checks actual compiler membership after generation, including restrictive files/include/exclude settings. */
+function checkGeneratedTypeInclusion(input) {
+	return withTypescriptProjects({
+		...input,
+		useFn: (projects) => {
+			return Effect.gen(function* () {
+				const missing = yield* runTypescriptOperation(async () => {
+					const missing = [];
+					for (const [project, files, config] of [[
+						projects.server,
+						input.serverFiles,
+						input.serverTsconfigFilePath
+					], [
+						projects.client,
+						input.clientFiles,
+						input.clientTsconfigFilePath
+					]]) for (const file of files) if (await project.program.getSourceFileMetadata(file) === void 0) missing.push({
+						project: config,
+						file
+					});
+					return missing;
+				});
+				return yield* missing.length === 0 ? Effect.void : Effect.fail({
+					_tag: "TypescriptProjectError",
+					message: missing.map(({ project, file }) => `${project} does not include generated type file ${file}. Include the entry's _vorma directory in that TypeScript project.`).join("\n")
+				});
+			});
+		}
+	});
+}
+/** Opens the two configured TypeScript projects for the duration of `useFn`, then closes the checker session. */
+function withTypescriptProjects(input) {
+	return withTypescriptApi({
+		...input,
+		useFn: (api) => {
+			return Effect.scoped(Effect.gen(function* () {
+				const projects = findProjects({
+					snapshot: yield* Effect.acquireRelease(runTypescriptOperation(() => {
+						return api.updateSnapshot({ openProjects: [input.serverTsconfigFilePath, input.clientTsconfigFilePath] });
+					}), (snapshot) => Effect.promise(() => snapshot.dispose())),
+					...input
+				});
+				return yield* Result.isFailure(projects) ? Effect.fail(projects.failure) : input.useFn(projects.success);
+			}));
+		}
+	});
+}
+/** Native compiler operations have no cancellation API; settle each operation before its session can close. */
+function runTypescriptOperation(fn) {
+	return Effect.tryPromise({
+		try: fn,
+		catch: (cause) => {
+			return {
+				_tag: "TypescriptProjectError",
+				message: "Vorma could not read the application's TypeScript projects",
+				cause
+			};
+		}
+	}).pipe(Effect.uninterruptible);
+}
+function withTypescriptApi(input) {
+	return Effect.scoped(Effect.gen(function* () {
+		const api = yield* Effect.acquireRelease(runTypescriptOperation(async () => {
+			return new API({
+				cwd: input.configDirectory,
+				...input.fileSystem === void 0 ? {} : { fs: input.fileSystem }
+			});
+		}), (api) => Effect.promise(() => api.close()));
+		return yield* input.useFn(api);
+	}));
+}
+function findProjects(input) {
+	const server = input.snapshot.getProject(input.serverTsconfigFilePath);
+	const client = input.snapshot.getProject(input.clientTsconfigFilePath);
+	if (server === void 0 || client === void 0) return Result.fail({
+		_tag: "TypescriptProjectError",
+		message: `TypeScript did not load ${server === void 0 ? input.serverTsconfigFilePath : input.clientTsconfigFilePath}`
+	});
+	return Result.succeed({
+		server,
+		client
+	});
+}
+//#endregion
 //#region src/build/inspect-projects.ts
 /** Reads every registerable declaration, view, the client application, and every public URL call from the two projects. */
 function inspectProjects(input) {
 	return Effect.gen(function* () {
 		const path = yield* Path$1.Path;
 		const excludedDirectories = getGeneratedSourceDirectories(input.layout);
-		const serverFiles = listOwnSourceFiles({
-			project: input.projects.server,
-			excludedDirectories,
-			path
+		const serverFiles = yield* runTypescriptOperation(() => {
+			return listOwnSourceFiles({
+				project: input.projects.server,
+				excludedDirectories,
+				path
+			});
 		});
-		const clientFiles = listOwnSourceFiles({
-			project: input.projects.client,
-			excludedDirectories,
-			path
+		const clientFiles = yield* runTypescriptOperation(() => {
+			return listOwnSourceFiles({
+				project: input.projects.client,
+				excludedDirectories,
+				path
+			});
 		});
-		const serverRenderer = createTypeRenderer({
-			checker: input.projects.server.checker,
-			program: input.projects.server.program,
-			emitter: input.projects.server.emitter
+		const serverRenderer = yield* runTypescriptOperation(() => {
+			return createTypeRenderer({
+				checker: input.projects.server.checker,
+				program: input.projects.server.program,
+				emitter: input.projects.server.emitter
+			});
 		});
-		const serverDeclarations = yield* Effect.fromResult(inspectServerDeclarations({
-			checker: input.projects.server.checker,
-			program: input.projects.server.program,
-			files: serverFiles,
-			renderer: serverRenderer
+		const serverDeclarations = yield* Effect.fromResult(yield* runTypescriptOperation(() => {
+			return inspectServerDeclarations({
+				checker: input.projects.server.checker,
+				program: input.projects.server.program,
+				files: serverFiles,
+				renderer: serverRenderer
+			});
 		}));
-		const client = yield* Effect.fromResult(inspectClientProject({
-			checker: input.projects.client.checker,
-			files: clientFiles,
-			clientEntryFilePath: input.layout.clientEntryFilePath
+		const client = yield* Effect.fromResult(yield* runTypescriptOperation(() => {
+			return inspectClientProject({
+				checker: input.projects.client.checker,
+				files: clientFiles,
+				clientEntryFilePath: input.layout.clientEntryFilePath
+			});
 		}));
 		return {
 			serverDeclarations,
@@ -968,10 +1077,10 @@ function inspectProjects(input) {
 	});
 }
 /** The project's own modules: not a library, not a declaration file, and not under a Vorma output directory. */
-function listOwnSourceFiles(input) {
+async function listOwnSourceFiles(input) {
 	const { program } = input.project;
 	const files = [];
-	for (const fileName of program.getSourceFileNames()) {
+	for (const fileName of await program.getSourceFileNames()) {
 		if (fileName.includes("/node_modules/") || input.excludedDirectories.some((directory) => {
 			const relativePath = input.path.relative(directory, fileName);
 			return containsRelativePath({
@@ -980,9 +1089,9 @@ function listOwnSourceFiles(input) {
 				absolute: input.path.isAbsolute(relativePath)
 			});
 		})) continue;
-		const metadata = program.getSourceFileMetadata(fileName);
+		const metadata = await program.getSourceFileMetadata(fileName);
 		if (metadata?.isDefaultLibrary || metadata?.isFromExternalLibrary) continue;
-		const sourceFile = program.getSourceFile(fileName);
+		const sourceFile = await program.getSourceFile(fileName);
 		if (sourceFile === void 0 || sourceFile.isDeclarationFile) continue;
 		files.push(sourceFile);
 	}
@@ -994,15 +1103,15 @@ function listOwnSourceFiles(input) {
 	});
 }
 /** Export bindings retain their public names while aliases resolve to one declaration identity. */
-function listModuleExports(input) {
+async function listModuleExports(input) {
 	const { checker, sourceFile } = input;
-	const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+	const moduleSymbol = await checker.getSymbolAtLocation(sourceFile);
 	if (moduleSymbol === void 0) return [];
 	const exports = [];
-	for (const exported of checker.getExportsOfModule(moduleSymbol)) {
-		const symbol = (exported.flags & SymbolFlags.Alias) !== 0 ? checker.getAliasedSymbol(exported) : exported;
-		if (checker.isUnknownSymbol(symbol)) continue;
-		const type = checker.getTypeOfSymbol(symbol);
+	for (const exported of await checker.getExportsOfModule(moduleSymbol)) {
+		const symbol = (exported.flags & SymbolFlags.Alias) !== 0 ? await checker.getAliasedSymbol(exported) : exported;
+		if (await checker.isUnknownSymbol(symbol)) continue;
+		const type = await checker.getTypeOfSymbol(symbol);
 		if (type === void 0) continue;
 		exports.push({
 			exportName: exported.name,
@@ -1013,9 +1122,9 @@ function listModuleExports(input) {
 	return exports;
 }
 /** Prefer a declaration's own exported module so a re-export barrel does not enlarge a view's import closure. */
-function listRegistrationExports(input) {
+async function listRegistrationExports(input) {
 	const exports = /* @__PURE__ */ new Map();
-	for (const sourceFile of input.files) for (const moduleExport of listModuleExports({
+	for (const sourceFile of input.files) for (const moduleExport of await listModuleExports({
 		checker: input.checker,
 		sourceFile
 	})) {
@@ -1030,55 +1139,55 @@ function listRegistrationExports(input) {
 	return [...exports.values()];
 }
 /** The phantom property that carries a definition's static types, by the unique symbol that keys it. */
-function findPhantomProperty(input) {
+async function findPhantomProperty(input) {
 	const prefix = `__@${input.symbolName}@`;
-	return input.checker.getPropertiesOfType(input.type).find((property) => String(property.escapedName).startsWith(prefix));
+	return (await input.checker.getPropertiesOfType(input.type)).find((property) => String(property.escapedName).startsWith(prefix));
 }
-function readPropertyType(input) {
-	const property = input.checker.getPropertyOfType(input.type, input.name);
-	return property === void 0 ? void 0 : input.checker.getTypeOfSymbol(property);
+async function readPropertyType(input) {
+	const property = await input.checker.getPropertyOfType(input.type, input.name);
+	return property === void 0 ? void 0 : await input.checker.getTypeOfSymbol(property);
 }
-function readLiteralProperty(input) {
-	const propertyType = readPropertyType(input);
+async function readLiteralProperty(input) {
+	const propertyType = await readPropertyType(input);
 	if (propertyType === void 0) return Result.fail(`the declaration has no ${input.name} property`);
-	if (!propertyType.isStringLiteralType()) return Result.fail(`${input.name} must have a literal type; its type is ${input.checker.typeToString(propertyType)}`);
+	if (!propertyType.isStringLiteralType()) return Result.fail(`${input.name} must have a literal type; its type is ${await input.checker.typeToString(propertyType)}`);
 	return Result.succeed(propertyType.value);
 }
 function matchesUndefinedType(type) {
 	return type.isIntrinsicType() && type.intrinsicName === "undefined";
 }
-function inspectServerDeclarations(input) {
+async function inspectServerDeclarations(input) {
 	const { checker, program, renderer } = input;
 	const declarations = [];
 	const candidates = [];
-	for (const { sourceFile, moduleExport } of listRegistrationExports(input)) {
+	for (const { sourceFile, moduleExport } of await listRegistrationExports(input)) {
 		const source = {
 			filePath: sourceFile.fileName,
 			exportName: moduleExport.exportName
 		};
-		const phantom = findPhantomProperty({
+		const phantom = await findPhantomProperty({
 			checker,
 			type: moduleExport.type,
 			symbolName: "DEFINITION_TYPES"
 		});
 		if (phantom === void 0) continue;
-		const tag = readPropertyType({
+		const tag = await readPropertyType({
 			checker,
 			type: moduleExport.type,
 			name: "_tag"
 		});
 		if (tag === void 0 || !tag.isStringLiteralType()) continue;
 		if (tag.value !== "UiLoader" && tag.value !== "Endpoint") continue;
-		const phantomType = checker.getTypeOfSymbol(phantom);
-		const types = phantomType === void 0 ? void 0 : checker.getNonNullableType(phantomType);
+		const phantomType = await checker.getTypeOfSymbol(phantom);
+		const types = phantomType === void 0 ? void 0 : await checker.getNonNullableType(phantomType);
 		if (types === void 0) return Result.fail(makeIssue(source, "the definition carries no static types"));
-		const pattern = readLiteralProperty({
+		const pattern = await readLiteralProperty({
 			checker,
 			type: moduleExport.type,
 			name: "pattern"
 		});
 		if (Result.isFailure(pattern)) return Result.fail(makeIssue(source, pattern.failure));
-		const method = readPropertyType({
+		const method = await readPropertyType({
 			checker,
 			type: moduleExport.type,
 			name: "method"
@@ -1102,13 +1211,13 @@ function inspectServerDeclarations(input) {
 		});
 	});
 	for (const { source, kind, type, types } of candidates) {
-		const inspected = kind === "UiLoader" ? inspectUiLoader({
+		const inspected = kind === "UiLoader" ? await inspectUiLoader({
 			checker,
 			renderer,
 			source,
 			type,
 			types
-		}) : inspectEndpoint({
+		}) : await inspectEndpoint({
 			checker,
 			program,
 			renderer,
@@ -1129,8 +1238,8 @@ function makeIssue(source, message) {
 		message: `${source.filePath} (export ${source.exportName}): ${message}`
 	};
 }
-function renderContract(input) {
-	return Result.mapError(input.renderer.renderType({
+async function renderContract(input) {
+	return Result.mapError(await input.renderer.renderType({
 		type: input.type,
 		depth: 2
 	}), (issue) => {
@@ -1138,27 +1247,27 @@ function renderContract(input) {
 	});
 }
 /** A contract's text, or `undefined` for the absent contract that the type `undefined` denotes. */
-function renderOptionalContract(input) {
-	const type = readPropertyType({
+async function renderOptionalContract(input) {
+	const type = await readPropertyType({
 		checker: input.checker,
 		type: input.types,
 		name: input.field
 	});
 	if (type === void 0 || matchesUndefinedType(type)) return Result.succeed(void 0);
-	return renderContract({
+	return await renderContract({
 		...input,
 		type
 	});
 }
-function inspectUiLoader(input) {
+async function inspectUiLoader(input) {
 	const { checker, renderer, source } = input;
-	const pattern = readLiteralProperty({
+	const pattern = await readLiteralProperty({
 		checker,
 		type: input.type,
 		name: "pattern"
 	});
 	if (Result.isFailure(pattern)) return Result.fail(makeIssue(source, pattern.failure));
-	const loaderInput = renderOptionalContract({
+	const loaderInput = await renderOptionalContract({
 		checker,
 		renderer,
 		source,
@@ -1166,13 +1275,13 @@ function inspectUiLoader(input) {
 		types: input.types
 	});
 	if (Result.isFailure(loaderInput)) return Result.fail(loaderInput.failure);
-	const outputType = readPropertyType({
+	const outputType = await readPropertyType({
 		checker,
 		type: input.types,
 		name: "output"
 	});
 	if (outputType === void 0) return Result.fail(makeIssue(source, "a UI loader must have an output contract"));
-	const output = renderContract({
+	const output = await renderContract({
 		renderer,
 		source,
 		field: "output",
@@ -1187,7 +1296,7 @@ function inspectUiLoader(input) {
 		output: output.success
 	});
 }
-function inspectEndpoint(input) {
+async function inspectEndpoint(input) {
 	const { checker, program, renderer, source } = input;
 	const literals = {
 		kind: "",
@@ -1199,7 +1308,7 @@ function inspectEndpoint(input) {
 		"method",
 		"pattern"
 	]) {
-		const literal = readLiteralProperty({
+		const literal = await readLiteralProperty({
 			checker,
 			type: input.type,
 			name
@@ -1212,25 +1321,25 @@ function inspectEndpoint(input) {
 	if (operation !== "query" && operation !== "mutation") return Result.fail(makeIssue(source, `unknown endpoint kind ${operation}`));
 	const method = literals.method;
 	if (!matchesHttpMethod(method)) return Result.fail(makeIssue(source, `unknown endpoint method ${method}`));
-	const inputType = readPropertyType({
+	const inputType = await readPropertyType({
 		checker,
 		type: input.types,
 		name: "input"
 	});
 	const hasInput = inputType !== void 0 && !matchesUndefinedType(inputType);
-	const inputTransport = !hasInput ? "none" : method === "GET" ? "search" : matchesFormInput({
+	const inputTransport = !hasInput ? "none" : method === "GET" ? "search" : await matchesFormInput({
 		checker,
 		program,
 		types: input.types
 	}) ? "formData" : "json";
-	const endpointInput = inputType === void 0 || !hasInput || inputTransport === "formData" ? Result.succeed(void 0) : renderContract({
+	const endpointInput = inputType === void 0 || !hasInput || inputTransport === "formData" ? Result.succeed(void 0) : await renderContract({
 		renderer,
 		source,
 		field: "input",
 		type: inputType
 	});
 	if (Result.isFailure(endpointInput)) return Result.fail(endpointInput.failure);
-	const output = renderOptionalContract({
+	const output = await renderOptionalContract({
 		checker,
 		renderer,
 		source,
@@ -1238,7 +1347,7 @@ function inspectEndpoint(input) {
 		types: input.types
 	});
 	if (Result.isFailure(output)) return Result.fail(output.failure);
-	const event = renderOptionalContract({
+	const event = await renderOptionalContract({
 		checker,
 		renderer,
 		source,
@@ -1246,7 +1355,7 @@ function inspectEndpoint(input) {
 		types: input.types
 	});
 	if (Result.isFailure(event)) return Result.fail(event.failure);
-	const errors = inspectEndpointErrors({
+	const errors = await inspectEndpointErrors({
 		checker,
 		renderer,
 		source,
@@ -1271,51 +1380,52 @@ function inspectEndpoint(input) {
 * form-transport marker carried by Vorma's FormData schema and its derived
 * codecs. The runtime recognizes the same factory's schema annotation.
 */
-function matchesFormInput(input) {
-	const symbol = readPropertyType({
+async function matchesFormInput(input) {
+	const symbol = await (await readPropertyType({
 		checker: input.checker,
 		type: input.types,
 		name: "inputEncoded"
-	})?.getSymbol();
+	}))?.getSymbol();
 	return symbol !== void 0 && symbol.name === "FormDataEncoded" && symbol.declarations.some((declaration) => {
 		return /\/vorma\/(?:src|dist)\/server\/form-data\.(?:d\.)?ts$/.test(String(declaration.path));
-	}) && matchesLibrarySymbol({
+	}) && await matchesLibrarySymbol({
 		program: input.program,
 		symbol
 	});
 }
 /** Each declared error: its decoded `_tag` and transportable schema fields. */
-function inspectEndpointErrors(input) {
+async function inspectEndpointErrors(input) {
 	const { checker, renderer, source } = input;
-	const errorsType = readPropertyType({
+	const errorsType = await readPropertyType({
 		checker,
 		type: input.types,
 		name: "errors"
 	});
 	if (errorsType === void 0) return Result.succeed([]);
-	const elementType = checker.getIndexInfosOfType(errorsType).find((index) => {
-		return index.keyType.id === checker.getNumberType().id;
+	const numberType = await checker.getNumberType();
+	const elementType = (await checker.getIndexInfosOfType(errorsType)).find((index) => {
+		return index.keyType.id === numberType.id;
 	})?.valueType;
 	if (elementType === void 0) return Result.fail(makeIssue(source, "declared errors must have an array element type"));
 	const errors = [];
 	const variantsByTag = [];
-	const elements = elementType.isUnionType() ? elementType.getTypes() : [elementType];
+	const elements = elementType.isUnionType() ? await elementType.getTypes() : [elementType];
 	for (const element of elements) {
 		if (element.isIntrinsicType() && element.intrinsicName === "never") continue;
-		const schemaType = readPropertyType({
+		const schemaType = await readPropertyType({
 			checker,
 			type: element,
 			name: "schema"
 		});
-		const decodedType = schemaType === void 0 ? void 0 : readPropertyType({
+		const decodedType = schemaType === void 0 ? void 0 : await readPropertyType({
 			checker,
 			type: schemaType,
 			name: "Type"
 		});
 		if (decodedType === void 0) return Result.fail(makeIssue(source, "each declared error's schema must expose its decoded Type"));
-		const variants = decodedType.isUnionType() ? decodedType.getTypes() : [decodedType];
+		const variants = decodedType.isUnionType() ? await decodedType.getTypes() : [decodedType];
 		for (const variant of variants) {
-			const tag = readLiteralProperty({
+			const tag = await readLiteralProperty({
 				checker,
 				type: variant,
 				name: "_tag"
@@ -1334,7 +1444,7 @@ function inspectEndpointErrors(input) {
 		});
 	});
 	for (const variant of variantsByTag) {
-		const fields = renderContract({
+		const fields = await renderContract({
 			renderer,
 			source,
 			field: `error ${variant.tag}`,
@@ -1348,23 +1458,23 @@ function inspectEndpointErrors(input) {
 	}
 	return Result.succeed(errors);
 }
-function inspectClientProject(input) {
+async function inspectClientProject(input) {
 	const { checker } = input;
 	const views = [];
 	const applications = /* @__PURE__ */ new Map();
 	const publicUrlSites = [];
 	const sourceTexts = /* @__PURE__ */ new Map();
-	for (const { sourceFile, moduleExport } of listRegistrationExports(input)) {
+	for (const { sourceFile, moduleExport } of await listRegistrationExports(input)) {
 		const source = {
 			filePath: sourceFile.fileName,
 			exportName: moduleExport.exportName
 		};
-		if (findPhantomProperty({
+		if (await findPhantomProperty({
 			checker,
 			type: moduleExport.type,
 			symbolName: "UI_VIEW_TYPES"
 		}) !== void 0) {
-			const pattern = readLiteralProperty({
+			const pattern = await readLiteralProperty({
 				checker,
 				type: moduleExport.type,
 				name: "pattern"
@@ -1378,10 +1488,10 @@ function inspectClientProject(input) {
 	}
 	for (const sourceFile of input.files) {
 		if (sourceFile.fileName === input.clientEntryFilePath) {
-			for (const moduleExport of listModuleExports({
+			for (const moduleExport of await listModuleExports({
 				checker,
 				sourceFile
-			})) if (findPhantomProperty({
+			})) if (await findPhantomProperty({
 				checker,
 				type: moduleExport.type,
 				symbolName: "CLIENT_APPLICATION_TYPES"
@@ -1390,7 +1500,7 @@ function inspectClientProject(input) {
 				exportName: moduleExport.exportName
 			});
 		}
-		const sites = collectPublicUrlSites({
+		const sites = await collectPublicUrlSites({
 			checker,
 			sourceFile
 		});
@@ -1414,14 +1524,14 @@ function inspectClientProject(input) {
 	});
 }
 /** Whether a symbol is the `getPublicUrl` declared by `vorma/client`, however the module reached it. */
-function matchesPublicUrlSymbol(input) {
-	const symbol = (input.symbol.flags & SymbolFlags.Alias) !== 0 ? input.checker.getAliasedSymbol(input.symbol) : input.symbol;
+async function matchesPublicUrlSymbol(input) {
+	const symbol = (input.symbol.flags & SymbolFlags.Alias) !== 0 ? await input.checker.getAliasedSymbol(input.symbol) : input.symbol;
 	if (symbol.name !== "getPublicUrl") return false;
 	const declaration = symbol.declarations[0];
 	return declaration !== void 0 && String(declaration.path).endsWith("/vorma/dist/client/index.d.ts");
 }
 /** Every call of `getPublicUrl` in one file. A use that is not a direct call with a string literal cannot be replaced by the build. */
-function collectPublicUrlSites(input) {
+async function collectPublicUrlSites(input) {
 	const { checker, sourceFile } = input;
 	const sites = [];
 	let issue;
@@ -1437,16 +1547,16 @@ function collectPublicUrlSites(input) {
 			};
 		}
 	}
-	function visit(node) {
+	async function visit(node) {
 		if (issue !== void 0 || isTypeNode(node)) return;
 		if (isIdentifier(node) || isPropertyAccessExpression(node) || isElementAccessExpression(node)) {
 			const parent = node.parent;
 			if (isImportSpecifier(parent) || isImportClause(parent) || isNamespaceImport(parent) || isExportSpecifier(parent)) return;
-			const symbol = isElementAccessExpression(node) ? getElementAccessSymbol({
+			const symbol = isElementAccessExpression(node) ? await getElementAccessSymbol({
 				checker,
 				node
-			}) : checker.getSymbolAtLocation(node);
-			if (symbol !== void 0 && matchesPublicUrlSymbol({
+			}) : await checker.getSymbolAtLocation(node);
+			if (symbol !== void 0 && await matchesPublicUrlSymbol({
 				checker,
 				symbol
 			})) {
@@ -1472,9 +1582,13 @@ function collectPublicUrlSites(input) {
 				return;
 			}
 		}
-		node.forEachChild(visit);
+		const children = [];
+		node.forEachChild((child) => {
+			children.push(child);
+		});
+		for (const child of children) await visit(child);
 	}
-	visit(sourceFile);
+	await visit(sourceFile);
 	return issue === void 0 ? Result.succeed(sites) : Result.fail(issue);
 }
 /** Parentheses and erased TypeScript wrappers preserve the underlying expression. */
@@ -1485,105 +1599,10 @@ function unwrapExpression(node) {
 	while (matchesTransparentExpression(node)) node = node.expression;
 	return node;
 }
-function getElementAccessSymbol(input) {
-	const objectType = input.checker.getTypeAtLocation(input.node.expression);
-	const keyType = input.checker.getTypeAtLocation(input.node.argumentExpression);
-	return objectType !== void 0 && keyType?.isStringLiteralType() ? input.checker.getPropertyOfType(objectType, keyType.value) : void 0;
-}
-//#endregion
-//#region src/build/typescript-projects.ts
-/** Reads native project membership without loading programs or declaration types. */
-function readTypescriptProjectRoots(input) {
-	return withTypescriptApi({
-		configDirectory: input.configDirectory,
-		useFn: (api) => {
-			return openCompilerResource(() => {
-				return {
-					server: api.parseConfigFile(input.serverTsconfigFilePath).fileNames,
-					client: api.parseConfigFile(input.clientTsconfigFilePath).fileNames
-				};
-			});
-		}
-	});
-}
-/** Checks actual compiler membership after generation, including restrictive files/include/exclude settings. */
-function checkGeneratedTypeInclusion(input) {
-	return withTypescriptProjects({
-		...input,
-		useFn: (projects) => {
-			const missing = [...input.serverFiles.filter((file) => {
-				return projects.server.program.getSourceFileMetadata(file) === void 0;
-			}).map((file) => {
-				return {
-					project: input.serverTsconfigFilePath,
-					file
-				};
-			}), ...input.clientFiles.filter((file) => {
-				return projects.client.program.getSourceFileMetadata(file) === void 0;
-			}).map((file) => {
-				return {
-					project: input.clientTsconfigFilePath,
-					file
-				};
-			})];
-			return missing.length === 0 ? Effect.void : Effect.fail({
-				_tag: "TypescriptProjectError",
-				message: missing.map(({ project, file }) => `${project} does not include generated type file ${file}. Include the entry's _vorma directory in that TypeScript project.`).join("\n")
-			});
-		}
-	});
-}
-/** Opens the two configured TypeScript projects for the duration of `useFn`, then closes the checker session. */
-function withTypescriptProjects(input) {
-	return withTypescriptApi({
-		...input,
-		useFn: (api) => {
-			return Effect.scoped(Effect.gen(function* () {
-				const projects = findProjects({
-					snapshot: yield* Effect.acquireRelease(openCompilerResource(() => {
-						return api.updateSnapshot({ openProjects: [input.serverTsconfigFilePath, input.clientTsconfigFilePath] });
-					}), (snapshot) => Effect.sync(() => snapshot.dispose())),
-					...input
-				});
-				return yield* Result.isFailure(projects) ? Effect.fail(projects.failure) : input.useFn(projects.success);
-			}));
-		}
-	});
-}
-function openCompilerResource(fn) {
-	return Effect.try({
-		try: fn,
-		catch: (cause) => {
-			return {
-				_tag: "TypescriptProjectError",
-				message: "Vorma could not read the application's TypeScript projects",
-				cause
-			};
-		}
-	});
-}
-function withTypescriptApi(input) {
-	return Effect.scoped(Effect.gen(function* () {
-		const api = yield* Effect.acquireRelease(openCompilerResource(() => {
-			return new API({
-				cwd: input.configDirectory,
-				...input.fileSystem === void 0 ? {} : { fs: input.fileSystem }
-			});
-		}), (api) => Effect.sync(() => api.close()));
-		return yield* input.useFn(api);
-	}));
-}
-function findProjects(input) {
-	const server = input.snapshot.getProject(input.serverTsconfigFilePath);
-	const client = input.snapshot.getProject(input.clientTsconfigFilePath);
-	if (server === void 0 || client === void 0) return Result.fail({
-		_tag: "TypescriptProjectError",
-		message: `TypeScript did not load ${server === void 0 ? input.serverTsconfigFilePath : input.clientTsconfigFilePath}`
-	});
-	return Result.succeed({
-		server,
-		client
-	});
+async function getElementAccessSymbol(input) {
+	const objectType = await input.checker.getTypeAtLocation(input.node.expression);
+	const keyType = await input.checker.getTypeAtLocation(input.node.argumentExpression);
+	return objectType !== void 0 && keyType?.isStringLiteralType() ? await input.checker.getPropertyOfType(objectType, keyType.value) : void 0;
 }
 //#endregion
 //#region src/build/compile-application.ts
@@ -3211,4 +3230,4 @@ function buildApplication(input) {
 	}));
 }
 //#endregion
-export { toContentDigest as C, encodeCanonicalJson as S, compileServerApplication as _, acquireOutputOwnership as a, getClientViewEntries as b, writeAndCheckApplicationGeneration as c, withTypescriptProjects as d, inspectProjects as f, createClientPublicUrlPlugin as g, createCssPublicAssets as h, publishApplicationArtifacts as i, collectPublicAssets as l, resolveVormaConfig as m, loadApplicationSourceLayout as n, checkOutputPath as o, getGeneratedSourceDirectories as p, preparePublicOutput as r, assembleApplicationGeneration as s, buildApplication as t, readTypescriptProjectRoots as u, containsRelativePath as v, projectBrowserContracts as x, CLIENT_SHARED_PACKAGES as y };
+export { encodeCanonicalJson as C, projectBrowserContracts as S, createClientPublicUrlPlugin as _, acquireOutputOwnership as a, CLIENT_SHARED_PACKAGES as b, writeAndCheckApplicationGeneration as c, readTypescriptProjectRoots as d, runTypescriptOperation as f, createCssPublicAssets as g, resolveVormaConfig as h, publishApplicationArtifacts as i, collectPublicAssets as l, getGeneratedSourceDirectories as m, loadApplicationSourceLayout as n, checkOutputPath as o, withTypescriptProjects as p, preparePublicOutput as r, assembleApplicationGeneration as s, buildApplication as t, inspectProjects as u, compileServerApplication as v, toContentDigest as w, getClientViewEntries as x, containsRelativePath as y };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sjcx/vorma",
-	"version": "0.0.0-pre.0",
+	"version": "0.0.0-pre.1",
 	"type": "module",
 	"sideEffects": false,
 	"license": "MIT",
@@ -42,7 +42,7 @@
 		"@effect/platform-node-shared": "^4.0.0-rc.115",
 		"@noble/hashes": "^2.4.0",
 		"@scure/base": "^2.4.0",
-		"@vorma/primitives": "npm:@sjcx/vorma-primitives@0.0.0-pre.0",
+		"@vorma/primitives": "npm:@sjcx/vorma-primitives@0.0.0-pre.1",
 		"chokidar": "^5.0.0",
 		"lightningcss": "^1.33.0",
 		"rolldown": "^1.2.6",