@stll/folio-agents 0.0.1 → 0.1.0

package/dist/parse.js

@@ -0,0 +1,157 @@
+//#region src/parse.ts
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isNonEmptyString = (value) => typeof value === "string" && value.length > 0;
+/**
+* Hard caps on `suggest_changes` / `add_comment` / `reply_comment` input
+* size. Without these, a single tool call could ask the bridge to apply an
+* unbounded number of operations, or push an arbitrarily large string into
+* the tracked-changes engine, in one shot. `execute.ts` reuses
+* {@link MAX_OPERATION_TEXT_LENGTH} for `reply_comment`'s text cap too, so
+* the limit stays a single number shared across every text-bearing tool.
+*/
+const MAX_OPERATIONS_PER_CALL = 50;
+const MAX_OPERATION_TEXT_LENGTH = 1e5;
+/** Plain-language error for a string argument over {@link MAX_OPERATION_TEXT_LENGTH}. */
+const explainTextTooLong = (label, length) => `${label} is ${length.toLocaleString()} characters, over the ${MAX_OPERATION_TEXT_LENGTH.toLocaleString()}-character limit; shorten it or split it into multiple operations.`;
+/**
+* Validate `add_comment`'s raw tool-call arguments and build the
+* `commentOnBlock` {@link FolioAIEditOperation} it applies. Pure: does not
+* touch a bridge or document.
+*/
+const parseAddCommentInput = (args) => {
+	if (!isPlainObject(args)) return {
+		ok: false,
+		error: "add_comment expects an object with `blockId` and `text` strings."
+	};
+	const blockId = args["blockId"];
+	const quote = args["quote"];
+	const text = args["text"];
+	if (!isNonEmptyString(blockId)) return {
+		ok: false,
+		error: "add_comment requires a non-empty string `blockId`."
+	};
+	if (!isNonEmptyString(text)) return {
+		ok: false,
+		error: "add_comment requires a non-empty string `text`."
+	};
+	if (text.length > 1e5) return {
+		ok: false,
+		error: explainTextTooLong("add_comment's `text`", text.length)
+	};
+	if (quote !== void 0 && typeof quote !== "string") return {
+		ok: false,
+		error: "add_comment's `quote` must be a string when provided."
+	};
+	if (typeof quote === "string" && quote.length > 1e5) return {
+		ok: false,
+		error: explainTextTooLong("add_comment's `quote`", quote.length)
+	};
+	return {
+		ok: true,
+		operation: {
+			id: "comment-1",
+			type: "commentOnBlock",
+			blockId,
+			comment: { text },
+			...quote !== void 0 ? { quote } : {}
+		}
+	};
+};
+const OPERATION_TYPES = "replaceInBlock, insertAfterBlock, insertBeforeBlock, replaceBlock, deleteBlock";
+const isOperationType = (value) => value === "replaceInBlock" || value === "insertAfterBlock" || value === "insertBeforeBlock" || value === "replaceBlock" || value === "deleteBlock";
+/** Validate + map one `suggest_changes` operation, or return a plain-language error string. */
+const buildSuggestedOperation = (raw, index) => {
+	if (!isPlainObject(raw)) return `operations[${index}] must be an object.`;
+	const type = raw["type"];
+	const blockId = raw["blockId"];
+	const id = raw["id"];
+	const comment = raw["comment"];
+	if (!isOperationType(type)) return `operations[${index}].type must be one of ${OPERATION_TYPES}.`;
+	if (!isNonEmptyString(blockId)) return `operations[${index}].blockId must be a non-empty string.`;
+	if (id !== void 0 && !isNonEmptyString(id)) return `operations[${index}].id must be a non-empty string when provided.`;
+	if (comment !== void 0 && typeof comment !== "string") return `operations[${index}].comment must be a string when provided.`;
+	if (typeof comment === "string" && comment.length > 1e5) return explainTextTooLong(`operations[${index}].comment`, comment.length);
+	const opId = isNonEmptyString(id) ? id : `op-${index + 1}`;
+	const commentField = typeof comment === "string" ? { comment: { text: comment } } : {};
+	if (type === "replaceInBlock") {
+		const find = raw["find"];
+		const replace = raw["replace"];
+		if (!isNonEmptyString(find)) return `operations[${index}] (replaceInBlock) requires a non-empty string \`find\`.`;
+		if (find.length > 1e5) return explainTextTooLong(`operations[${index}] (replaceInBlock) \`find\``, find.length);
+		if (typeof replace !== "string") return `operations[${index}] (replaceInBlock) requires a string \`replace\`.`;
+		if (replace.length > 1e5) return explainTextTooLong(`operations[${index}] (replaceInBlock) \`replace\``, replace.length);
+		return {
+			id: opId,
+			type,
+			blockId,
+			find,
+			replace,
+			...commentField
+		};
+	}
+	if (type === "insertAfterBlock" || type === "insertBeforeBlock") {
+		const text = raw["text"];
+		if (!isNonEmptyString(text)) return `operations[${index}] (${type}) requires a non-empty string \`text\`.`;
+		if (text.length > 1e5) return explainTextTooLong(`operations[${index}] (${type}) \`text\``, text.length);
+		return {
+			id: opId,
+			type,
+			blockId,
+			text,
+			...commentField
+		};
+	}
+	if (type === "replaceBlock") {
+		const text = raw["text"];
+		if (!isNonEmptyString(text)) return "operations[" + index + "] (replaceBlock) requires a non-empty string `text`.";
+		if (text.length > 1e5) return explainTextTooLong(`operations[${index}] (replaceBlock) \`text\``, text.length);
+		return {
+			id: opId,
+			type,
+			blockId,
+			text,
+			...commentField
+		};
+	}
+	return {
+		id: opId,
+		type,
+		blockId,
+		...commentField
+	};
+};
+/**
+* Validate `suggest_changes`' raw tool-call arguments and build the
+* {@link FolioAIEditOperation}s it applies. Pure: does not touch a bridge or
+* document.
+*/
+const parseSuggestChangesInput = (args) => {
+	if (!isPlainObject(args) || !Array.isArray(args["operations"])) return {
+		ok: false,
+		error: "suggest_changes requires an `operations` array."
+	};
+	const rawOperations = args["operations"];
+	if (rawOperations.length === 0) return {
+		ok: false,
+		error: "suggest_changes' `operations` array must not be empty."
+	};
+	if (rawOperations.length > 50) return {
+		ok: false,
+		error: `suggest_changes' \`operations\` array has ${rawOperations.length.toLocaleString()} entries, over the 50-operation limit; batch it across multiple suggest_changes calls.`
+	};
+	const operations = [];
+	for (const [index, raw] of rawOperations.entries()) {
+		const built = buildSuggestedOperation(raw, index);
+		if (typeof built === "string") return {
+			ok: false,
+			error: built
+		};
+		operations.push(built);
+	}
+	return {
+		ok: true,
+		operations
+	};
+};
+//#endregion
+export { MAX_OPERATIONS_PER_CALL, MAX_OPERATION_TEXT_LENGTH, explainTextTooLong, parseAddCommentInput, parseSuggestChangesInput };

