langchain 1.2.35 → 1.3.0-dev-1773962633795

package/dist/tools/headless.d.ts

@@ -0,0 +1,122 @@
+import { DynamicStructuredTool, tool } from "@langchain/core/tools";
+import { InferInteropZodInput, InferInteropZodOutput, InteropZodObject } from "@langchain/core/utils/types";
+
+//#region src/tools/headless.d.ts
+/**
+ * Configuration fields for creating a headless tool.
+ */
+type HeadlessToolFields<SchemaT extends InteropZodObject, NameT extends string = string> = {
+  /** The name of the tool. Used by the client to match implementations. */name: NameT; /** Description of what the tool does. */
+  description: string; /** The Zod schema defining the tool's input. */
+  schema: SchemaT;
+};
+/**
+ * A tool implementation that pairs a headless tool with its execution function.
+ *
+ * Created by calling `.implement()` on a {@link HeadlessTool}.
+ * Pass to `useStream({ tools: [...] })` on the client side.
+ */
+type HeadlessToolImplementation<SchemaT extends InteropZodObject = InteropZodObject, OutputT = unknown, NameT extends string = string> = {
+  tool: HeadlessTool<SchemaT, NameT>;
+  execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;
+};
+/**
+ * A headless tool that always interrupts agent execution on the server.
+ *
+ * The implementation is provided separately on the client via
+ * `useStream({ tools: [...] })` using `.implement()`.
+ */
+type HeadlessTool<SchemaT extends InteropZodObject = InteropZodObject, NameT extends string = string> = DynamicStructuredTool<SchemaT, InferInteropZodOutput<SchemaT>, InferInteropZodInput<SchemaT>, unknown, unknown, NameT> & {
+  /**
+   * Pairs this headless tool with a client-side implementation.
+   *
+   * The returned object should be passed to `useStream({ tools: [...] })`.
+   * The SDK matches the implementation to the tool by name and calls
+   * `execute` with the typed arguments from the interrupt payload.
+   *
+   * @param execute - The function that implements the tool on the client
+   */
+  implement: <OutputT>(execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>) => HeadlessToolImplementation<SchemaT, OutputT, NameT>;
+};
+/**
+ * The headless overload signature added to the core `tool` function.
+ *
+ * When called **without** an implementation function — just `tool({ name, description, schema })` —
+ * returns a {@link HeadlessTool} that interrupts on every agent invocation.
+ * The client provides the implementation via `useStream({ tools: [...] })`.
+ */
+type HeadlessToolOverload = {
+  <SchemaT extends InteropZodObject, NameT extends string>(fields: HeadlessToolFields<SchemaT, NameT>): HeadlessTool<SchemaT, NameT>;
+};
+/**
+ * Unified tool primitive for LangChain agents.
+ *
+ * Enhances the `tool` function from `@langchain/core/tools` with a headless
+ * overload: when called **without** an implementation function, the tool
+ * interrupts agent execution and lets the client supply the implementation.
+ *
+ * ---
+ *
+ * **Normal tool** — pass an implementation function as the first argument:
+ *
+ * ```typescript
+ * import { tool } from "langchain/tools";
+ * import { z } from "zod";
+ *
+ * const getWeather = tool(
+ *   async ({ city }) => `The weather in ${city} is sunny.`,
+ *   {
+ *     name: "get_weather",
+ *     description: "Get the weather for a city",
+ *     schema: z.object({ city: z.string() }),
+ *   }
+ * );
+ * ```
+ *
+ * ---
+ *
+ * **Headless tool** — omit the implementation; the client provides it later:
+ *
+ * ```typescript
+ * import { tool } from "langchain/tools";
+ * import { z } from "zod";
+ *
+ * // Server: define the tool shape — no implementation needed
+ * export const getLocation = tool({
+ *   name: "get_location",
+ *   description: "Get the user's current GPS location",
+ *   schema: z.object({
+ *     highAccuracy: z.boolean().optional().describe("Request high accuracy GPS"),
+ *   }),
+ * });
+ *
+ * // Server: register with the agent
+ * const agent = createAgent({
+ *   model: "openai:gpt-4o",
+ *   tools: [getLocation],
+ * });
+ *
+ * // Client: provide the implementation in useStream
+ * const stream = useStream({
+ *   assistantId: "agent",
+ *   tools: [
+ *     getLocation.implement(async ({ highAccuracy }) => {
+ *       return new Promise((resolve, reject) => {
+ *         navigator.geolocation.getCurrentPosition(
+ *           (pos) => resolve({
+ *             latitude: pos.coords.latitude,
+ *             longitude: pos.coords.longitude,
+ *           }),
+ *           (err) => reject(new Error(err.message)),
+ *           { enableHighAccuracy: highAccuracy }
+ *         );
+ *       });
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+declare const tool$1: HeadlessToolOverload & typeof tool;
+//#endregion
+export { HeadlessTool, HeadlessToolFields, HeadlessToolImplementation, tool$1 as tool };
+//# sourceMappingURL=headless.d.ts.map

package/dist/tools/headless.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headless.d.ts","names":[],"sources":["../../src/tools/headless.ts"],"mappings":";;;;;;;KAyBY,kBAAA,iBACM,gBAAA;EAIV,yEAAN,IAAA,EAAM,KAAA,EAIN;EAFA,WAAA,UAEe;EAAf,MAAA,EAAQ,OAAA;AAAA;;;;;;;KASE,0BAAA,iBACM,gBAAA,GAAmB,gBAAA;EAInC,IAAA,EAAM,YAAA,CAAa,OAAA,EAAS,KAAA;EAC5B,OAAA,GAAU,IAAA,EAAM,qBAAA,CAAsB,OAAA,MAAa,OAAA,CAAQ,OAAA;AAAA;;;;;;;KASjD,YAAA,iBACM,gBAAA,GAAmB,gBAAA,mCAEjC,qBAAA,CACF,OAAA,EACA,qBAAA,CAAsB,OAAA,GACtB,oBAAA,CAAqB,OAAA,qBAGrB,KAAA;EArBA;;;;;;;;;EAgCA,SAAA,YACE,OAAA,GAAU,IAAA,EAAM,qBAAA,CAAsB,OAAA,MAAa,OAAA,CAAQ,OAAA,MACxD,0BAAA,CAA2B,OAAA,EAAS,OAAA,EAAS,KAAA;AAAA;;;AAtBpD;;;;;KA8EK,oBAAA;EAAA,iBACc,gBAAA,wBACf,MAAA,EAAQ,kBAAA,CAAmB,OAAA,EAAS,KAAA,IACnC,YAAA,CAAa,OAAA,EAAS,KAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA1DzB;;;;;;;;;;;;;;;;;;;;;;;;AAiIF;;;;;cAAa,MAAA,EAAM,oBAAA,UAA8B,IAAA"}

package/dist/tools/headless.js

@@ -0,0 +1,112 @@
+import { tool } from "@langchain/core/tools";
+//#region src/tools/headless.ts
+/**
+* Unified Tool Primitive for LangChain Agents
+*
+* This module re-exports the `tool` primitive from `@langchain/core/tools` with
+* an additional overload: when called without an implementation function, it
+* creates a **headless tool** that interrupts agent execution and delegates the
+* implementation to the client (e.g. via `useStream({ tools: [...] })`).
+*
+* @module
+*/
+function createHeadlessTool(fields) {
+	const { name, description, schema } = fields;
+	const wrappedTool = tool(async (args, config) => {
+		const { interrupt } = await import("@langchain/langgraph");
+		return interrupt({
+			type: "tool",
+			toolCall: {
+				id: config?.toolCall?.id,
+				name,
+				args
+			}
+		});
+	}, {
+		name,
+		description,
+		schema,
+		metadata: { headlessTool: true }
+	});
+	const headlessTool = Object.assign(wrappedTool, { implement: (execute) => ({
+		tool: headlessTool,
+		execute
+	}) });
+	return headlessTool;
+}
+/**
+* Unified tool primitive for LangChain agents.
+*
+* Enhances the `tool` function from `@langchain/core/tools` with a headless
+* overload: when called **without** an implementation function, the tool
+* interrupts agent execution and lets the client supply the implementation.
+*
+* ---
+*
+* **Normal tool** — pass an implementation function as the first argument:
+*
+* ```typescript
+* import { tool } from "langchain/tools";
+* import { z } from "zod";
+*
+* const getWeather = tool(
+*   async ({ city }) => `The weather in ${city} is sunny.`,
+*   {
+*     name: "get_weather",
+*     description: "Get the weather for a city",
+*     schema: z.object({ city: z.string() }),
+*   }
+* );
+* ```
+*
+* ---
+*
+* **Headless tool** — omit the implementation; the client provides it later:
+*
+* ```typescript
+* import { tool } from "langchain/tools";
+* import { z } from "zod";
+*
+* // Server: define the tool shape — no implementation needed
+* export const getLocation = tool({
+*   name: "get_location",
+*   description: "Get the user's current GPS location",
+*   schema: z.object({
+*     highAccuracy: z.boolean().optional().describe("Request high accuracy GPS"),
+*   }),
+* });
+*
+* // Server: register with the agent
+* const agent = createAgent({
+*   model: "openai:gpt-4o",
+*   tools: [getLocation],
+* });
+*
+* // Client: provide the implementation in useStream
+* const stream = useStream({
+*   assistantId: "agent",
+*   tools: [
+*     getLocation.implement(async ({ highAccuracy }) => {
+*       return new Promise((resolve, reject) => {
+*         navigator.geolocation.getCurrentPosition(
+*           (pos) => resolve({
+*             latitude: pos.coords.latitude,
+*             longitude: pos.coords.longitude,
+*           }),
+*           (err) => reject(new Error(err.message)),
+*           { enableHighAccuracy: highAccuracy }
+*         );
+*       });
+*     }),
+*   ],
+* });
+* ```
+*/
+const tool$1 = ((funcOrFields, fields) => {
+	if (typeof funcOrFields !== "function") return createHeadlessTool(funcOrFields);
+	return tool(funcOrFields, fields);
+});
+//#endregion
+export { tool$1 as tool };
+
+//# sourceMappingURL=headless.js.map

