@ariobarin/glossa 0.1.1 → 0.2.0-beta.2

package/dist/app.js

@@ -39921,6 +39921,9 @@ var MAX_TEXT_BYTES = 1024 * 1024;
 var MAX_EDIT_DIFF_BYTES = 128 * 1024;
 var MAX_EDIT_OPERATIONS = 100;
 var MAX_COMMAND_OUTPUT_BYTES = 12 * 1024;
+var MAX_COMMAND_RETAINED_STREAM_BYTES = 1024 * 1024;
+var DEFAULT_COMMAND_OUTPUT_RANGE_BYTES = 32 * 1024;
+var MAX_COMMAND_OUTPUT_RANGE_BYTES = 64 * 1024;
 var DEFAULT_COMMAND_TIMEOUT_MS = 15 * 60 * 1e3;
 var MAX_COMMAND_TIMEOUT_MS = 60 * 60 * 1e3;
 var DEFAULT_COMMAND_FAST_WAIT_MS = 750;
@@ -39976,12 +39979,16 @@ var listFilesJobSchema = listFilesRequestSchema.extend({
   requestId: external_exports.string().uuid(),
   timeoutMs: structuredReadTimeoutSchema
 });
+var searchGlobSchema = external_exports.string().min(1).max(256).refine((value) => !/[\r\n\u0000]/.test(value), "Search glob must fit on one line").describe("Root-relative glob pattern using forward slashes, for example src/**/*.ts.");
 var searchTextRequestSchema = external_exports.object({
-  query: external_exports.string().min(1).max(256).refine((value) => !/[\r\n\u0000]/.test(value), "Search text must fit on one line").describe("Literal single-line UTF-8 text to search for."),
+  query: external_exports.string().min(1).max(256).refine((value) => !/[\r\n\u0000]/.test(value), "Search text must fit on one line").describe("Single-line UTF-8 search expression. Interpreted literally by default or as a JavaScript regular expression when matchMode is regex."),
   path: relativePathSchema.optional().describe("File or directory relative to the exposed root. Defaults to the root."),
+  matchMode: external_exports.enum(["literal", "regex"]).optional().describe("How to interpret query. Defaults to literal; regex uses JavaScript regular-expression syntax."),
   caseSensitive: external_exports.boolean().optional().describe("Whether matching is case-sensitive. Defaults to false."),
   maxResults: external_exports.number().int().min(1).max(MAX_SEARCH_TEXT_RESULTS).optional().describe("Maximum matching lines to return, from 1 through 100. Defaults to 50."),
-  extensions: external_exports.array(external_exports.string().regex(/^\.[A-Za-z0-9][A-Za-z0-9._-]{0,19}$/).describe("Filename suffix including the leading dot, such as .ts or .d.ts.")).min(1).max(20).optional().describe("Optional filename extensions to search.")
+  extensions: external_exports.array(external_exports.string().regex(/^\.[A-Za-z0-9][A-Za-z0-9._-]{0,19}$/).describe("Filename suffix including the leading dot, such as .ts or .d.ts.")).min(1).max(20).optional().describe("Optional filename extensions to search."),
+  includeGlobs: external_exports.array(searchGlobSchema).min(1).max(20).optional().describe("Optional root-relative glob patterns. A file must match at least one include pattern before its contents are scanned."),
+  excludeGlobs: external_exports.array(searchGlobSchema).min(1).max(20).optional().describe("Optional root-relative glob patterns. Matching files are skipped before their contents are scanned.")
 }).strict();
 var searchTextJobSchema = searchTextRequestSchema.extend({
   type: external_exports.literal("search_text"),
@@ -40000,8 +40007,8 @@ var readFileRangeJobSchema = readFileRangeRequestSchema.extend({
 });
 var writeFileRequestSchema = external_exports.object({
   path: relativePathSchema,
-  content: boundedTextSchema.describe("Complete UTF-8 text content that will replace the file."),
-  expectedSha256: external_exports.string().regex(/^[a-f0-9]{64}$/).optional().describe("Full-file SHA-256 returned by read_file or read_file_range. When provided, the write fails if the file changed.")
+  content: boundedTextSchema.describe("Complete UTF-8 text content for the new file or replacement revision."),
+  expectedSha256: external_exports.string().regex(/^[a-f0-9]{64}$/).optional().describe("Full-file SHA-256 returned by read_file or read_file_range. Omit only when creating a new path; when provided, write_file replaces exactly that existing revision and fails if it is missing or changed.")
 }).strict();
 var writeFileJobSchema = writeFileRequestSchema.extend({
   type: external_exports.literal("write_file"),
@@ -40029,6 +40036,30 @@ var editFileJobSchema = editFileRequestSchema.safeExtend({
   type: external_exports.literal("edit_file"),
   requestId: external_exports.string().uuid()
 });
+var makeDirectoryRequestSchema = external_exports.object({
+  path: relativePathSchema,
+  recursive: external_exports.boolean().optional().describe("Whether to create missing parent directories. Defaults to false.")
+}).strict();
+var makeDirectoryJobSchema = makeDirectoryRequestSchema.extend({
+  type: external_exports.literal("make_directory"),
+  requestId: external_exports.string().uuid()
+});
+var deletePathRequestSchema = external_exports.object({
+  path: relativePathSchema,
+  recursive: external_exports.boolean().optional().describe("Whether to delete a non-empty directory tree. Defaults to false.")
+}).strict();
+var deletePathJobSchema = deletePathRequestSchema.extend({
+  type: external_exports.literal("delete_path"),
+  requestId: external_exports.string().uuid()
+});
+var movePathRequestSchema = external_exports.object({
+  source: relativePathSchema.describe("Existing file or directory to move."),
+  destination: relativePathSchema.describe("New path inside the exposed root. The destination must not already exist.")
+}).strict();
+var movePathJobSchema = movePathRequestSchema.extend({
+  type: external_exports.literal("move_path"),
+  requestId: external_exports.string().uuid()
+});
 function requireOneCommand(value, context) {
   if ((value.argv ? 1 : 0) + (value.shellCommand ? 1 : 0) !== 1) {
     context.addIssue({
@@ -40058,6 +40089,16 @@ var getCommandJobSchema = getCommandRequestSchema.extend({
   type: external_exports.literal("get_command"),
   requestId: external_exports.string().uuid()
 });
+var readCommandOutputRequestSchema = external_exports.object({
+  commandId: external_exports.string().uuid().describe("Command identifier returned by run_command."),
+  stream: external_exports.enum(["stdout", "stderr"]).describe("Command output stream to read independently."),
+  offset: external_exports.number().int().min(0).optional().describe("Zero-based retained byte offset. Defaults to 0."),
+  maxBytes: external_exports.number().int().min(4).max(MAX_COMMAND_OUTPUT_RANGE_BYTES).optional().describe("Maximum retained source bytes to inspect, from 4 through 65536. Defaults to 32768.")
+}).strict();
+var readCommandOutputJobSchema = readCommandOutputRequestSchema.extend({
+  type: external_exports.literal("read_command_output"),
+  requestId: external_exports.string().uuid()
+});
 var cancelCommandRequestSchema = external_exports.object({
   commandId: external_exports.string().uuid().describe("Command identifier returned by run_command.")
 }).strict();
@@ -40072,8 +40113,12 @@ var workerJobSchema = external_exports.discriminatedUnion("type", [
   readFileRangeJobSchema,
   writeFileJobSchema,
   editFileJobSchema,
+  makeDirectoryJobSchema,
+  deletePathJobSchema,
+  movePathJobSchema,
   runCommandJobSchema,
   getCommandJobSchema,
+  readCommandOutputJobSchema,
   cancelCommandJobSchema
 ]);
 var workerResultSchema = external_exports.object({
@@ -49820,6 +49865,8 @@ var WorkerError = class extends Error {
 var STREAM_HEAD_BYTES = Math.floor(MAX_COMMAND_OUTPUT_BYTES / 3);
 var STREAM_TAIL_BYTES = MAX_COMMAND_OUTPUT_BYTES - STREAM_HEAD_BYTES;
 var RESTRICTED_SCAN_TAIL_BYTES = 1024;
+var COMMAND_RECORD_RETENTION_MS = 5 * 60 * 1e3;
+var MAX_RETAINED_COMMAND_RECORDS = 8;
 function restrictedDataError() {
   return new WorkerError(
     RESTRICTED_DATA_ERROR_CODE,
@@ -49836,20 +49883,26 @@ function scanOutputChunk(previousTail, chunk) {
     tail
   };
 }
+function markRestrictedData(record2) {
+  if (record2.restrictedDataDetected) return;
+  record2.restrictedDataDetected = true;
+  record2.stdout = emptyCapture();
+  record2.stderr = emptyCapture();
+  record2.stdoutScanTail = Buffer.alloc(0);
+  record2.stderrScanTail = Buffer.alloc(0);
+  if (record2.status === "running") {
+    record2.requestedTerminal = "canceled";
+    void terminateProcessTree(record2.child).catch(() => void 0);
+  }
+  markChanged(record2);
+}
 function recordCommandOutput(record2, streamName, chunk) {
   if (record2.restrictedDataDetected || chunk.byteLength === 0) return;
   const tailName = streamName === "stdout" ? "stdoutScanTail" : "stderrScanTail";
   const scan = scanOutputChunk(record2[tailName], chunk);
   record2[tailName] = scan.tail;
   if (scan.detected) {
-    record2.restrictedDataDetected = true;
-    record2.stdout = emptyCapture();
-    record2.stderr = emptyCapture();
-    if (record2.status === "running") {
-      record2.requestedTerminal = "canceled";
-      void terminateProcessTree(record2.child).catch(() => void 0);
-    }
-    markChanged(record2);
+    markRestrictedData(record2);
     return;
   }
   if (capture(record2, record2[streamName], chunk)) markChanged(record2);
@@ -49864,6 +49917,17 @@ function appendTail(existing, chunk) {
 function capture(_record2, stream, chunk) {
   if (chunk.byteLength === 0) return false;
   stream.totalBytes += chunk.byteLength;
+  const retentionBudget = MAX_COMMAND_RETAINED_STREAM_BYTES - stream.retainedBytes;
+  if (retentionBudget > 0) {
+    const retained = chunk.subarray(0, Math.min(chunk.byteLength, retentionBudget));
+    if (retained.byteLength > 0) {
+      stream.retained.push(Buffer.from(retained));
+      stream.retainedBytes += retained.byteLength;
+    }
+  }
+  if (chunk.byteLength > Math.max(0, retentionBudget)) {
+    stream.retentionTruncated = true;
+  }
   let offset = 0;
   if (stream.headBytes < STREAM_HEAD_BYTES) {
     const accepted = chunk.subarray(
@@ -49912,7 +49976,10 @@ function emptyCapture() {
     head: [],
     headBytes: 0,
     tail: Buffer.alloc(0),
-    totalBytes: 0
+    retained: [],
+    retainedBytes: 0,
+    totalBytes: 0,
+    retentionTruncated: false
   };
 }
 function retainedBytes(stream, complete) {
@@ -49954,6 +50021,44 @@ function utf8SuffixWithinBudget(value, budget) {
   }
   return characters.slice(start).join("");
 }
+function isUtf8Continuation(byte) {
+  return byte !== void 0 && (byte & 192) === 128;
+}
+function utf8SequenceBytes(byte) {
+  if ((byte & 128) === 0) return 1;
+  if ((byte & 224) === 192) return 2;
+  if ((byte & 240) === 224) return 3;
+  if ((byte & 248) === 240) return 4;
+  return 1;
+}
+function retainedRange(stream, requestedOffset, maxBytes) {
+  const retained = Buffer.concat(stream.retained, stream.retainedBytes);
+  let offset = requestedOffset;
+  while (offset < retained.byteLength && isUtf8Continuation(retained[offset])) {
+    offset += 1;
+  }
+  if (offset >= retained.byteLength) {
+    return { offset, content: "" };
+  }
+  let end = Math.min(retained.byteLength, offset + maxBytes);
+  if (end < retained.byteLength) {
+    while (end > offset && isUtf8Continuation(retained[end])) end -= 1;
+  }
+  if (end > offset) {
+    let lead = end - 1;
+    while (lead > offset && isUtf8Continuation(retained[lead])) lead -= 1;
+    const expected = utf8SequenceBytes(retained[lead]);
+    if (expected > 1 && end - lead < expected) end = lead;
+  }
+  if (end <= offset) {
+    end = Math.min(retained.byteLength, offset + maxBytes);
+  }
+  return {
+    offset,
+    content: retained.subarray(offset, end).toString("utf8"),
+    ...end < retained.byteLength ? { nextOffset: end } : {}
+  };
+}
 function renderStream(stream, budget, complete) {
   if (budget <= 0 || stream.totalBytes === 0) {
     return { content: "", truncated: stream.totalBytes > 0 };
@@ -50046,6 +50151,21 @@ var CommandService = class {
   policy;
   #commands = /* @__PURE__ */ new Map();
   #activeCommandId = null;
+  #pruneRetainedCommands() {
+    while (this.#commands.size >= MAX_RETAINED_COMMAND_RECORDS) {
+      const oldestTerminal = [...this.#commands].find(
+        ([, record2]) => record2.status !== "running"
+      );
+      if (!oldestTerminal) return;
+      this.#commands.delete(oldestTerminal[0]);
+    }
+  }
+  #scheduleDeletion(commandId) {
+    setTimeout(
+      () => this.#commands.delete(commandId),
+      COMMAND_RECORD_RETENTION_MS
+    ).unref();
+  }
   async start(options) {
     if (this.#activeCommandId) {
       const active = this.#commands.get(this.#activeCommandId);
@@ -50130,6 +50250,7 @@ var CommandService = class {
       void terminateProcessTree(child);
     }, timeoutMs);
     record2.timeout.unref();
+    this.#pruneRetainedCommands();
     this.#commands.set(id, record2);
     this.#activeCommandId = id;
     child.stdout.on("data", (chunk) => {
@@ -50147,6 +50268,7 @@ var CommandService = class {
       this.#activeCommandId = null;
       markChanged(record2);
       record2.complete();
+      this.#scheduleDeletion(id);
     });
     child.once("close", (exitCode, signal) => {
       if (record2.status !== "running") return;
@@ -50158,7 +50280,7 @@ var CommandService = class {
       this.#activeCommandId = null;
       markChanged(record2);
       record2.complete();
-      setTimeout(() => this.#commands.delete(id), 5 * 60 * 1e3).unref();
+      this.#scheduleDeletion(id);
     });
     if (options.stdin !== void 0) child.stdin.end(options.stdin);
     else child.stdin.end();
@@ -50215,6 +50337,53 @@ var CommandService = class {
     }
     return this.snapshot(record2);
   }
+  async readOutput(commandId, streamName, offset = 0, maxBytes = DEFAULT_COMMAND_OUTPUT_RANGE_BYTES) {
+    const record2 = this.#commands.get(commandId);
+    if (!record2) throw new WorkerError("command_not_found", "The command was not found.");
+    if (streamName !== "stdout" && streamName !== "stderr") {
+      throw new WorkerError(
+        "invalid_output_stream",
+        "Command output stream must be stdout or stderr."
+      );
+    }
+    if (!Number.isInteger(offset) || offset < 0) {
+      throw new WorkerError(
+        "invalid_output_offset",
+        "Command output offset must be a non-negative integer."
+      );
+    }
+    if (!Number.isInteger(maxBytes) || maxBytes < 4 || maxBytes > MAX_COMMAND_OUTPUT_RANGE_BYTES) {
+      throw new WorkerError(
+        "invalid_output_range",
+        "Command output range must be between 4 and 65536 source bytes."
+      );
+    }
+    if (record2.restrictedDataDetected) throw restrictedDataError();
+    const stream = record2[streamName];
+    if (offset > stream.retainedBytes) {
+      throw new WorkerError(
+        "output_offset_out_of_range",
+        "The command output offset exceeds the retained stream length."
+      );
+    }
+    const range = retainedRange(stream, offset, maxBytes);
+    if (containsRestrictedAuthenticationData(range.content)) {
+      markRestrictedData(record2);
+      throw restrictedDataError();
+    }
+    return {
+      commandId,
+      stream: streamName,
+      status: record2.status,
+      offset: range.offset,
+      content: range.content,
+      ...range.nextOffset === void 0 ? {} : { nextOffset: range.nextOffset },
+      retainedBytes: stream.retainedBytes,
+      totalBytes: stream.totalBytes,
+      retentionTruncated: stream.retentionTruncated,
+      complete: record2.status !== "running"
+    };
+  }
   async cancel(commandId) {
     const record2 = this.#commands.get(commandId);
     if (!record2) throw new WorkerError("command_not_found", "The command was not found.");
@@ -50262,124 +50431,414 @@ var CommandService = class {
 import { createHash, randomUUID as randomUUID2 } from "node:crypto";
 import {
   chmod as chmod2,
-  lstat,
+  link as link2,
+  lstat as lstat2,
+  mkdir as mkdir3,
   opendir,
   open,
   readFile as readFile3,
   rename,
   rm as rm2,
-  stat,
+  rmdir,
+  stat as stat2,
   writeFile as writeFile3
 } from "node:fs/promises";
-import path5 from "node:path";
+import path6 from "node:path";
 import { performance as performance2 } from "node:perf_hooks";
 import { StringDecoder as StringDecoder2 } from "node:string_decoder";
-function sha256(content) {
-  return createHash("sha256").update(content).digest("hex");
+
+// src/worker/path-policy.ts
+import { lstat, realpath, stat } from "node:fs/promises";
+import os5 from "node:os";
+import path5 from "node:path";
+function samePath(left, right) {
+  return process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
 }
-var fileWriteTails = /* @__PURE__ */ new Map();
-async function withFileWriteLock(target, operation) {
-  const normalized = path5.normalize(target);
-  const key = process.platform === "win32" ? normalized.toLowerCase() : normalized;
-  const predecessor = fileWriteTails.get(key);
-  let release;
-  const tail = new Promise((resolve) => {
-    release = resolve;
-  });
-  fileWriteTails.set(key, tail);
-  if (predecessor) await predecessor;
+function accountHomeDirectory() {
   try {
-    return await operation();
-  } finally {
-    release();
-    if (fileWriteTails.get(key) === tail) fileWriteTails.delete(key);
+    return os5.userInfo().homedir;
+  } catch {
+    return os5.homedir();
   }
 }
-async function requireRevision(target, expectedSha256) {
-  let actual = null;
-  try {
-    actual = sha256(await readFile3(target));
-  } catch (error46) {
-    if (error46.code !== "ENOENT") throw error46;
+function isWithin(root, candidate) {
+  const relative = path5.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path5.sep}`) && relative !== ".." && !path5.isAbsolute(relative);
+}
+function validateRelativePath(value) {
+  if (value.includes("\0")) {
+    throw new WorkerError("invalid_path", "Paths cannot contain null bytes.");
   }
-  if (actual !== expectedSha256) {
-    throw new WorkerError("stale_revision", "The file revision has changed.");
+  const explicitNativePosixPath = process.platform !== "win32" && value.startsWith("./");
+  if (path5.isAbsolute(value) || path5.posix.isAbsolute(value) || !explicitNativePosixPath && path5.win32.isAbsolute(value)) {
+    throw new WorkerError("absolute_path", "Absolute paths are not allowed.");
   }
+  const segments = explicitNativePosixPath ? value.split(/\/+/).filter(Boolean) : value.split(/[\\/]+/);
+  if (segments.includes("..")) {
+    throw new WorkerError("path_traversal", "Parent path traversal is not allowed.");
+  }
+  return value === "" ? "." : value;
 }
-var DEFAULT_LIST_FILES_LIMIT = 100;
-var DEFAULT_SEARCH_TEXT_RESULTS = 50;
-var DEFAULT_READ_RANGE_LINES = 200;
-var MAX_REPOSITORY_SCAN_ENTRIES = 2e4;
-var MAX_SEARCH_FILES = 5e3;
-var MAX_SEARCH_BYTES = 32 * 1024 * 1024;
-var SKIPPED_RECURSIVE_DIRECTORIES = /* @__PURE__ */ new Set([
-  ".git",
-  ".hg",
-  ".svn",
-  "node_modules"
-]);
-function compareNames(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
-function relativeSortKey(root, target) {
-  const relative = path5.relative(root, target);
-  if (!relative) return ".";
-  return process.platform === "win32" ? relative.replaceAll("\\", "/") : relative;
-}
-function displayPath(root, target) {
-  const relative = relativeSortKey(root, target);
-  if (process.platform === "win32") return relative;
-  return relative.includes("\\") ? "./" + relative : relative;
-}
-function isUnavailableFileError(error46) {
-  const code = error46?.code;
-  return code === "ENOENT" || code === "EACCES" || code === "EPERM" || code === "ENOTDIR";
-}
-function isUnavailableDiscoveredPathError(error46) {
-  return isUnavailableFileError(error46) || error46 instanceof WorkerError && error46.code === "path_not_found";
-}
-function isLinkedPathError(error46) {
-  return error46 instanceof WorkerError && error46.code === "linked_path";
+async function canonicalizeRoot(candidate) {
+  const root = await realpath(path5.resolve(candidate)).catch((error46) => {
+    if (error46.code === "ENOENT") {
+      throw new WorkerError("root_not_found", "The workspace directory does not exist.");
+    }
+    throw error46;
+  });
+  const rootStat = await stat(root);
+  if (!rootStat.isDirectory()) {
+    throw new WorkerError("root_not_directory", "The exposed root must be a directory.");
+  }
+  const filesystemRoot = path5.parse(root).root;
+  const homes = await Promise.all(
+    [os5.homedir(), accountHomeDirectory()].map(
+      async (home) => await realpath(home).catch(() => path5.resolve(home))
+    )
+  );
+  const isHomeDirectory = homes.some((home) => samePath(root, home));
+  if (samePath(root, filesystemRoot) || isHomeDirectory) {
+    const kind = isHomeDirectory ? "your home directory" : "a filesystem root";
+    throw new WorkerError(
+      "broad_root_refused",
+      `The selected root is ${kind}, which Glossa will not expose. Choose a project directory instead.`
+    );
+  }
+  return root;
 }
-async function readBoundedFile(target, maximumBytes, expectedBytes) {
-  const handle = await open(target, "r");
-  try {
-    const openedStat = await handle.stat();
-    if (!openedStat.isFile()) {
-      throw new WorkerError("not_file", "The requested path is not a file.");
+var PathPolicy = class _PathPolicy {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  static async create(candidate) {
+    return new _PathPolicy(await canonicalizeRoot(candidate));
+  }
+  async resolveExisting(relativePath) {
+    const lexical = this.resolveLexical(relativePath);
+    await this.rejectLinkedComponents(lexical);
+    const canonical = await realpath(lexical).catch((error46) => {
+      if (error46.code === "ENOENT") {
+        throw new WorkerError("path_not_found", "The requested path does not exist.");
+      }
+      throw error46;
+    });
+    if (!isWithin(this.root, canonical)) {
+      throw new WorkerError("path_escape", "The requested path escapes the exposed root.");
     }
-    if (openedStat.size !== expectedBytes) {
-      throw new WorkerError("file_changed", "The file changed while it was being read.");
+    return canonical;
+  }
+  async resolveDiscoveredExisting(candidate) {
+    const lexical = path5.resolve(candidate);
+    if (!isWithin(this.root, lexical)) {
+      throw new WorkerError("path_escape", "The requested path escapes the exposed root.");
     }
-    if (openedStat.size > maximumBytes) {
-      throw new WorkerError("search_byte_limit", "The search byte limit was reached.");
+    await this.rejectLinkedComponents(lexical);
+    const canonical = await realpath(lexical).catch((error46) => {
+      if (error46.code === "ENOENT") {
+        throw new WorkerError("path_not_found", "The requested path does not exist.");
+      }
+      throw error46;
+    });
+    if (!isWithin(this.root, canonical)) {
+      throw new WorkerError("path_escape", "The requested path escapes the exposed root.");
     }
-    const buffer = Buffer.allocUnsafe(openedStat.size);
-    let offset = 0;
-    while (offset < buffer.byteLength) {
-      const { bytesRead } = await handle.read(
-        buffer,
-        offset,
-        buffer.byteLength - offset,
-        offset
-      );
-      if (bytesRead === 0) break;
-      offset += bytesRead;
+    return canonical;
+  }
+  async resolveWritableFile(relativePath) {
+    const lexical = this.resolveLexical(relativePath);
+    const parent = path5.dirname(lexical);
+    await this.rejectLinkedComponents(parent);
+    const canonicalParent = await realpath(parent).catch((error46) => {
+      if (error46.code === "ENOENT") {
+        throw new WorkerError("parent_not_found", "The destination directory does not exist.");
+      }
+      throw error46;
+    });
+    if (!isWithin(this.root, canonicalParent)) {
+      throw new WorkerError("path_escape", "The destination escapes the exposed root.");
     }
-    const completedStat = await handle.stat();
-    if (completedStat.size !== openedStat.size || offset !== openedStat.size) {
-      throw new WorkerError("file_changed", "The file changed while it was being read.");
+    if (!(await stat(canonicalParent)).isDirectory()) {
+      throw new WorkerError("not_directory", "The destination parent is not a directory.");
     }
-    return Buffer.from(buffer);
-  } finally {
-    await handle.close();
+    try {
+      const targetStat = await lstat(lexical);
+      if (targetStat.isSymbolicLink()) {
+        throw new WorkerError("linked_path", "Writes through links are not allowed.");
+      }
+      if (targetStat.isDirectory()) {
+        throw new WorkerError("not_file", "The destination is a directory.");
+      }
+      const canonicalTarget = await realpath(lexical);
+      if (!isWithin(this.root, canonicalTarget)) {
+        throw new WorkerError("path_escape", "The destination escapes the exposed root.");
+      }
+      return canonicalTarget;
+    } catch (error46) {
+      if (error46 instanceof WorkerError) throw error46;
+      if (error46.code !== "ENOENT") throw error46;
+    }
+    return path5.join(canonicalParent, path5.basename(lexical));
   }
-}
-function normalizedLines(content) {
-  if (content.length === 0) return [];
-  const normalized = content.replace(/\r\n?/g, "\n");
-  const lines = normalized.split("\n");
-  if (normalized.endsWith("\n")) lines.pop();
+  async resolveWritableDirectory(relativePath, recursive) {
+    const lexical = this.resolveLexical(relativePath);
+    await this.rejectLinkedComponents(lexical);
+    try {
+      const targetStat = await lstat(lexical);
+      if (targetStat.isSymbolicLink()) {
+        throw new WorkerError("linked_path", "Directory creation through links is not allowed.");
+      }
+      if (!targetStat.isDirectory()) {
+        throw new WorkerError("not_directory", "The destination is not a directory.");
+      }
+      const canonicalTarget = await realpath(lexical);
+      if (!isWithin(this.root, canonicalTarget)) {
+        throw new WorkerError("path_escape", "The destination escapes the exposed root.");
+      }
+      return { target: canonicalTarget, exists: true };
+    } catch (error46) {
+      if (error46 instanceof WorkerError) throw error46;
+      if (error46.code !== "ENOENT") throw error46;
+    }
+    if (!recursive) {
+      const parent = path5.dirname(lexical);
+      await this.rejectLinkedComponents(parent);
+      const canonicalParent = await realpath(parent).catch(
+        (error46) => {
+          if (error46.code === "ENOENT") {
+            throw new WorkerError(
+              "parent_not_found",
+              "The destination directory does not exist."
+            );
+          }
+          throw error46;
+        }
+      );
+      if (!isWithin(this.root, canonicalParent)) {
+        throw new WorkerError("path_escape", "The destination escapes the exposed root.");
+      }
+      if (!(await stat(canonicalParent)).isDirectory()) {
+        throw new WorkerError("not_directory", "The destination parent is not a directory.");
+      }
+      return {
+        target: path5.join(canonicalParent, path5.basename(lexical)),
+        exists: false
+      };
+    }
+    let existingAncestor = path5.dirname(lexical);
+    while (!samePath(existingAncestor, this.root)) {
+      try {
+        await this.rejectLinkedComponents(existingAncestor);
+        const canonicalAncestor = await realpath(existingAncestor);
+        if (!isWithin(this.root, canonicalAncestor)) {
+          throw new WorkerError("path_escape", "The destination escapes the exposed root.");
+        }
+        if (!(await stat(canonicalAncestor)).isDirectory()) {
+          throw new WorkerError("not_directory", "The destination parent is not a directory.");
+        }
+        return {
+          target: path5.join(
+            canonicalAncestor,
+            path5.relative(existingAncestor, lexical)
+          ),
+          exists: false
+        };
+      } catch (error46) {
+        if (error46 instanceof WorkerError) throw error46;
+        if (error46.code !== "ENOENT") throw error46;
+      }
+      existingAncestor = path5.dirname(existingAncestor);
+    }
+    return { target: lexical, exists: false };
+  }
+  async resolveVacantPath(relativePath) {
+    const lexical = this.resolveLexical(relativePath);
+    const parent = path5.dirname(lexical);
+    await this.rejectLinkedComponents(parent);
+    const canonicalParent = await realpath(parent).catch(
+      (error46) => {
+        if (error46.code === "ENOENT") {
+          throw new WorkerError(
+            "parent_not_found",
+            "The destination directory does not exist."
+          );
+        }
+        throw error46;
+      }
+    );
+    if (!isWithin(this.root, canonicalParent)) {
+      throw new WorkerError("path_escape", "The destination escapes the exposed root.");
+    }
+    if (!(await stat(canonicalParent)).isDirectory()) {
+      throw new WorkerError("not_directory", "The destination parent is not a directory.");
+    }
+    try {
+      await lstat(lexical);
+      throw new WorkerError(
+        "destination_exists",
+        "The destination already exists."
+      );
+    } catch (error46) {
+      if (error46 instanceof WorkerError) throw error46;
+      if (error46.code !== "ENOENT") throw error46;
+    }
+    return path5.join(canonicalParent, path5.basename(lexical));
+  }
+  resolveLexical(relativePath) {
+    const validated = validateRelativePath(relativePath);
+    const candidate = path5.resolve(this.root, validated);
+    if (!isWithin(this.root, candidate)) {
+      throw new WorkerError("path_escape", "The requested path escapes the exposed root.");
+    }
+    return candidate;
+  }
+  async rejectLinkedComponents(candidate) {
+    if (!isWithin(this.root, candidate)) {
+      throw new WorkerError("path_escape", "The requested path escapes the exposed root.");
+    }
+    const relative = path5.relative(this.root, candidate);
+    if (!relative) return;
+    let current = this.root;
+    for (const segment of relative.split(path5.sep)) {
+      current = path5.join(current, segment);
+      try {
+        const currentStat = await lstat(current);
+        if (currentStat.isSymbolicLink()) {
+          throw new WorkerError(
+            "linked_path",
+            "Symlink and junction paths are not allowed."
+          );
+        }
+      } catch (error46) {
+        if (error46 instanceof WorkerError) throw error46;
+        if (error46.code === "ENOENT") return;
+        throw error46;
+      }
+    }
+  }
+};
+
+// src/worker/file-service.ts
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function isPathWithin(root, candidate) {
+  const relative = path6.relative(root, candidate);
+  return relative === "" || !relative.startsWith(`..${path6.sep}`) && relative !== ".." && !path6.isAbsolute(relative);
+}
+var fileWriteTails = /* @__PURE__ */ new Map();
+async function withFileWriteLock(target, operation) {
+  const normalized = path6.normalize(target);
+  const key = process.platform === "win32" ? normalized.toLowerCase() : normalized;
+  const predecessor = fileWriteTails.get(key);
+  let release;
+  const tail = new Promise((resolve) => {
+    release = resolve;
+  });
+  fileWriteTails.set(key, tail);
+  if (predecessor) await predecessor;
+  try {
+    return await operation();
+  } finally {
+    release();
+    if (fileWriteTails.get(key) === tail) fileWriteTails.delete(key);
+  }
+}
+async function withFileWriteLocks(targets, operation) {
+  const unique = [...new Set(targets.map((target) => path6.normalize(target)))].sort(
+    (left, right) => left.localeCompare(right)
+  );
+  const run = async (index) => {
+    const target = unique[index];
+    return target === void 0 ? await operation() : await withFileWriteLock(target, async () => await run(index + 1));
+  };
+  return await run(0);
+}
+async function requireRevision(target, expectedSha256) {
+  let actual = null;
+  try {
+    actual = sha256(await readFile3(target));
+  } catch (error46) {
+    if (error46.code !== "ENOENT") throw error46;
+  }
+  if (actual !== expectedSha256) {
+    throw new WorkerError("stale_revision", "The file revision has changed.");
+  }
+}
+var DEFAULT_LIST_FILES_LIMIT = 100;
+var DEFAULT_SEARCH_TEXT_RESULTS = 50;
+var DEFAULT_READ_RANGE_LINES = 200;
+var MAX_REPOSITORY_SCAN_ENTRIES = 2e4;
+var MAX_SEARCH_FILES = 5e3;
+var MAX_SEARCH_BYTES = 32 * 1024 * 1024;
+var SKIPPED_RECURSIVE_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  "node_modules"
+]);
+function compareNames(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function relativeSortKey(root, target) {
+  const relative = path6.relative(root, target);
+  if (!relative) return ".";
+  return process.platform === "win32" ? relative.replaceAll("\\", "/") : relative;
+}
+function displayPath(root, target) {
+  const relative = relativeSortKey(root, target);
+  if (process.platform === "win32") return relative;
+  return relative.includes("\\") ? "./" + relative : relative;
+}
+function isUnavailableFileError(error46) {
+  const code = error46?.code;
+  return code === "ENOENT" || code === "EACCES" || code === "EPERM" || code === "ENOTDIR";
+}
+function isUnavailableDiscoveredPathError(error46) {
+  return isUnavailableFileError(error46) || error46 instanceof WorkerError && error46.code === "path_not_found";
+}
+function isLinkedPathError(error46) {
+  return error46 instanceof WorkerError && error46.code === "linked_path";
+}
+async function readBoundedFile(target, maximumBytes, expectedBytes) {
+  const handle = await open(target, "r");
+  try {
+    const openedStat = await handle.stat();
+    if (!openedStat.isFile()) {
+      throw new WorkerError("not_file", "The requested path is not a file.");
+    }
+    if (openedStat.size !== expectedBytes) {
+      throw new WorkerError("file_changed", "The file changed while it was being read.");
+    }
+    if (openedStat.size > maximumBytes) {
+      throw new WorkerError("search_byte_limit", "The search byte limit was reached.");
+    }
+    const buffer = Buffer.allocUnsafe(openedStat.size);
+    let offset = 0;
+    while (offset < buffer.byteLength) {
+      const { bytesRead } = await handle.read(
+        buffer,
+        offset,
+        buffer.byteLength - offset,
+        offset
+      );
+      if (bytesRead === 0) break;
+      offset += bytesRead;
+    }
+    const completedStat = await handle.stat();
+    if (completedStat.size !== openedStat.size || offset !== openedStat.size) {
+      throw new WorkerError("file_changed", "The file changed while it was being read.");
+    }
+    return Buffer.from(buffer);
+  } finally {
+    await handle.close();
+  }
+}
+function normalizedLines(content) {
+  if (content.length === 0) return [];
+  const normalized = content.replace(/\r\n?/g, "\n");
+  const lines = normalized.split("\n");
+  if (normalized.endsWith("\n")) lines.pop();
   return lines;
 }
 function escapeRegExp(value) {
@@ -50563,7 +51022,7 @@ var FileService = class {
     this.#beforeDeadline = dependencies.beforeDeadline ?? defaultBeforeDeadline;
     this.#openDirectory = dependencies.openDirectory ?? ((directory) => opendir(directory));
     this.#readFileBytes = dependencies.readFileBytes ?? readBoundedFile;
-    this.#lstatPath = dependencies.lstatPath ?? ((target) => lstat(target));
+    this.#lstatPath = dependencies.lstatPath ?? ((target) => lstat2(target));
     this.#trustDirectoryEntryTypes = dependencies.trustDirectoryEntryTypes ?? dependencies.lstatPath === void 0;
     this.#maxRepositoryScanEntries = dependencies.maxRepositoryScanEntries ?? MAX_REPOSITORY_SCAN_ENTRIES;
     this.#maxSearchBytes = dependencies.maxSearchBytes ?? MAX_SEARCH_BYTES;
@@ -50634,7 +51093,7 @@ var FileService = class {
   }
   async #readResolvedText(target, maximumBytes = MAX_TEXT_BYTES) {
     const boundedMaximum = Math.min(maximumBytes, MAX_TEXT_BYTES);
-    const targetStat = await stat(target);
+    const targetStat = await stat2(target);
     if (!targetStat.isFile()) {
       throw new WorkerError("not_file", "The requested path is not a file.");
     }
@@ -50677,7 +51136,7 @@ var FileService = class {
       this.policy.resolveExisting(startPath),
       deadlineAt
     );
-    const startStat = await this.#withinDeadline(stat(start), deadlineAt);
+    const startStat = await this.#withinDeadline(stat2(start), deadlineAt);
     if (!startStat.isDirectory()) {
       throw new WorkerError("not_directory", "The requested path is not a directory.");
     }
@@ -50706,7 +51165,7 @@ var FileService = class {
       if (batch.overflow) throw scanLimitError();
       scannedEntries += batch.children.length;
       for (const child of batch.children) {
-        const target = path5.join(directory, child.name);
+        const target = path6.join(directory, child.name);
         heapPush(frontier, {
           target,
           sortKey: relativeSortKey(this.policy.root, target),
@@ -50730,7 +51189,7 @@ var FileService = class {
             throw scanLimitError();
           }
           scannedEntries += 1;
-          const target = path5.join(directory, child.name);
+          const target = path6.join(directory, child.name);
           let childStat;
           try {
             childStat = await this.#withinDeadline(
@@ -50876,15 +51335,31 @@ var FileService = class {
     );
     const matchLimit = maxResults + 1;
     const extensions = options.extensions?.map((extension) => extension.toLowerCase());
-    const matcher = new RegExp(
-      escapeRegExp(options.query),
-      options.caseSensitive === true ? "u" : "iu"
-    );
+    const includeGlobs = options.includeGlobs;
+    const excludeGlobs = options.excludeGlobs;
+    const globMatches = (relativePath, patterns) => {
+      if (!patterns) return false;
+      const normalized = relativePath.replaceAll("\\", "/");
+      try {
+        return patterns.some((pattern) => path6.posix.matchesGlob(normalized, pattern));
+      } catch {
+        throw new WorkerError("invalid_search", "Search glob pattern is invalid.");
+      }
+    };
+    let matcher;
+    try {
+      matcher = new RegExp(
+        options.matchMode === "regex" ? options.query : escapeRegExp(options.query),
+        options.caseSensitive === true ? "u" : "iu"
+      );
+    } catch {
+      throw new WorkerError("invalid_search", "Search regular expression is invalid.");
+    }
     const start = await this.#withinDeadline(
       this.policy.resolveExisting(options.path ?? "."),
       deadlineAt
     );
-    const startStat = await this.#withinDeadline(stat(start), deadlineAt);
+    const startStat = await this.#withinDeadline(stat2(start), deadlineAt);
     const matches = [];
     let scannedEntries = 0;
     let scannedFiles = 0;
@@ -50895,10 +51370,12 @@ var FileService = class {
     const searchFile = async (target) => {
       const relative = displayPath(this.policy.root, target);
       if (extensions && !extensions.some(
-        (extension) => path5.basename(target).toLowerCase().endsWith(extension)
+        (extension) => path6.basename(target).toLowerCase().endsWith(extension)
       )) {
         return false;
       }
+      if (includeGlobs && !globMatches(relative, includeGlobs)) return false;
+      if (globMatches(relative, excludeGlobs)) return false;
       if (scannedFiles >= MAX_SEARCH_FILES) {
         scanTruncated = true;
         return true;
@@ -50988,7 +51465,7 @@ var FileService = class {
       scannedEntries += batch.children.length;
       for (const child of batch.children) {
         this.#assertBeforeDeadline(deadlineAt);
-        const target = path5.join(directory, child.name);
+        const target = path6.join(directory, child.name);
         let targetType;
         if (this.#trustDirectoryEntryTypes) {
           if (child.isSymbolicLink()) {
@@ -51123,6 +51600,118 @@ var FileService = class {
       ...endLine < lines.length ? { nextLine: endLine + 1 } : {}
     };
   }
+  async makeDirectory(relativePath, recursive = false) {
+    const initial = await this.policy.resolveWritableDirectory(
+      relativePath,
+      recursive
+    );
+    if (initial.exists) return { created: false };
+    return await withFileWriteLock(initial.target, async () => {
+      const current = await this.policy.resolveWritableDirectory(
+        relativePath,
+        recursive
+      );
+      if (current.exists) return { created: false };
+      try {
+        await mkdir3(current.target, { recursive });
+      } catch (error46) {
+        if (error46.code !== "EEXIST") throw error46;
+      }
+      const resolved = await this.policy.resolveExisting(relativePath);
+      if (!(await stat2(resolved)).isDirectory()) {
+        throw new WorkerError("not_directory", "The destination is not a directory.");
+      }
+      return { created: true };
+    });
+  }
+  async deletePath(relativePath, recursive = false) {
+    const initial = await this.policy.resolveExisting(relativePath);
+    if (samePath(initial, this.policy.root)) {
+      throw new WorkerError(
+        "root_operation_refused",
+        "The exposed workspace root cannot be deleted."
+      );
+    }
+    return await withFileWriteLock(initial, async () => {
+      const target = await this.policy.resolveExisting(relativePath);
+      if (samePath(target, this.policy.root)) {
+        throw new WorkerError(
+          "root_operation_refused",
+          "The exposed workspace root cannot be deleted."
+        );
+      }
+      const targetStat = await lstat2(target);
+      if (!targetStat.isFile() && !targetStat.isDirectory()) {
+        throw new WorkerError(
+          "unsupported_path_type",
+          "Only regular files and directories can be deleted."
+        );
+      }
+      try {
+        if (targetStat.isDirectory()) {
+          if (recursive) {
+            await rm2(target, { recursive: true, force: false });
+          } else {
+            await rmdir(target);
+          }
+        } else {
+          await rm2(target, { force: false });
+        }
+      } catch (error46) {
+        const code = error46.code;
+        if (targetStat.isDirectory() && !recursive && (code === "ENOTEMPTY" || code === "EEXIST" || code === "EPERM")) {
+          throw new WorkerError(
+            "directory_not_empty",
+            "The directory is not empty. Set recursive to true to delete its contents."
+          );
+        }
+        throw error46;
+      }
+      return {
+        deletedType: targetStat.isDirectory() ? "directory" : "file"
+      };
+    });
+  }
+  async movePath(sourcePath, destinationPath) {
+    const initialSource = await this.policy.resolveExisting(sourcePath);
+    if (samePath(initialSource, this.policy.root)) {
+      throw new WorkerError(
+        "root_operation_refused",
+        "The exposed workspace root cannot be moved."
+      );
+    }
+    const initialDestination = await this.policy.resolveVacantPath(destinationPath);
+    return await withFileWriteLocks(
+      [initialSource, initialDestination],
+      async () => {
+        const source = await this.policy.resolveExisting(sourcePath);
+        if (samePath(source, this.policy.root)) {
+          throw new WorkerError(
+            "root_operation_refused",
+            "The exposed workspace root cannot be moved."
+          );
+        }
+        const destination = await this.policy.resolveVacantPath(destinationPath);
+        const sourceStat = await lstat2(source);
+        if (!sourceStat.isFile() && !sourceStat.isDirectory()) {
+          throw new WorkerError(
+            "unsupported_path_type",
+            "Only regular files and directories can be moved."
+          );
+        }
+        if (sourceStat.isDirectory() && isPathWithin(source, destination)) {
+          throw new WorkerError(
+            "invalid_destination",
+            "A directory cannot be moved inside itself."
+          );
+        }
+        await rename(source, destination);
+        return {
+          movedType: sourceStat.isDirectory() ? "directory" : "file"
+        };
+      }
+    );
+  }
   async editText(relativePath, edits, expectedSha256) {
     const original = await this.readText(relativePath);
     if (expectedSha256 && original.sha256 !== expectedSha256) {
@@ -51174,25 +51763,45 @@ var FileService = class {
     return await withFileWriteLock(target, async () => {
       let existingMode;
       try {
-        const existingStat = await stat(target);
+        const existingStat = await stat2(target);
         if (existingStat.isFile()) existingMode = existingStat.mode & 4095;
       } catch (error46) {
         if (error46.code !== "ENOENT") throw error46;
       }
+      if (existingMode !== void 0 && expectedSha256 === void 0) {
+        throw new WorkerError(
+          "path_exists",
+          "The file already exists. Read it first and pass expectedSha256 to replace that revision."
+        );
+      }
       if (expectedSha256) await requireRevision(target, expectedSha256);
-      const temporary = path5.join(path5.dirname(target), `.glossa-${randomUUID2()}.tmp`);
+      const temporary = path6.join(path6.dirname(target), `.glossa-${randomUUID2()}.tmp`);
       try {
         await writeFile3(temporary, bytes, { flag: "wx", mode: 384 });
         target = await this.policy.resolveWritableFile(relativePath);
-        const tempStat = await lstat(temporary);
+        const tempStat = await lstat2(temporary);
         if (!tempStat.isFile() || tempStat.isSymbolicLink()) {
           throw new WorkerError("unsafe_temporary_file", "The atomic write temporary file changed.");
         }
         if (existingMode !== void 0 && process.platform !== "win32") {
           await chmod2(temporary, existingMode);
         }
-        if (expectedSha256) await requireRevision(target, expectedSha256);
-        await rename(temporary, target);
+        if (expectedSha256) {
+          await requireRevision(target, expectedSha256);
+          await rename(temporary, target);
+        } else {
+          try {
+            await link2(temporary, target);
+          } catch (error46) {
+            if (error46.code === "EEXIST") {
+              throw new WorkerError(
+                "path_exists",
+                "The file already exists. Read it first and pass expectedSha256 to replace that revision."
+              );
+            }
+            throw error46;
+          }
+        }
       } finally {
         await rm2(temporary, { force: true });
       }
@@ -51201,173 +51810,6 @@ var FileService = class {
   }
 };
 
-// src/worker/path-policy.ts
-import { lstat as lstat2, realpath, stat as stat2 } from "node:fs/promises";
-import os5 from "node:os";
-import path6 from "node:path";
-function samePath(left, right) {
-  return process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
-}
-function accountHomeDirectory() {
-  try {
-    return os5.userInfo().homedir;
-  } catch {
-    return os5.homedir();
-  }
-}
-function isWithin(root, candidate) {
-  const relative = path6.relative(root, candidate);
-  return relative === "" || !relative.startsWith(`..${path6.sep}`) && relative !== ".." && !path6.isAbsolute(relative);
-}
-function validateRelativePath(value) {
-  if (value.includes("\0")) {
-    throw new WorkerError("invalid_path", "Paths cannot contain null bytes.");
-  }
-  const explicitNativePosixPath = process.platform !== "win32" && value.startsWith("./");
-  if (path6.isAbsolute(value) || path6.posix.isAbsolute(value) || !explicitNativePosixPath && path6.win32.isAbsolute(value)) {
-    throw new WorkerError("absolute_path", "Absolute paths are not allowed.");
-  }
-  const segments = explicitNativePosixPath ? value.split(/\/+/).filter(Boolean) : value.split(/[\\/]+/);
-  if (segments.includes("..")) {
-    throw new WorkerError("path_traversal", "Parent path traversal is not allowed.");
-  }
-  return value === "" ? "." : value;
-}
-async function canonicalizeRoot(candidate) {
-  const root = await realpath(path6.resolve(candidate)).catch((error46) => {
-    if (error46.code === "ENOENT") {
-      throw new WorkerError("root_not_found", "The workspace directory does not exist.");
-    }
-    throw error46;
-  });
-  const rootStat = await stat2(root);
-  if (!rootStat.isDirectory()) {
-    throw new WorkerError("root_not_directory", "The exposed root must be a directory.");
-  }
-  const filesystemRoot = path6.parse(root).root;
-  const homes = await Promise.all(
-    [os5.homedir(), accountHomeDirectory()].map(
-      async (home) => await realpath(home).catch(() => path6.resolve(home))
-    )
-  );
-  const isHomeDirectory = homes.some((home) => samePath(root, home));
-  if (samePath(root, filesystemRoot) || isHomeDirectory) {
-    const kind = isHomeDirectory ? "your home directory" : "a filesystem root";
-    throw new WorkerError(
-      "broad_root_refused",
-      `The selected root is ${kind}, which Glossa will not expose. Choose a project directory instead.`
-    );
-  }
-  return root;
-}
-var PathPolicy = class _PathPolicy {
-  constructor(root) {
-    this.root = root;
-  }
-  root;
-  static async create(candidate) {
-    return new _PathPolicy(await canonicalizeRoot(candidate));
-  }
-  async resolveExisting(relativePath) {
-    const lexical = this.resolveLexical(relativePath);
-    await this.rejectLinkedComponents(lexical);
-    const canonical = await realpath(lexical).catch((error46) => {
-      if (error46.code === "ENOENT") {
-        throw new WorkerError("path_not_found", "The requested path does not exist.");
-      }
-      throw error46;
-    });
-    if (!isWithin(this.root, canonical)) {
-      throw new WorkerError("path_escape", "The requested path escapes the exposed root.");
-    }
-    return canonical;
-  }
-  async resolveDiscoveredExisting(candidate) {
-    const lexical = path6.resolve(candidate);
-    if (!isWithin(this.root, lexical)) {
-      throw new WorkerError("path_escape", "The requested path escapes the exposed root.");
-    }
-    await this.rejectLinkedComponents(lexical);
-    const canonical = await realpath(lexical).catch((error46) => {
-      if (error46.code === "ENOENT") {
-        throw new WorkerError("path_not_found", "The requested path does not exist.");
-      }
-      throw error46;
-    });
-    if (!isWithin(this.root, canonical)) {
-      throw new WorkerError("path_escape", "The requested path escapes the exposed root.");
-    }
-    return canonical;
-  }
-  async resolveWritableFile(relativePath) {
-    const lexical = this.resolveLexical(relativePath);
-    const parent = path6.dirname(lexical);
-    await this.rejectLinkedComponents(parent);
-    const canonicalParent = await realpath(parent).catch((error46) => {
-      if (error46.code === "ENOENT") {
-        throw new WorkerError("parent_not_found", "The destination directory does not exist.");
-      }
-      throw error46;
-    });
-    if (!isWithin(this.root, canonicalParent)) {
-      throw new WorkerError("path_escape", "The destination escapes the exposed root.");
-    }
-    if (!(await stat2(canonicalParent)).isDirectory()) {
-      throw new WorkerError("not_directory", "The destination parent is not a directory.");
-    }
-    try {
-      const targetStat = await lstat2(lexical);
-      if (targetStat.isSymbolicLink()) {
-        throw new WorkerError("linked_path", "Writes through links are not allowed.");
-      }
-      if (targetStat.isDirectory()) {
-        throw new WorkerError("not_file", "The destination is a directory.");
-      }
-      const canonicalTarget = await realpath(lexical);
-      if (!isWithin(this.root, canonicalTarget)) {
-        throw new WorkerError("path_escape", "The destination escapes the exposed root.");
-      }
-      return canonicalTarget;
-    } catch (error46) {
-      if (error46 instanceof WorkerError) throw error46;
-      if (error46.code !== "ENOENT") throw error46;
-    }
-    return path6.join(canonicalParent, path6.basename(lexical));
-  }
-  resolveLexical(relativePath) {
-    const validated = validateRelativePath(relativePath);
-    const candidate = path6.resolve(this.root, validated);
-    if (!isWithin(this.root, candidate)) {
-      throw new WorkerError("path_escape", "The requested path escapes the exposed root.");
-    }
-    return candidate;
-  }
-  async rejectLinkedComponents(candidate) {
-    if (!isWithin(this.root, candidate)) {
-      throw new WorkerError("path_escape", "The requested path escapes the exposed root.");
-    }
-    const relative = path6.relative(this.root, candidate);
-    if (!relative) return;
-    let current = this.root;
-    for (const segment of relative.split(path6.sep)) {
-      current = path6.join(current, segment);
-      try {
-        const currentStat = await lstat2(current);
-        if (currentStat.isSymbolicLink()) {
-          throw new WorkerError(
-            "linked_path",
-            "Symlink and junction paths are not allowed."
-          );
-        }
-      } catch (error46) {
-        if (error46 instanceof WorkerError) throw error46;
-        if (error46.code === "ENOENT") return;
-        throw error46;
-      }
-    }
-  }
-};
-
 // src/worker/local-worker.ts
 function restrictedDataError2() {
   return new WorkerError(
@@ -51402,6 +51844,14 @@ function jobInputContainsRestrictedData(job) {
         path: job.path,
         edits: job.edits
       });
+    case "make_directory":
+    case "delete_path":
+      return containsRestrictedAuthenticationData(job.path);
+    case "move_path":
+      return containsRestrictedAuthenticationData({
+        source: job.source,
+        destination: job.destination
+      });
     case "run_command":
       return containsRestrictedAuthenticationData({
         argv: job.argv,
@@ -51409,12 +51859,13 @@ function jobInputContainsRestrictedData(job) {
         stdin: job.stdin
       });
     case "get_command":
+    case "read_command_output":
     case "cancel_command":
       return false;
   }
 }
 function resultMayContainRestrictedData(job) {
-  return job.type === "read_file" || job.type === "list_files" || job.type === "search_text" || job.type === "read_file_range" || job.type === "edit_file" || job.type === "run_command" || job.type === "get_command" || job.type === "cancel_command";
+  return job.type === "read_file" || job.type === "list_files" || job.type === "search_text" || job.type === "read_file_range" || job.type === "edit_file" || job.type === "run_command" || job.type === "get_command" || job.type === "read_command_output" || job.type === "cancel_command";
 }
 var LocalWorker = class _LocalWorker {
   constructor(accessProfile, policy, files, commands) {
@@ -51439,13 +51890,13 @@ var LocalWorker = class _LocalWorker {
   async handle(job) {
     try {
       const permissions = workerPermissions(this.accessProfile);
-      if ((job.type === "write_file" || job.type === "edit_file") && !permissions.writeFiles) {
+      if ((job.type === "write_file" || job.type === "edit_file" || job.type === "make_directory" || job.type === "delete_path" || job.type === "move_path") && !permissions.writeFiles) {
         throw new WorkerError(
           "write_access_disabled",
           "This worker was started without file-write access."
         );
       }
-      if ((job.type === "run_command" || job.type === "get_command" || job.type === "cancel_command") && !permissions.runCommands) {
+      if ((job.type === "run_command" || job.type === "get_command" || job.type === "read_command_output" || job.type === "cancel_command") && !permissions.runCommands) {
         throw new WorkerError(
           "command_access_disabled",
           "This worker was started without system-command access."
@@ -51470,9 +51921,12 @@ var LocalWorker = class _LocalWorker {
           value = await this.files.searchText({
             query: job.query,
             ...job.path ? { path: job.path } : {},
+            ...job.matchMode === void 0 ? {} : { matchMode: job.matchMode },
             ...job.caseSensitive === void 0 ? {} : { caseSensitive: job.caseSensitive },
             ...job.maxResults === void 0 ? {} : { maxResults: job.maxResults },
             ...job.extensions ? { extensions: job.extensions } : {},
+            ...job.includeGlobs ? { includeGlobs: job.includeGlobs } : {},
+            ...job.excludeGlobs ? { excludeGlobs: job.excludeGlobs } : {},
             timeoutMs: job.timeoutMs
           });
           break;
@@ -51503,6 +51957,15 @@ var LocalWorker = class _LocalWorker {
           );
           break;
         }
+        case "make_directory":
+          value = await this.files.makeDirectory(job.path, job.recursive);
+          break;
+        case "delete_path":
+          value = await this.files.deletePath(job.path, job.recursive);
+          break;
+        case "move_path":
+          value = await this.files.movePath(job.source, job.destination);
+          break;
         case "run_command":
           value = await this.commands.start({
             ...job.argv ? { argv: job.argv } : {},
@@ -51519,6 +51982,14 @@ var LocalWorker = class _LocalWorker {
             job.afterSequence
           );
           break;
+        case "read_command_output":
+          value = await this.commands.readOutput(
+            job.commandId,
+            job.stream,
+            job.offset,
+            job.maxBytes
+          );
+          break;
         case "cancel_command":
           value = await this.commands.cancel(job.commandId);
           break;
@@ -51556,6 +52027,14 @@ var DeviceRejectedError = class extends Error {
     this.name = "DeviceRejectedError";
   }
 };
+var RelayAccessProfileUnsupportedError = class extends Error {
+  constructor(profile) {
+    super(
+      `The relay needs an update before it can represent ${profile} access. Update the relay before reconnecting this workspace.`
+    );
+    this.name = "RelayAccessProfileUnsupportedError";
+  }
+};
 var RelayResponseError = class extends Error {
   constructor(status) {
     super(`The relay returned HTTP ${status}.`);
@@ -51581,6 +52060,7 @@ function supportsCapability(value, capability) {
 function jobLane(job) {
   switch (job.type) {
     case "get_command":
+    case "read_command_output":
       return "status";
     case "cancel_command":
       return "cancel";
@@ -51591,14 +52071,20 @@ function jobLane(job) {
       return "read";
     case "write_file":
     case "edit_file":
+    case "make_directory":
+    case "delete_path":
+    case "move_path":
     case "run_command":
       return "mutation";
   }
 }
-function acceptedJobTypes(counts, total, structuredReads) {
+function acceptedJobTypes(counts, total, structuredReads, structuredMutations, commandOutputRanges) {
   if (total >= MAX_CONCURRENT_JOBS) return [];
   const accepted = [];
-  if (counts.status < 1) accepted.push("get_command");
+  if (counts.status < 1) {
+    accepted.push("get_command");
+    if (commandOutputRanges) accepted.push("read_command_output");
+  }
   if (counts.cancel < 1) accepted.push("cancel_command");
   if (counts.read < 2) {
     accepted.push("read_file");
@@ -51608,6 +52094,9 @@ function acceptedJobTypes(counts, total, structuredReads) {
   }
   if (counts.mutation < 1) {
     accepted.push("write_file", "edit_file", "run_command");
+    if (structuredMutations) {
+      accepted.push("make_directory", "delete_path", "move_path");
+    }
   }
   return accepted;
 }
@@ -51685,7 +52174,9 @@ var RemoteWorker = class {
           await this.#pollGeneration(session);
         } catch (error46) {
           if (this.#signal.aborted) return;
-          if (error46 instanceof DeviceRejectedError) throw error46;
+          if (error46 instanceof DeviceRejectedError || error46 instanceof RelayAccessProfileUnsupportedError) {
+            throw error46;
+          }
           const delay4 = reconnectDelayMs(
             failures,
             this.#random,
@@ -51712,6 +52203,25 @@ var RemoteWorker = class {
     }
   }
   async #register() {
+    const currentBody = {
+      workerId: this.#workerId,
+      capabilities: {
+        commandProgress: true,
+        concurrentJobs: true,
+        structuredReads: true,
+        structuredMutations: true,
+        commandOutputRanges: true
+      }
+    };
+    const mutationBody = {
+      workerId: this.#workerId,
+      capabilities: {
+        commandProgress: true,
+        concurrentJobs: true,
+        structuredReads: true,
+        structuredMutations: true
+      }
+    };
     const structuredBody = {
       workerId: this.#workerId,
       capabilities: {
@@ -51724,60 +52234,74 @@ var RemoteWorker = class {
       workerId: this.#workerId,
       capabilities: { commandProgress: true, concurrentJobs: true }
     };
-    const versionedStructuredBody = this.#workerVersion ? { ...structuredBody, workerVersion: this.#workerVersion } : void 0;
-    const preferredProfileBody = this.#accessProfile ? {
-      ...versionedStructuredBody ?? structuredBody,
-      accessProfile: this.#accessProfile,
-      ...this.#workspaceLabel ? { workspaceLabel: this.#workspaceLabel } : {}
-    } : void 0;
-    const attempts = [
-      ...preferredProfileBody ? [{ body: preferredProfileBody, legacyRelay: false }] : [],
-      ...versionedStructuredBody && this.#workspaceLabel ? [{
-        body: {
-          ...versionedStructuredBody,
-          workspaceLabel: this.#workspaceLabel
-        },
-        legacyRelay: false
-      }] : [],
-      ...this.#workspaceLabel ? [{
-        body: {
-          ...structuredBody,
-          workspaceLabel: this.#workspaceLabel
-        },
-        legacyRelay: false
-      }] : [],
-      ...versionedStructuredBody ? [{ body: versionedStructuredBody, legacyRelay: false }] : [],
-      {
-        body: structuredBody,
-        legacyRelay: false
-      },
-      ...this.#workspaceLabel ? [{
-        body: {
-          ...concurrentBody,
-          workspaceLabel: this.#workspaceLabel
-        },
-        legacyRelay: false
-      }] : [],
+    const capabilityBodies = [
+      currentBody,
+      mutationBody,
+      structuredBody,
+      concurrentBody,
       {
-        body: concurrentBody,
-        legacyRelay: false
+        workerId: this.#workerId,
+        capabilities: { commandProgress: true }
       },
+      { workerId: this.#workerId }
+    ];
+    const metadataPhases = [
       {
-        body: {
-          workerId: this.#workerId,
-          capabilities: { commandProgress: true }
-        },
-        legacyRelay: false
+        includeVersion: Boolean(this.#workerVersion),
+        includeLabel: Boolean(this.#workspaceLabel)
       },
-      { body: { workerId: this.#workerId }, legacyRelay: false },
-      { body: {}, legacyRelay: true }
+      ...this.#workspaceLabel ? [{
+        includeVersion: Boolean(this.#workerVersion),
+        includeLabel: false
+      }] : [],
+      ...this.#workerVersion && this.#workspaceLabel ? [{ includeVersion: false, includeLabel: true }] : [],
+      { includeVersion: false, includeLabel: false }
     ];
-    for (const [index, attempt] of attempts.entries()) {
+    const attempts = [];
+    const seenAttempts = /* @__PURE__ */ new Set();
+    const pushAttempt = (base, includeProfile, includeVersion, includeLabel, legacyRelay = false) => {
+      const body = {
+        ...base,
+        ...includeProfile && this.#accessProfile ? { accessProfile: this.#accessProfile } : {},
+        ...includeVersion && this.#workerVersion ? { workerVersion: this.#workerVersion } : {},
+        ...includeLabel && this.#workspaceLabel ? { workspaceLabel: this.#workspaceLabel } : {}
+      };
+      const key = JSON.stringify(body);
+      if (seenAttempts.has(key)) return;
+      seenAttempts.add(key);
+      attempts.push({ body, legacyRelay, profileIncluded: includeProfile });
+    };
+    if (this.#accessProfile) {
+      for (const metadata of metadataPhases) {
+        for (const body of capabilityBodies) {
+          pushAttempt(
+            body,
+            true,
+            metadata.includeVersion,
+            metadata.includeLabel
+          );
+        }
+      }
+    }
+    if (this.#accessProfile === void 0 || this.#accessProfile === "system") {
+      for (const metadata of metadataPhases) {
+        for (const body of capabilityBodies) {
+          pushAttempt(
+            body,
+            false,
+            metadata.includeVersion,
+            metadata.includeLabel
+          );
+        }
+      }
+      attempts.push({ body: {}, legacyRelay: true, profileIncluded: false });
+    }
+    for (const attempt of attempts) {
       let response;
       try {
         response = await this.#post("/device/register", attempt.body);
       } catch (error46) {
-        if (error46 instanceof RelayResponseError && error46.status === 400 && index < attempts.length - 1) {
+        if (error46 instanceof RelayResponseError && error46.status === 400) {
           continue;
         }
         throw error46;
@@ -51795,11 +52319,16 @@ var RemoteWorker = class {
         legacyRelay: attempt.legacyRelay,
         concurrentJobs: !attempt.legacyRelay && supportsCapability(value, "concurrentJobs"),
         structuredReads: !attempt.legacyRelay && supportsCapability(value, "structuredReads"),
-        accessProfileAccepted: this.#accessProfile === void 0 || "accessProfile" in value && value.accessProfile === this.#accessProfile,
+        structuredMutations: !attempt.legacyRelay && supportsCapability(value, "structuredMutations"),
+        commandOutputRanges: !attempt.legacyRelay && supportsCapability(value, "commandOutputRanges"),
+        accessProfileAccepted: this.#accessProfile === void 0 || "accessProfile" in value && value.accessProfile === this.#accessProfile || this.#accessProfile === "system" && !attempt.profileIncluded,
         workspaceLabelAccepted: this.#workspaceLabel === void 0 || "workspaceLabel" in value && value.workspaceLabel === this.#workspaceLabel,
         ...workerToken ? { workerToken } : {}
       };
     }
+    if (this.#accessProfile && this.#accessProfile !== "system") {
+      throw new RelayAccessProfileUnsupportedError(this.#accessProfile);
+    }
     throw new Error("The relay rejected every supported registration shape.");
   }
   async #pollGeneration(session) {
@@ -51889,7 +52418,9 @@ var RemoteWorker = class {
         const acceptedTypes = acceptedJobTypes(
           counts,
           inFlight.size,
-          session.structuredReads
+          session.structuredReads,
+          session.structuredMutations,
+          session.commandOutputRanges
         );
         if (acceptedTypes.length === 0) {
           await Promise.race(inFlight);
@@ -51919,7 +52450,9 @@ var RemoteWorker = class {
           const refreshedTypes = acceptedJobTypes(
             counts,
             inFlight.size,
-            session.structuredReads
+            session.structuredReads,
+            session.structuredMutations,
+            session.commandOutputRanges
           );
           const newlyAcceptedTypes = refreshedTypes.filter(
             (type) => !acceptedTypes.includes(type)
@@ -52099,6 +52632,15 @@ function activitySafeJob(job) {
           newText: ""
         }]
       };
+    case "make_directory":
+    case "delete_path":
+      return { ...job, path: "[restricted input blocked]" };
+    case "move_path":
+      return {
+        ...job,
+        source: "[restricted input blocked]",
+        destination: "[restricted input blocked]"
+      };
     case "run_command":
       return {
         type: "run_command",
@@ -52108,6 +52650,7 @@ function activitySafeJob(job) {
         ...job.waitMs === void 0 ? {} : { waitMs: job.waitMs }
       };
     case "get_command":
+    case "read_command_output":
     case "cancel_command":
       return job;
   }
@@ -52541,6 +53084,16 @@ function summarizeJob(job) {
         `${job.edits.length} ${job.edits.length === 1 ? "edit" : "edits"}`,
         ...job.expectedSha256 ? ["guarded"] : []
       ]);
+    case "make_directory":
+      return pathSummary(job.path, job.recursive ? ["recursive"] : []);
+    case "delete_path":
+      return pathSummary(job.path, job.recursive ? ["recursive"] : []);
+    case "move_path":
+      return {
+        target: `${quoteActivityInput(job.source)} \u2192 ${quoteActivityInput(job.destination)}`,
+        details: [],
+        truncation: "middle"
+      };
     case "run_command":
       return {
         target: job.argv ? `argv [${job.argv.map(quoteActivityInput).join(", ")}]` : `shell ${quoteActivityInput(job.shellCommand ?? "")}`,
@@ -52560,6 +53113,15 @@ function summarizeJob(job) {
         ],
         truncation: "middle"
       };
+    case "read_command_output":
+      return {
+        target: `command ${job.commandId} ${job.stream}`,
+        details: [
+          ...job.offset === void 0 ? [] : [`offset ${job.offset}`],
+          ...job.maxBytes === void 0 ? [] : [`max ${job.maxBytes} bytes`]
+        ],
+        truncation: "middle"
+      };
     case "cancel_command":
       return {
         target: `command ${job.commandId}`,
@@ -53504,7 +54066,7 @@ import path8 from "node:path";
 
 // src/update-lock.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { mkdir as mkdir3, readdir, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir4, readdir, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
 import path7 from "node:path";
 var UPDATE_SUFFIX = ".update";
 var SESSION_SUFFIX = ".session";
@@ -53552,7 +54114,7 @@ async function activeSessionFiles(directory) {
   return await activeLeaseFiles(directory, SESSION_SUFFIX);
 }
 async function createUpdateLock(directory) {
-  await mkdir3(directory, { recursive: true, mode: 448 });
+  await mkdir4(directory, { recursive: true, mode: 448 });
   const lockFile = path7.join(
     directory,
     `${process.pid}-${randomUUID4()}${UPDATE_SUFFIX}`
@@ -53587,7 +54149,7 @@ async function withUpdateLease(action, directory = updateRuntimeDirectory()) {
   }
 }
 async function withWorkspaceLease(action, directory = updateRuntimeDirectory()) {
-  await mkdir3(directory, { recursive: true, mode: 448 });
+  await mkdir4(directory, { recursive: true, mode: 448 });
   if (await updateLockIsActive(directory)) {
     throw new Error("Glossa is updating. Run this workspace again after the update finishes.");
   }
@@ -53725,14 +54287,25 @@ async function fetchText(url2, fetchImpl, version2) {
   if (!response.ok) throw new Error(`Glossa could not download ${url2} (HTTP ${response.status}).`);
   return await response.text();
 }
+function npmInstallInvocation(version2, platform2 = process.platform, commandShell = process.env.ComSpec ?? "cmd.exe") {
+  const normalizedVersion = import_semver.default.valid(version2);
+  if (!normalizedVersion) throw new Error(`Glossa version ${version2} is invalid.`);
+  const packageSpec = `${PACKAGE_NAME}@${normalizedVersion}`;
+  if (platform2 === "win32") {
+    return {
+      command: commandShell,
+      args: ["/d", "/s", "/c", `npm.cmd install --global ${packageSpec}`]
+    };
+  }
+  return {
+    command: "npm",
+    args: ["install", "--global", packageSpec]
+  };
+}
 async function runNpmInstall(version2) {
-  const command = process.platform === "win32" ? "npm.cmd" : "npm";
+  const { command, args } = npmInstallInvocation(version2);
   await new Promise((resolve, reject) => {
-    const child = spawn3(
-      command,
-      ["install", "--global", `${PACKAGE_NAME}@${version2}`],
-      { stdio: "inherit" }
-    );
+    const child = spawn3(command, args, { stdio: "inherit" });
     child.once("error", reject);
     child.once("close", (status) => {
       if (status === 0) resolve();
@@ -53795,7 +54368,7 @@ async function installUpdate(info, distribution, options = {}) {
 }
 
 // src/update-state.ts
-import { chmod as chmod4, mkdir as mkdir4, readFile as readFile4, rename as rename3, rm as rm5, writeFile as writeFile6 } from "node:fs/promises";
+import { chmod as chmod4, mkdir as mkdir5, readFile as readFile4, rename as rename3, rm as rm5, writeFile as writeFile6 } from "node:fs/promises";
 import path9 from "node:path";
 var UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 function defaultUpdateChannel(version2) {
@@ -53838,7 +54411,7 @@ async function loadUpdateState(currentVersion, file2 = updateStateFile()) {
 async function saveUpdateState(state, file2 = updateStateFile()) {
   const directory = path9.dirname(file2);
   const temporary = `${file2}.${process.pid}.tmp`;
-  await mkdir4(directory, { recursive: true, mode: 448 });
+  await mkdir5(directory, { recursive: true, mode: 448 });
   try {
     await writeFile6(temporary, `${JSON.stringify(state, null, 2)}
 `, {
@@ -53876,14 +54449,14 @@ function isUpdateCheckDue(lastCheckedAt, now = Date.now()) {
 }
 
 // src/usage-store.ts
-import { appendFile, chmod as chmod5, mkdir as mkdir5, readFile as readFile5 } from "node:fs/promises";
+import { appendFile, chmod as chmod5, mkdir as mkdir6, readFile as readFile5 } from "node:fs/promises";
 import path10 from "node:path";
 function usageFile() {
   return path10.join(configDirectory(), "usage.jsonl");
 }
 async function recordUsageEvent(event, file2 = usageFile()) {
   const directory = path10.dirname(file2);
-  await mkdir5(directory, { recursive: true, mode: 448 });
+  await mkdir6(directory, { recursive: true, mode: 448 });
   await appendFile(file2, `${JSON.stringify(event)}
 `, {
     encoding: "utf8",
@@ -53927,7 +54500,7 @@ async function selectExposureRoot(explicitPath, cwd2 = process.cwd()) {
 
 // src/worker/workspace-lease.ts
 import { createHash as createHash3 } from "node:crypto";
-import { lstat as lstat3, mkdir as mkdir6, rm as rm6, stat as stat3 } from "node:fs/promises";
+import { lstat as lstat3, mkdir as mkdir7, rm as rm6, stat as stat3 } from "node:fs/promises";
 import net from "node:net";
 import path12 from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
@@ -53958,7 +54531,7 @@ function defaultLeaseDirectory() {
   return path12.join(accountHomeDirectory(), ".glossa-workspace-leases");
 }
 async function ensureLeaseDirectory(directory) {
-  await mkdir6(directory, { recursive: true, mode: 448 });
+  await mkdir7(directory, { recursive: true, mode: 448 });
   const directoryStat = await lstat3(directory);
   if (directoryStat.isSymbolicLink() || !directoryStat.isDirectory()) {
     throw new Error("The Glossa workspace lease location is not a private directory.");
@@ -53982,7 +54555,7 @@ async function acquireGuard(directory, identity) {
   const deadline = Date.now() + GUARD_TIMEOUT_MS;
   while (true) {
     try {
-      await mkdir6(guard, { mode: 448 });
+      await mkdir7(guard, { mode: 448 });
       return async () => await rm6(guard, { recursive: true, force: true });
     } catch (error46) {
       if (error46.code !== "EEXIST") throw error46;
@@ -54077,10 +54650,10 @@ async function acquireWorkspaceLease(root, options = {}) {
         };
       } catch (error46) {
         await closeServer(server);
-        if (error46.code !== "EADDRINUSE") throw error46;
         if (await endpointIsActive(endpoint3)) {
           throw new WorkspaceAlreadyActiveError();
         }
+        if (error46.code !== "EADDRINUSE") throw error46;
         if (process.platform !== "win32") await rm6(endpoint3, { force: true });
       }
     }
@@ -54091,7 +54664,7 @@ async function acquireWorkspaceLease(root, options = {}) {
 }
 
 // src/main.ts
-var VERSION = "0.1.1";
+var VERSION = "0.2.0-beta.2";
 var DISTRIBUTION = "npm";
 var HELP = `Glossa ${VERSION}