package/dist/providers.d.ts

@@ -0,0 +1,24 @@
+import { FolioAgentToolDefinition } from "./types.js";
+
+//#region src/providers.d.ts
+/** Anthropic Messages API tool-definition shape (`input_schema`, snake_case). */
+type AnthropicToolDefinition = {
+  name: string;
+  description: string;
+  input_schema: Record<string, unknown>;
+};
+/** Map folio's provider-neutral tool definitions onto Anthropic's tool shape. */
+declare const toAnthropicTools: (definitions: FolioAgentToolDefinition[]) => AnthropicToolDefinition[];
+/** OpenAI Chat Completions / Responses API function-tool shape. */
+type OpenAIToolDefinition = {
+  type: "function";
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  };
+};
+/** Map folio's provider-neutral tool definitions onto OpenAI's function-tool shape. */
+declare const toOpenAITools: (definitions: FolioAgentToolDefinition[]) => OpenAIToolDefinition[];
+//#endregion
+export { AnthropicToolDefinition, OpenAIToolDefinition, toAnthropicTools, toOpenAITools };

package/dist/providers.js

@@ -0,0 +1,18 @@
+//#region src/providers.ts
+/** Map folio's provider-neutral tool definitions onto Anthropic's tool shape. */
+const toAnthropicTools = (definitions) => definitions.map((definition) => ({
+	name: definition.name,
+	description: definition.description,
+	input_schema: definition.inputSchema
+}));
+/** Map folio's provider-neutral tool definitions onto OpenAI's function-tool shape. */
+const toOpenAITools = (definitions) => definitions.map((definition) => ({
+	type: "function",
+	function: {
+		name: definition.name,
+		description: definition.description,
+		parameters: definition.inputSchema
+	}
+}));
+//#endregion
+export { toAnthropicTools, toOpenAITools };

