@caplets/core 0.18.9 → 0.20.0

package/dist/generated-tool-input-schema.d.ts

@@ -1,20 +1,23 @@
 import { z } from "zod";
-export declare const operations: readonly ["inspect", "check_backend", "list_tools", "search_tools", "get_tool", "call_tool"];
-export declare const mcpOperations: readonly ["inspect", "check_backend", "list_tools", "search_tools", "get_tool", "call_tool", "list_resources", "search_resources", "list_resource_templates", "read_resource", "list_prompts", "search_prompts", "get_prompt", "complete"];
+export declare const operations: readonly ["inspect", "check", "tools", "search_tools", "describe_tool", "call_tool"];
+export declare const mcpOperations: readonly ["inspect", "check", "tools", "search_tools", "describe_tool", "call_tool", "resources", "search_resources", "resource_templates", "read_resource", "prompts", "search_prompts", "get_prompt", "complete"];
 export type GeneratedOperation = (typeof operations)[number];
 export type GeneratedMcpOperation = (typeof mcpOperations)[number];
 export type CapletSchemaBackend = {
     backend: string;
 };
+export type GeneratedToolInputSchemaOptions = {
+    includeFields?: boolean;
+};
 export declare const generatedToolInputDescriptions: {
-    readonly operation: "Wrapper operation: inspect, check_backend, list_tools, search_tools, get_tool, call_tool. MCP Caplets also expose resources, prompts, and completions.";
+    readonly operation: "Wrapper operation: inspect, check, tools, search_tools, describe_tool, call_tool, resources, search_resources, resource_templates, read_resource, prompts, search_prompts, get_prompt, complete.";
     readonly query: "Required for search operations only.";
     readonly limit: "Optional list/search result limit.";
-    readonly tool: "Exact downstream tool name for get_tool or call_tool.";
-    readonly arguments: "JSON object for call_tool arguments/downstream inputs or get_prompt arguments.";
-    readonly fields: "Optional call_tool structured output paths when outputSchema allows it.";
+    readonly cursor: "Opaque pagination cursor returned by list/search operations.";
+    readonly name: "Exact downstream tool or prompt name from tools/search_tools/prompts/search_prompts; do not guess.";
+    readonly args: "JSON object for call_tool/get_prompt arguments; use tools/search_tools arg hints when enough, otherwise describe_tool inputSchema.";
+    readonly fields: "Optional call_tool structured output paths. Use only after describe_tool returns fieldSelection.supported true.";
     readonly uri: "Exact downstream resource URI for read_resource.";
-    readonly prompt: "Exact downstream prompt name for get_prompt.";
     readonly ref: "Completion target reference for complete.";
     readonly argument: "Completion argument object for complete.";
 };
@@ -29,9 +32,8 @@ export declare const completionArgumentSchema: z.ZodObject<{
     name: z.ZodString;
     value: z.ZodString;
 }, z.core.$strict>;
-export declare function generatedToolInputSchemaForCaplet(caplet: CapletSchemaBackend): z.ZodObject<{
+export declare function generatedToolInputSchemaForCaplet(caplet: CapletSchemaBackend, options?: GeneratedToolInputSchemaOptions): z.ZodObject<{
     uri?: z.ZodOptional<z.ZodString>;
-    prompt?: z.ZodOptional<z.ZodString>;
     ref?: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         type: z.ZodLiteral<"prompt">;
         name: z.ZodString;
@@ -45,44 +47,68 @@ export declare function generatedToolInputSchemaForCaplet(caplet: CapletSchemaBa
     }, z.core.$strict>>;
     query: z.ZodOptional<z.ZodString>;
     limit: z.ZodOptional<z.ZodNumber>;
-    tool: z.ZodOptional<z.ZodString>;
-    arguments: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodAny>>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodAny>>>;
     fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     operation: z.ZodEnum<{
-        list_tools: "list_tools";
+        check: "check";
+        inspect: "inspect";
+        call_tool: "call_tool";
+        tools: "tools";
         search_tools: "search_tools";
-        get_tool: "get_tool";
-        check_backend: "check_backend";
+        describe_tool: "describe_tool";
+    }>;
+} | {
+    uri?: z.ZodOptional<z.ZodString>;
+    ref?: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"prompt">;
+        name: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"resourceTemplate">;
+        uri: z.ZodString;
+    }, z.core.$strict>]>>;
+    argument?: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strict>>;
+    query: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodAny>>>;
+    operation: z.ZodEnum<{
+        check: "check";
         inspect: "inspect";
         call_tool: "call_tool";
+        tools: "tools";
+        search_tools: "search_tools";
+        describe_tool: "describe_tool";
     }>;
 }, z.core.$strict>;
 export declare const generatedToolInputSchema: z.ZodObject<{
     query: z.ZodOptional<z.ZodString>;
     limit: z.ZodOptional<z.ZodNumber>;
-    tool: z.ZodOptional<z.ZodString>;
-    arguments: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodAny>>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodAny>>>;
     fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     operation: z.ZodEnum<{
-        list_tools: "list_tools";
-        search_tools: "search_tools";
-        get_tool: "get_tool";
-        check_backend: "check_backend";
+        check: "check";
         inspect: "inspect";
         call_tool: "call_tool";
+        tools: "tools";
+        search_tools: "search_tools";
+        describe_tool: "describe_tool";
     }>;
 }, z.core.$strict>;
