@sjcx/vorma 0.0.0-pre.7 → 0.0.0-pre.9

package/dist/build/cli.js

@@ -2,7 +2,7 @@
 import { i as readConfigFilePath, r as checkVormaPlugin } from "../plugin-api-Btb0teGk.js";
 import { t as VormaConfigSchema } from "../config-FbabCxBO.js";
 import { NodeChildProcessSpawner, NodeCrypto, NodeFileSystem, NodePath, NodeRuntime, NodeSocketServer, NodeStdio, NodeTerminal } from "@effect/platform-node-shared";
-import { Cause, Console, Deferred, Effect, Equal, Exit, Fiber, FileSystem, Layer, Option, Order, Path, Predicate, Queue, Record, Result, Schedule, Schema, Scope, ScopedRef, Stream } from "effect";
+import { Cause, Console, Deferred, Effect, Equal, Exit, Fiber, FileSystem, Layer, Order, Path, Predicate, Queue, Record, Result, Schedule, Schema, Scope, ScopedRef, Stream } from "effect";
 import { Argument, Command } from "effect/cli";
 import { stripVTControlCharacters } from "node:util";
 import * as FileSystem$1 from "effect/FileSystem";
@@ -24,9 +24,10 @@ import { Writable } from "node:stream";
 import { ChildProcess as ChildProcess$1 } from "effect/process";
 import * as NativeHttpMethod from "effect/http/HttpMethod";
 import { DEV_CONTROLS_PROTOCOL, DOCUMENT_PROTOCOL, GENERATED_TYPES_PROTOCOL, HTTP_PROTOCOL, PATTERN_PROTOCOL, encodeRoutePattern, formatPathWireError } from "@sjcx/vorma-client/unstable";
-import { compileNestedPattern, formatPatternCompileError } from "@sjcx/vorma-primitives/matcher";
+import { compileNestedPattern, formatPatternCompileError } from "primitives-ts/matcher";
 import { createServer as createServer$1, request } from "node:http";
 import { createConnection } from "node:net";
+import { encodeBytes } from "primitives-ts";
 import { watch } from "chokidar";
 //#region package.json
 var version = "0.87.0-pre.0";