package/dist/tools/headless.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"headless.js","names":["coreTool","tool"],"sources":["../../src/tools/headless.ts"],"sourcesContent":["/**\n * Unified Tool Primitive for LangChain Agents\n *\n * This module re-exports the `tool` primitive from `@langchain/core/tools` with\n * an additional overload: when called without an implementation function, it\n * creates a **headless tool** that interrupts agent execution and delegates the\n * implementation to the client (e.g. via `useStream({ tools: [...] })`).\n *\n * @module\n */\n\nimport {\n  tool as coreTool,\n  DynamicStructuredTool,\n  type ToolRunnableConfig,\n} from \"@langchain/core/tools\";\nimport type {\n  InteropZodObject,\n  InferInteropZodInput,\n  InferInteropZodOutput,\n} from \"@langchain/core/utils/types\";\n\n/**\n * Configuration fields for creating a headless tool.\n */\nexport type HeadlessToolFields<\n  SchemaT extends InteropZodObject,\n  NameT extends string = string,\n> = {\n  /** The name of the tool. Used by the client to match implementations. */\n  name: NameT;\n  /** Description of what the tool does. */\n  description: string;\n  /** The Zod schema defining the tool's input. */\n  schema: SchemaT;\n};\n\n/**\n * A tool implementation that pairs a headless tool with its execution function.\n *\n * Created by calling `.implement()` on a {@link HeadlessTool}.\n * Pass to `useStream({ tools: [...] })` on the client side.\n */\nexport type HeadlessToolImplementation<\n  SchemaT extends InteropZodObject = InteropZodObject,\n  OutputT = unknown,\n  NameT extends string = string,\n> = {\n  tool: HeadlessTool<SchemaT, NameT>;\n  execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;\n};\n\n/**\n * A headless tool that always interrupts agent execution on the server.\n *\n * The implementation is provided separately on the client via\n * `useStream({ tools: [...] })` using `.implement()`.\n */\nexport type HeadlessTool<\n  SchemaT extends InteropZodObject = InteropZodObject,\n  NameT extends string = string,\n> = DynamicStructuredTool<\n  SchemaT,\n  InferInteropZodOutput<SchemaT>,\n  InferInteropZodInput<SchemaT>,\n  unknown,\n  unknown,\n  NameT\n> & {\n  /**\n   * Pairs this headless tool with a client-side implementation.\n   *\n   * The returned object should be passed to `useStream({ tools: [...] })`.\n   * The SDK matches the implementation to the tool by name and calls\n   * `execute` with the typed arguments from the interrupt payload.\n   *\n   * @param execute - The function that implements the tool on the client\n   */\n  implement: <OutputT>(\n    execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>\n  ) => HeadlessToolImplementation<SchemaT, OutputT, NameT>;\n};\n\nfunction createHeadlessTool<\n  SchemaT extends InteropZodObject,\n  NameT extends string,\n>(fields: HeadlessToolFields<SchemaT, NameT>): HeadlessTool<SchemaT, NameT> {\n  const { name, description, schema } = fields;\n\n  const wrappedTool = coreTool(\n    async (\n      args: InferInteropZodOutput<SchemaT>,\n      config?: ToolRunnableConfig\n    ) => {\n      const { interrupt } = await import(\"@langchain/langgraph\");\n      return interrupt({\n        type: \"tool\",\n        toolCall: {\n          id: config?.toolCall?.id,\n          name,\n          args,\n        },\n      });\n    },\n    {\n      name,\n      description,\n      schema,\n      metadata: {\n        headlessTool: true,\n      },\n    }\n  );\n\n  const headlessTool: HeadlessTool<SchemaT, NameT> = Object.assign(\n    wrappedTool,\n    {\n      implement: <OutputT>(\n        execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>\n      ): HeadlessToolImplementation<SchemaT, OutputT, NameT> => ({\n        tool: headlessTool,\n        execute,\n      }),\n    }\n  ) as HeadlessTool<SchemaT, NameT>;\n\n  return headlessTool;\n}\n\n/**\n * The headless overload signature added to the core `tool` function.\n *\n * When called **without** an implementation function — just `tool({ name, description, schema })` —\n * returns a {@link HeadlessTool} that interrupts on every agent invocation.\n * The client provides the implementation via `useStream({ tools: [...] })`.\n */\ntype HeadlessToolOverload = {\n  <SchemaT extends InteropZodObject, NameT extends string>(\n    fields: HeadlessToolFields<SchemaT, NameT>\n  ): HeadlessTool<SchemaT, NameT>;\n};\n\n/**\n * Unified tool primitive for LangChain agents.\n *\n * Enhances the `tool` function from `@langchain/core/tools` with a headless\n * overload: when called **without** an implementation function, the tool\n * interrupts agent execution and lets the client supply the implementation.\n *\n * ---\n *\n * **Normal tool** — pass an implementation function as the first argument:\n *\n * ```typescript\n * import { tool } from \"langchain/tools\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool(\n *   async ({ city }) => `The weather in ${city} is sunny.`,\n *   {\n *     name: \"get_weather\",\n *     description: \"Get the weather for a city\",\n *     schema: z.object({ city: z.string() }),\n *   }\n * );\n * ```\n *\n * ---\n *\n * **Headless tool** — omit the implementation; the client provides it later:\n *\n * ```typescript\n * import { tool } from \"langchain/tools\";\n * import { z } from \"zod\";\n *\n * // Server: define the tool shape — no implementation needed\n * export const getLocation = tool({\n *   name: \"get_location\",\n *   description: \"Get the user's current GPS location\",\n *   schema: z.object({\n *     highAccuracy: z.boolean().optional().describe(\"Request high accuracy GPS\"),\n *   }),\n * });\n *\n * // Server: register with the agent\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getLocation],\n * });\n *\n * // Client: provide the implementation in useStream\n * const stream = useStream({\n *   assistantId: \"agent\",\n *   tools: [\n *     getLocation.implement(async ({ highAccuracy }) => {\n *       return new Promise((resolve, reject) => {\n *         navigator.geolocation.getCurrentPosition(\n *           (pos) => resolve({\n *             latitude: pos.coords.latitude,\n *             longitude: pos.coords.longitude,\n *           }),\n *           (err) => reject(new Error(err.message)),\n *           { enableHighAccuracy: highAccuracy }\n *         );\n *       });\n *     }),\n *   ],\n * });\n * ```\n */\nexport const tool: HeadlessToolOverload & typeof coreTool = ((\n  funcOrFields: unknown,\n  fields?: unknown\n) => {\n  if (typeof funcOrFields !== \"function\") {\n    return createHeadlessTool(\n      funcOrFields as HeadlessToolFields<InteropZodObject, string>\n    );\n  }\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return (coreTool as any)(funcOrFields, fields);\n}) as HeadlessToolOverload & typeof coreTool;\n"],"mappings":";;;;;;;;;;;;AAmFA,SAAS,mBAGP,QAA0E;CAC1E,MAAM,EAAE,MAAM,aAAa,WAAW;CAEtC,MAAM,cAAcA,KAClB,OACE,MACA,WACG;EACH,MAAM,EAAE,cAAc,MAAM,OAAO;AACnC,SAAO,UAAU;GACf,MAAM;GACN,UAAU;IACR,IAAI,QAAQ,UAAU;IACtB;IACA;IACD;GACF,CAAC;IAEJ;EACE;EACA;EACA;EACA,UAAU,EACR,cAAc,MACf;EACF,CACF;CAED,MAAM,eAA6C,OAAO,OACxD,aACA,EACE,YACE,aACyD;EACzD,MAAM;EACN;EACD,GACF,CACF;AAED,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFT,MAAaC,WACX,cACA,WACG;AACH,KAAI,OAAO,iBAAiB,WAC1B,QAAO,mBACL,aACD;AAGH,QAAQD,KAAiB,cAAc,OAAO"}

