@fungi.computer/knapsack 0.0.2 → 0.1.0

package/dist/files-patch.d.ts

@@ -1,10 +1,10 @@
 import * as z from "zod";
 /** Browser-safe patch contracts shared by native Files tools and Computer HTTP. */
-export declare const patchInputSchema: z.ZodObject<{
+export declare const patchInputSchema: z.ZodLazy<z.ZodObject<{
     patch: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Native patch completion, cancellation or failure, including an optional mismatch. */
-export declare const patchOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+export declare const patchOutputSchema: z.ZodLazy<z.ZodUnion<readonly [z.ZodObject<{
     status: z.ZodEnum<{
         completed: "completed";
         failed: "failed";
@@ -27,4 +27,4 @@ export declare const patchOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
     error: z.ZodObject<{
         kind: z.ZodLiteral<"mismatch">;
     }, z.core.$strict>;
-}, z.core.$strict>]>;
+}, z.core.$strict>]>>;

package/dist/files-patch.js

@@ -1,11 +1,11 @@
 import * as z from "zod";
 import { boundedTextSchema, maximumReadBytes } from "./files-read.js";
 /** Browser-safe patch contracts shared by native Files tools and Computer HTTP. */
-export const patchInputSchema = z.strictObject({
+export const patchInputSchema = z.lazy(() => z.strictObject({
     patch: boundedTextSchema(1).meta({
         description: `Codex patch text, at most ${String(maximumReadBytes)} UTF-8 bytes.`,
     }),
-});
+}));
 const patchResultSchema = z.strictObject({
     status: z.enum(["completed", "failed", "cancelled"]),
     exitCode: z.number().int(),
@@ -14,9 +14,9 @@ const patchResultSchema = z.strictObject({
     truncated: z.boolean(),
 });
 /** Native patch completion, cancellation or failure, including an optional mismatch. */
-export const patchOutputSchema = z.union([
+export const patchOutputSchema = z.lazy(() => z.union([
     patchResultSchema,
     patchResultSchema.extend({
         error: z.strictObject({ kind: z.literal("mismatch") }),
     }),
-]);
+]));

package/dist/files-read.d.ts

@@ -2,24 +2,24 @@ import * as z from "zod";
 /** Maximum UTF-8 byte length of a Files text page. */
 export declare const maximumReadBytes: number;
 /** Nonempty file path bounded to 4,096 characters, without null bytes. */
-export declare const pathSchema: z.ZodString;
+export declare const pathSchema: z.ZodLazy<z.ZodString>;
 /** Validate text against a minimum character length and the Files UTF-8 byte limit. */
 export declare function boundedTextSchema(minimumLength?: number): z.ZodString;
 /** Canonical bounded Files read request and result, shared with display consumers. */
-export declare const readInputSchema: z.ZodObject<{
-    path: z.ZodString;
+export declare const readInputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodLazy<z.ZodString>;
     offset: z.ZodDefault<z.ZodNumber>;
     limit: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Bounded text page, continuation offset and optional hosted file identity. */
-export declare const readOutputSchema: z.ZodObject<{
-    path: z.ZodString;
+export declare const readOutputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodLazy<z.ZodString>;
     content: z.ZodString;
     offset: z.ZodNumber;
     nextOffset: z.ZodNullable<z.ZodNumber>;
     truncated: z.ZodBoolean;
     file: z.ZodExactOptional<z.ZodObject<{
         computerId: z.ZodString;
-        path: z.ZodString;
+        path: z.ZodLazy<z.ZodString>;
     }, z.core.$strict>>;
-}, z.core.$strict>;
+}, z.core.$strict>>;

package/dist/files-read.js

@@ -3,11 +3,11 @@ import * as z from "zod";
 export const maximumReadBytes = 128 * 1_024;
 const utf8 = new TextEncoder();
 /** Nonempty file path bounded to 4,096 characters, without null bytes. */
-export const pathSchema = z
+export const pathSchema = z.lazy(() => z
     .string()
     .min(1)
     .max(4_096)
-    .refine((path) => !path.includes("\0"), "Path cannot contain null bytes");
+    .refine((path) => !path.includes("\0"), "Path cannot contain null bytes"));
 /** Validate text against a minimum character length and the Files UTF-8 byte limit. */
 export function boundedTextSchema(minimumLength = 0) {
     return z
@@ -16,7 +16,7 @@ export function boundedTextSchema(minimumLength = 0) {
         .refine((content) => utf8.encode(content).byteLength <= maximumReadBytes, `Text exceeds the ${String(maximumReadBytes)}-byte Files bound`);
 }
 /** Canonical bounded Files read request and result, shared with display consumers. */
-export const readInputSchema = z.strictObject({
+export const readInputSchema = z.lazy(() => z.strictObject({
     path: pathSchema,
     offset: z.number().int().min(0).default(0),
     limit: z
@@ -25,9 +25,9 @@ export const readInputSchema = z.strictObject({
         .min(4)
         .max(maximumReadBytes)
         .default(maximumReadBytes),
-});
+}));
 /** Bounded text page, continuation offset and optional hosted file identity. */
-export const readOutputSchema = z.strictObject({
+export const readOutputSchema = z.lazy(() => z.strictObject({
     path: pathSchema,
     content: boundedTextSchema(),
     offset: z.number().int().min(0),
@@ -40,4 +40,4 @@ export const readOutputSchema = z.strictObject({
         path: pathSchema.refine((path) => path.startsWith("/"), "Computer file paths must be absolute"),
     })
         .exactOptional(),
-});
+}));

package/dist/files.d.ts

@@ -14,14 +14,14 @@ export declare class FilesEditError extends Error {
 }
 /** Bounded directory listing request. */
 export declare const listInputSchema: z.ZodObject<{
-    path: z.ZodString;
+    path: z.ZodLazy<z.ZodString>;
     limit: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
 /** Directory entries and an explicit truncation flag. */
-export declare const listOutputSchema: z.ZodObject<{
-    path: z.ZodString;
-    entries: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
+export declare const listOutputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodLazy<z.ZodString>;
+    entries: z.ZodArray<z.ZodLazy<z.ZodObject<{
+        path: z.ZodLazy<z.ZodString>;
         name: z.ZodString;
         type: z.ZodEnum<{
             file: "file";
@@ -30,47 +30,47 @@ export declare const listOutputSchema: z.ZodObject<{
         }>;
         size: z.ZodNumber;
         modifiedAt: z.ZodNumber;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>>;
     truncated: z.ZodBoolean;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Bounded path-pattern search request. */
-export declare const globInputSchema: z.ZodObject<{
-    path: z.ZodString;
+export declare const globInputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodLazy<z.ZodString>;
     pattern: z.ZodString;
     limit: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Matching paths and an explicit truncation flag. */
-export declare const globOutputSchema: z.ZodObject<{
-    path: z.ZodString;
-    matches: z.ZodArray<z.ZodString>;
+export declare const globOutputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodLazy<z.ZodString>;
+    matches: z.ZodArray<z.ZodLazy<z.ZodString>>;
     truncated: z.ZodBoolean;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Bounded content-search request with optional regular-expression matching. */
-export declare const grepInputSchema: z.ZodObject<{
-    path: z.ZodString;
+export declare const grepInputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodLazy<z.ZodString>;
     pattern: z.ZodString;
     regex: z.ZodDefault<z.ZodBoolean>;
     ignoreCase: z.ZodDefault<z.ZodBoolean>;
     limit: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Content matches and an explicit truncation flag. */
-export declare const grepOutputSchema: z.ZodObject<{
-    path: z.ZodString;
+export declare const grepOutputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodLazy<z.ZodString>;
     matches: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
+        path: z.ZodLazy<z.ZodString>;
         line: z.ZodNumber;
         text: z.ZodString;
     }, z.core.$strict>>;
     truncated: z.ZodBoolean;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Text replacement request decoded before the captured Files port is called. */
-export declare const editInputSchema: z.ZodObject<{
-    path: z.ZodString;
+export declare const editInputSchema: z.ZodLazy<z.ZodObject<{
+    path: z.ZodLazy<z.ZodString>;
     oldText: z.ZodString;
     newText: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Structured edit refusal, including its reason and affected path. */
-export declare const filesEditFailureSchema: z.ZodObject<{
+export declare const filesEditFailureSchema: z.ZodLazy<z.ZodObject<{
     status: z.ZodLiteral<"failed">;
     error: z.ZodObject<{
         kind: z.ZodEnum<{
@@ -81,13 +81,13 @@ export declare const filesEditFailureSchema: z.ZodObject<{
             unchanged: "unchanged";
             conflict: "conflict";
         }>;
-        path: z.ZodString;
+        path: z.ZodLazy<z.ZodString>;
         message: z.ZodString;
     }, z.core.$strict>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Successful edit metadata or a typed edit refusal. */
-export declare const editOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
-    path: z.ZodString;
+export declare const editOutputSchema: z.ZodUnion<readonly [z.ZodLazy<z.ZodObject<{
+    path: z.ZodLazy<z.ZodString>;
     bytes: z.ZodNumber;
     diff: z.ZodString;
     firstChangedLine: z.ZodNullable<z.ZodNumber>;
@@ -96,7 +96,7 @@ export declare const editOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
     unifiedPatchAddedLines: z.ZodNumber;
     unifiedPatchRemovedLines: z.ZodNumber;
     unifiedPatchTruncated: z.ZodBoolean;
-}, z.core.$strict>, z.ZodObject<{
+}, z.core.$strict>>, z.ZodLazy<z.ZodObject<{
     status: z.ZodLiteral<"failed">;
     error: z.ZodObject<{
         kind: z.ZodEnum<{
@@ -107,10 +107,10 @@ export declare const editOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
             unchanged: "unchanged";
             conflict: "conflict";
         }>;
-        path: z.ZodString;
+        path: z.ZodLazy<z.ZodString>;
         message: z.ZodString;
     }, z.core.$strict>;
-}, z.core.$strict>]>;
+}, z.core.$strict>>]>;
 /** Host-owned native patch operation receiving the invocation's deadline and signal. */
 export type FilesPatch = (input: z.output<typeof patchInputSchema>, context: InvocationContext) => Promise<z.output<typeof patchOutputSchema>>;
 /** Captured host file authority; the host owns path confinement and atomic replacement. */

package/dist/files.js

@@ -35,21 +35,21 @@ export const listInputSchema = z.strictObject({
         .max(maximumResultEntries)
         .default(maximumResultEntries),
 });
-const listEntrySchema = z.strictObject({
+const listEntrySchema = z.lazy(() => z.strictObject({
     path: pathSchema,
     name: z.string().min(1),
     type: z.enum(["file", "directory", "symlink"]),
     size: z.number().int().nonnegative(),
     modifiedAt: z.number(),
-});
+}));
 /** Directory entries and an explicit truncation flag. */
-export const listOutputSchema = z.strictObject({
+export const listOutputSchema = z.lazy(() => z.strictObject({
     path: pathSchema,
     entries: z.array(listEntrySchema).max(maximumResultEntries),
     truncated: z.boolean(),
-});
+}));
 /** Bounded path-pattern search request. */
-export const globInputSchema = z.strictObject({
+export const globInputSchema = z.lazy(() => z.strictObject({
     path: pathSchema,
     pattern: z.string().min(1).max(maximumPatternCharacters),
     limit: z
@@ -58,15 +58,15 @@ export const globInputSchema = z.strictObject({
         .min(1)
         .max(maximumResultEntries)
         .default(maximumResultEntries),
-});
+}));
 /** Matching paths and an explicit truncation flag. */
-export const globOutputSchema = z.strictObject({
+export const globOutputSchema = z.lazy(() => z.strictObject({
     path: pathSchema,
     matches: z.array(pathSchema).max(maximumResultEntries),
     truncated: z.boolean(),
-});
+}));
 /** Bounded content-search request with optional regular-expression matching. */
-export const grepInputSchema = z.strictObject({
+export const grepInputSchema = z.lazy(() => z.strictObject({
     path: pathSchema,
     pattern: z.string().min(1).max(maximumPatternCharacters),
     regex: z.boolean().default(false),
@@ -77,9 +77,9 @@ export const grepInputSchema = z.strictObject({
         .min(1)
         .max(maximumResultEntries)
         .default(maximumResultEntries),
-});
+}));
 /** Content matches and an explicit truncation flag. */
-export const grepOutputSchema = z.strictObject({
+export const grepOutputSchema = z.lazy(() => z.strictObject({
     path: pathSchema,
     matches: z
         .array(z.strictObject({
@@ -89,14 +89,14 @@ export const grepOutputSchema = z.strictObject({
     }))
         .max(maximumResultEntries),
     truncated: z.boolean(),
-});
+}));
 /** Text replacement request decoded before the captured Files port is called. */
-export const editInputSchema = z.strictObject({
+export const editInputSchema = z.lazy(() => z.strictObject({
     path: pathSchema,
     oldText: boundedTextSchema(1),
     newText: boundedTextSchema(),
-});
-const editSuccessSchema = z.strictObject({
+}));
+const editSuccessSchema = z.lazy(() => z.strictObject({
     path: pathSchema,
     bytes: z.number().int().nonnegative(),
     diff: z.string(),
@@ -106,9 +106,9 @@ const editSuccessSchema = z.strictObject({
     unifiedPatchAddedLines: z.number().int().nonnegative(),
     unifiedPatchRemovedLines: z.number().int().nonnegative(),
     unifiedPatchTruncated: z.boolean(),
-});
+}));
 /** Structured edit refusal, including its reason and affected path. */
-export const filesEditFailureSchema = z.strictObject({
+export const filesEditFailureSchema = z.lazy(() => z.strictObject({
     status: z.literal("failed"),
     error: z.strictObject({
         kind: z.enum([
@@ -122,7 +122,7 @@ export const filesEditFailureSchema = z.strictObject({
         path: pathSchema,
         message: z.string(),
     }),
-});
+}));
 /** Successful edit metadata or a typed edit refusal. */
 export const editOutputSchema = z.union([
     editSuccessSchema,

package/dist/index.js

@@ -9,21 +9,21 @@ const describeConcurrency = 8;
 const defaultDescribeTimeoutMillis = 10_000;
 const utf8 = new TextEncoder();
 const jsonValueSchema = z.json();
-const jsonSchemaDocument = z.custom((value) => jsonValueSchema.safeParse(value).success);
-const capabilityNameSchema = z
+const jsonSchemaDocument = z.lazy(() => z.custom((value) => jsonValueSchema.safeParse(value).success));
+const capabilityNameSchema = z.lazy(() => z
     .string()
     .min(1)
     .max(128)
-    .regex(/^[A-Za-z][A-Za-z0-9_]*$/);
-const capabilitySchema = z.strictObject({
+    .regex(/^[A-Za-z][A-Za-z0-9_]*$/));
+const capabilitySchema = z.lazy(() => z.strictObject({
     id: capabilityNameSchema,
     name: capabilityNameSchema,
     kind: z.string().min(1).max(128),
     description: z.string().min(1).max(2_048),
     parameters: jsonSchemaDocument,
     output: jsonSchemaDocument.optional(),
-});
-const capabilitiesSchema = z.array(capabilitySchema).max(maximumCapabilities);
+}));
+const capabilitiesSchema = z.lazy(() => z.array(capabilitySchema).max(maximumCapabilities));
 function operationSchema(document) {
     return z.fromJSONSchema(document).pipe(jsonValueSchema);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fungi.computer/knapsack",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "author": "Levi <levi@technomancy.dev>",
   "description": "Agent tool connections projected into Mycelium capability sources",
   "type": "module",
@@ -38,9 +38,9 @@
   ],
   "dependencies": {
     "@fungi.computer/cairn": "0.0.1",
-    "@fungi.computer/forage": "0.0.2",
+    "@fungi.computer/forage": "0.1.0",
     "@fungi.computer/mule": "0.0.2",
-    "@fungi.computer/mycelium": "0.0.2",
+    "@fungi.computer/mycelium": "0.1.0",
     "@modelcontextprotocol/client": "2.0.0",
     "diff": "8.0.4",
     "effect": "4.0.2",