hankweave 0.5.7 → 0.6.2

package/dist/utils.d.ts

@@ -0,0 +1,452 @@
+import WebSocket from "crossws/websocket";
+import { z } from "zod";
+import type { ClientCommand, FileNode, ServerEvent } from "./types/types.js";
+export { WebSocket };
+export declare function generateId(): string;
+export declare class Logger {
+    private logFile;
+    constructor(logFile: string);
+    log(message: string, level?: "info" | "error" | "debug"): void;
+    /**
+     * Log WebSocket traffic as JSONL (JSON Lines format).
+     * Each line is a complete JSON object representing a WebSocket message.
+     *
+     * @param socketLogFile - Path to the websocket log file
+     * @param direction - Whether this is an incoming or outgoing message
+     * @param data - The actual WebSocket message (ClientCommand or ServerEvent)
+     */
+    logWebSocketMessage(socketLogFile: string, direction: "in" | "out", data: ClientCommand | ServerEvent): void;
+    /**
+     * @deprecated Use logWebSocketMessage instead
+     */
+    logSocketTraffic(socketLogFile: string, direction: "in" | "out", data: unknown): void;
+}
+/**
+ * Build a hierarchical file tree from files matching a pattern.
+ *
+ * Creates a tree structure suitable for UI display, with directories
+ * as nodes containing their children. Used for filetree.updated events.
+ * Includes last modified times for files.
+ *
+ * @param projectPath - Base directory
+ * @param pattern - Glob pattern to match files
+ * @returns Root nodes of the file tree
+ */
+export declare function buildFileTree(projectPath: string, pattern: string): Promise<FileNode[]>;
+/**
+ * Escape a string for safe use in shell commands.
+ * Replaces single quotes with '\'' and wraps in single quotes.
+ */
+export declare function escapeShellArg(arg: string): string;
+/**
+ * Supported JavaScript runtimes.
+ */
+export type Runtime = "bun" | "node" | "deno";
+/**
+ * Detect the current JavaScript runtime.
+ * Uses global object inspection following the crossws pattern.
+ *
+ * @returns The detected runtime ('bun', 'deno', or 'node')
+ */
+export declare function detectRuntime(): Runtime;
+/**
+ * Get the current runtime name and version as a string.
+ * e.g. "bun 1.2.0", "node 22.0.0", "deno 2.1.0"
+ */
+export declare function getRuntimeVersion(): string;
+/**
+ * Detects if we're running from a compiled Bun executable.
+ *
+ * When compiled, Bun puts files in a virtual filesystem at:
+ * - On Unix: /$bunfs/root/...
+ * - On Windows: X:/~BUN/root/... (drive letter varies)
+ *
+ * @returns true if running from a compiled executable, false otherwise
+ */
+export declare function isCompiledExecutable(): boolean;
+/**
+ * Schema for application metadata.
+ * This is embedded in compiled executables and used to track version info.
+ */
+export declare const metadataSchema: z.ZodObject<{
+    version: z.ZodString;
+    buildDate: z.ZodOptional<z.ZodString>;
+    buildTarget: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    buildDate?: string | undefined;
+    buildTarget?: string | undefined;
+}, {
+    version: string;
+    buildDate?: string | undefined;
+    buildTarget?: string | undefined;
+}>;
+export type Metadata = z.infer<typeof metadataSchema>;
+/**
+ * Metadata class for managing application metadata.
+ * Supports serialization/deserialization and validation via Zod.
+ */
+export declare class AppMetadata {
+    private data;
+    private constructor();
+    /**
+     * Create metadata from object (validates with Zod schema)
+     */
+    static create(data: unknown): AppMetadata;
+    /**
+     * Deserialize metadata from JSON string
+     */
+    static deserialize(json: string): AppMetadata;
+    /**
+     * Serialize metadata to JSON string
+     */
+    serialize(): string;
+    /**
+     * Get the version string
+     */
+    get version(): string;
+    /**
+     * Get the build date (if available)
+     */
+    get buildDate(): string | undefined;
+    /**
+     * Get the build target (if available)
+     */
+    get buildTarget(): string | undefined;
+    /**
+     * Get raw metadata object
+     */
+    toObject(): Metadata;
+}
+/**
+ * Get application metadata (version, build info, etc.).
+ * Works in both development (reads from filesystem) and compiled executable
+ * (uses build-time constants) contexts.
+ *
+ * In compiled mode: Uses BUILD_VERSION, BUILD_DATE, BUILD_TARGET constants
+ * In dev mode: Reads from package.json
+ *
+ * @returns AppMetadata instance, or metadata with fallback version
+ */
+export declare function getMetadata(): AppMetadata;
+/**
+ * Render the startup banner box with version and platform info.
+ * Matches the style of the codon structure boxes.
+ */
+export declare function renderStartupBanner(): void;
+/**
+ * Shorten a path by replacing the home directory with ~
+ */
+export declare function shortenPath(fullPath: string): string;
+export interface StartupInfo {
+    executionId: string;
+    isResuming: boolean;
+    sourcePath: string;
+    executionPath: string;
+    linkType: string;
+    sdks: Array<{
+        name: string;
+        version: string;
+        cached: boolean;
+    }>;
+}
+/**
+ * Render the execution info section after the startup banner.
+ */
+export declare function renderStartupInfo(info: StartupInfo): void;
+/**
+ * Get the appropriate command array to run a script in the current runtime.
+ * This ensures shims and other scripts are executed with the correct runtime.
+ *
+ * For compiled executables, we check if 'bun' is available on PATH and use it
+ * if present (for better performance), otherwise fall back to 'node'.
+ * This ensures standalone executables work on systems without Bun installed.
+ *
+ * @param scriptPath - Path to the script to execute
+ * @returns Command array suitable for spawn/exec (e.g., ['bun', scriptPath])
+ *
+ * @example
+ * ```ts
+ * // In Bun (source): ['bun', '/path/to/shim.mjs']
+ * // In compiled executable with bun on PATH: ['bun', '/path/to/shim.mjs']
+ * // In compiled executable without bun: ['node', '/path/to/shim.mjs']
+ * // In Node: ['node', '/path/to/shim.mjs']
+ * // In Deno: ['deno', 'run', '--allow-all', '/path/to/shim.mjs']
+ * const cmd = getRuntimeCommand('/path/to/shim.mjs');
+ * spawn(cmd[0], cmd.slice(1), options);
+ * ```
+ */
+export declare function getRuntimeCommand(scriptPath: string): string[];
+/**
+ * Type guard to check if a value is an Error instance.
+ */
+export declare function isError(error: unknown): error is Error;
+/**
+ * Convert any value to an Error instance.
+ * If already an Error, returns it unchanged.
+ * Otherwise creates a new Error with string representation.
+ */
+export declare function toError(error: unknown): Error;
+/**
+ * Helper type to check if two types are exactly equal at compile time.
+ * Returns `true` if the types match, `never` if they don't.
+ *
+ * Use this to enforce type constraints that must be validated at compile time.
+ *
+ * @example
+ * // Ensure all event types are categorized
+ * const _check: AssertEqual<EventType, CategoryA | CategoryB> = true;
+ */
+export type AssertEqual<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : never;
+/**
+ * Exhaustive checking helper for switch statements.
+ * Use this in the default case to ensure all union cases are handled.
+ * TypeScript will error if a case is missing.
+ */
+export declare function assertNever(x: never): never;
+export declare class IdleTimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+/**
+ * Wraps an async iterable with an idle timeout. If no event is received
+ * within `timeoutMs` milliseconds, throws an `IdleTimeoutError`.
+ *
+ * The timer resets on each received event, so long-running operations
+ * that produce regular events will not be interrupted.
+ */
+export declare function withIdleTimeout<T>(events: AsyncIterable<T>, timeoutMs: number): AsyncGenerator<T>;
+/**
+ * Calculate the total size of a directory recursively.
+ * Includes a timeout to prevent hanging on large directories.
+ */
+export declare function getDirectorySize(dirPath: string, timeoutMs?: number): Promise<number>;
+/**
+ * Format a byte size into a human-readable string.
+ */
+export declare function formatSize(bytes: number): string;
+/**
+ * Generate a non-conflicting filename by adding a numbered suffix with timestamp.
+ * Format: file_<counter>_<timestamp>.txt (e.g., report_1_1738678800.txt)
+ *
+ * @param destPath - The desired destination path
+ * @returns Object with resolved path and conflict info
+ * @throws Error if more than MAX_CONFLICT_COPIES exist (prevents runaway loops)
+ */
+export declare function resolveFileConflict(destPath: string): Promise<{
+    resolvedPath: string;
+    hadConflict: boolean;
+    conflictNumber?: number;
+    timestamp?: number;
+}>;
+/**
+ * Copy files from a source directory to a destination directory using glob patterns.
+ *
+ * This function uses fast-glob directly to resolve file patterns without respecting
+ * .gitignore rules (unlike UnifiedFileResolver), ensuring all matching files are copied regardless of git ignore status.
+ *
+ * @param sourceDirectory - The source directory path from which to copy files
+ * @param filesToCopy - Array of glob patterns to match files for copying (e.g., `["*.txt"]`)
+ * @param destinationDirectory - The destination directory path where files will be copied
+ * @param logger - Logger instance for debug and info messages
+ * @param options - Optional settings
+ * @param options.overwrite - When true, overwrite existing files instead of renaming
+ * @returns Promise with conflicts array listing any files that were renamed
+ */
+export declare function copyFiles(sourceDirectory: string, filesToCopy: string[], destinationDirectory: string, logger: Logger, options?: {
+    overwrite?: boolean;
+}): Promise<{
+    conflicts: Array<{
+        original: string;
+        resolved: string;
+    }>;
+}>;
+/**
+ * Deep merge multiple objects with proper handling of nested structures.
+ *
+ * Uses lodash.merge for deep merging. Note that arrays are merged by index
+ * (not replaced entirely).
+ *
+ * Merging rules:
+ * - Plain objects are merged recursively
+ * - Arrays are merged by index (e.g., [1,2,3] + [4,5] = [4,5,3])
+ * - Primitives (string, number, boolean, null) are replaced
+ * - Later sources take precedence over earlier ones
+ *
+ * @param sources - Objects to merge, in priority order (later = higher priority)
+ * @returns Merged object with all properties from all sources
+ *
+ * @example
+ * const defaults = { port: 8080, sentinel: { enabled: true, timeout: 1000 } };
+ * const userConfig = { port: 3000, sentinel: { timeout: 5000 } };
+ * const merged = deepMerge(defaults, userConfig);
+ * // Result: { port: 3000, sentinel: { enabled: true, timeout: 5000 } }
+ */
+export declare function deepMerge<T extends Record<string, unknown>>(...sources: Array<T | undefined>): T;
+/**
+ * Rename file with retry logic for Windows file locking issues.
+ *
+ * On Windows, EPERM/EBUSY errors can occur transiently due to:
+ * - Antivirus scanning (Windows Defender in CI environments)
+ * - File handles not fully released after previous operations
+ * - Windows filesystem timing differences vs Unix
+ *
+ * This implements exponential backoff retry to handle these transient locks.
+ *
+ * @param source - Source file path
+ * @param target - Target file path
+ * @param options - Retry configuration options
+ * @param options.maxRetries - Maximum number of retry attempts (default: 5)
+ * @param options.initialDelay - Initial delay in milliseconds (default: 10ms)
+ * @param options.logger - Optional logger for debugging retry attempts
+ * @returns Promise that resolves when rename succeeds
+ * @throws Error if rename fails after all retries or encounters non-retryable error
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * await renameWithRetry('temp.json', 'state.json');
+ *
+ * // With custom retry settings and logging
+ * await renameWithRetry('temp.json', 'state.json', {
+ *   maxRetries: 10,
+ *   initialDelay: 20,
+ *   logger: myLogger
+ * });
+ * ```
+ */
+export declare function renameWithRetry(source: string, target: string, options?: {
+    maxRetries?: number;
+    initialDelay?: number;
+    logger?: Logger;
+}): Promise<void>;
+/**
+ * Synchronous version of renameWithRetry for use in synchronous contexts.
+ *
+ * Same behavior as renameWithRetry but uses synchronous fs operations.
+ * Useful for scenarios where async/await cannot be used.
+ *
+ * @param source - Source file path
+ * @param target - Target file path
+ * @param options - Retry configuration options
+ * @param options.maxRetries - Maximum number of retry attempts (default: 5)
+ * @param options.initialDelay - Initial delay in milliseconds (default: 10ms)
+ * @param options.logger - Optional logger for debugging retry attempts
+ * @throws Error if rename fails after all retries or encounters non-retryable error
+ *
+ * @example
+ * ```ts
+ * renameWithRetrySync('temp.json', 'state.json');
+ * ```
+ */
+export declare function renameWithRetrySync(source: string, target: string, options?: {
+    maxRetries?: number;
+    initialDelay?: number;
+    logger?: Logger;
+}): void;
+/**
+ * Synchronous directory/file removal with retry logic for Windows file locking issues.
+ *
+ * On Windows, file handles can take time to release after process termination,
+ * causing EBUSY/EPERM errors when trying to delete directories. This function
+ * retries the operation with exponential backoff to handle these transient errors.
+ *
+ * @param targetPath - Path to file or directory to remove
+ * @param options - Removal and retry configuration options
+ * @param options.recursive - Allow recursive removal of directories (default: false)
+ * @param options.force - Continue even if path doesn't exist (default: false)
+ * @param options.maxRetries - Maximum number of retry attempts (default: 5)
+ * @param options.initialDelay - Initial delay in milliseconds (default: 10ms)
+ * @param options.logger - Optional logger for debugging retry attempts
+ * @throws Error if removal fails after all retries or encounters non-retryable error
+ *
+ * @example
+ * ```ts
+ * rmSyncWithRetry(tempDir, { recursive: true, force: true, logger });
+ * ```
+ */
+export declare function rmSyncWithRetry(targetPath: string, options?: {
+    recursive?: boolean;
+    force?: boolean;
+    maxRetries?: number;
+    initialDelay?: number;
+    logger?: Logger;
+}): void;
+/**
+ * Abstraction over server instances providing a common interface.
+ * This allows the codebase to be runtime-agnostic.
+ */
+export interface HankweaveServer {
+    /** Stop the server and clean up resources */
+    stop(): void;
+    /** The actual port the server is listening on (may differ from configured port if 0 was specified) */
+    readonly port: number;
+}
+/**
+ * Runtime-agnostic WebSocket interface.
+ * Provides a common interface that works across Bun, Node.js, and other runtimes.
+ */
+export interface HankweaveWebSocket<T = unknown> {
+    /** Custom data attached to this WebSocket connection */
+    data: T;
+    /** Send a message to the client */
+    send(message: string | Buffer): void;
+    /** Close the WebSocket connection */
+    close(code?: number, reason?: string): void;
+}
+/**
+ * Configuration options for creating an HTTP or WebSocket server.
+ * Provides a runtime-agnostic interface for both HTTP and WebSocket servers.
+ *
+ * The generic type T represents the WebSocket connection data type.
+ */
+export interface ServeOptions<T = unknown> {
+    /** Port number to listen on */
+    port: number;
+    /** Idle timeout in seconds (optional, only for HTTP servers) */
+    idleTimeout?: number;
+    /** HTTP request handler (required for HTTP servers) */
+    fetch?: (request: Request, server?: unknown) => Response | Promise<Response> | undefined;
+    /** WebSocket handlers (required for WebSocket servers) */
+    websocket?: {
+        /**
+         * Called before upgrading to WebSocket.
+         * Return context data to attach to the connection.
+         */
+        upgrade?: (request: Request) => T | Promise<T>;
+        /** Called when a WebSocket connection is opened */
+        open?: (ws: HankweaveWebSocket<T>) => void;
+        /** Called when a message is received on the WebSocket */
+        message?: (ws: HankweaveWebSocket<T>, message: string | Buffer) => void;
+        /** Called when a WebSocket connection is closed */
+        close?: (ws: HankweaveWebSocket<T>) => void;
+    };
+}
+/**
+ * Create an HTTP or WebSocket server using crossws.
+ *
+ * This provides a runtime-agnostic interface that works with Bun, Node.js, Deno,
+ * and other runtimes via the crossws library.
+ *
+ * @param options - Server configuration options
+ * @returns Server instance with stop() method
+ *
+ * @example
+ * // HTTP server
+ * const server = serve({
+ *   port: 3000,
+ *   fetch: async (req) => new Response("Hello"),
+ * });
+ *
+ * @example
+ * // WebSocket server
+ * const server = serve({
+ *   port: 8080,
+ *   websocket: {
+ *     open: (ws) => console.log("connected"),
+ *     message: (ws, msg) => console.log(msg),
+ *   },
+ *   fetch: (req, server) => server.upgrade(req),
+ * });
+ */
+export declare function serve<T = unknown>(options: ServeOptions<T>): HankweaveServer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hankweave",
-  "version": "0.5.7",
+  "version": "0.6.2",
   "description": "Orchestration runtime for antibrittle agentic workflows",
   "author": {
     "name": "Southbridge AI",
@@ -18,9 +18,21 @@
     "hankweave": "dist/index.js"
   },
   "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./schemas": {
+      "types": "./dist/exports/schemas.d.ts",
+      "import": "./dist/exports/schemas.js",
+      "default": "./dist/exports/schemas.js"
+    },
+    "./types": {
+      "types": "./dist/exports/types.d.ts",
+      "import": "./dist/exports/types.js",
+      "default": "./dist/exports/types.js"
+    }
+  },
   "files": [
     "dist",
-    "shims",
     "schemas"
   ],
   "engines": {
@@ -54,6 +66,7 @@
     "cleanup": "echo 'Error: --cleanup requires --config' && exit 1",
     "cleanup:example": "bun server/index.ts --cleanup --config=hank.json",
     "cleanup:force": "bun server/index.ts --cleanup --config=hank.json -y",
+    "test:shims": "bun scripts/test-shims.ts",
     "test:cross-runtime:bun": "bun scripts/run-cross-runtime-tests.ts bun",
     "test:cross-runtime:node": "bun scripts/run-cross-runtime-tests.ts node",
     "test:cross-runtime:deno": "bun scripts/run-cross-runtime-tests.ts deno",

package/schemas/hank.schema.json

@@ -76,8 +76,51 @@
             "shimIdleTimeout": {
               "type": "integer",
               "exclusiveMinimum": 0,
-              "maximum": 600,
+              "maximum": 1800,
               "description": "Default shim idle timeout for all codons in this hank (seconds)"
+            },
+            "budget": {
+              "type": "object",
+              "properties": {
+                "maxDollars": {
+                  "type": "number",
+                  "exclusiveMinimum": 0,
+                  "description": "Total cost budget in USD."
+                },
+                "maxTimeSeconds": {
+                  "type": "number",
+                  "exclusiveMinimum": 0,
+                  "description": "Wall-clock time limit in seconds."
+                },
+                "allocation": {
+                  "type": "string",
+                  "enum": [
+                    "shared",
+                    "proportional",
+                    "proportional-strict"
+                  ],
+                  "default": "shared",
+                  "description": "How the dollar budget is distributed among children. 'shared': first-past-the-post (default). 'proportional': pre-allocate shares, unspent flows back. 'proportional-strict': pre-allocate shares, unspent evaporates."
+                },
+                "shares": {
+                  "type": "object",
+                  "additionalProperties": {
+                    "type": "number",
+                    "exclusiveMinimum": 0,
+                    "maximum": 1
+                  },
+                  "description": "Map of child codon/loop ID to fraction (0-1) of the budget."
+                },
+                "onExceeded": {
+                  "type": "string",
+                  "enum": [
+                    "complete",
+                    "fail"
+                  ],
+                  "description": "What happens when budget is exceeded. 'complete' = graceful completion (default). 'fail' = codon failure, triggers onFailure policy."
+                }
+              },
+              "additionalProperties": false
             }
           },
           "additionalProperties": false,