package/dist/tools/index.cjs

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_headless = require("./headless.cjs");
+//#region src/tools/index.ts
+var tools_exports = /* @__PURE__ */ require_runtime.__exportAll({ tool: () => require_headless.tool });
+//#endregion
+exports.tool = require_headless.tool;
+Object.defineProperty(exports, "tools_exports", {
+	enumerable: true,
+	get: function() {
+		return tools_exports;
+	}
+});
+
+//# sourceMappingURL=index.cjs.map

package/dist/tools/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/tools/index.ts"],"sourcesContent":["/**\n * LangChain Tools\n *\n * This module provides tool utilities for LangChain agents.\n *\n * @module\n */\n\nexport {\n  tool,\n  type HeadlessTool,\n  type HeadlessToolFields,\n  type HeadlessToolImplementation,\n} from \"./headless.js\";\n"],"mappings":""}

package/dist/tools/index.d.cts

@@ -0,0 +1,2 @@
+import { HeadlessTool, HeadlessToolFields, HeadlessToolImplementation, tool } from "./headless.cjs";
+export { type HeadlessTool, type HeadlessToolFields, type HeadlessToolImplementation, tool };

package/dist/tools/index.d.ts

@@ -0,0 +1,2 @@
+import { HeadlessTool, HeadlessToolFields, HeadlessToolImplementation, tool } from "./headless.js";
+export { type HeadlessTool, type HeadlessToolFields, type HeadlessToolImplementation, tool };