package/dist/tools.d.ts

@@ -0,0 +1,16 @@
+import { FolioAgentToolDefinition } from "./types.js";
+
+//#region src/tools.d.ts
+/**
+ * The tools this package exposes, described for an LLM. Every tool that reads
+ * or mutates the document expects `blockId` values that came from
+ * `read_document` or `find_text` in THIS conversation — block ids are not
+ * guessable and change whenever the document's structure changes. Every
+ * mutation (`add_comment`, `suggest_changes`) becomes a tracked change or
+ * comment pending human review; nothing is silently finalized.
+ */
+declare const FOLIO_AGENT_TOOLS: FolioAgentToolDefinition[];
+/** The tool definitions this package exposes. Same array as {@link FOLIO_AGENT_TOOLS}, as a function for symmetry with the other providers. */
+declare const getFolioToolDefinitions: () => FolioAgentToolDefinition[];
+//#endregion
+export { FOLIO_AGENT_TOOLS, getFolioToolDefinitions };

package/dist/tools.js

@@ -0,0 +1,224 @@
+import { FOLIO_AGENT_TOOL_NAMES } from "./types.js";
+/**
+* The tools this package exposes, described for an LLM. Every tool that reads
+* or mutates the document expects `blockId` values that came from
+* `read_document` or `find_text` in THIS conversation — block ids are not
+* guessable and change whenever the document's structure changes. Every
+* mutation (`add_comment`, `suggest_changes`) becomes a tracked change or
+* comment pending human review; nothing is silently finalized.
+*/
+const FOLIO_AGENT_TOOLS = [
+	{
+		name: FOLIO_AGENT_TOOL_NAMES.readDocument,
+		description: "Read the full document body as a list of blocks (paragraphs, headings, list items). Call this first, or whenever you need fresh block ids after a mutation — block ids from a stale read may no longer resolve.",
+		inputSchema: {
+			type: "object",
+			properties: {},
+			required: [],
+			additionalProperties: false
+		}
+	},
+	{
+		name: FOLIO_AGENT_TOOL_NAMES.findText,
+		description: "Search the document body for a text string and return `{ matches, truncated, totalMatches }`, where each match has its block id, which occurrence within that block it is, and surrounding context. `matches` is capped at 200 entries; `truncated` is true and `totalMatches` reports the real count when there were more — narrow the query instead of assuming you saw every hit. Use this to locate the blockId for a known phrase instead of reading the whole document.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				query: {
+					type: "string",
+					description: "Non-empty text to search for, up to 1,000 characters."
+				},
+				matchCase: {
+					type: "boolean",
+					description: "Case-sensitive match. Defaults to false (case-insensitive)."
+				}
+			},
+			required: ["query"],
+			additionalProperties: false
+		}
+	},
+	{
+		name: FOLIO_AGENT_TOOL_NAMES.readComments,
+		description: "Read comment threads in the document, each with its author, text, resolved status, anchored block, and replies. Filter to unresolved (\"open\") comments to see what still needs attention.",
+		inputSchema: {
+			type: "object",
+			properties: { filter: {
+				type: "string",
+				enum: [
+					"all",
+					"open",
+					"resolved"
+				],
+				description: "Which comments to return. Defaults to \"all\"."
+			} },
+			required: [],
+			additionalProperties: false
+		}
+	},
+	{
+		name: FOLIO_AGENT_TOOL_NAMES.readChanges,
+		description: "Read pending tracked changes (insertions and deletions) awaiting human review. Use this to see the effect of edits already suggested via `suggest_changes` before proposing more.",
+		inputSchema: {
+			type: "object",
+			properties: {},
+			required: [],
+			additionalProperties: false
+		}
+	},
+	{
+		name: FOLIO_AGENT_TOOL_NAMES.addComment,
+		description: "Attach a comment to a block, optionally quoting the specific text it is about. The comment is added immediately (comments are not tracked changes) but the underlying text is left untouched — use this for notes/questions, and `suggest_changes` for edits. `text` and `quote` are each capped at 100,000 characters.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				blockId: {
+					type: "string",
+					description: "The block to comment on, from `read_document` or `find_text`."
+				},
+				quote: {
+					type: "string",
+					description: "Optional exact text within the block this comment is about, up to 100,000 characters."
+				},
+				text: {
+					type: "string",
+					description: "The comment body, up to 100,000 characters."
+				}
+			},
+			required: ["blockId", "text"],
+			additionalProperties: false
+		}
+	},
+	{
+		name: FOLIO_AGENT_TOOL_NAMES.suggestChanges,
+		description: "Propose one or more edits as tracked changes for a human to accept or reject — nothing is applied directly to the visible text. Each operation needs a blockId from `read_document` or `find_text`; if the document changed since that read, re-read it and retry with fresh ids (a skip reason will say so). At most 50 operations per call — batch larger edits across multiple calls. Each `find` / `replace` / `text` / `comment` string is capped at 100,000 characters.",
+		inputSchema: {
+			type: "object",
+			properties: { operations: {
+				type: "array",
+				description: "The edits to propose, applied in order. At most 50 per call.",
+				items: {
+					type: "object",
+					properties: {
+						id: {
+							type: "string",
+							description: "Optional caller-supplied operation id, echoed back in `applied`/`skipped`. Auto-generated (op-1, op-2, …) when omitted."
+						},
+						type: {
+							type: "string",
+							enum: [
+								"replaceInBlock",
+								"insertAfterBlock",
+								"insertBeforeBlock",
+								"replaceBlock",
+								"deleteBlock"
+							],
+							description: "The kind of edit to make."
+						},
+						blockId: {
+							type: "string",
+							description: "The block to edit, from `read_document` or `find_text`."
+						},
+						find: {
+							type: "string",
+							description: "Required for `replaceInBlock`: the exact text to find within the block, up to 100,000 characters."
+						},
+						replace: {
+							type: "string",
+							description: "Required for `replaceInBlock`: the text to replace `find` with, up to 100,000 characters."
+						},
+						text: {
+							type: "string",
+							description: "Required for `insertAfterBlock` / `insertBeforeBlock` / `replaceBlock`: the text to insert or replace the block with, up to 100,000 characters."
+						},
+						comment: {
+							type: "string",
+							description: "Optional comment explaining this edit, attached to the affected text, up to 100,000 characters."
+						}
+					},
+					required: ["type", "blockId"],
+					additionalProperties: false
+				}
+			} },
+			required: ["operations"],
+			additionalProperties: false
+		}
+	},
+	{
+		name: FOLIO_AGENT_TOOL_NAMES.replyComment,
+		description: "Reply to an existing comment thread, referenced by the id from `read_comments`. `text` is capped at 100,000 characters.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				commentId: {
+					type: "string",
+					description: "The comment id from `read_comments`."
+				},
+				text: {
+					type: "string",
+					description: "The reply body, up to 100,000 characters."
+				}
+			},
+			required: ["commentId", "text"],
+			additionalProperties: false
+		}
+	},
+	{
+		name: FOLIO_AGENT_TOOL_NAMES.resolveComment,
+		description: "Mark a comment thread resolved, or pass `reopen: true` to reopen a previously resolved one.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				commentId: {
+					type: "string",
+					description: "The comment id from `read_comments`."
+				},
+				reopen: {
+					type: "boolean",
+					description: "Reopen an already-resolved thread instead of resolving it."
+				}
+			},
+			required: ["commentId"],
+			additionalProperties: false
+		}
+	},
+	{
+		name: FOLIO_AGENT_TOOL_NAMES.readPage,
+		description: "Read the plain text of one page (1-based) as currently paginated in the live editor. Only available when the document is open in a live, paginated editor surface — not on a headless document.",
+		inputSchema: {
+			type: "object",
+			properties: { page: {
+				type: "number",
+				description: "1-based page number."
+			} },
+			required: ["page"],
+			additionalProperties: false
+		}
+	},
+	{
+		name: FOLIO_AGENT_TOOL_NAMES.readSelection,
+		description: "Read the user's current text selection in the live editor, as plain text. Only available on a live editor surface with an active selection.",
+		inputSchema: {
+			type: "object",
+			properties: {},
+			required: [],
+			additionalProperties: false
+		}
+	},
+	{
+		name: FOLIO_AGENT_TOOL_NAMES.scrollToBlock,
+		description: "Scroll the live editor to the given block and select it, so the user can see what you are discussing. Only available on a live editor surface.",
+		inputSchema: {
+			type: "object",
+			properties: { blockId: {
+				type: "string",
+				description: "The block to scroll to, from `read_document` or `find_text`."
+			} },
+			required: ["blockId"],
+			additionalProperties: false
+		}
+	}
+];
+/** The tool definitions this package exposes. Same array as {@link FOLIO_AGENT_TOOLS}, as a function for symmetry with the other providers. */
+const getFolioToolDefinitions = () => FOLIO_AGENT_TOOLS;
+//#endregion
+export { FOLIO_AGENT_TOOLS, getFolioToolDefinitions };