@@ -1098,8 +1141,42 @@
                   "shimIdleTimeout": {
                     "type": "integer",
                     "exclusiveMinimum": 0,
-                    "maximum": 600,
+                    "maximum": 1800,
                     "description": "Max seconds between agent events before the shim aborts (idle timeout). Overrides hank-level and runtime defaults. If unset, falls back to hank override, runtime config, or shim default (120s)."
+                  },
+                  "budget": {
+                    "type": "object",
+                    "properties": {
+                      "maxDollars": {
+                        "type": "number",
+                        "exclusiveMinimum": 0,
+                        "description": "Max cost in USD. Execution stopped when exceeded."
+                      },
+                      "maxTimeSeconds": {
+                        "type": "number",
+                        "exclusiveMinimum": 0,
+                        "description": "Max wall-clock time in seconds."
+                      },
+                      "maxOutputTokens": {
+                        "type": "integer",
+                        "exclusiveMinimum": 0,
+                        "description": "Max output tokens."
+                      },
+                      "maxContextTokens": {
+                        "type": "integer",
+                        "exclusiveMinimum": 0,
+                        "description": "Max context window tokens (high-water mark of input+output per turn). Useful for capping context growth independent of cost."
+                      },
+                      "onExceeded": {
+                        "type": "string",
+                        "enum": [
+                          "complete",
+                          "fail"
+                        ],
+                        "description": "Override hank-level onExceeded for this codon."
+                      }
+                    },
+                    "additionalProperties": false
                   }
                 },
                 "required": [
@@ -2181,8 +2258,42 @@
                         "shimIdleTimeout": {
                           "type": "integer",
                           "exclusiveMinimum": 0,
-                          "maximum": 600,
+                          "maximum": 1800,
                           "description": "Max seconds between agent events before the shim aborts (idle timeout). Overrides hank-level and runtime defaults. If unset, falls back to hank override, runtime config, or shim default (120s)."
+                        },
+                        "budget": {
+                          "type": "object",
+                          "properties": {
+                            "maxDollars": {
+                              "type": "number",
+                              "exclusiveMinimum": 0,
+                              "description": "Max cost in USD. Execution stopped when exceeded."
+                            },
+                            "maxTimeSeconds": {
+                              "type": "number",
+                              "exclusiveMinimum": 0,
+                              "description": "Max wall-clock time in seconds."
+                            },
+                            "maxOutputTokens": {
+                              "type": "integer",
+                              "exclusiveMinimum": 0,
+                              "description": "Max output tokens."
+                            },
+                            "maxContextTokens": {
+                              "type": "integer",
+                              "exclusiveMinimum": 0,
+                              "description": "Max context window tokens (high-water mark of input+output per turn). Useful for capping context growth independent of cost."
+                            },
+                            "onExceeded": {
+                              "type": "string",
+                              "enum": [
+                                "complete",
+                                "fail"
+                              ],
+                              "description": "Override hank-level onExceeded for this codon."
+                            }
+                          },
+                          "additionalProperties": false
                         }
                       },
                       "required": [
@@ -2196,6 +2307,50 @@
                     "minItems": 1,
                     "description": "Array of codons to execute in each iteration"
                   },