package/dist/tools/index.js

@@ -0,0 +1,8 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { tool } from "./headless.js";
+//#region src/tools/index.ts
+var tools_exports = /* @__PURE__ */ __exportAll({ tool: () => tool });
+//#endregion
+export { tool, tools_exports };
+
+//# sourceMappingURL=index.js.map

package/dist/tools/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/tools/index.ts"],"sourcesContent":["/**\n * LangChain Tools\n *\n * This module provides tool utilities for LangChain agents.\n *\n * @module\n */\n\nexport {\n  tool,\n  type HeadlessTool,\n  type HeadlessToolFields,\n  type HeadlessToolImplementation,\n} from \"./headless.js\";\n"],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langchain",
-  "version": "1.2.35",
+  "version": "1.3.0-dev-1773962633795",
   "description": "Typescript bindings for langchain",
   "author": "LangChain",
   "license": "MIT",
@@ -52,15 +52,15 @@
     "typescript": "~5.8.3",
     "vitest": "^3.2.4",
     "yaml": "^2.8.1",
-    "@langchain/anthropic": "1.3.25",
+    "@langchain/anthropic": "1.3.24-dev-1773962633795",
     "@langchain/cohere": "1.0.4",
-    "@langchain/core": "^1.1.34",
+    "@langchain/core": "^1.1.33-dev-1773962633795",
+    "@langchain/openai": "1.3.0-dev-1773962633795",
     "@langchain/eslint": "0.1.1",
