@hachej/boring-bash 0.1.64

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 boringdata
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { BoundFilesystemContext, FilesystemAccess, FilesystemBinding, FilesystemBindingProvider, FilesystemBindingResolver, FilesystemId, FilesystemProjection, PreparedFilesystemBinding, RuntimeBindingPlan } from './shared/index.js';

package/dist/server/index.d.ts

@@ -0,0 +1,228 @@
+import { PreparedFilesystemBinding, FilesystemId, FilesystemProjection, BoundFilesystemContext, FilesystemBindingProvider, FilesystemBinding, FilesystemAccess, FilesystemBindingResolver, RuntimeBindingPlan } from '../shared/index.js';
+
+declare const COMPANY_CONTEXT_FILESYSTEM_ID = "company_context";
+declare const COMPANY_CONTEXT_SENTINEL = "FORBIDDEN_FINANCE_SECRET_123";
+interface CompanyContextFixtureFile {
+    path: string;
+    content: string;
+}
+declare const DEFAULT_COMPANY_CONTEXT_FIXTURE_FILES: readonly CompanyContextFixtureFile[];
+interface CompanyContextFixtureProjectionPolicy {
+    readonly allowedPathPrefixes: readonly string[];
+    readonly grantManagementBinding?: boolean;
+}
+interface CompanyContextFixtureProviderOptions {
+    readonly sourceRoot: string;
+    readonly projectionRootParent?: string;
+    readonly resolvePolicy: (ctx: BoundFilesystemContext) => CompanyContextFixtureProjectionPolicy | Promise<CompanyContextFixtureProjectionPolicy>;
+}
+interface CompanyContextFixturePreparedLifecycle {
+    active: boolean;
+}
+interface CompanyContextFixturePreparedHandle {
+    readonly kind: "company-context-fixture-projection";
+    /** Logical filesystem identity for this prepared binding; paths are scoped by this id. */
+    readonly filesystem: FilesystemId;
+    readonly sourceRoot: string;
+    readonly projectionRoot: string;
+    readonly visiblePaths: readonly string[];
+    readonly access?: "readonly" | "readwrite";
+    readonly projection?: FilesystemProjection;
+    readonly lifecycle?: CompanyContextFixturePreparedLifecycle;
+}
+type CompanyContextFixturePreparedBinding = PreparedFilesystemBinding & {
+    handle: CompanyContextFixturePreparedHandle;
+};
+declare function seedCompanyContextFixture(root: string): Promise<void>;
+declare class FixtureCompanyContextBindingProvider implements FilesystemBindingProvider {
+    #private;
+    constructor(options: CompanyContextFixtureProviderOptions);
+    invalidateBinding(_ctx: BoundFilesystemContext, _filesystem: FilesystemId): Promise<void>;
+    disposeBinding(prepared: PreparedFilesystemBinding): Promise<void>;
+    prepareBinding(ctx: BoundFilesystemContext, binding: FilesystemBinding): Promise<CompanyContextFixturePreparedBinding>;
+}
+declare function readFixtureProjectionFile(handle: CompanyContextFixturePreparedHandle, companyPath: string): Promise<string>;
+declare function listFixtureProjectionFiles(handle: CompanyContextFixturePreparedHandle): Promise<string[]>;
+
+declare const READONLY_PROJECTION_MUTATION_CODE = "READONLY_PROJECTION_READONLY";
+declare const READONLY_PROJECTION_INVALID_PATH_CODE = "READONLY_PROJECTION_INVALID_PATH";
+declare const READONLY_PROJECTION_BINDING_NOT_FOUND_CODE = "READONLY_PROJECTION_BINDING_NOT_FOUND";
+interface FilesystemPathDescriptor {
+    readonly filesystem: FilesystemId;
+    readonly path: string;
+}
+interface ReadonlyProjectionOperationMetadata {
+    readonly filesystem: FilesystemId;
+    readonly path: string;
+    readonly operation: string;
+}
+declare class ReadonlyProjectionOperationError extends Error {
+    readonly code: string;
+    readonly metadata: ReadonlyProjectionOperationMetadata;
+    constructor(code: string, message: string, metadata: ReadonlyProjectionOperationMetadata);
+}
+interface ReadonlyProjectionSearchOptions {
+    readonly offset?: number;
+    readonly limit?: number;
+}
+interface ReadonlyProjectionOperations {
+    read(descriptor: FilesystemPathDescriptor): Promise<{
+        content: string;
+        metadata: ReadonlyProjectionOperationMetadata;
+    }>;
+    list(descriptor: FilesystemPathDescriptor): Promise<{
+        entries: string[];
+        metadata: ReadonlyProjectionOperationMetadata;
+    }>;
+    find(descriptor: FilesystemPathDescriptor, pattern: string, options?: ReadonlyProjectionSearchOptions): Promise<{
+        paths: string[];
+        metadata: ReadonlyProjectionOperationMetadata;
+    }>;
+    grep(descriptor: FilesystemPathDescriptor, pattern: string, options?: ReadonlyProjectionSearchOptions): Promise<{
+        matches: Array<{
+            path: string;
+            line: number;
+            text: string;
+        }>;
+        metadata: ReadonlyProjectionOperationMetadata;
+    }>;
+    stat(descriptor: FilesystemPathDescriptor): Promise<{
+        isDirectory: boolean;
+        metadata: ReadonlyProjectionOperationMetadata;
+    }>;
+    rejectMutation(operation: string, descriptor: FilesystemPathDescriptor): never;
+}
+interface ReadonlyProjectionHandle {
+    readonly filesystem: FilesystemId;
+    readonly projectionRoot: string;
+}
+declare function createReadonlyProjectionOperations(handle: ReadonlyProjectionHandle): ReadonlyProjectionOperations;
+
+declare const MANAGEMENT_PROJECTION_BINDING_REQUIRED_CODE = "MANAGEMENT_PROJECTION_BINDING_REQUIRED";
+declare const MANAGEMENT_PROJECTION_INVALID_PATH_CODE = "MANAGEMENT_PROJECTION_INVALID_PATH";
+interface ManagementProjectionOperationMetadata {
+    readonly filesystem: FilesystemId;
+    readonly path: string;
+    readonly operation: string;
+}
+declare class ManagementProjectionOperationError extends Error {
+    readonly code: string;
+    readonly metadata: ManagementProjectionOperationMetadata;
+    constructor(code: string, message: string, metadata: ManagementProjectionOperationMetadata);
+}
+interface ManagementProjectionHandle {
+    readonly filesystem: FilesystemId;
+    readonly projectionRoot: string;
+    readonly access?: "readonly" | "readwrite";
+    readonly projection?: "policy-filtered" | "management";
+    readonly lifecycle?: {
+        readonly active: boolean;
+    };
+}
+interface ManagementProjectionOperations {
+    read(descriptor: FilesystemPathDescriptor): Promise<{
+        content: string;
+        metadata: ManagementProjectionOperationMetadata;
+    }>;
+    list(descriptor: FilesystemPathDescriptor): Promise<{
+        entries: string[];
+        metadata: ManagementProjectionOperationMetadata;
+    }>;
+    write(descriptor: FilesystemPathDescriptor, content: string): Promise<{
+        metadata: ManagementProjectionOperationMetadata;
+    }>;
+    edit(descriptor: FilesystemPathDescriptor, oldText: string, newText: string): Promise<{
+        metadata: ManagementProjectionOperationMetadata;
+    }>;
+}
+declare function createManagementProjectionOperations(handle: ManagementProjectionHandle): ManagementProjectionOperations;
+
+interface FilesystemRuntimeLifecycleEvent {
+    readonly type: "prepare" | "prepare-error" | "dispose" | "invalidate";
+    readonly context: BoundFilesystemContext;
+    readonly bindings: readonly string[];
+    readonly preparedLabels: readonly string[];
+}
+interface ScopedFilesystemRuntimeBindingManagerOptions {
+    readonly resolver: FilesystemBindingResolver;
+    readonly providers: Readonly<Record<string, FilesystemBindingProvider>>;
+    readonly onLifecycleEvent?: (event: FilesystemRuntimeLifecycleEvent) => void;
+}
+interface PreparedBindingSelector {
+    readonly filesystem: FilesystemId;
+    readonly access?: FilesystemAccess;
+    readonly projection?: FilesystemProjection;
+}
+interface ScopedPreparedFilesystemBinding extends PreparedFilesystemBinding {
+    readonly scopeKey: string;
+    readonly context: BoundFilesystemContext;
+    readonly preparedLabel: string;
+}
+interface ScopedRuntimeBindingPlan extends RuntimeBindingPlan {
+    readonly scopeKey: string;
+    readonly context: BoundFilesystemContext;
+    readonly bindings: ScopedPreparedFilesystemBinding[];
+}
+declare function filesystemRuntimeScopeKey(ctx: BoundFilesystemContext): string;
+declare class ScopedFilesystemRuntimeBindingManager {
+    #private;
+    constructor(options: ScopedFilesystemRuntimeBindingManagerOptions);
+    prepareRuntime(ctx: BoundFilesystemContext): Promise<ScopedRuntimeBindingPlan>;
+    getPreparedBinding(ctx: BoundFilesystemContext, selector: PreparedBindingSelector): ScopedPreparedFilesystemBinding | undefined;
+    disposeRuntime(ctx: BoundFilesystemContext): Promise<void>;
+    invalidate(ctx: BoundFilesystemContext, filesystem: FilesystemId): Promise<void>;
+}
+
+interface ReadonlyProjectionConformanceSubject {
+    readonly filesystem: string;
+    readonly rootPath: string;
+    readonly operations: ReadonlyProjectionConformanceOperations;
+    readonly allowedReadPath: string;
+    readonly deniedReadPath: string;
+    readonly deniedDirectoryName: string;
+    readonly deniedSentinel: string;
+    readonly allowedFindPattern: string;
+    readonly expectedAllowedFindCount: number;
+    readonly expectedVisiblePaths: readonly string[];
+    readonly projection: ReadonlyProjectionProbe;
+}
+interface ReadonlyProjectionConformanceOperations {
+    read(descriptor: {
+        filesystem: string;
+        path: string;
+    }): Promise<{
+        content: string;
+    }>;
+    list(descriptor: {
+        filesystem: string;
+        path: string;
+    }): Promise<{
+        entries: readonly unknown[];
+    }>;
+    find(descriptor: {
+        filesystem: string;
+        path: string;
+    }, pattern: string): Promise<{
+        matches?: readonly unknown[];
+        paths?: readonly unknown[];
+    }>;
+    grep(descriptor: {
+        filesystem: string;
+        path: string;
+    }, pattern: string): Promise<{
+        matches: readonly unknown[];
+    }>;
+}
+interface ReadonlyProjectionProbe {
+    listVisiblePaths(): Promise<readonly string[]>;
+    writeExistingAllowedPath(): Promise<unknown>;
+    writeNewAllowedPath(): Promise<unknown>;
+    followSymlinkEscape(): Promise<unknown>;
+}
+interface ReadonlyProjectionConformanceResult {
+    readonly passed: boolean;
+    readonly failures: readonly string[];
+}
+declare function checkReadonlyProjectionConformance(subject: ReadonlyProjectionConformanceSubject): Promise<ReadonlyProjectionConformanceResult>;
+
+export { BoundFilesystemContext, COMPANY_CONTEXT_FILESYSTEM_ID, COMPANY_CONTEXT_SENTINEL, type CompanyContextFixtureFile, type CompanyContextFixturePreparedBinding, type CompanyContextFixturePreparedHandle, type CompanyContextFixturePreparedLifecycle, type CompanyContextFixtureProjectionPolicy, type CompanyContextFixtureProviderOptions, DEFAULT_COMPANY_CONTEXT_FIXTURE_FILES, FilesystemBinding, FilesystemBindingProvider, FilesystemBindingResolver, FilesystemId, type FilesystemPathDescriptor, type FilesystemRuntimeLifecycleEvent, FixtureCompanyContextBindingProvider, MANAGEMENT_PROJECTION_BINDING_REQUIRED_CODE, MANAGEMENT_PROJECTION_INVALID_PATH_CODE, ManagementProjectionOperationError, type ManagementProjectionOperationMetadata, type ManagementProjectionOperations, type PreparedBindingSelector, PreparedFilesystemBinding, READONLY_PROJECTION_BINDING_NOT_FOUND_CODE, READONLY_PROJECTION_INVALID_PATH_CODE, READONLY_PROJECTION_MUTATION_CODE, type ReadonlyProjectionConformanceOperations, type ReadonlyProjectionConformanceResult, type ReadonlyProjectionConformanceSubject, ReadonlyProjectionOperationError, type ReadonlyProjectionOperationMetadata, type ReadonlyProjectionOperations, type ReadonlyProjectionProbe, RuntimeBindingPlan, ScopedFilesystemRuntimeBindingManager, type ScopedFilesystemRuntimeBindingManagerOptions, type ScopedPreparedFilesystemBinding, type ScopedRuntimeBindingPlan, checkReadonlyProjectionConformance, createManagementProjectionOperations, createReadonlyProjectionOperations, filesystemRuntimeScopeKey, listFixtureProjectionFiles, readFixtureProjectionFile, seedCompanyContextFixture };