package/dist/types.d.ts

@@ -0,0 +1,115 @@
+//#region src/types.d.ts
+/**
+ * Provider-neutral tool-layer types. `FolioAgentToolDefinition` describes a
+ * tool the same way every model provider ends up wanting it described (name +
+ * prose description + a JSON-Schema-shaped input schema); `providers.ts` maps
+ * that single shape onto each SDK's own tool-definition envelope.
+ */
+/** Every tool name this package exposes, as a stable string union (no enums). */
+declare const FOLIO_AGENT_TOOL_NAMES: {
+  readonly readDocument: "read_document";
+  readonly findText: "find_text";
+  readonly readComments: "read_comments";
+  readonly readChanges: "read_changes";
+  readonly addComment: "add_comment";
+  readonly suggestChanges: "suggest_changes";
+  readonly replyComment: "reply_comment";
+  readonly resolveComment: "resolve_comment";
+  readonly readPage: "read_page";
+  readonly readSelection: "read_selection";
+  readonly scrollToBlock: "scroll_to_block";
+};
+type FolioAgentToolName = (typeof FOLIO_AGENT_TOOL_NAMES)[keyof typeof FOLIO_AGENT_TOOL_NAMES];
+/**
+ * A provider-neutral tool definition: name, an LLM-facing description (when to
+ * call it, what it returns), and a JSON-Schema (draft-07-ish) object schema for
+ * its arguments. `providers.ts` maps a list of these onto Anthropic's or
+ * OpenAI's tool-definition shape.
+ */
+type FolioAgentToolDefinition = {
+  name: FolioAgentToolName;
+  description: string;
+  inputSchema: Record<string, unknown>;
+};
+/**
+ * Result of executing one tool call. `ok: false` covers every EXPECTED failure
+ * (bad arguments, an unknown tool, a capability the bridge does not support, a
+ * domain-level skip) — never throw for these, since the whole point is to feed
+ * the reason back to the model so it can retry or adjust. `executeFolioToolCall`
+ * is the only boundary layer allowed to catch an unexpected throw and fold it
+ * into this shape too.
+ */
+type FolioToolCallResult = {
+  ok: true;
+  result: unknown;
+} | {
+  ok: false;
+  error: string;
+};
+/** One document block as exposed to a model: id, kind, and its plain text. */
+type FolioAgentBlock = {
+  blockId: string;
+  kind: string;
+  text: string;
+};
+/** One `find_text` match: which block, which occurrence within it, and a text window around the match. */
+type FolioAgentTextMatch = {
+  blockId: string; /** 0-based index of this occurrence within its block (multiple matches in one block increment this). */
+  occurrenceInBlock: number; /** The match plus ~40 characters of surrounding context on each side. */
+  context: string;
+};
+/**
+ * Result of {@link FOLIO_AGENT_TOOL_NAMES.findText}. `matches` is capped at a
+ * fixed limit; when the query has more hits than that, `truncated` is `true`
+ * and `totalMatches` reports the real count so the model knows to narrow the
+ * query instead of assuming it saw everything.
+ */
+type FolioAgentFindTextResult = {
+  matches: FolioAgentTextMatch[];
+  truncated: boolean;
+  totalMatches: number;
+};
+/** One reply within a comment thread. */
+type FolioAgentCommentReply = {
+  id: string;
+  author: string;
+  text: string;
+};
+/**
+ * A comment thread, shaped to match what {@link FolioDocxReviewer.getComments}
+ * (from `@stll/folio-core/server`) returns, minus fields a tool-calling model
+ * has no use for (raw dates). `resolved` mirrors the underlying model's
+ * `done` flag; `quote` mirrors `anchoredText` (the text the comment is
+ * attached to, empty when unavailable).
+ */
+type FolioAgentComment = {
+  id: string;
+  author: string;
+  text: string;
+  resolved: boolean;
+  blockId: string | null;
+  quote: string;
+  replies: FolioAgentCommentReply[];
+};
+/** A pending tracked change (insertion or deletion), shaped to match {@link FolioDocxReviewer.getChanges}. */
+type FolioAgentChange = {
+  id: string;
+  type: "insertion" | "deletion";
+  author: string;
+  text: string;
+  blockId: string | null;
+};
+/** Filter for {@link FOLIO_AGENT_TOOL_NAMES.readComments}. */
+type FolioAgentCommentFilter = "all" | "open" | "resolved";
+/** Result of {@link FOLIO_AGENT_TOOL_NAMES.addComment} / `suggest_changes`. */
+type FolioAgentApplyOperationsSummary = {
+  applied: {
+    id: string;
+  }[];
+  skipped: {
+    id: string;
+    reason: string;
+  }[];
+};
+//#endregion
+export { FOLIO_AGENT_TOOL_NAMES, FolioAgentApplyOperationsSummary, FolioAgentBlock, FolioAgentChange, FolioAgentComment, FolioAgentCommentFilter, FolioAgentCommentReply, FolioAgentFindTextResult, FolioAgentTextMatch, FolioAgentToolDefinition, FolioAgentToolName, FolioToolCallResult };