@@ -242,7 +243,7 @@ const ARTIFACT_PROTOCOL = {
 	/** Inside the build directory: the published static public assets. */
 	publicDirName: "public",
 	/** Inside the build directory: the lock that a running build or development session holds. */
-	lockFileName: "build.lock",
+	lockDirName: "build.lock",
 	/** Inside the build directory: the directory in which a running build stages its output. */
 	stagingDirName: "staging",
 	publicOutputFileNamePrefix: PUBLIC_OUTPUT_FILE_NAME_PREFIX,
@@ -515,14 +516,14 @@ const Owner = Schema.fromJsonString(Schema.Struct({
 	dir: Schema.String,
 	/**
 	* Identifies one acquisition, so that a process releases only the lock
-	* that it took. A lock written without it is still recognized as stale
-	* when its process no longer exists, and no process releases it.
+	* that it took. A flat lock file is readable for diagnostics but cannot
+	* be removed atomically by owner.
 	*/
 	token: Schema.optionalKey(Schema.NonEmptyString)
 }));
 function getRemovalCmd(lockPath) {
-	if (platform === "win32") return `PowerShell: Remove-Item -LiteralPath '${lockPath.replaceAll("'", "''")}'`;
-	return `rm -- '${lockPath.replaceAll("'", "'\"'\"'")}'`;
+	if (platform === "win32") return `PowerShell: Remove-Item -Recurse -LiteralPath '${lockPath.replaceAll("'", "''")}'`;
+	return `rm -r -- '${lockPath.replaceAll("'", "'\"'\"'")}'`;
 }
 /** Whether a process with this id exists; a process of another user exists but refuses the signal. */
 function testProcessExists(processId) {
@@ -533,61 +534,35 @@ function testProcessExists(processId) {
 		return error.code === "EPERM";
 	}
 }
-/**
-* Removes the lock at `lockPath` when `testOwnerRemovable` accepts the owner
-* that it records, and reports whether it removed the lock. A missing lock, a
-* lock that records no owner, and a lock whose owner `testOwnerRemovable`
-* rejects stay as they are. The lock moves to `claimedPath` first, so that of
-* two contenders only one removes it, and the moved file is read again: a lock
-* that another process created in the meantime is moved back and kept.
-*/
-function removeLockIfRemovable(input) {
-	const { fileSystem, lockPath, claimedPath, testOwnerRemovable } = input;
-	function readOwner(path) {
-		return fileSystem.readFileString(path).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Owner)), Effect.option);
-	}
+/** Reads complete directory records and flat lock files used for diagnostics. */
+function readLockRecord(input) {
+	const { fileSystem, path, lockPath } = input;
 	return Effect.gen(function* () {
-		const recorded = yield* readOwner(lockPath);
-		if (Option.isNone(recorded) || !testOwnerRemovable(recorded.value)) return false;
-		yield* fileSystem.rename(lockPath, claimedPath);
-		const claimed = yield* readOwner(claimedPath);
-		if (Option.isNone(claimed) || !testOwnerRemovable(claimed.value)) {
-			yield* fileSystem.rename(claimedPath, lockPath);
-			return false;
-		}
-		yield* fileSystem.remove(claimedPath, { force: true });
-		return true;
-	}).pipe(Effect.catchReason("PlatformError", "NotFound", () => {
-		return Effect.succeed(false);
-	}));
+		if ((yield* fileSystem.stat(lockPath)).type !== "Directory") return {
+			owner: yield* fileSystem.readFileString(lockPath).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Owner))),
+			recordPath: void 0
+		};
+		const entries = yield* fileSystem.readDirectory(lockPath);
+		if (entries.length !== 1) return;
+		const recordPath = path.join(lockPath, entries[0]);
+		const owner = yield* fileSystem.readFileString(recordPath).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Owner)));
+		return owner.token !== void 0 && entries[0] === getOwnerFileName(owner.token) ? {
+			owner,
+			recordPath
+		} : void 0;
+	}).pipe(Effect.catch(() => Effect.succeed(void 0)));
 }
-/**
-* Removes a lock whose recorded process no longer exists. The check assumes
-* that the lock's process ran on this machine, as a build directory is local to
-* the machine that builds it.
-*/
-function removeStaleLock(input) {
-	return removeLockIfRemovable({
-		fileSystem: input.fileSystem,
-		lockPath: input.lockPath,
-		claimedPath: `${input.lockPath}.stale-${pid}`,
-		testOwnerRemovable: (owner) => owner.pid === input.pid
-	}).pipe(Effect.catch(() => Effect.succeed(false)));
+function getOwnerFileName(token) {
+	return `owner-${token}.json`;
 }
 /**
-* Removes the lock that `owner` took, and only that lock. A build's
-* publication moves the build directory, and its lock with it, so that the
-* path can hold the lock of a later build by the time that this one releases.
+* Only the process that removes the unique owner record may remove its directory.
+* A delayed cleanup cannot remove a later owner's record, so it cannot expose
+* the later build to another writer. The directory stays locked until removal
+* completes. A flat lock file has no such conditional-removal operation.
 */
-function removeOwnedLock(input) {
-	return removeLockIfRemovable({
-		fileSystem: input.fileSystem,
-		lockPath: input.lockPath,
-		claimedPath: `${input.lockPath}.release-${input.owner.token}`,
-		testOwnerRemovable: (recorded) => recorded.token === input.owner.token
-	}).pipe(Effect.catch((cause) => {
-		return Effect.logError(`Could not remove Vorma lock ${input.lockPath}. If the owner has stopped, run ${getRemovalCmd(input.lockPath)}`, cause);
-	}));
+function removeLockRecord(input) {
+	return input.fileSystem.remove(input.recordPath).pipe(Effect.andThen(input.fileSystem.remove(input.lockPath, { recursive: true })), Effect.as(true), Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(false)));
 }
 /** Resolves aliases even when the output directory has not been created. */
 function canonicalizeOutputPath(filePath) {
@@ -629,10 +604,10 @@ function checkOutputPath(input) {
 	});
 }
 /** The entries that Vorma writes in a build directory. */
