@paraharness/fs 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Tornike Tsomaia
+
+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/README.md

@@ -1,3 +1,63 @@
-# Temporary Holding Version
+# @paraharness/fs
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Workspace-jailed filesystem tools, glob effect matchers, pre-flight and post-flight write policy guards, file-count quota tripwires, regex checks, and content-addressed JSONL lesson stores for [Paraharness](https://github.com/paraharness/paraharness). This package provides symlink-safe file reading, editing, and search tools alongside declarative `fs.*` guards that enforce partition boundaries and test ratchets inside `P.policy`.
+
+## Installation
+
+With npm:
+
+```bash
+npm install @paraharness/fs @paraharness/core zod
+```
+
+With yarn:
+
+```bash
+yarn add @paraharness/fs @paraharness/core zod
+```
+
+With pnpm:
+
+```bash
+pnpm add @paraharness/fs @paraharness/core zod
+```
+
+## Usage
+
+```ts
+import { P, z } from '@paraharness/core';
+import { createExecutorRegistry } from '@paraharness/core/runtime';
+import { claude, claudeExecutors } from '@paraharness/claude';
+import { fs, fsExecutors } from '@paraharness/fs';
+import { local, nodeExecutors } from '@paraharness/node';
+
+const runner = local.runner({ slots: 4 });
+const sonnet = claude.model('sonnet', { id: 'claude-sonnet-4-6' });
+
+const workerPolicy = P.policy('worker-policy')
+  .guard(
+    fs.protect(['packages/*/src/index.ts', 'PRODUCT_SPEC.md']),
+    fs.requireReadBeforeWrite(),
+    fs.secretLiterals(),
+  )
+  .onViolation('deny-with-error')
+  .tripwire(fs.maxFilesMutated(6));
+
+const worker = P.agent('worker')
+  .model(sonnet)
+  .policy(workerPolicy)
+  .tools(fs.codingTools(runner))
+  .instructions(fs.text('.harness/prompts/worker.md'))
+  .input(z.object({ prompt: z.string() }))
+  .output(z.object({ summary: z.string() }));
+
+const registry = createExecutorRegistry(claudeExecutors, fsExecutors, nodeExecutors);
+```
+
+## Documentation
+
+See the [`@paraharness/fs` API Reference](https://paraharness.github.io/paraharness/modules/_paraharness_fs.html) for full type and builder specifications.
+
+## License
+
+[MIT](./LICENSE) © Tornike Tsomaia

package/dist/builders/create-fs-allow-only-guard-builder.d.ts

@@ -0,0 +1,13 @@
+import type { FsAllowOnlyGuardNode } from '@paraharness/core';
+/**
+ * Compiles a passive `FsAllowOnlyGuardNode` (`fs:allow-only`) for `fs.allowOnly(globs)`.
+ *
+ * Restricts filesystem write mutations strictly to paths matching at least one glob
+ * in `globs` (or an active `LeaseDelta` grant).
+ *
+ * @param {readonly string[]} globs - Allowed write glob patterns.
+ *
+ * @returns {FsAllowOnlyGuardNode} Deeply frozen `FsAllowOnlyGuardNode` AST descriptor.
+ */
+export declare function createFsAllowOnlyGuardBuilder(globs: readonly string[]): FsAllowOnlyGuardNode;
+//# sourceMappingURL=create-fs-allow-only-guard-builder.d.ts.map

package/dist/builders/create-fs-allow-only-guard-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-allow-only-guard-builder.d.ts","sourceRoot":"","sources":["../../src/builders/create-fs-allow-only-guard-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAE9D;;;;;;;;;GASG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,oBAAoB,CAU5F"}

package/dist/builders/create-fs-allow-only-guard-builder.js

@@ -0,0 +1,22 @@
+/**
+ * Compiles a passive `FsAllowOnlyGuardNode` (`fs:allow-only`) for `fs.allowOnly(globs)`.
+ *
+ * Restricts filesystem write mutations strictly to paths matching at least one glob
+ * in `globs` (or an active `LeaseDelta` grant).
+ *
+ * @param {readonly string[]} globs - Allowed write glob patterns.
+ *
+ * @returns {FsAllowOnlyGuardNode} Deeply frozen `FsAllowOnlyGuardNode` AST descriptor.
+ */
+export function createFsAllowOnlyGuardBuilder(globs) {
+    if (!Array.isArray(globs) || globs.length === 0) {
+        throw new Error('fs.allowOnly requires a non-empty globs array.');
+    }
+    const frozenGlobs = Object.freeze([...globs]);
+    return Object.freeze({
+        type: 'fs:allow-only',
+        id: `fs:allow-only:${frozenGlobs.join(',')}`,
+        globs: frozenGlobs,
+    });
+}
+//# sourceMappingURL=create-fs-allow-only-guard-builder.js.map

package/dist/builders/create-fs-allow-only-guard-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-allow-only-guard-builder.js","sourceRoot":"","sources":["../../src/builders/create-fs-allow-only-guard-builder.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,UAAU,6BAA6B,CAAC,KAAwB;IACpE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAChD,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;IACpE,CAAC;IACD,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;IAC9C,OAAO,MAAM,CAAC,MAAM,CAAuB;QACzC,IAAI,EAAE,eAAe;QACrB,EAAE,EAAE,iBAAiB,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QAC5C,KAAK,EAAE,WAAW;KACnB,CAAC,CAAC;AACL,CAAC"}

package/dist/builders/create-fs-allow-write-globs-lease-delta.d.ts

@@ -0,0 +1,13 @@
+import type { LeaseDelta } from '@paraharness/core';
+/**
+ * Creates a serializable `LeaseDelta` unlocking writes to `globs` (`fs.allowWriteGlobs(globs)`).
+ *
+ * Emits a `grantedMatchers` entry with a deterministic `FsGlobMatcherNode` (`mode: 'write'`)
+ * that matches both exact normalized file paths (including bracketed routes) and POSIX globs.
+ *
+ * @param {readonly string[]} globs - Exact file paths or POSIX glob patterns to unlock for writing.
+ *
+ * @returns {LeaseDelta} Deeply frozen `LeaseDelta` capability grant.
+ */
+export declare function createFsAllowWriteGlobsLeaseDelta(globs: readonly string[]): LeaseDelta;
+//# sourceMappingURL=create-fs-allow-write-globs-lease-delta.d.ts.map

package/dist/builders/create-fs-allow-write-globs-lease-delta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-allow-write-globs-lease-delta.d.ts","sourceRoot":"","sources":["../../src/builders/create-fs-allow-write-globs-lease-delta.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,UAAU,CAOtF"}

package/dist/builders/create-fs-allow-write-globs-lease-delta.js

@@ -0,0 +1,20 @@
+import { createFsGlobMatcherBuilder } from './create-fs-glob-matcher-builder.js';
+/**
+ * Creates a serializable `LeaseDelta` unlocking writes to `globs` (`fs.allowWriteGlobs(globs)`).
+ *
+ * Emits a `grantedMatchers` entry with a deterministic `FsGlobMatcherNode` (`mode: 'write'`)
+ * that matches both exact normalized file paths (including bracketed routes) and POSIX globs.
+ *
+ * @param {readonly string[]} globs - Exact file paths or POSIX glob patterns to unlock for writing.
+ *
+ * @returns {LeaseDelta} Deeply frozen `LeaseDelta` capability grant.
+ */
+export function createFsAllowWriteGlobsLeaseDelta(globs) {
+    const matcher = createFsGlobMatcherBuilder(globs, 'write');
+    return Object.freeze({
+        type: 'harness:lease-delta',
+        id: `fs:allow-write-globs:${matcher.globs.join(',')}`,
+        grantedMatchers: Object.freeze([matcher]),
+    });
+}
+//# sourceMappingURL=create-fs-allow-write-globs-lease-delta.js.map

package/dist/builders/create-fs-allow-write-globs-lease-delta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-allow-write-globs-lease-delta.js","sourceRoot":"","sources":["../../src/builders/create-fs-allow-write-globs-lease-delta.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AAEjF;;;;;;;;;GASG;AACH,MAAM,UAAU,iCAAiC,CAAC,KAAwB;IACxE,MAAM,OAAO,GAAG,0BAA0B,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC3D,OAAO,MAAM,CAAC,MAAM,CAAa;QAC/B,IAAI,EAAE,qBAAqB;QAC3B,EAAE,EAAE,wBAAwB,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QACrD,eAAe,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC;KAC1C,CAAC,CAAC;AACL,CAAC"}

package/dist/builders/create-fs-boundary-guard-builder.d.ts

@@ -0,0 +1,15 @@
+import type { FsBoundaryGuardNode, FsPartitionMapNode } from '@paraharness/core';
+/**
+ * Compiles a passive `FsBoundaryGuardNode` (`fs:boundary-guard`) for `fs.boundaryGuard(partitionMap)`.
+ *
+ * Blocks any pre-flight or post-flight write effect matching a partition's `boundaryGlobs`
+ * unless covered by an active `LeaseDelta` grant.
+ *
+ * @template TPartition Literal union of partition identifiers in `partitionMap`.
+ *
+ * @param {FsPartitionMapNode<TPartition>} partitionMap - Filesystem partition map AST node.
+ *
+ * @returns {FsBoundaryGuardNode} Deeply frozen `FsBoundaryGuardNode` AST descriptor.
+ */
+export declare function createFsBoundaryGuardBuilder<TPartition extends string = string>(partitionMap: FsPartitionMapNode<TPartition>): FsBoundaryGuardNode;
+//# sourceMappingURL=create-fs-boundary-guard-builder.d.ts.map

package/dist/builders/create-fs-boundary-guard-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-boundary-guard-builder.d.ts","sourceRoot":"","sources":["../../src/builders/create-fs-boundary-guard-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEjF;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAAC,UAAU,SAAS,MAAM,GAAG,MAAM,EAC7E,YAAY,EAAE,kBAAkB,CAAC,UAAU,CAAC,GAC3C,mBAAmB,CAMrB"}

package/dist/builders/create-fs-boundary-guard-builder.js

@@ -0,0 +1,20 @@
+/**
+ * Compiles a passive `FsBoundaryGuardNode` (`fs:boundary-guard`) for `fs.boundaryGuard(partitionMap)`.
+ *
+ * Blocks any pre-flight or post-flight write effect matching a partition's `boundaryGlobs`
+ * unless covered by an active `LeaseDelta` grant.
+ *
+ * @template TPartition Literal union of partition identifiers in `partitionMap`.
+ *
+ * @param {FsPartitionMapNode<TPartition>} partitionMap - Filesystem partition map AST node.
+ *
+ * @returns {FsBoundaryGuardNode} Deeply frozen `FsBoundaryGuardNode` AST descriptor.
+ */
+export function createFsBoundaryGuardBuilder(partitionMap) {
+    return Object.freeze({
+        type: 'fs:boundary-guard',
+        id: `fs:boundary-guard:${partitionMap.topology.id}`,
+        partitionMap: partitionMap,
+    });
+}
+//# sourceMappingURL=create-fs-boundary-guard-builder.js.map

package/dist/builders/create-fs-boundary-guard-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-boundary-guard-builder.js","sourceRoot":"","sources":["../../src/builders/create-fs-boundary-guard-builder.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,4BAA4B,CAC1C,YAA4C;IAE5C,OAAO,MAAM,CAAC,MAAM,CAAsB;QACxC,IAAI,EAAE,mBAAmB;QACzB,EAAE,EAAE,qBAAqB,YAAY,CAAC,QAAQ,CAAC,EAAE,EAAE;QACnD,YAAY,EAAE,YAA0C;KACzD,CAAC,CAAC;AACL,CAAC"}

package/dist/builders/create-fs-coding-tools.d.ts

@@ -0,0 +1,21 @@
+import { type FsEditToolNode, type FsGlobToolNode, type FsGrepToolNode, type FsReadToolNode, type FsWriteToolNode, type MaybeBuilder, type NodeRunnerNode } from '@paraharness/core';
+/**
+ * Compiles the 5-tool workspace-jailed coding bundle (`fs.codingTools(runner)`).
+ *
+ * Returns passive `ToolASTNode` descriptors (`read_file`, `edit_file`, `write_file`,
+ * `glob_files`, `grep_files`) with `effectTracking: 'declared'`.
+ *
+ * @template THandle Runtime handle type of the active isolation scope.
+ *
+ * @param {MaybeBuilder<NodeRunnerNode>} runner - Runner pool AST node or builder.
+ *
+ * @returns {readonly [FsReadToolNode<THandle>, FsEditToolNode<THandle>, FsWriteToolNode<THandle>, FsGlobToolNode<THandle>, FsGrepToolNode<THandle>]} Frozen 5-tuple of filesystem coding tool AST nodes.
+ */
+export declare function createFsCodingTools<THandle = unknown>(runner: MaybeBuilder<NodeRunnerNode>): readonly [
+    FsReadToolNode<THandle>,
+    FsEditToolNode<THandle>,
+    FsWriteToolNode<THandle>,
+    FsGlobToolNode<THandle>,
+    FsGrepToolNode<THandle>
+];
+//# sourceMappingURL=create-fs-coding-tools.d.ts.map

package/dist/builders/create-fs-coding-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-coding-tools.d.ts","sourceRoot":"","sources":["../../src/builders/create-fs-coding-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAS3B;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAG,OAAO,EACnD,MAAM,EAAE,YAAY,CAAC,cAAc,CAAC,GACnC,SAAS;IACV,cAAc,CAAC,OAAO,CAAC;IACvB,cAAc,CAAC,OAAO,CAAC;IACvB,eAAe,CAAC,OAAO,CAAC;IACxB,cAAc,CAAC,OAAO,CAAC;IACvB,cAAc,CAAC,OAAO,CAAC;CACxB,CASA"}

package/dist/builders/create-fs-coding-tools.js

@@ -0,0 +1,25 @@
+import { extractAST, } from '@paraharness/core';
+import { buildFsEditToolNode, buildFsGlobToolNode, buildFsGrepToolNode, buildFsReadToolNode, buildFsWriteToolNode, } from './internal/build-fs-tool-nodes.js';
+/**
+ * Compiles the 5-tool workspace-jailed coding bundle (`fs.codingTools(runner)`).
+ *
+ * Returns passive `ToolASTNode` descriptors (`read_file`, `edit_file`, `write_file`,
+ * `glob_files`, `grep_files`) with `effectTracking: 'declared'`.
+ *
+ * @template THandle Runtime handle type of the active isolation scope.
+ *
+ * @param {MaybeBuilder<NodeRunnerNode>} runner - Runner pool AST node or builder.
+ *
+ * @returns {readonly [FsReadToolNode<THandle>, FsEditToolNode<THandle>, FsWriteToolNode<THandle>, FsGlobToolNode<THandle>, FsGrepToolNode<THandle>]} Frozen 5-tuple of filesystem coding tool AST nodes.
+ */
+export function createFsCodingTools(runner) {
+    const runnerNode = extractAST(runner);
+    return Object.freeze([
+        buildFsReadToolNode(runnerNode),
+        buildFsEditToolNode(runnerNode),
+        buildFsWriteToolNode(runnerNode),
+        buildFsGlobToolNode(runnerNode),
+        buildFsGrepToolNode(runnerNode),
+    ]);
+}
+//# sourceMappingURL=create-fs-coding-tools.js.map

package/dist/builders/create-fs-coding-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-coding-tools.js","sourceRoot":"","sources":["../../src/builders/create-fs-coding-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,GAQX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,mCAAmC,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,mBAAmB,CACjC,MAAoC;IAQpC,MAAM,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IACtC,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,mBAAmB,CAAU,UAAU,CAAC;QACxC,mBAAmB,CAAU,UAAU,CAAC;QACxC,oBAAoB,CAAU,UAAU,CAAC;QACzC,mBAAmB,CAAU,UAAU,CAAC;QACxC,mBAAmB,CAAU,UAAU,CAAC;KACzC,CAAC,CAAC;AACL,CAAC"}

package/dist/builders/create-fs-glob-matcher-builder.d.ts

@@ -0,0 +1,14 @@
+import type { FsGlobMatcherNode } from '@paraharness/core';
+/**
+ * Compiles a passive `FsGlobMatcherNode` (`fs:match-globs`) for `fs.matchGlobs(globs, mode)`.
+ *
+ * Matches `FsToolEffect` paths against exact normalized file paths and POSIX glob patterns
+ * for reactive `when.effects` triggers and capability lease matching.
+ *
+ * @param {readonly string[]}        globs          - Glob patterns or exact normalized file paths to match.
+ * @param {'read' | 'write' | 'any'} [mode='write'] - Access mode filter (`'read' | 'write' | 'any'`).
+ *
+ * @returns {FsGlobMatcherNode} Deeply frozen `FsGlobMatcherNode` AST descriptor.
+ */
+export declare function createFsGlobMatcherBuilder(globs: readonly string[], mode?: 'read' | 'write' | 'any'): FsGlobMatcherNode;
+//# sourceMappingURL=create-fs-glob-matcher-builder.d.ts.map

package/dist/builders/create-fs-glob-matcher-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-glob-matcher-builder.d.ts","sourceRoot":"","sources":["../../src/builders/create-fs-glob-matcher-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,IAAI,GAAE,MAAM,GAAG,OAAO,GAAG,KAAe,GACvC,iBAAiB,CAWnB"}

package/dist/builders/create-fs-glob-matcher-builder.js

@@ -0,0 +1,24 @@
+/**
+ * Compiles a passive `FsGlobMatcherNode` (`fs:match-globs`) for `fs.matchGlobs(globs, mode)`.
+ *
+ * Matches `FsToolEffect` paths against exact normalized file paths and POSIX glob patterns
+ * for reactive `when.effects` triggers and capability lease matching.
+ *
+ * @param {readonly string[]}        globs          - Glob patterns or exact normalized file paths to match.
+ * @param {'read' | 'write' | 'any'} [mode='write'] - Access mode filter (`'read' | 'write' | 'any'`).
+ *
+ * @returns {FsGlobMatcherNode} Deeply frozen `FsGlobMatcherNode` AST descriptor.
+ */
+export function createFsGlobMatcherBuilder(globs, mode = 'write') {
+    if (!Array.isArray(globs) || globs.length === 0) {
+        throw new Error('fs.matchGlobs requires a non-empty array of glob patterns.');
+    }
+    const frozenGlobs = Object.freeze([...globs]);
+    return Object.freeze({
+        type: 'fs:match-globs',
+        id: `fs:match-globs:${mode}:${frozenGlobs.join(',')}`,
+        globs: frozenGlobs,
+        mode,
+    });
+}
+//# sourceMappingURL=create-fs-glob-matcher-builder.js.map

package/dist/builders/create-fs-glob-matcher-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-glob-matcher-builder.js","sourceRoot":"","sources":["../../src/builders/create-fs-glob-matcher-builder.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,0BAA0B,CACxC,KAAwB,EACxB,OAAiC,OAAO;IAExC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAChD,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;IAChF,CAAC;IACD,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;IAC9C,OAAO,MAAM,CAAC,MAAM,CAAoB;QACtC,IAAI,EAAE,gBAAgB;QACtB,EAAE,EAAE,kBAAkB,IAAI,IAAI,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QACrD,KAAK,EAAE,WAAW;QAClB,IAAI;KACL,CAAC,CAAC;AACL,CAAC"}

package/dist/builders/create-fs-glob-source-builder.d.ts

@@ -0,0 +1,13 @@
+import type { FsGlobSourceNode } from '@paraharness/core';
+/**
+ * Compiles a passive `FsGlobSourceNode` (`fs:glob-source`) for `fs.glob(globPattern)`.
+ *
+ * Resolves all files matching `globPattern` in deterministic lexicographical path order
+ * and pairs their relative paths and UTF-8 contents with a combined SHA-256 digest.
+ *
+ * @param {string} globPattern - POSIX glob pattern matched against the repository root.
+ *
+ * @returns {FsGlobSourceNode} Deeply frozen `FsGlobSourceNode` AST descriptor.
+ */
+export declare function createFsGlobSourceBuilder(globPattern: string): FsGlobSourceNode;
+//# sourceMappingURL=create-fs-glob-source-builder.d.ts.map

package/dist/builders/create-fs-glob-source-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-glob-source-builder.d.ts","sourceRoot":"","sources":["../../src/builders/create-fs-glob-source-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,gBAAgB,CAU/E"}

package/dist/builders/create-fs-glob-source-builder.js

@@ -0,0 +1,22 @@
+/**
+ * Compiles a passive `FsGlobSourceNode` (`fs:glob-source`) for `fs.glob(globPattern)`.
+ *
+ * Resolves all files matching `globPattern` in deterministic lexicographical path order
+ * and pairs their relative paths and UTF-8 contents with a combined SHA-256 digest.
+ *
+ * @param {string} globPattern - POSIX glob pattern matched against the repository root.
+ *
+ * @returns {FsGlobSourceNode} Deeply frozen `FsGlobSourceNode` AST descriptor.
+ */
+export function createFsGlobSourceBuilder(globPattern) {
+    if (typeof globPattern !== 'string' || globPattern.trim().length === 0) {
+        throw new Error('fs.glob requires a non-empty globPattern string.');
+    }
+    const normalizedPattern = globPattern.trim();
+    return Object.freeze({
+        type: 'fs:glob-source',
+        id: `fs:glob-source:${normalizedPattern}`,
+        pattern: normalizedPattern,
+    });
+}
+//# sourceMappingURL=create-fs-glob-source-builder.js.map

package/dist/builders/create-fs-glob-source-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-glob-source-builder.js","sourceRoot":"","sources":["../../src/builders/create-fs-glob-source-builder.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,UAAU,yBAAyB,CAAC,WAAmB;IAC3D,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvE,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;IACD,MAAM,iBAAiB,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC;IAC7C,OAAO,MAAM,CAAC,MAAM,CAAmB;QACrC,IAAI,EAAE,gBAAgB;QACtB,EAAE,EAAE,kBAAkB,iBAAiB,EAAE;QACzC,OAAO,EAAE,iBAAiB;KAC3B,CAAC,CAAC;AACL,CAAC"}

package/dist/builders/create-fs-in-partition-predicate.d.ts

@@ -0,0 +1,16 @@
+import type { FsPartitionMapNode, ScopePredicate } from '@paraharness/core';
+/**
+ * Builds a `ScopePredicate` matching a specific partition in `partitionMap` (`fs.inPartition`).
+ *
+ * Populates both `partitions: [partitionId]` for Turn-0 partition injection and `effects`
+ * with an `'any'`-mode `FsGlobMatcherNode` covering the partition's member globs.
+ *
+ * @template TPartition Literal union of partition identifiers in `partitionMap`.
+ *
+ * @param {FsPartitionMapNode<TPartition>} partitionMap - Filesystem partition map AST node.
+ * @param {TPartition}                     partitionId  - Target partition identifier to scope against.
+ *
+ * @returns {ScopePredicate} Frozen `ScopePredicate` record for scoped rules and skills.
+ */
+export declare function createFsInPartitionPredicate<TPartition extends string = string>(partitionMap: FsPartitionMapNode<TPartition>, partitionId: TPartition): ScopePredicate;
+//# sourceMappingURL=create-fs-in-partition-predicate.d.ts.map

package/dist/builders/create-fs-in-partition-predicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-in-partition-predicate.d.ts","sourceRoot":"","sources":["../../src/builders/create-fs-in-partition-predicate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAG5E;;;;;;;;;;;;GAYG;AACH,wBAAgB,4BAA4B,CAAC,UAAU,SAAS,MAAM,GAAG,MAAM,EAC7E,YAAY,EAAE,kBAAkB,CAAC,UAAU,CAAC,EAC5C,WAAW,EAAE,UAAU,GACtB,cAAc,CAWhB"}

package/dist/builders/create-fs-in-partition-predicate.js

@@ -0,0 +1,25 @@
+import { createFsGlobMatcherBuilder } from './create-fs-glob-matcher-builder.js';
+/**
+ * Builds a `ScopePredicate` matching a specific partition in `partitionMap` (`fs.inPartition`).
+ *
+ * Populates both `partitions: [partitionId]` for Turn-0 partition injection and `effects`
+ * with an `'any'`-mode `FsGlobMatcherNode` covering the partition's member globs.
+ *
+ * @template TPartition Literal union of partition identifiers in `partitionMap`.
+ *
+ * @param {FsPartitionMapNode<TPartition>} partitionMap - Filesystem partition map AST node.
+ * @param {TPartition}                     partitionId  - Target partition identifier to scope against.
+ *
+ * @returns {ScopePredicate} Frozen `ScopePredicate` record for scoped rules and skills.
+ */
+export function createFsInPartitionPredicate(partitionMap, partitionId) {
+    const entry = partitionMap.mapping[partitionId];
+    if (entry === undefined) {
+        throw new Error(`fs.inPartition failed: partition '${partitionId}' is not defined in topology '${partitionMap.topology.id}'.`);
+    }
+    return Object.freeze({
+        partitions: [partitionId],
+        effects: createFsGlobMatcherBuilder(entry.globs, 'any'),
+    });
+}
+//# sourceMappingURL=create-fs-in-partition-predicate.js.map

package/dist/builders/create-fs-in-partition-predicate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-in-partition-predicate.js","sourceRoot":"","sources":["../../src/builders/create-fs-in-partition-predicate.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AAEjF;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,4BAA4B,CAC1C,YAA4C,EAC5C,WAAuB;IAEvB,MAAM,KAAK,GAAG,YAAY,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IAChD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CACb,qCAAqC,WAAW,iCAAiC,YAAY,CAAC,QAAQ,CAAC,EAAE,IAAI,CAC9G,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAiB;QACnC,UAAU,EAAE,CAAC,WAAW,CAAC;QACzB,OAAO,EAAE,0BAA0B,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC;KACxD,CAAC,CAAC;AACL,CAAC"}

package/dist/builders/create-fs-jsonl-lesson-store-builder.d.ts

@@ -0,0 +1,29 @@
+import type { FsJsonlLessonStoreNode } from '@paraharness/core';
+/**
+ * Configuration options for `fs.jsonlLessonStore(options)`.
+ *
+ * Configures the host-root directory for immutable content-addressed lesson JSON files,
+ * the mutable telemetry counter file path, and the advisory lockfile path.
+ */
+export interface FsJsonlLessonStoreOptions {
+    /** Host-root directory storing immutable `<lessonId>.json` definition files. */
+    readonly definitionsDir: string;
+    /** Host-root file path storing mutable lesson telemetry and outcome counters. */
+    readonly statsPath: string;
+    /** Host-root advisory lockfile path used for cross-process synchronization. */
+    readonly lockFile: string;
+}
+/**
+ * Compiles a passive `FsJsonlLessonStoreNode` (`fs:jsonl-lesson-store`) for `fs.jsonlLessonStore(options)`.
+ *
+ * Configures a host-root-resolved content-addressed lesson store splitting immutable
+ * `<definitionsDir>/<lessonId>.json` definitions from mutable `statsPath` counters.
+ *
+ * @param {FsJsonlLessonStoreOptions} options - Host-root paths for definitions, stats, and lockfile.
+ *
+ * @returns {FsJsonlLessonStoreNode} Deeply frozen `FsJsonlLessonStoreNode` AST descriptor.
+ *
+ * @throws {Error} If any of `definitionsDir`, `statsPath`, or `lockFile` is empty.
+ */
+export declare function createFsJsonlLessonStoreBuilder(options: FsJsonlLessonStoreOptions): FsJsonlLessonStoreNode;
+//# sourceMappingURL=create-fs-jsonl-lesson-store-builder.d.ts.map

package/dist/builders/create-fs-jsonl-lesson-store-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-jsonl-lesson-store-builder.d.ts","sourceRoot":"","sources":["../../src/builders/create-fs-jsonl-lesson-store-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAEhE;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB;IACxC,gFAAgF;IAChF,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,iFAAiF;IACjF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,yBAAyB,GACjC,sBAAsB,CAgBxB"}

package/dist/builders/create-fs-jsonl-lesson-store-builder.js

@@ -0,0 +1,30 @@
+/**
+ * Compiles a passive `FsJsonlLessonStoreNode` (`fs:jsonl-lesson-store`) for `fs.jsonlLessonStore(options)`.
+ *
+ * Configures a host-root-resolved content-addressed lesson store splitting immutable
+ * `<definitionsDir>/<lessonId>.json` definitions from mutable `statsPath` counters.
+ *
+ * @param {FsJsonlLessonStoreOptions} options - Host-root paths for definitions, stats, and lockfile.
+ *
+ * @returns {FsJsonlLessonStoreNode} Deeply frozen `FsJsonlLessonStoreNode` AST descriptor.
+ *
+ * @throws {Error} If any of `definitionsDir`, `statsPath`, or `lockFile` is empty.
+ */
+export function createFsJsonlLessonStoreBuilder(options) {
+    if (typeof options.definitionsDir !== 'string' || options.definitionsDir.trim().length === 0) {
+        throw new Error('fs.jsonlLessonStore requires a non-empty definitionsDir path.');
+    }
+    if (typeof options.statsPath !== 'string' || options.statsPath.trim().length === 0) {
+        throw new Error('fs.jsonlLessonStore requires a non-empty statsPath.');
+    }
+    if (typeof options.lockFile !== 'string' || options.lockFile.trim().length === 0) {
+        throw new Error('fs.jsonlLessonStore requires a non-empty lockFile path.');
+    }
+    return Object.freeze({
+        type: 'fs:jsonl-lesson-store',
+        definitionsDir: options.definitionsDir.trim(),
+        statsPath: options.statsPath.trim(),
+        lockFile: options.lockFile.trim(),
+    });
+}
+//# sourceMappingURL=create-fs-jsonl-lesson-store-builder.js.map

package/dist/builders/create-fs-jsonl-lesson-store-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-jsonl-lesson-store-builder.js","sourceRoot":"","sources":["../../src/builders/create-fs-jsonl-lesson-store-builder.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,+BAA+B,CAC7C,OAAkC;IAElC,IAAI,OAAO,OAAO,CAAC,cAAc,KAAK,QAAQ,IAAI,OAAO,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7F,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;IACnF,CAAC;IACD,IAAI,OAAO,OAAO,CAAC,SAAS,KAAK,QAAQ,IAAI,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACnF,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;IACzE,CAAC;IACD,IAAI,OAAO,OAAO,CAAC,QAAQ,KAAK,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACjF,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;IAC7E,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAyB;QAC3C,IAAI,EAAE,uBAAuB;QAC7B,cAAc,EAAE,OAAO,CAAC,cAAc,CAAC,IAAI,EAAE;QAC7C,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE;QACnC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,IAAI,EAAE;KAClC,CAAC,CAAC;AACL,CAAC"}

package/dist/builders/create-fs-max-files-mutated-builder.d.ts

@@ -0,0 +1,13 @@
+import type { FsQuotaTripwireNode } from '@paraharness/core';
+/**
+ * Compiles a passive `FsQuotaTripwireNode` (`fs:quota-tripwire`) for `fs.maxFilesMutated(count)`.
+ *
+ * Trips `PolicyNode.onLimitExceeded` when the number of distinct mutated file paths in
+ * a step session exceeds `count`.
+ *
+ * @param {number} count - Maximum number of distinct mutated files allowed before tripping.
+ *
+ * @returns {FsQuotaTripwireNode} Deeply frozen `FsQuotaTripwireNode` AST descriptor.
+ */
+export declare function createFsMaxFilesMutatedBuilder(count: number): FsQuotaTripwireNode;
+//# sourceMappingURL=create-fs-max-files-mutated-builder.d.ts.map

package/dist/builders/create-fs-max-files-mutated-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-max-files-mutated-builder.d.ts","sourceRoot":"","sources":["../../src/builders/create-fs-max-files-mutated-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,MAAM,GAAG,mBAAmB,CASjF"}

package/dist/builders/create-fs-max-files-mutated-builder.js

@@ -0,0 +1,21 @@
+/**
+ * Compiles a passive `FsQuotaTripwireNode` (`fs:quota-tripwire`) for `fs.maxFilesMutated(count)`.
+ *
+ * Trips `PolicyNode.onLimitExceeded` when the number of distinct mutated file paths in
+ * a step session exceeds `count`.
+ *
+ * @param {number} count - Maximum number of distinct mutated files allowed before tripping.
+ *
+ * @returns {FsQuotaTripwireNode} Deeply frozen `FsQuotaTripwireNode` AST descriptor.
+ */
+export function createFsMaxFilesMutatedBuilder(count) {
+    if (!Number.isInteger(count) || count < 0) {
+        throw new Error(`fs.maxFilesMutated requires a non-negative integer count (received ${String(count)}).`);
+    }
+    return Object.freeze({
+        type: 'fs:quota-tripwire',
+        id: `fs:max-files-mutated:${String(count)}`,
+        maxFilesMutated: count,
+    });
+}
+//# sourceMappingURL=create-fs-max-files-mutated-builder.js.map

package/dist/builders/create-fs-max-files-mutated-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-max-files-mutated-builder.js","sourceRoot":"","sources":["../../src/builders/create-fs-max-files-mutated-builder.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,UAAU,8BAA8B,CAAC,KAAa;IAC1D,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QAC1C,MAAM,IAAI,KAAK,CAAC,sEAAsE,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3G,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAsB;QACxC,IAAI,EAAE,mBAAmB;QACzB,EAAE,EAAE,wBAAwB,MAAM,CAAC,KAAK,CAAC,EAAE;QAC3C,eAAe,EAAE,KAAK;KACvB,CAAC,CAAC;AACL,CAAC"}

package/dist/builders/create-fs-partition-map.d.ts

@@ -0,0 +1,16 @@
+import { type FsPartitionMapNode, type FsPartitionPathMapping, type MaybeBuilder, type TopologyNode } from '@paraharness/core';
+/**
+ * Compiles a passive `FsPartitionMapNode` (`fs:partition-map`) for `fs.partitionMap(topology, mapping)`.
+ *
+ * Associates each logical partition in `topology` with its physical implementation globs
+ * (`globs`) and protected public boundary surface globs (`boundaryGlobs`).
+ *
+ * @template TPartition Literal union of partition identifiers in `topology`.
+ *
+ * @param {MaybeBuilder<TopologyNode<TPartition>>}               topology - Relational topology AST node or builder.
+ * @param {Readonly<Record<TPartition, FsPartitionPathMapping>>} mapping  - Per-partition member and boundary globs.
+ *
+ * @returns {FsPartitionMapNode<TPartition>} Deeply frozen `FsPartitionMapNode` AST descriptor.
+ */
+export declare function createFsPartitionMap<TPartition extends string = string>(topology: MaybeBuilder<TopologyNode<TPartition>>, mapping: Readonly<Record<TPartition, FsPartitionPathMapping>>): FsPartitionMapNode<TPartition>;
+//# sourceMappingURL=create-fs-partition-map.d.ts.map

package/dist/builders/create-fs-partition-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-partition-map.d.ts","sourceRoot":"","sources":["../../src/builders/create-fs-partition-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,YAAY,EACjB,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,SAAS,MAAM,GAAG,MAAM,EACrE,QAAQ,EAAE,YAAY,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,EAChD,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,sBAAsB,CAAC,CAAC,GAC5D,kBAAkB,CAAC,UAAU,CAAC,CAoBhC"}

package/dist/builders/create-fs-partition-map.js

@@ -0,0 +1,34 @@
+import { extractAST, } from '@paraharness/core';
+/**
+ * Compiles a passive `FsPartitionMapNode` (`fs:partition-map`) for `fs.partitionMap(topology, mapping)`.
+ *
+ * Associates each logical partition in `topology` with its physical implementation globs
+ * (`globs`) and protected public boundary surface globs (`boundaryGlobs`).
+ *
+ * @template TPartition Literal union of partition identifiers in `topology`.
+ *
+ * @param {MaybeBuilder<TopologyNode<TPartition>>}               topology - Relational topology AST node or builder.
+ * @param {Readonly<Record<TPartition, FsPartitionPathMapping>>} mapping  - Per-partition member and boundary globs.
+ *
+ * @returns {FsPartitionMapNode<TPartition>} Deeply frozen `FsPartitionMapNode` AST descriptor.
+ */
+export function createFsPartitionMap(topology, mapping) {
+    const topologyNode = extractAST(topology);
+    const frozenMapping = {};
+    for (const partitionKey of Object.keys(topologyNode.partitions)) {
+        const entry = mapping[partitionKey];
+        if (entry === undefined) {
+            throw new Error(`fs.partitionMap missing mapping for partition '${partitionKey}' in topology '${topologyNode.id}'.`);
+        }
+        frozenMapping[partitionKey] = Object.freeze({
+            globs: Object.freeze([...entry.globs]),
+            boundaryGlobs: Object.freeze([...(entry.boundaryGlobs ?? [])]),
+        });
+    }
+    return Object.freeze({
+        type: 'fs:partition-map',
+        topology: topologyNode,
+        mapping: Object.freeze(frozenMapping),
+    });
+}
+//# sourceMappingURL=create-fs-partition-map.js.map

package/dist/builders/create-fs-partition-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-partition-map.js","sourceRoot":"","sources":["../../src/builders/create-fs-partition-map.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,GAKX,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,oBAAoB,CAClC,QAAgD,EAChD,OAA6D;IAE7D,MAAM,YAAY,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;IAC1C,MAAM,aAAa,GAAG,EAAgD,CAAC;IACvE,KAAK,MAAM,YAAY,IAAI,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAiB,EAAE,CAAC;QAChF,MAAM,KAAK,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;QACpC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CACb,kDAAkD,YAAY,kBAAkB,YAAY,CAAC,EAAE,IAAI,CACpG,CAAC;QACJ,CAAC;QACD,aAAa,CAAC,YAAY,CAAC,GAAG,MAAM,CAAC,MAAM,CAAyB;YAClE,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;YACtC,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,CAAC;SAC/D,CAAC,CAAC;IACL,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAiC;QACnD,IAAI,EAAE,kBAAkB;QACxB,QAAQ,EAAE,YAAY;QACtB,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC;KACtC,CAAC,CAAC;AACL,CAAC"}

package/dist/builders/create-fs-protect-guard-builder.d.ts

@@ -0,0 +1,13 @@
+import type { FsProtectGuardNode } from '@paraharness/core';
+/**
+ * Compiles a passive `FsProtectGuardNode` (`fs:protect`) for `fs.protect(globs)`.
+ *
+ * Blocks any write mutation targeting files matching `globs` unless covered by an
+ * explicitly elevated capability lease.
+ *
+ * @param {readonly string[]} globs - Protected file glob patterns.
+ *
+ * @returns {FsProtectGuardNode} Deeply frozen `FsProtectGuardNode` AST descriptor.
+ */
+export declare function createFsProtectGuardBuilder(globs: readonly string[]): FsProtectGuardNode;
+//# sourceMappingURL=create-fs-protect-guard-builder.d.ts.map

package/dist/builders/create-fs-protect-guard-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-fs-protect-guard-builder.d.ts","sourceRoot":"","sources":["../../src/builders/create-fs-protect-guard-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5D;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,kBAAkB,CAUxF"}