-    "@langchain/openai": "1.3.0",
     "@langchain/tsconfig": "0.0.1"
   },
   "peerDependencies": {
-    "@langchain/core": "^1.1.34"
+    "@langchain/core": "^1.1.33-dev-1773962633795"
   },
   "dependencies": {
     "@langchain/langgraph": "^1.1.2",
@@ -200,6 +200,17 @@
         "default": "./dist/storage/in_memory.js"
       }
     },
+    "./tools": {
+      "input": "./src/tools/index.ts",
+      "require": {
+        "types": "./dist/tools/index.d.cts",
+        "default": "./dist/tools/index.cjs"
+      },
+      "import": {
+        "types": "./dist/tools/index.d.ts",
+        "default": "./dist/tools/index.js"
+      }
+    },
     "./package.json": "./package.json"
   },
   "module": "./dist/index.js",

package/chat_models/universal.cjs

@@ -1 +0,0 @@
-module.exports = require("../dist/chat_models/universal.cjs");

package/chat_models/universal.d.cts

@@ -1 +0,0 @@
-export * from "../dist/chat_models/universal.js";

package/chat_models/universal.d.ts

@@ -1 +0,0 @@
-export * from "../dist/chat_models/universal.js";

package/chat_models/universal.js

@@ -1 +0,0 @@
-export * from "../dist/chat_models/universal.js";