-const VORMA_DIST_ENTRY_NAMES = /* @__PURE__ */ new Set([
+const VORMA_BUILD_DIR_ENTRY_NAMES = /* @__PURE__ */ new Set([
 	ARTIFACT_PROTOCOL.buildMetadataFileName,
 	ARTIFACT_PROTOCOL.publicDirName,
-	ARTIFACT_PROTOCOL.lockFileName,
+	ARTIFACT_PROTOCOL.lockDirName,
 	ARTIFACT_PROTOCOL.stagingDirName
 ]);
 /**
@@ -646,7 +621,7 @@ function checkBuildDirContents(input) {
 		const entries = yield* input.fileSystem.readDirectory(input.dir).pipe(Effect.catchReason("PlatformError", "NotFound", () => {
 			return Effect.succeed([]);
 		}));
-		if (entries.includes(ARTIFACT_PROTOCOL.buildMetadataFileName) || entries.every((entry) => VORMA_DIST_ENTRY_NAMES.has(entry))) return;
+		if (entries.includes(ARTIFACT_PROTOCOL.buildMetadataFileName) || entries.every((entry) => VORMA_BUILD_DIR_ENTRY_NAMES.has(entry))) return;
 		return yield* Effect.fail({
 			_tag: "OutputOwnershipIssue",
 			dir: input.dir,
@@ -782,7 +757,7 @@ function createStagedBuildDir(input) {
 					discard: true
 				});
 				yield* Effect.forEach(yield* fileSystem.readDirectory(buildDir), (entry) => {
-					return VORMA_DIST_ENTRY_NAMES.has(entry) ? Effect.void : fileSystem.remove(path.join(buildDir, entry), {
+					return VORMA_BUILD_DIR_ENTRY_NAMES.has(entry) ? Effect.void : fileSystem.remove(path.join(buildDir, entry), {
 						recursive: true,
 						force: true
 					});
@@ -816,31 +791,33 @@ function acquireOutputOwnership(input) {
 			dir
 		});
 		yield* fileSystem.makeDirectory(dir, { recursive: true });
-		const lockPath = path.join(dir, ARTIFACT_PROTOCOL.lockFileName);
+		const lockPath = path.join(dir, ARTIFACT_PROTOCOL.lockDirName);
 		const owner = {
 			pid,
 			kind: input.kind,
 			dir,
 			token: randomUUID()
 		};
-		const createLock = Effect.scoped(fileSystem.open(lockPath, {
-			flag: "wx",
-			mode: 384
-		})).pipe(Effect.asVoid, Effect.catch((cause) => {
+		const createLock = fileSystem.makeDirectory(lockPath, { mode: 448 }).pipe(Effect.catch((cause) => {
 			return Effect.gen(function* () {
 				if (cause.reason._tag !== "AlreadyExists") return yield* Effect.fail(cause);
-				const recorded = Option.getOrUndefined(yield* fileSystem.readFileString(lockPath).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Owner)), Effect.option));
-				if (recorded !== void 0 && !testProcessExists(recorded.pid) && (yield* removeStaleLock({
+				const record = yield* readLockRecord({
+					fileSystem,
+					path,
+					lockPath
+				});
+				const recorded = record?.owner;
+				if (record?.recordPath !== void 0 && !testProcessExists(record.owner.pid) && (yield* removeLockRecord({
 					fileSystem,
 					lockPath,
-					pid: recorded.pid
-				}))) return yield* createLock;
+					recordPath: record.recordPath
+				}).pipe(Effect.catch(() => Effect.succeed(false))))) return yield* createLock;
 				return yield* Effect.fail({
 					_tag: "OutputOwnershipIssue",
 					dir,
 					msg: [
 						`Cannot start ${input.kind}: the build directory is locked.`,
-						`Lockfile: ${lockPath}`,
+						`Lock: ${lockPath}`,
 						`Recorded owner PID: ${recorded?.pid ?? "unavailable"}`,
 						`Recorded operation: ${recorded?.kind ?? "unavailable"}`,
 						"Wait for the owning process to finish. If it has stopped, remove the leftover lock and retry:",
@@ -849,14 +826,18 @@ function acquireOutputOwnership(input) {
 				});
 			});
 		}));
-		yield* Effect.acquireRelease(createLock, () => removeOwnedLock({
-			fileSystem,
-			lockPath,
-			owner
-		}));
-		yield* fileSystem.writeFileString(lockPath, JSON.stringify(owner)).pipe(Effect.tapError(() => {
-			return fileSystem.remove(lockPath, { force: true }).pipe(Effect.ignore);
-		}));
+		const recordPath = path.join(lockPath, getOwnerFileName(owner.token));
+		yield* Effect.acquireRelease(createLock.pipe(Effect.andThen(fileSystem.writeFileString(recordPath, JSON.stringify(owner)).pipe(Effect.tapError(() => {
+			return fileSystem.remove(lockPath, { recursive: true }).pipe(Effect.ignore);
+		})))), () => {
+			return removeLockRecord({
+				fileSystem,
+				lockPath,
+				recordPath
+			}).pipe(Effect.catch((cause) => {
+				return Effect.logError(`Could not remove Vorma lock ${lockPath}. If the owner has stopped, run ${getRemovalCmd(lockPath)}`, cause);
+			}));
+		});
 	}).pipe(Effect.mapError((cause) => {
 		return cause._tag === "OutputOwnershipIssue" ? cause : {
 			_tag: "OutputOwnershipIssue",
@@ -2784,10 +2765,9 @@ function writeOutputFile(input) {
 }
 //#endregion
 //#region src/build/patterns/nested-route-chains.ts
-/** Materializes each target's compiledPattern outer-to-inner route chain in time proportional to route depth. */
+/** Builds each unique target's outer-to-inner chain by looking up its compiled path prefixes. */
 function createNestedRouteChains(input) {
 	const branches = /* @__PURE__ */ new Map();
-	const exact = new Map(input.nodes.map((node) => [node.compiledPattern.pattern, node]));
 	for (const node of input.nodes) {
 		const terminal = node.compiledPattern.segments.at(-1)?.kind;
 		if (terminal !== "index" && terminal !== "splat") branches.set(getNestedRoutePathKey(node.compiledPattern.segments), node);
@@ -2800,10 +2780,7 @@ function createNestedRouteChains(input) {
 			if (branch !== void 0) chain.push(branch);
 		}
 		const terminal = target.compiledPattern.segments.at(-1)?.kind;
-		if (terminal === "index" || terminal === "splat") {
-			const leaf = exact.get(target.compiledPattern.pattern);
-			if (leaf !== void 0) chain.push(leaf);
-		}
+		if (terminal === "index" || terminal === "splat") chain.push(target);
 		return {
 			target,
 			chain
@@ -3062,7 +3039,11 @@ function compileApplicationModel(inspection) {
 	const childPatterns = /* @__PURE__ */ new Map();
 	for (const { target, chain } of chains) {
 		const parent = chain.at(-1) === target ? chain.at(-2) : void 0;
-		if (parent !== void 0) childPatterns.set(parent.pattern, [...childPatterns.get(parent.pattern) ?? [], target.pattern]);
+		if (parent !== void 0) {
+			const siblings = childPatterns.get(parent.pattern);
+			if (siblings === void 0) childPatterns.set(parent.pattern, [target.pattern]);
+			else siblings.push(target.pattern);
+		}
 	}
 	const linkedViews = chains.map(({ target, chain }) => {
 		return {
@@ -3376,7 +3357,7 @@ const PROCESS_ENV_PROTOCOL = {
 * reads its build from the build directory of `vorma dev` in it.
 * `vorma dev` sets the variable for the server that it starts. A server in
 * any other process ignores it and reads the application's
-* `prod_dist_dir`.
+* `dist_dir`.
 */
 distDirEnvVar: "VORMA_DIST_DIR" };
 /** Private development coordination between the launcher and the application process. */
@@ -4127,7 +4108,7 @@ function startDevClient(input) {
 			finishInspection = void 0;
 		}
 		/** Admits the live critical CSS update under a strict `style-src`; the application's own `html.cspNonce` replaces it. */
-		const sessionCspNonce = randomBytes(16).toString("base64");
+		const sessionCspNonce = encodeBytes(randomBytes(16), { encoding: "base64" });
 		const devPlugin = {
 			name: "vorma:development",
 			enforce: "pre",

package/dist/build/dev/dev-protocol.d.ts

@@ -5,7 +5,7 @@ export declare const PROCESS_ENV_PROTOCOL: {
      * reads its build from the build directory of `vorma dev` in it.
      * `vorma dev` sets the variable for the server that it starts. A server in
      * any other process ignores it and reads the application's
-     * `prod_dist_dir`.
+     * `dist_dir`.
      */
     readonly distDirEnvVar: "VORMA_DIST_DIR";
 };

package/dist/build/generation/compile-application.d.ts

@@ -1,5 +1,5 @@
-import type { CompiledNestedPattern } from "@sjcx/vorma-primitives/matcher";
 import { Result } from "effect";
+import type { CompiledNestedPattern } from "primitives-ts/matcher";
 import type { InspectedClientView, InspectedEndpoint, InspectedProjects, InspectedViewLoader } from "../inspection/inspect-projects.ts";
 export type ApplicationView = {
     /** The authored pattern, as the loader or the view wrote it. */

package/dist/build/output/dist-dir.d.ts

@@ -10,7 +10,7 @@ export declare const ARTIFACT_PROTOCOL: {
     /** Inside the build directory: the published static public assets. */
     readonly publicDirName: "public";
     /** Inside the build directory: the lock that a running build or development session holds. */
-    readonly lockFileName: "build.lock";
+    readonly lockDirName: "build.lock";
     /** Inside the build directory: the directory in which a running build stages its output. */
     readonly stagingDirName: "staging";
     readonly publicOutputFileNamePrefix: "vorma_out_";

package/dist/build/patterns/nested-route-chains.d.ts

@@ -1,8 +1,8 @@
-import type { CompiledNestedPattern } from "@sjcx/vorma-primitives/matcher";
+import type { CompiledNestedPattern } from "primitives-ts/matcher";
 type NestedRouteNode = {
     readonly compiledPattern: CompiledNestedPattern;
 };
-/** Materializes each target's compiledPattern outer-to-inner route chain in time proportional to route depth. */
+/** Builds each unique target's outer-to-inner chain by looking up its compiled path prefixes. */
 export declare function createNestedRouteChains<Node extends NestedRouteNode>(input: {
     readonly nodes: ReadonlyArray<Node>;
 }): ReadonlyArray<{

package/dist/build/patterns/pattern-language.d.ts

@@ -1,3 +1,3 @@
-import type * as Matcher from "@sjcx/vorma-primitives/matcher";
+import type * as Matcher from "primitives-ts/matcher";
 /** The view pattern language, with the markers that the client and the server use. */
 export declare const NESTED_PATTERN_LANGUAGE: Matcher.NestedPatternLanguage;

package/dist/build/patterns/route-patterns.d.ts

@@ -1,6 +1,6 @@
 import { type PathWireError } from "@sjcx/vorma-client/unstable";
-import { type CompiledNestedPattern, type PatternCompileError } from "@sjcx/vorma-primitives/matcher";
 import { Result } from "effect";
+import { type CompiledNestedPattern, type PatternCompileError } from "primitives-ts/matcher";
 export type RoutePatternError = PathWireError | PatternCompileError;
 /**
  * Compiles an authored view route pattern: wire encoding first, then the

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sjcx/vorma",
-	"version": "0.0.0-pre.7",
+	"version": "0.0.0-pre.9",
 	"type": "module",
 	"sideEffects": false,
 	"license": "(MIT OR Apache-2.0)",
@@ -22,10 +22,10 @@
 		"@effect/platform-node-shared": "^4.0.0",
 		"@noble/hashes": "^2.4.0",
 		"@scure/base": "^2.4.0",
-		"@sjcx/vorma-primitives": "0.0.0-pre.7",
 		"chokidar": "^5.0.0",
 		"effect": "^4.0.0",
 		"lightningcss": "^1.33.0",
+		"primitives-ts": "0.0.1-pre.1",
 		"rolldown": "^1.2.6",
 		"typescript": "7.0.2"
 	},