-export declare function generatedToolInputJsonSchemaForCaplet(caplet: CapletSchemaBackend): {
+export declare function generatedToolInputJsonSchemaForCaplet(caplet: CapletSchemaBackend, options?: GeneratedToolInputSchemaOptions): {
     readonly type: "object";
     readonly properties: {
         readonly uri?: {
             type: string;
             description: "Exact downstream resource URI for read_resource.";
         };
-        readonly prompt?: {
-            type: string;
-            description: "Exact downstream prompt name for get_prompt.";
-        };
         readonly ref?: {
             oneOf: ({
                 type: string;
@@ -130,10 +156,19 @@ export declare function generatedToolInputJsonSchemaForCaplet(caplet: CapletSche
             additionalProperties: boolean;
             description: "Completion argument object for complete.";
         };
+        readonly fields?: {
+            type: string;
+            items: {
+                type: string;
+                minLength: number;
+            };
+            minItems: number;
+            description: "Optional call_tool structured output paths. Use only after describe_tool returns fieldSelection.supported true.";
+        };
         readonly operation: {
             readonly type: "string";
-            readonly enum: readonly ["inspect", "check_backend", "list_tools", "search_tools", "get_tool", "call_tool"] | readonly ["inspect", "check_backend", "list_tools", "search_tools", "get_tool", "call_tool", "list_resources", "search_resources", "list_resource_templates", "read_resource", "list_prompts", "search_prompts", "get_prompt", "complete"];
-            readonly description: "Wrapper operation: inspect, check_backend, list_tools, search_tools, get_tool, call_tool. MCP Caplets also expose resources, prompts, and completions.";
+            readonly enum: readonly ["inspect", "check", "tools", "search_tools", "describe_tool", "call_tool"] | readonly ["inspect", "check", "tools", "search_tools", "describe_tool", "call_tool", "resources", "search_resources", "resource_templates", "read_resource", "prompts", "search_prompts", "get_prompt", "complete"];
+            readonly description: "Wrapper operation: inspect, check, tools, search_tools, describe_tool, call_tool, resources, search_resources, resource_templates, read_resource, prompts, search_prompts, get_prompt, complete.";
         };
         readonly query: {
             readonly type: "string";
@@ -144,22 +179,17 @@ export declare function generatedToolInputJsonSchemaForCaplet(caplet: CapletSche
             readonly minimum: 1;
             readonly description: "Optional list/search result limit.";
         };
-        readonly tool: {
+        readonly cursor: {
             readonly type: "string";
-            readonly description: "Exact downstream tool name for get_tool or call_tool.";
+            readonly description: "Opaque pagination cursor returned by list/search operations.";
         };
-        readonly arguments: {
-            readonly type: "object";
-            readonly description: "JSON object for call_tool arguments/downstream inputs or get_prompt arguments.";
+        readonly name: {
+            readonly type: "string";
+            readonly description: "Exact downstream tool or prompt name from tools/search_tools/prompts/search_prompts; do not guess.";
         };
-        readonly fields: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-                readonly minLength: 1;
-            };
-            readonly minItems: 1;
-            readonly description: "Optional call_tool structured output paths when outputSchema allows it.";
+        readonly args: {
+            readonly type: "object";
+            readonly description: "JSON object for call_tool/get_prompt arguments; use tools/search_tools arg hints when enough, otherwise describe_tool inputSchema.";
         };
     };
     readonly required: readonly ["operation"];
@@ -172,10 +202,6 @@ export declare function generatedToolInputJsonSchema(): {
             type: string;
             description: "Exact downstream resource URI for read_resource.";
         };
-        readonly prompt?: {
-            type: string;
-            description: "Exact downstream prompt name for get_prompt.";
-        };
         readonly ref?: {
             oneOf: ({
                 type: string;
@@ -223,10 +249,19 @@ export declare function generatedToolInputJsonSchema(): {
             additionalProperties: boolean;
             description: "Completion argument object for complete.";
         };
+        readonly fields?: {
+            type: string;
+            items: {
+                type: string;
+                minLength: number;
+            };
+            minItems: number;
+            description: "Optional call_tool structured output paths. Use only after describe_tool returns fieldSelection.supported true.";
+        };
         readonly operation: {
             readonly type: "string";
-            readonly enum: readonly ["inspect", "check_backend", "list_tools", "search_tools", "get_tool", "call_tool"] | readonly ["inspect", "check_backend", "list_tools", "search_tools", "get_tool", "call_tool", "list_resources", "search_resources", "list_resource_templates", "read_resource", "list_prompts", "search_prompts", "get_prompt", "complete"];
-            readonly description: "Wrapper operation: inspect, check_backend, list_tools, search_tools, get_tool, call_tool. MCP Caplets also expose resources, prompts, and completions.";
+            readonly enum: readonly ["inspect", "check", "tools", "search_tools", "describe_tool", "call_tool"] | readonly ["inspect", "check", "tools", "search_tools", "describe_tool", "call_tool", "resources", "search_resources", "resource_templates", "read_resource", "prompts", "search_prompts", "get_prompt", "complete"];
+            readonly description: "Wrapper operation: inspect, check, tools, search_tools, describe_tool, call_tool, resources, search_resources, resource_templates, read_resource, prompts, search_prompts, get_prompt, complete.";
         };
         readonly query: {
             readonly type: "string";
@@ -237,22 +272,17 @@ export declare function generatedToolInputJsonSchema(): {
             readonly minimum: 1;
             readonly description: "Optional list/search result limit.";
         };
-        readonly tool: {
+        readonly cursor: {
             readonly type: "string";
-            readonly description: "Exact downstream tool name for get_tool or call_tool.";
+            readonly description: "Opaque pagination cursor returned by list/search operations.";
         };
-        readonly arguments: {
-            readonly type: "object";
-            readonly description: "JSON object for call_tool arguments/downstream inputs or get_prompt arguments.";
+        readonly name: {
+            readonly type: "string";
+            readonly description: "Exact downstream tool or prompt name from tools/search_tools/prompts/search_prompts; do not guess.";
         };
-        readonly fields: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-                readonly minLength: 1;
-            };
-            readonly minItems: 1;
-            readonly description: "Optional call_tool structured output paths when outputSchema allows it.";
+        readonly args: {
+            readonly type: "object";
+            readonly description: "JSON object for call_tool/get_prompt arguments; use tools/search_tools arg hints when enough, otherwise describe_tool inputSchema.";
         };
     };
     readonly required: readonly ["operation"];

package/dist/generated-tool-input-schema.js

@@ -1,2 +1,173 @@
-import { a as generatedToolInputJsonSchemaForCaplet, c as mcpOperations, i as generatedToolInputJsonSchema, l as operations, n as completionRefSchema, o as generatedToolInputSchema, r as generatedToolInputDescriptions, s as generatedToolInputSchemaForCaplet, t as completionArgumentSchema } from "./generated-tool-input-schema--kVuUNc5.js";
+import { a as any, d as literal, m as object, o as array, p as number, r as _enum, v as string, y as union } from "./schemas-BZ6BBrh7.js";
+//#region src/generated-tool-input-schema.ts
+const operations = [
+	"inspect",
+	"check",
+	"tools",
+	"search_tools",
+	"describe_tool",
+	"call_tool"
+];
+const mcpOperations = [
+	...operations,
+	"resources",
+	"search_resources",
+	"resource_templates",
+	"read_resource",
+	"prompts",
+	"search_prompts",
+	"get_prompt",
+	"complete"
+];
+const generatedToolInputDescriptions = {
+	operation: "Wrapper operation: inspect, check, tools, search_tools, describe_tool, call_tool, resources, search_resources, resource_templates, read_resource, prompts, search_prompts, get_prompt, complete.",
+	query: "Required for search operations only.",
+	limit: "Optional list/search result limit.",
+	cursor: "Opaque pagination cursor returned by list/search operations.",
+	name: "Exact downstream tool or prompt name from tools/search_tools/prompts/search_prompts; do not guess.",
+	args: "JSON object for call_tool/get_prompt arguments; use tools/search_tools arg hints when enough, otherwise describe_tool inputSchema.",
+	fields: "Optional call_tool structured output paths. Use only after describe_tool returns fieldSelection.supported true.",
+	uri: "Exact downstream resource URI for read_resource.",
+	ref: "Completion target reference for complete.",
+	argument: "Completion argument object for complete."
+};
+const completionRefSchema = union([object({
+	type: literal("prompt"),
+	name: string().min(1)
+}).strict(), object({
+	type: literal("resourceTemplate"),
+	uri: string().min(1)
+}).strict()]);
+const completionArgumentSchema = object({
+	name: string().min(1),
+	value: string()
+}).strict();
+const baseShape = {
+	query: string().optional().describe(generatedToolInputDescriptions.query),
+	limit: number().int().positive().optional().describe(generatedToolInputDescriptions.limit),
+	cursor: string().optional().describe(generatedToolInputDescriptions.cursor),
+	name: string().optional().describe(generatedToolInputDescriptions.name),
+	args: object({}).catchall(any()).optional().describe(generatedToolInputDescriptions.args),
+	fields: array(string().min(1)).min(1).optional().describe(generatedToolInputDescriptions.fields)
+};
+function generatedToolInputSchemaForCaplet(caplet, options = {}) {
+	const includeFields = options.includeFields ?? true;
+	return object({
+		operation: (caplet.backend === "mcp" ? _enum(mcpOperations) : _enum(operations)).describe(generatedToolInputDescriptions.operation),
+		...schemaShape(includeFields),
+		...caplet.backend === "mcp" ? {
+			uri: string().optional().describe(generatedToolInputDescriptions.uri),
+			ref: completionRefSchema.optional().describe(generatedToolInputDescriptions.ref),
+			argument: completionArgumentSchema.optional().describe(generatedToolInputDescriptions.argument)
+		} : {}
+	}).strict();
+}
+const generatedToolInputSchema = object({
+	operation: _enum(operations).describe(generatedToolInputDescriptions.operation),
+	...baseShape
+}).strict();
+function generatedToolInputJsonSchemaForCaplet(caplet, options = {}) {
+	const mcp = caplet.backend === "mcp";
+	const includeFields = options.includeFields ?? true;
+	return {
+		type: "object",
+		properties: {
+			operation: {
+				type: "string",
+				enum: mcp ? mcpOperations : operations,
+				description: generatedToolInputDescriptions.operation
+			},
+			query: {
+				type: "string",
+				description: generatedToolInputDescriptions.query
+			},
+			limit: {
+				type: "integer",
+				minimum: 1,
+				description: generatedToolInputDescriptions.limit
+			},
+			cursor: {
+				type: "string",
+				description: generatedToolInputDescriptions.cursor
+			},
+			name: {
+				type: "string",
+				description: generatedToolInputDescriptions.name
+			},
+			args: {
+				type: "object",
+				description: generatedToolInputDescriptions.args
+			},
+			...includeFields ? { fields: {
+				type: "array",
+				items: {
+					type: "string",
+					minLength: 1
+				},
+				minItems: 1,
+				description: generatedToolInputDescriptions.fields
+			} } : {},
+			...mcp ? {
+				uri: {
+					type: "string",
+					description: generatedToolInputDescriptions.uri
+				},
+				ref: {
+					oneOf: [{
+						type: "object",
+						properties: {
+							type: { const: "prompt" },
+							name: {
+								type: "string",
+								minLength: 1
+							}
+						},
+						required: ["type", "name"],
+						additionalProperties: false
+					}, {
+						type: "object",
+						properties: {
+							type: { const: "resourceTemplate" },
+							uri: {
+								type: "string",
+								minLength: 1
+							}
+						},
+						required: ["type", "uri"],
+						additionalProperties: false
+					}],
+					description: generatedToolInputDescriptions.ref
+				},
+				argument: {
+					type: "object",
+					properties: {
+						name: {
+							type: "string",
+							minLength: 1
+						},
+						value: { type: "string" }
+					},
+					required: ["name", "value"],
+					additionalProperties: false,
+					description: generatedToolInputDescriptions.argument
+				}
+			} : {}
+		},
+		required: ["operation"],
+		additionalProperties: false
+	};
+}
+function schemaShape(includeFields) {
+	return includeFields ? baseShape : {
+		query: baseShape.query,
+		limit: baseShape.limit,
+		cursor: baseShape.cursor,
+		name: baseShape.name,
+		args: baseShape.args
+	};
+}
+function generatedToolInputJsonSchema() {
+	return generatedToolInputJsonSchemaForCaplet({ backend: "tool" });
+}
+//#endregion
 export { completionArgumentSchema, completionRefSchema, generatedToolInputDescriptions, generatedToolInputJsonSchema, generatedToolInputJsonSchemaForCaplet, generatedToolInputSchema, generatedToolInputSchemaForCaplet, mcpOperations, operations };

package/dist/graphql.d.ts

@@ -1,6 +1,6 @@
 import type { CompatibilityCallToolResult, Tool } from "@modelcontextprotocol/sdk/types";
 import type { GraphQlEndpointConfig } from "./config";
-import type { CompactTool } from "./downstream";
+import { type CompactTool } from "./downstream";
 import type { ServerRegistry } from "./registry";
 export type { GraphQlEndpointConfig as GraphqlEndpointConfig } from "./config";
 export declare class GraphQLManager {

package/dist/http-actions.d.ts

@@ -1,6 +1,6 @@
 import type { CompatibilityCallToolResult, Tool } from "@modelcontextprotocol/sdk/types";
 import type { HttpApiConfig } from "./config";
-import type { CompactTool } from "./downstream";
+import { type CompactTool } from "./downstream";
 import type { ServerRegistry } from "./registry";
 export declare class HttpActionManager {
     private registry;

package/dist/index.d.ts

@@ -1,9 +1,57 @@
 export { CapletsRuntime } from "./runtime";
 export { runCli, createProgram } from "./cli";
 export { parseConfig, loadConfig } from "./config";
+export { BundleCapletSource, parseCapletSource } from "./caplet-source";
+export { FilesystemCapletSource } from "./caplet-source/filesystem";
+export { classifyCapletRuntimeRoute, planCapletRuntimeRoute, planCapletRuntimeRoutes, } from "./runtime-plan";
+export type { CapletSource, CapletSourceFile, CapletSourceParseMessage, CapletSourceParseResult, CapletSourceReference, ParsedCapletSourceCaplet, } from "./caplet-source";
+export type { CapletRuntimePlan, RuntimePlanDeployment, RuntimePlanOptions, RuntimeRouteKind, SetupTargetKind as RuntimePlanSetupTargetKind, } from "./runtime-plan";
 export { capabilityDescription, ServerRegistry } from "./registry";
 export { generatedToolInputSchema, handleServerTool } from "./tools";
+export type { CapletExecutionMetadata, CapletResultMetadata } from "./tools";
+export { createCodeModeCapletsApi, listCodeModeCallableCaplets } from "./code-mode/api";
+export type { CodeModeCapletHandle, CodeModeCapletsApi, CodeModeDebugApi, CreateCodeModeCapletsApiInput, } from "./code-mode/api";
+export { codeModeDeclarationHash, generateCodeModeDeclarations, generateCodeModeRunToolDescription, minifyCodeModeDeclarationText, } from "./code-mode/declarations";
+export { diagnoseCodeModeTypeScript } from "./code-mode/diagnostics";
+export type { DiagnoseCodeModeTypeScriptInput } from "./code-mode/diagnostics";
+export { CodeModeLogStore, redactCodeModeLogText } from "./code-mode/logs";
+export type { CodeModeLogStoreOptions, StoreCodeModeLogsResult } from "./code-mode/logs";
+export { FileObservedOutputShapeStore, observeOutputShape, observedOutputShapeKey, type ObservedOutputShape, type ObservedOutputShapeKey, type ObservedOutputShapeStore, } from "./observed-output-shapes";
+export { runCodeMode } from "./code-mode/runner";
+export type { RunCodeModeInput } from "./code-mode/runner";
+export { QuickJsCodeModeSandbox } from "./code-mode/sandbox";
+export type { CodeModeSandbox, CodeModeSandboxInput, CodeModeSandboxInvokeInput, CodeModeSandboxResult, } from "./code-mode/sandbox";
+export type { CodeModeCallableCaplet, CodeModeDeclarationInput, CodeModeDiagnostic, CodeModeLogs, CodeModeRunEnvelope, CodeModeRunError, CodeModeRunMeta, CodeModeTypesJson, JsonValue, ReadLogsInput, ReadLogsResult, ToolCallResult, } from "./code-mode/types";
+export type { CapletSetupCommandConfig, CapletSetupConfig } from "./config";
+export { capletSetupContentHash, stableJson } from "./setup/hash";
+export { LocalSetupStore } from "./setup/local-store";
+export { runCapletSetup } from "./setup/runner";
+export { CloudAuthClient } from "./cloud-auth/client";
+export { openBrowserUrl } from "./cloud-auth/open-url";
+export { CloudAuthStore, cloudAuthPath, migrateCredentials, redactedCloudAuthStatus, } from "./cloud-auth/store";
+export type { CloudAuthCredentials, CloudAuthStoreOptions } from "./cloud-auth/store";
+export type { CloudAuthLoginPollResult, CloudAuthLoginStart, CloudAuthScope, CloudAuthState, CloudAuthTokenResponse, CloudAuthWorkspace, RedactedCloudAuthStatus, } from "./cloud-auth/types";
+export type { SetupActor, SetupApproval, SetupAttempt, SetupAttemptStatus, SetupPlan, SetupTargetKind, } from "./setup/types";
 export { hasRenderableStructuredContent, markdownCallToolResultContent, markdownStructuredContent, } from "./result-content";
 export type { ResultMarkdownContext } from "./result-content";
 export { serveCaplets, serveHttp, serveResolvedCaplets, serveStdio } from "./serve";
 export type { HttpServeOptions, RawServeOptions, ServeOptions, StdioServeOptions } from "./serve";
+export { PROJECT_BINDING_STATES, PROJECT_BINDING_SYNC_STATES } from "./project-binding/types";
+export type { BindingTerminalReason, ProjectBindingLease, ProjectBindingSetupReceipt, ProjectBindingState, ProjectBindingSyncState, ProjectBindingWorkspaceMetadata, } from "./project-binding/types";
+export { PROJECT_BINDING_ERROR_CODES, ProjectBindingError, projectBindingError, projectBindingRecovery, } from "./project-binding/errors";
+export type { ProjectBindingErrorCode, ProjectBindingRecovery } from "./project-binding/errors";
+export { buildProjectSyncManifest } from "./project-binding/sync-filter";
+export type { ProjectSyncExclusionSource, ProjectSyncExclusionSummary, ProjectSyncManifest, ProjectSyncManifestFile, } from "./project-binding/sync-filter";
+export { DEFAULT_SYNC_LIMITS, enforceProjectSyncSizeLimits } from "./project-binding/sync-size";
+export type { ProjectSyncLimits, ProjectSyncSizeResult, ProjectSyncTier, } from "./project-binding/sync-size";
+export { PROJECT_BINDING_CONNECT_PATH, PROJECT_BINDINGS_CONTROL_PATH, projectBindingConnectPath, projectBindingConnectUrl, projectBindingStatusPath, projectBindingStatusUrl, } from "./project-binding/routes";
+export { attachProjectOnce, attachProjectSession, resolveAttachOptions, } from "./project-binding/attach";
+export type { AttachSessionEvent, RawAttachOptions, ResolvedAttachOptions, } from "./project-binding/attach";
+export { runProjectBindingSession } from "./project-binding/session";
+export type { ProjectBindingSessionEvent, ProjectBindingSocketClientMessage, ProjectBindingSocketServerMessage, RunProjectBindingSessionInput, } from "./project-binding/session";
+export { defaultProjectBindingWebSocketFactory } from "./project-binding/transport";
+export type { ProjectBindingWebSocket, ProjectBindingWebSocketFactory, } from "./project-binding/transport";
+export { ProjectBindingWorkspaceStore, projectBindingWorkspacePaths, projectBindingWorkspaceRoot, } from "./project-binding/workspaces";
+export type { EnsureProjectBindingWorkspaceInput, ProjectBindingCleanupResult, ProjectBindingWorkspacePaths, ProjectBindingWorkspaceRootOptions, ProjectBindingWorkspaceStoreOptions, } from "./project-binding/workspaces";
+export { ManagedMutagenProjectSync, mutagenProjectSyncDoctorData, mutagenSyncName, parseMutagenVersionOutput as parseManagedMutagenVersionOutput, planMutagenSyncCreateCommand, planMutagenSyncListCommand, planMutagenSyncTerminateCommand, planMutagenVersionCommand, } from "./project-binding/mutagen";
+export type { ManagedMutagenProjectSyncOptions, ManagedSyncDiagnosticCode, ManagedSyncState, ManagedSyncStateSnapshot, MutagenCommandPlan, MutagenLastCommandStatus, MutagenProcessResult, MutagenProcessRunner, MutagenProjectSyncBindingInput, MutagenProjectSyncDoctorData, StartMutagenProjectSyncInput, } from "./project-binding/mutagen";