+                  "budget": {
+                    "type": "object",
+                    "properties": {
+                      "maxDollars": {
+                        "type": "number",
+                        "exclusiveMinimum": 0,
+                        "description": "Total cost budget in USD."
+                      },
+                      "maxTimeSeconds": {
+                        "type": "number",
+                        "exclusiveMinimum": 0,
+                        "description": "Wall-clock time limit in seconds."
+                      },
+                      "allocation": {
+                        "type": "string",
+                        "enum": [
+                          "shared",
+                          "proportional",
+                          "proportional-strict"
+                        ],
+                        "default": "shared",
+                        "description": "How the dollar budget is distributed among children. 'shared': first-past-the-post (default). 'proportional': pre-allocate shares, unspent flows back. 'proportional-strict': pre-allocate shares, unspent evaporates."
+                      },
+                      "shares": {
+                        "type": "object",
+                        "additionalProperties": {
+                          "type": "number",
+                          "exclusiveMinimum": 0,
+                          "maximum": 1
+                        },
+                        "description": "Map of child codon/loop ID to fraction (0-1) of the budget."
+                      },
+                      "onExceeded": {
+                        "type": "string",
+                        "enum": [
+                          "complete",
+                          "fail"
+                        ],
+                        "description": "What happens when budget is exceeded. 'complete' = graceful completion (default). 'fail' = codon failure, triggers onFailure policy."
+                      }
+                    },
+                    "additionalProperties": false,
+                    "description": "Budget scope for this loop."
+                  },
                   "archiveOnSuccess": {
                     "type": "array",
                     "items": {