package/hub/node.cjs

@@ -1 +0,0 @@
-module.exports = require("../dist/hub/node.cjs");

package/hub/node.d.cts

@@ -1 +0,0 @@
-export * from "../dist/hub/node.js";

package/hub/node.d.ts

@@ -1 +0,0 @@
-export * from "../dist/hub/node.js";

package/hub/node.js

@@ -1 +0,0 @@
-export * from "../dist/hub/node.js";

package/hub.cjs

@@ -1 +0,0 @@
-module.exports = require("./dist/hub/index.cjs");

package/hub.d.cts

@@ -1 +0,0 @@
-export * from "./dist/hub/index.js";

package/hub.d.ts

@@ -1 +0,0 @@
-export * from "./dist/hub/index.js";

package/hub.js

@@ -1 +0,0 @@
-export * from "./dist/hub/index.js";

package/load/serializable.cjs

@@ -1 +0,0 @@
-module.exports = require("../dist/load/serializable.cjs");

package/load/serializable.d.cts

@@ -1 +0,0 @@
-export * from "../dist/load/serializable.js";

package/load/serializable.d.ts

@@ -1 +0,0 @@
-export * from "../dist/load/serializable.js";

package/load/serializable.js

@@ -1 +0,0 @@
-export * from "../dist/load/serializable.js";

package/load.cjs

@@ -1 +0,0 @@
-module.exports = require("./dist/load/index.cjs");

package/load.d.cts

@@ -1 +0,0 @@
-export * from "./dist/load/index.js";

package/load.d.ts

@@ -1 +0,0 @@
-export * from "./dist/load/index.js";

package/load.js

@@ -1 +0,0 @@
-export * from "./dist/load/index.js";

package/storage/encoder_backed.cjs

@@ -1 +0,0 @@
-module.exports = require("../dist/storage/encoder_backed.cjs");

package/storage/encoder_backed.d.cts

@@ -1 +0,0 @@
-export * from "../dist/storage/encoder_backed.js";

package/storage/encoder_backed.d.ts

@@ -1 +0,0 @@
-export * from "../dist/storage/encoder_backed.js";

package/storage/encoder_backed.js

@@ -1 +0,0 @@
-export * from "../dist/storage/encoder_backed.js";

package/storage/file_system.cjs

@@ -1 +0,0 @@
-module.exports = require("../dist/storage/file_system.cjs");

package/storage/file_system.d.cts

@@ -1 +0,0 @@
-export * from "../dist/storage/file_system.js";

package/storage/file_system.d.ts

@@ -1 +0,0 @@
-export * from "../dist/storage/file_system.js";

package/storage/file_system.js

@@ -1 +0,0 @@
-export * from "../dist/storage/file_system.js";

package/storage/in_memory.cjs

@@ -1 +0,0 @@
-module.exports = require("../dist/storage/in_memory.cjs");

package/storage/in_memory.d.cts

@@ -1 +0,0 @@
-export * from "../dist/storage/in_memory.js";

package/storage/in_memory.d.ts

@@ -1 +0,0 @@
-export * from "../dist/storage/in_memory.js";

package/storage/in_memory.js

@@ -1 +0,0 @@
-export * from "../dist/storage/in_memory.js";