package/dist/types.js

@@ -0,0 +1,23 @@
+//#region src/types.ts
+/**
+* Provider-neutral tool-layer types. `FolioAgentToolDefinition` describes a
+* tool the same way every model provider ends up wanting it described (name +
+* prose description + a JSON-Schema-shaped input schema); `providers.ts` maps
+* that single shape onto each SDK's own tool-definition envelope.
+*/
+/** Every tool name this package exposes, as a stable string union (no enums). */
+const FOLIO_AGENT_TOOL_NAMES = {
+	readDocument: "read_document",
+	findText: "find_text",
+	readComments: "read_comments",
+	readChanges: "read_changes",
+	addComment: "add_comment",
+	suggestChanges: "suggest_changes",
+	replyComment: "reply_comment",
+	resolveComment: "resolve_comment",
+	readPage: "read_page",
+	readSelection: "read_selection",
+	scrollToBlock: "scroll_to_block"
+};
+//#endregion
+export { FOLIO_AGENT_TOOL_NAMES };

package/package.json

@@ -1 +1,61 @@
-{"name":"@stll/folio-agents","version":"0.0.1","description":"Placeholder. Real releases publish from stella/folio CI via OIDC trusted publishing.","license":"Apache-2.0"}
+{
+  "name": "@stll/folio-agents",
+  "version": "0.1.0",
+  "description": "Framework-neutral LLM tool layer over folio's ai-edits engine: function-calling tools so an agent can read and mutate .docx documents through @stll/folio-core.",
+  "keywords": [
+    "agent",
+    "ai",
+    "docx",
+    "function-calling",
+    "llm",
+    "ooxml",
+    "tanstack-intent",
+    "tools",
+    "word"
+  ],
+  "homepage": "https://github.com/stella/folio",
+  "bugs": {
+    "url": "https://github.com/stella/folio/issues"
+  },
+  "license": "Apache-2.0",
+  "author": "STLL",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stella/folio.git",
+    "directory": "packages/agents"
+  },
+  "files": [
+    "dist",
+    "skills",
+    "README.md",
+    "LICENSE",
+    "NOTICE.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsdown",
+    "prepack": "bun run build",
+    "pack:dry-run": "bun pm pack --dry-run",
+    "typecheck": "tsgo --noEmit -p tsconfig.build.json",
+    "test": "bun test src"
+  },
+  "dependencies": {
+    "@stll/folio-core": "^0.2.0"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}