package/dist/server/index.js

@@ -0,0 +1,697 @@
+// src/server/testing/companyContextFixtureProvider.ts
+import { constants } from "fs";
+import { access, chmod, copyFile, lstat, mkdir, mkdtemp, readFile, readdir, realpath } from "fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+import { tmpdir } from "os";
+var COMPANY_CONTEXT_FILESYSTEM_ID = "company_context";
+var COMPANY_CONTEXT_SENTINEL = "FORBIDDEN_FINANCE_SECRET_123";
+var DEFAULT_COMPANY_CONTEXT_FIXTURE_FILES = [
+  { path: "/company/hr/policy.md", content: "# HR policy\nVacation and onboarding policies.\n" },
+  { path: "/company/hr/onboarding.md", content: "# Onboarding\nWelcome to the company.\n" },
+  { path: "/company/finance/budget.md", content: `# Finance budget
+${COMPANY_CONTEXT_SENTINEL}
+` },
+  { path: "/company/legal/contract.md", content: "# Legal contract\nStandard terms.\n" }
+];
+function normalizeCompanyPath(path) {
+  const normalized = path.replace(/\\/g, "/");
+  if (!normalized.startsWith("/")) return `/${normalized}`;
+  return normalized;
+}
+function assertSafeCompanyPath(path) {
+  const normalized = normalizeCompanyPath(path);
+  if (normalized.includes("\0")) throw new Error(`invalid company path: ${path}`);
+  for (const part of normalized.split("/")) {
+    if (part === "..") throw new Error(`invalid company path traversal: ${path}`);
+  }
+  return normalized.replace(/\/+/g, "/");
+}
+function isAllowed(path, prefixes) {
+  const normalized = assertSafeCompanyPath(path);
+  return prefixes.some((prefix) => {
+    const normalizedPrefix = assertSafeCompanyPath(prefix).replace(/\/+$/, "");
+    return normalized === normalizedPrefix || normalized.startsWith(`${normalizedPrefix}/`);
+  });
+}
+async function assertInsideRoot(root, candidate) {
+  const realRoot = await realpath(root);
+  const existing = await realpath(candidate);
+  const rel = relative(realRoot, existing);
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    throw new Error(`path escapes company context root: ${candidate}`);
+  }
+}
+async function walkFiles(root, current = root) {
+  const entries = await readdir(current, { withFileTypes: true });
+  const out = [];
+  for (const entry of entries) {
+    const absolutePath = join(current, entry.name);
+    const entryStat = await lstat(absolutePath);
+    if (entryStat.isSymbolicLink()) {
+      await assertInsideRoot(root, absolutePath);
+      continue;
+    }
+    if (entry.isDirectory()) out.push(...await walkFiles(root, absolutePath));
+    else if (entry.isFile()) out.push(absolutePath);
+  }
+  return out;
+}
+async function makeProjectionReadonly(root, current = root) {
+  const entries = await readdir(current, { withFileTypes: true });
+  for (const entry of entries) {
+    const absolutePath = join(current, entry.name);
+    if (entry.isDirectory()) await makeProjectionReadonly(root, absolutePath);
+    else if (entry.isFile()) await chmod(absolutePath, 292);
+  }
+  await chmod(current, 365);
+}
+async function seedCompanyContextFixture(root) {
+  for (const file of DEFAULT_COMPANY_CONTEXT_FIXTURE_FILES) {
+    const safePath = assertSafeCompanyPath(file.path);
+    const target = join(root, ...safePath.slice(1).split("/"));
+    await mkdir(dirname(target), { recursive: true });
+    await access(dirname(target), constants.W_OK);
+    await import("fs/promises").then(({ writeFile: writeFile2 }) => writeFile2(target, file.content));
+  }
+}
+var FixtureCompanyContextBindingProvider = class {
+  #sourceRoot;
+  #projectionRootParent;
+  #resolvePolicy;
+  constructor(options) {
+    this.#sourceRoot = resolve(options.sourceRoot);
+    this.#projectionRootParent = resolve(options.projectionRootParent ?? tmpdir());
+    this.#resolvePolicy = options.resolvePolicy;
+  }
+  async invalidateBinding(_ctx, _filesystem) {
+  }
+  async disposeBinding(prepared) {
+    const handle = prepared.handle;
+    if (handle.lifecycle) handle.lifecycle.active = false;
+  }
+  async prepareBinding(ctx, binding) {
+    if (binding.filesystem !== COMPANY_CONTEXT_FILESYSTEM_ID) {
+      throw new Error(`fixture company provider cannot prepare filesystem ${binding.filesystem}`);
+    }
+    if (binding.access === "readwrite" && binding.projection === "management") {
+      const policy2 = await this.#resolvePolicy(ctx);
+      if (!policy2.grantManagementBinding) {
+        throw new Error("fixture company provider policy did not grant readwrite management binding");
+      }
+      const lifecycle2 = { active: true };
+      return {
+        binding,
+        handle: {
+          kind: "company-context-fixture-projection",
+          filesystem: binding.filesystem,
+          sourceRoot: this.#sourceRoot,
+          projectionRoot: this.#sourceRoot,
+          visiblePaths: await listFixtureProjectionFiles({
+            kind: "company-context-fixture-projection",
+            filesystem: binding.filesystem,
+            sourceRoot: this.#sourceRoot,
+            projectionRoot: this.#sourceRoot,
+            visiblePaths: [],
+            access: "readwrite",
+            projection: "management"
+          }),
+          access: "readwrite",
+          projection: "management",
+          lifecycle: lifecycle2
+        }
+      };
+    }
+    if (binding.access !== "readonly" || binding.projection !== "policy-filtered") {
+      throw new Error("fixture company provider only prepares readonly policy-filtered or readwrite management bindings");
+    }
+    const policy = await this.#resolvePolicy(ctx);
+    const projectionRoot = await mkdtemp(join(this.#projectionRootParent, "boring-company-context-"));
+    const visiblePaths = [];
+    const files = await walkFiles(this.#sourceRoot);
+    for (const sourceFile of files) {
+      await assertInsideRoot(this.#sourceRoot, sourceFile);
+      const rel = relative(this.#sourceRoot, sourceFile).split(sep).join("/");
+      const companyPath = assertSafeCompanyPath(`/${rel}`);
+      if (!isAllowed(companyPath, policy.allowedPathPrefixes)) continue;
+      const destination = join(projectionRoot, ...companyPath.slice(1).split("/"));
+      await mkdir(dirname(destination), { recursive: true });
+      await copyFile(sourceFile, destination);
+      visiblePaths.push(companyPath);
+    }
+    visiblePaths.sort();
+    await makeProjectionReadonly(projectionRoot);
+    const lifecycle = { active: true };
+    return {
+      binding,
+      handle: {
+        kind: "company-context-fixture-projection",
+        filesystem: binding.filesystem,
+        sourceRoot: this.#sourceRoot,
+        projectionRoot,
+        visiblePaths,
+        access: "readonly",
+        projection: "policy-filtered",
+        lifecycle
+      }
+    };
+  }
+};
+async function readFixtureProjectionFile(handle, companyPath) {
+  const safePath = assertSafeCompanyPath(companyPath);
+  const target = join(handle.projectionRoot, ...safePath.slice(1).split("/"));
+  await assertInsideRoot(handle.projectionRoot, target);
+  return await readFile(target, "utf8");
+}
+async function listFixtureProjectionFiles(handle) {
+  const files = await walkFiles(handle.projectionRoot);
+  return files.map((file) => `/${relative(handle.projectionRoot, file).split(sep).join("/")}`).sort();
+}
+
+// src/server/managementProjectionOperations.ts
+import { lstat as lstat2, mkdir as mkdir2, readFile as readFile2, readdir as readdir2, realpath as realpath2, stat, writeFile } from "fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, relative as relative2, sep as sep2 } from "path";
+var MANAGEMENT_PROJECTION_BINDING_REQUIRED_CODE = "MANAGEMENT_PROJECTION_BINDING_REQUIRED";
+var MANAGEMENT_PROJECTION_INVALID_PATH_CODE = "MANAGEMENT_PROJECTION_INVALID_PATH";
+var ManagementProjectionOperationError = class extends Error {
+  code;
+  metadata;
+  constructor(code, message, metadata) {
+    super(message);
+    this.name = "ManagementProjectionOperationError";
+    this.code = code;
+    this.metadata = metadata;
+  }
+};
+function normalizeProjectionPath(path) {
+  const normalized = path.replace(/\\/g, "/");
+  if (normalized.includes("\0")) throw new Error("null byte in projection path");
+  if (normalized.includes(":/")) throw new Error("filesystem prefixes are not valid path strings");
+  if (normalized === "") return "/";
+  const withRoot = normalized.startsWith("/") ? normalized : `/${normalized}`;
+  const parts = withRoot.split("/").filter(Boolean);
+  if (parts.some((part) => part === ".." || part === ".")) throw new Error("path traversal is not allowed");
+  return `/${parts.join("/")}`;
+}
+function assertManagementHandle(handle) {
+  if (handle.access !== "readwrite" || handle.projection !== "management") {
+    throw new ManagementProjectionOperationError(
+      MANAGEMENT_PROJECTION_BINDING_REQUIRED_CODE,
+      "management operation requires a readwrite management binding",
+      { filesystem: handle.filesystem, path: "management_binding_required", operation: "bind" }
+    );
+  }
+  if (handle.lifecycle?.active === false) {
+    throw new ManagementProjectionOperationError(
+      MANAGEMENT_PROJECTION_BINDING_REQUIRED_CODE,
+      "management binding is no longer active",
+      { filesystem: handle.filesystem, path: "management_binding_inactive", operation: "bind" }
+    );
+  }
+}
+function assertProjectionDescriptor(descriptor, operation, expectedFilesystem) {
+  if (descriptor.filesystem !== expectedFilesystem) {
+    throw new ManagementProjectionOperationError(
+      MANAGEMENT_PROJECTION_BINDING_REQUIRED_CODE,
+      `No management binding for filesystem ${descriptor.filesystem}`,
+      { filesystem: descriptor.filesystem, path: descriptor.path, operation }
+    );
+  }
+  try {
+    return { filesystem: descriptor.filesystem, path: normalizeProjectionPath(descriptor.path), operation };
+  } catch (err) {
+    throw new ManagementProjectionOperationError(
+      MANAGEMENT_PROJECTION_INVALID_PATH_CODE,
+      err.message,
+      { filesystem: descriptor.filesystem, path: "invalid_path", operation }
+    );
+  }
+}
+function managementPath(handle, path) {
+  const normalized = normalizeProjectionPath(path);
+  return join2(handle.projectionRoot, ...normalized.slice(1).split("/"));
+}
+function assertRelativeInsideRoot(root, candidate) {
+  const rel = relative2(root, candidate);
+  if (rel.startsWith("..") || isAbsolute2(rel)) throw new Error("path escapes management projection root");
+}
+async function assertExistingPathInsideManagementRoot(handle, candidate) {
+  const root = await realpath2(handle.projectionRoot);
+  assertRelativeInsideRoot(root, await realpath2(candidate));
+}
+async function assertWritablePathInsideManagementRoot(handle, candidate) {
+  try {
+    await lstat2(candidate);
+    await assertExistingPathInsideManagementRoot(handle, candidate);
+    return;
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const root = await realpath2(handle.projectionRoot);
+  assertRelativeInsideRoot(root, await realpath2(dirname2(candidate)));
+}
+async function walkFiles2(root, current = root) {
+  const entries = await readdir2(current, { withFileTypes: true });
+  const out = [];
+  for (const entry of entries) {
+    const absolutePath = join2(current, entry.name);
+    if (entry.isDirectory()) out.push(...await walkFiles2(root, absolutePath));
+    else if (entry.isFile()) out.push(absolutePath);
+  }
+  return out;
+}
+function createManagementProjectionOperations(handle) {
+  assertManagementHandle(handle);
+  return {
+    async read(descriptor) {
+      assertManagementHandle(handle);
+      const metadata = assertProjectionDescriptor(descriptor, "read", handle.filesystem);
+      const target = managementPath(handle, metadata.path);
+      await assertExistingPathInsideManagementRoot(handle, target);
+      return { content: await readFile2(target, "utf8"), metadata };
+    },
+    async list(descriptor) {
+      assertManagementHandle(handle);
+      const metadata = assertProjectionDescriptor(descriptor, "list", handle.filesystem);
+      const target = managementPath(handle, metadata.path);
+      await assertExistingPathInsideManagementRoot(handle, target);
+      const rootStat = await stat(target);
+      const files = rootStat.isDirectory() ? await walkFiles2(handle.projectionRoot, target) : [target];
+      return { entries: files.map((file) => `/${relative2(handle.projectionRoot, file).split(sep2).join("/")}`).sort(), metadata };
+    },
+    async write(descriptor, content) {
+      assertManagementHandle(handle);
+      const metadata = assertProjectionDescriptor(descriptor, "write", handle.filesystem);
+      const target = managementPath(handle, metadata.path);
+      await mkdir2(dirname2(target), { recursive: true });
+      await assertWritablePathInsideManagementRoot(handle, target);
+      await writeFile(target, content, "utf8");
+      return { metadata };
+    },
+    async edit(descriptor, oldText, newText) {
+      assertManagementHandle(handle);
+      const metadata = assertProjectionDescriptor(descriptor, "edit", handle.filesystem);
+      const target = managementPath(handle, metadata.path);
+      await assertExistingPathInsideManagementRoot(handle, target);
+      const content = await readFile2(target, "utf8");
+      if (!content.includes(oldText)) throw new Error("oldText not found in management projection file");
+      await writeFile(target, content.replace(oldText, newText), "utf8");
+      return { metadata };
+    }
+  };
+}
+
+// src/server/readonlyProjectionOperations.ts
+import { lstat as lstat3, readdir as readdir3, readFile as readFile3, realpath as realpath3 } from "fs/promises";
+import { dirname as dirname3, isAbsolute as isAbsolute3, join as join3, relative as relative3, resolve as resolve3, sep as sep3 } from "path";
+var READONLY_PROJECTION_MUTATION_CODE = "READONLY_PROJECTION_READONLY";
+var READONLY_PROJECTION_INVALID_PATH_CODE = "READONLY_PROJECTION_INVALID_PATH";
+var READONLY_PROJECTION_BINDING_NOT_FOUND_CODE = "READONLY_PROJECTION_BINDING_NOT_FOUND";
+var ReadonlyProjectionOperationError = class extends Error {
+  code;
+  metadata;
+  constructor(code, message, metadata) {
+    super(message);
+    this.name = "ReadonlyProjectionOperationError";
+    this.code = code;
+    this.metadata = metadata;
+  }
+};
+function normalizeProjectionPath2(path) {
+  const normalized = path.replace(/\\/g, "/");
+  if (normalized.includes("\0")) throw new Error("null byte in projection path");
+  if (normalized.includes(":/")) throw new Error("filesystem prefixes are not valid path strings");
+  if (normalized === "") return "/";
+  const withRoot = normalized.startsWith("/") ? normalized : `/${normalized}`;
+  const parts = withRoot.split("/").filter(Boolean);
+  if (parts.some((part) => part === ".." || part === ".")) {
+    throw new Error("path traversal is not allowed");
+  }
+  return `/${parts.join("/")}`;
+}
+function unreadableProjectionPathError(metadata) {
+  return new ReadonlyProjectionOperationError(
+    READONLY_PROJECTION_INVALID_PATH_CODE,
+    "projection path is not readable",
+    { ...metadata, path: "not_found_or_denied" }
+  );
+}
+function assertProjectionDescriptor2(descriptor, operation, expectedFilesystem) {
+  if (descriptor.filesystem !== expectedFilesystem) {
+    throw new ReadonlyProjectionOperationError(
+      READONLY_PROJECTION_BINDING_NOT_FOUND_CODE,
+      `No readonly binding for filesystem ${descriptor.filesystem}`,
+      { filesystem: descriptor.filesystem, path: descriptor.path, operation }
+    );
+  }
+  try {
+    return { filesystem: descriptor.filesystem, path: normalizeProjectionPath2(descriptor.path), operation };
+  } catch (err) {
+    throw new ReadonlyProjectionOperationError(
+      READONLY_PROJECTION_INVALID_PATH_CODE,
+      err.message,
+      { filesystem: descriptor.filesystem, path: "invalid_path", operation }
+    );
+  }
+}
+function projectionPath(handle, path) {
+  const normalized = normalizeProjectionPath2(path);
+  return join3(handle.projectionRoot, ...normalized.slice(1).split("/"));
+}
+function isNotFoundError(error) {
+  return error?.code === "ENOENT";
+}
+async function assertNoSymlinkInProjectionPath(root, candidate) {
+  const rootStat = await lstat3(root);
+  if (rootStat.isSymbolicLink()) throw new Error("readonly projection root must not be a symlink");
+  const rel = relative3(root, candidate);
+  if (!rel) return;
+  let current = root;
+  for (const part of rel.split(sep3).filter(Boolean)) {
+    current = join3(current, part);
+    const currentStat = await lstat3(current).catch((error) => {
+      if (isNotFoundError(error)) return null;
+      throw error;
+    });
+    if (!currentStat) return;
+    if (currentStat.isSymbolicLink()) throw new Error("symlinks are not readable in readonly projections");
+  }
+}
+async function assertInsideProjection(handle, candidate) {
+  const root = resolve3(handle.projectionRoot);
+  const resolvedCandidate = resolve3(candidate);
+  const rel = relative3(root, resolvedCandidate);
+  if (rel.startsWith("..") || isAbsolute3(rel)) throw new Error("path escapes readonly projection");
+  await assertNoSymlinkInProjectionPath(root, resolvedCandidate);
+  const realRoot = await realpath3(root);
+  const targetExists = await lstat3(resolvedCandidate).then(() => true).catch((error) => {
+    if (isNotFoundError(error)) return false;
+    throw error;
+  });
+  const anchor = targetExists ? resolvedCandidate : resolve3(dirname3(resolvedCandidate));
+  const realAnchor = await realpath3(anchor).catch((error) => {
+    if (isNotFoundError(error)) return null;
+    throw error;
+  });
+  if (!realAnchor) return;
+  const realRel = relative3(realRoot, realAnchor);
+  if (realRel.startsWith("..") || isAbsolute3(realRel)) throw new Error("path escapes readonly projection");
+}
+async function walkFiles3(root, current = root) {
+  const entries = await readdir3(current, { withFileTypes: true });
+  const out = [];
+  for (const entry of entries) {
+    const absolutePath = join3(current, entry.name);
+    const entryStat = await lstat3(absolutePath);
+    if (entryStat.isSymbolicLink()) continue;
+    if (entryStat.isDirectory()) out.push(...await walkFiles3(root, absolutePath));
+    else if (entryStat.isFile()) out.push(absolutePath);
+  }
+  return out;
+}
+function pageVisibleResults(items, options) {
+  const offset = Math.max(0, Math.trunc(options?.offset ?? 0));
+  const limit = options?.limit == null ? void 0 : Math.max(0, Math.trunc(options.limit));
+  return limit == null ? items.slice(offset) : items.slice(offset, offset + limit);
+}
+function globToRegex(pattern) {
+  const escaped = pattern.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+  return new RegExp(`^${escaped}$`);
+}
+function createReadonlyProjectionOperations(handle) {
+  const expectedFilesystem = handle.filesystem;
+  async function filesUnder(path) {
+    const root = projectionPath(handle, path);
+    await assertInsideProjection(handle, root);
+    const rootStat = await lstat3(root);
+    if (rootStat.isSymbolicLink()) throw new Error("symlinks are not readable in readonly projections");
+    const files = rootStat.isDirectory() ? await walkFiles3(handle.projectionRoot, root) : [root];
+    return files.map((file) => `/${relative3(handle.projectionRoot, file).split(sep3).join("/")}`).sort();
+  }
+  return {
+    async read(descriptor) {
+      const metadata = assertProjectionDescriptor2(descriptor, "read", expectedFilesystem);
+      const target = projectionPath(handle, metadata.path);
+      try {
+        await assertInsideProjection(handle, target);
+        return { content: await readFile3(target, "utf8"), metadata };
+      } catch {
+        throw unreadableProjectionPathError(metadata);
+      }
+    },
+    async list(descriptor) {
+      const metadata = assertProjectionDescriptor2(descriptor, "list", expectedFilesystem);
+      const target = projectionPath(handle, metadata.path);
+      try {
+        await assertInsideProjection(handle, target);
+        const entries = await readdir3(target, { withFileTypes: true });
+        if (entries.some((entry) => entry.isSymbolicLink())) throw new Error("symlinks are not readable in readonly projections");
+        return { entries: entries.map((entry) => entry.name).sort(), metadata };
+      } catch {
+        throw unreadableProjectionPathError(metadata);
+      }
+    },
+    async find(descriptor, pattern, options) {
+      const metadata = assertProjectionDescriptor2(descriptor, "find", expectedFilesystem);
+      try {
+        const matcher = globToRegex(pattern);
+        const paths = (await filesUnder(metadata.path)).filter((path) => matcher.test(path.slice(1)) || matcher.test(path.split("/").at(-1) ?? path));
+        return { paths: pageVisibleResults(paths, options), metadata };
+      } catch {
+        throw unreadableProjectionPathError(metadata);
+      }
+    },
+    async grep(descriptor, pattern, options) {
+      const metadata = assertProjectionDescriptor2(descriptor, "grep", expectedFilesystem);
+      try {
+        const matches = [];
+        for (const path of await filesUnder(metadata.path)) {
+          const content = await readFile3(projectionPath(handle, path), "utf8");
+          content.split("\n").forEach((text, index) => {
+            if (text.includes(pattern)) matches.push({ path, line: index + 1, text });
+          });
+        }
+        return { matches: pageVisibleResults(matches, options), metadata };
+      } catch {
+        throw unreadableProjectionPathError(metadata);
+      }
+    },
+    async stat(descriptor) {
+      const metadata = assertProjectionDescriptor2(descriptor, "stat", expectedFilesystem);
+      const target = projectionPath(handle, metadata.path);
+      try {
+        await assertInsideProjection(handle, target);
+        return { isDirectory: (await lstat3(target)).isDirectory(), metadata };
+      } catch {
+        throw unreadableProjectionPathError(metadata);
+      }
+    },
+    rejectMutation(operation, descriptor) {
+      const metadata = assertProjectionDescriptor2(descriptor, operation, expectedFilesystem);
+      throw new ReadonlyProjectionOperationError(
+        READONLY_PROJECTION_MUTATION_CODE,
+        `filesystem is readonly for ${operation}`,
+        { ...metadata, path: "readonly" }
+      );
+    }
+  };
+}
+
+// src/server/runtimeBindingManager.ts
+function filesystemRuntimeScopeKey(ctx) {
+  return [
+    ctx.humanUserId,
+    ctx.agentId,
+    ctx.sessionId,
+    ctx.workspaceId,
+    ctx.requestId
+  ].join("\0");
+}
+function sameBinding(binding, selector) {
+  return binding.filesystem === selector.filesystem && (selector.access === void 0 || binding.access === selector.access) && (selector.projection === void 0 || binding.projection === selector.projection);
+}
+var ScopedFilesystemRuntimeBindingManager = class {
+  #resolver;
+  #providers;
+  #onLifecycleEvent;
+  #plans = /* @__PURE__ */ new Map();
+  #nextPreparedLabel = 1;
+  constructor(options) {
+    this.#resolver = options.resolver;
+    this.#providers = options.providers;
+    this.#onLifecycleEvent = options.onLifecycleEvent;
+  }
+  async prepareRuntime(ctx) {
+    const scopeKey = filesystemRuntimeScopeKey(ctx);
+    await this.disposeRuntime(ctx);
+    const bindings = await this.#resolver.resolveBindings(ctx);
+    const prepared = [];
+    try {
+      for (const binding of bindings) {
+        const provider = this.#providers[String(binding.filesystem)];
+        if (!provider) throw new Error(`no filesystem binding provider for ${binding.filesystem}`);
+        const preparedBinding = await provider.prepareBinding(ctx, binding);
+        prepared.push({
+          ...preparedBinding,
+          scopeKey,
+          context: { ...ctx },
+          preparedLabel: `prepared-${this.#nextPreparedLabel++}`
+        });
+      }
+    } catch (error) {
+      this.#emit("prepare-error", ctx, bindings, prepared);
+      await Promise.allSettled(prepared.map((binding) => this.#disposePrepared(binding)));
+      throw error;
+    }
+    const plan = { scopeKey, context: { ...ctx }, bindings: prepared };
+    this.#plans.set(scopeKey, plan);
+    this.#emit("prepare", ctx, bindings, prepared);
+    return plan;
+  }
+  getPreparedBinding(ctx, selector) {
+    const plan = this.#plans.get(filesystemRuntimeScopeKey(ctx));
+    return plan?.bindings.find((binding) => sameBinding(binding.binding, selector));
+  }
+  async disposeRuntime(ctx) {
+    const scopeKey = filesystemRuntimeScopeKey(ctx);
+    const plan = this.#plans.get(scopeKey);
+    if (!plan) return;
+    this.#plans.delete(scopeKey);
+    await Promise.all(plan.bindings.map((binding) => this.#disposePrepared(binding)));
+    this.#emit("dispose", ctx, plan.bindings.map((binding) => binding.binding), plan.bindings);
+  }
+  async invalidate(ctx, filesystem) {
+    const scopeKey = filesystemRuntimeScopeKey(ctx);
+    const plan = this.#plans.get(scopeKey);
+    if (!plan) return;
+    const remaining = [];
+    for (const binding of plan.bindings) {
+      if (binding.binding.filesystem === filesystem) {
+        await this.#disposePrepared(binding);
+      } else {
+        remaining.push(binding);
+      }
+    }
+    const provider = this.#providers[String(filesystem)];
+    await provider?.invalidateBinding?.(ctx, filesystem);
+    const invalidated = plan.bindings.filter((binding) => binding.binding.filesystem === filesystem);
+    if (remaining.length === 0) {
+      this.#plans.delete(scopeKey);
+    } else {
+      this.#plans.set(scopeKey, { ...plan, bindings: remaining });
+    }
+    this.#emit("invalidate", ctx, invalidated.map((binding) => binding.binding), invalidated);
+  }
+  #emit(type, ctx, bindings, prepared) {
+    this.#onLifecycleEvent?.({
+      type,
+      context: { ...ctx },
+      bindings: bindings.map((binding) => `${binding.filesystem}:${binding.access}:${binding.projection}`),
+      preparedLabels: prepared.map((binding) => binding.preparedLabel)
+    });
+  }
+  async #disposePrepared(binding) {
+    const provider = this.#providers[String(binding.binding.filesystem)];
+    await provider?.disposeBinding?.(binding);
+  }
+};
+
+// src/server/testing/readonlyProjectionConformance.ts
+async function expectRejects(label, failures, fn) {
+  try {
+    await fn();
+    failures.push(label);
+  } catch {
+  }
+}
+function assertSerializedDoesNotLeak(label, value, deniedDirectoryName, deniedSentinel, failures) {
+  const serialized = JSON.stringify(value);
+  if (serialized.includes(deniedDirectoryName)) {
+    failures.push(`${label} leaked denied directory name`);
+  }
+  if (serialized.includes(deniedSentinel)) {
+    failures.push(`${label} leaked denied sentinel`);
+  }
+}
+async function checkReadonlyProjectionConformance(subject) {
+  const failures = [];
+  const {
+    filesystem,
+    rootPath,
+    operations,
+    allowedReadPath,
+    deniedReadPath,
+    deniedDirectoryName,
+    deniedSentinel,
+    allowedFindPattern,
+    expectedAllowedFindCount,
+    expectedVisiblePaths,
+    projection
+  } = subject;
+  const visiblePaths = [...await projection.listVisiblePaths()].sort();
+  const expectedPaths = [...expectedVisiblePaths].sort();
+  if (JSON.stringify(visiblePaths) !== JSON.stringify(expectedPaths)) {
+    failures.push("visible path set/count does not match the expected policy-filtered projection");
+  }
+  if (visiblePaths.some((path) => path === deniedReadPath || path.startsWith(`${deniedReadPath}/`))) {
+    failures.push("denied path is present in visiblePaths");
+  }
+  assertSerializedDoesNotLeak("visiblePaths", visiblePaths, deniedDirectoryName, deniedSentinel, failures);
+  const allowed = await operations.read({ filesystem, path: allowedReadPath });
+  assertSerializedDoesNotLeak("allowed read", allowed, deniedDirectoryName, deniedSentinel, failures);
+  await expectRejects("denied read unexpectedly succeeded", failures, async () => {
+    await operations.read({ filesystem, path: deniedReadPath });
+  });
+  const list = await operations.list({ filesystem, path: rootPath });
+  assertSerializedDoesNotLeak("list", list, deniedDirectoryName, deniedSentinel, failures);
+  const deniedFileName = deniedReadPath.split("/").at(-1) ?? deniedDirectoryName;
+  const findDeniedName = await operations.find({ filesystem, path: rootPath }, deniedFileName);
+  const deniedFindItems = findDeniedName.matches ?? findDeniedName.paths ?? [];
+  if (deniedFindItems.length > 0) {
+    failures.push("find returned denied resource matches");
+  }
+  assertSerializedDoesNotLeak("find denied resource", findDeniedName, deniedDirectoryName, deniedSentinel, failures);
+  const findAllowed = await operations.find({ filesystem, path: rootPath }, allowedFindPattern);
+  const allowedFindItems = findAllowed.matches ?? findAllowed.paths ?? [];
+  if (allowedFindItems.length !== expectedAllowedFindCount) {
+    failures.push("find visible count does not match expected policy-filtered results");
+  }
+  assertSerializedDoesNotLeak("find allowed", findAllowed, deniedDirectoryName, deniedSentinel, failures);
+  const grep = await operations.grep({ filesystem, path: rootPath }, deniedSentinel);
+  if (grep.matches.length > 0) {
+    failures.push("grep returned denied sentinel matches");
+  }
+  assertSerializedDoesNotLeak("grep", grep, deniedDirectoryName, deniedSentinel, failures);
+  await expectRejects(
+    "write to existing projection file unexpectedly succeeded",
+    failures,
+    () => projection.writeExistingAllowedPath()
+  );
+  await expectRejects(
+    "write to new projection file unexpectedly succeeded",
+    failures,
+    () => projection.writeNewAllowedPath()
+  );
+  await expectRejects("symlink escape unexpectedly succeeded", failures, () => projection.followSymlinkEscape());
+  return { passed: failures.length === 0, failures };
+}
+export {
+  COMPANY_CONTEXT_FILESYSTEM_ID,
+  COMPANY_CONTEXT_SENTINEL,
+  DEFAULT_COMPANY_CONTEXT_FIXTURE_FILES,
+  FixtureCompanyContextBindingProvider,
+  MANAGEMENT_PROJECTION_BINDING_REQUIRED_CODE,
+  MANAGEMENT_PROJECTION_INVALID_PATH_CODE,
+  ManagementProjectionOperationError,
+  READONLY_PROJECTION_BINDING_NOT_FOUND_CODE,
+  READONLY_PROJECTION_INVALID_PATH_CODE,
+  READONLY_PROJECTION_MUTATION_CODE,
+  ReadonlyProjectionOperationError,
+  ScopedFilesystemRuntimeBindingManager,
+  checkReadonlyProjectionConformance,
+  createManagementProjectionOperations,
+  createReadonlyProjectionOperations,
+  filesystemRuntimeScopeKey,
+  listFixtureProjectionFiles,
+  readFixtureProjectionFile,
+  seedCompanyContextFixture
+};

package/dist/shared/index.d.ts

@@ -0,0 +1,46 @@
+/** Logical filesystem identity used by tools, UI, and runtime bindings. */
+type FilesystemId = "user" | "company_context" | (string & {});
+/** Access granted for a prepared runtime filesystem binding. */
+type FilesystemAccess = "readonly" | "readwrite";
+/** Provider-declared projection mode for a bound filesystem. */
+type FilesystemProjection = 
+/** Contains only resources allowed for this actor/session. */
+"policy-filtered"
+/** Broader management view; still policy-granted by the host app/provider. */
+ | "management";
+/** Policy-resolved filesystem binding requested for one runtime/session. */
+interface FilesystemBinding {
+    filesystem: FilesystemId;
+    access: FilesystemAccess;
+    mountPath: string;
+    projection: FilesystemProjection;
+}
+/** Actor/session identity supplied when resolving or invalidating bindings. */
+interface BoundFilesystemContext {
+    humanUserId: string;
+    agentId: string;
+    sessionId: string;
+    workspaceId: string;
+    requestId: string;
+}
+/** Resolves policy-granted filesystem bindings for one actor/session. */
+interface FilesystemBindingResolver {
+    resolveBindings(ctx: BoundFilesystemContext): Promise<FilesystemBinding[]>;
+}
+/** Provider/runtime-prepared binding with an opaque mount/projection handle. */
+interface PreparedFilesystemBinding {
+    binding: FilesystemBinding;
+    handle: unknown;
+}
+/** Provider lifecycle seam for preparing, disposing, and invalidating bindings. */
+interface FilesystemBindingProvider {
+    prepareBinding(ctx: BoundFilesystemContext, binding: FilesystemBinding): Promise<PreparedFilesystemBinding>;
+    disposeBinding?(prepared: PreparedFilesystemBinding): Promise<void>;
+    invalidateBinding?(ctx: BoundFilesystemContext, filesystem: FilesystemId): Promise<void>;
+}
+/** Bindings prepared for this one runtime/session. */
+interface RuntimeBindingPlan {
+    bindings: PreparedFilesystemBinding[];
+}
+
+export type { BoundFilesystemContext, FilesystemAccess, FilesystemBinding, FilesystemBindingProvider, FilesystemBindingResolver, FilesystemId, FilesystemProjection, PreparedFilesystemBinding, RuntimeBindingPlan };

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@hachej/boring-bash",
+  "version": "0.1.64",
+  "type": "module",
+  "license": "MIT",
+  "description": "Filesystem and shell binding contracts for Boring runtimes.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hachej/boring-ui"
+  },
+  "homepage": "https://github.com/hachej/boring-ui",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./shared": {
+      "types": "./dist/shared/index.d.ts",
+      "import": "./dist/shared/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js"
+    }
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3",
+    "vitest": "^4.1.9"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "check:invariants": "node ./scripts/check-invariants.mjs",
+    "lint": "pnpm run typecheck && pnpm run check:invariants",
+    "test": "vitest run --passWithNoTests",
+    "clean": "rm -rf dist .tsbuildinfo"
+  }
+}