@sanity/agent-directives 0.0.7 → 0.0.9

package/dist/lib/react.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"react.d.ts","names":["CallableInstance","Parameters","Result","property","parameters","unified5","trough0","vfile1","___index_js2","CallableInstance","Processor","Key","Parameters_1","Input","Output","ParseTree","HeadTree","TailTree","CompileTree","CompileResult","unist26","Node","CompileResults","Compiler","Parser","Plugin","Array","Data","Pipeline","Compatible","VFileWithOutput","ProcessCallback","Promise","RunCallback","Value","Preset","PluggableList","UsePlugin","constructor","attachers","plugin","parameters","compiler","freezeIndex","frozen","namespace","parser","transformers","copy","data","dataset","key","value","freeze","parse","file","process","done","processSync","run","tree","runSync","stringify","use","preset","list","unified","CompileResultMap","Settings","Tree","Result","VFile","document","Pluggable","PluginTuple","PluginParameters","Transformer","this","TupleParameters","plugins","settings","File","Error","error","TransformCallback","next","result","Value","CompileResults","Compiler","Parser","Pluggable","PluggableList","Plugin","PluginTuple","Preset","ProcessCallback","Processor","RunCallback","TransformCallback","Transformer","unified","emptyObjectSymbol","CompileResultMap","Uint8Array","string","Data","Settings","settings"],"sources":["../../../../node_modules/.pnpm/unified@11.0.5/node_modules/unified/lib/callable-instance.d.ts","../../../../node_modules/.pnpm/unified@11.0.5/node_modules/unified/lib/index.d.ts","../../../../node_modules/.pnpm/unified@11.0.5/node_modules/unified/index.d.ts","../../src/lib/react.tsx"],"x_google_ignoreList":[0,1,2],"mappings":"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"}
+{"version":3,"file":"react.d.ts","names":[],"sources":["../../src/lib/react.tsx"],"mappings":";;;;KAoBK,cAAA,WAAyB,aAAA,IAAiB,iBAAA,CAAkB,CAAA;AAAA,UAEhD,SAAA;EACf,IAAA;IAAS,UAAA,GAAa,MAAA;EAAA;AAAA;AAAA,KAGZ,oBAAA,eACI,aAAA,2EAGZ,cAAA,CAAe,KAAA;EACjB,QAAA;AAAA,KACG,oBAAA,gBACC,YAAA;EAEI,WAAA,EAAa,YAAA;AAAA;AAAA,KAKX,uBAAA,eAAsC,aAAA,IAAiB,cAAA,CAAe,KAAA;EAChF,MAAA;AAAA,IACE,SAAA;AApBJ;;;;;;;;;AAIA;;;;AAJA,iBAmMgB,qBAAA,CAAsB,IAAA,EAAM,SAAA,IAAS,IAAA,EAnIrC,IAAA;AAAA,UAqJC,mBAAA;EACf,cAAA,IAAkB,MAAA,yBAA+B,YAAA;AAAA;;;;;;;;;;;;;;;;;iBAmBnC,kBAAA,0BAAA,CACd,OAAA,GAAS,mBAAA,CAAoB,YAAA;kCAKb,aAAA,+CACsB,IAAA,EAE9B,KAAA,EAAK,MAAA,GACF,KAAA,EAAO,oBAAA,CAAqB,KAAA,EAAO,YAAA,EAAc,oBAAA,MAA0B,SAAA,EAAS,gBAAA,GAC3E,sBAAA,KACjB,aAAA,CAAc,uBAAA,CAAwB,KAAA;AAAA"}

package/dist/lib/react.js

@@ -2,8 +2,8 @@ import { pascalCase } from "es-toolkit";
 import { directiveFromMarkdown, directiveToMarkdown } from "mdast-util-directive";
 import { directive } from "micromark-extension-directive";
 import { visit } from "unist-util-visit";
-import { DirectiveSchemas } from "../index.js";
-const DIRECTIVE_TYPES = ["textDirective", "leafDirective", "containerDirective"], isDirectiveNode = (node) => "name" in node && typeof node.name == "string" && /^[a-zA-Z-]+$/.test(node.name) && DIRECTIVE_TYPES.includes(node.type), isListItemWithOnlyDirective = (node) => {
+import { DIRECTIVE_TYPES, DirectiveSchemas } from "../_chunks-es/formatters.js";
+const isDirectiveNode = (node) => "name" in node && typeof node.name == "string" && /^[a-zA-Z-]+$/.test(node.name) && DIRECTIVE_TYPES.includes(node.type), isListItemWithOnlyDirective = (node) => {
   if (node.type !== "listItem") return !1;
   const children = node.children || [];
   return children.length === 1 && children[0].type === "leafDirective";
@@ -85,7 +85,8 @@ function createDirectiveKit(options = {}) {
         return console.error(`Directive "${name}" validation error:`, result.error.format()), null;
       const renderProps = {
         ...result.data,
-        ...requiresContext && useApplication ? { application } : {}
+        ...requiresContext && useApplication ? { application } : {},
+        isInline: merged.isInline === !0
       };
       return render(renderProps);
     }

package/dist/lib/react.js.map

@@ -1 +1 @@
-{"version":3,"file":"react.js","sources":["../../src/lib/react.tsx"],"sourcesContent":["import { pascalCase } from 'es-toolkit'\nimport { directiveFromMarkdown, directiveToMarkdown } from 'mdast-util-directive'\nimport { directive } from 'micromark-extension-directive'\nimport type { ComponentType, ReactNode } from 'react'\nimport type { Processor } from 'unified'\nimport type { Node } from 'unist'\nimport { visit } from 'unist-util-visit'\nimport {\n  type DefineDirectiveOptions,\n  type DirectiveName,\n  type DirectivePropsMap,\n  DirectiveSchemas,\n} from '../_internal'\n\n// ============================================================================\n// Types\n// ============================================================================\n\ntype DirectiveProps<T extends DirectiveName> = DirectivePropsMap[T]\n\nexport interface NodeProps {\n  node?: { properties?: Record<string, unknown> }\n}\n\nexport type DirectiveRenderProps<\n  TName extends DirectiveName,\n  TApplication = undefined,\n  TRequiresApplication extends boolean = true,\n> = DirectiveProps<TName> &\n  (TRequiresApplication extends true\n    ? TApplication extends undefined\n      ? {}\n      : { application: TApplication }\n    : {})\n\nexport type { DefineDirectiveOptions }\n\nexport type DirectiveComponentProps<TName extends DirectiveName> = DirectiveProps<TName> & {\n  source?: string\n} & NodeProps\n\n// ============================================================================\n// Remark Plugin Types\n// ============================================================================\n\ninterface DirectiveNode extends Node {\n  type: 'textDirective' | 'leafDirective' | 'containerDirective'\n  name: string\n  attributes?: Record<string, string>\n  children?: DirectiveNode[]\n  value?: string\n  data?: {\n    hName?: string\n    hProperties?: Record<string, unknown>\n  }\n}\n\ntype DirectiveType = 'textDirective' | 'leafDirective' | 'containerDirective'\n\nconst DIRECTIVE_TYPES: DirectiveType[] = ['textDirective', 'leafDirective', 'containerDirective']\n\nconst isDirectiveNode = (node: Node): node is DirectiveNode =>\n  'name' in node &&\n  typeof (node as DirectiveNode).name === 'string' &&\n  /^[a-zA-Z-]+$/.test((node as DirectiveNode).name) &&\n  DIRECTIVE_TYPES.includes(node.type as DirectiveType)\n\nconst isListItemWithOnlyDirective = (node: Node): boolean => {\n  if (node.type !== 'listItem') return false\n  const children = (node as DirectiveNode).children || []\n  return children.length === 1 && children[0].type === 'leafDirective'\n}\n\n// ============================================================================\n// Remark Plugin\n// ============================================================================\n\n/**\n * Remark plugin that transforms directive syntax into React components.\n *\n * - Validates directive names (letters and hyphens only)\n * - Extracts directives from list items\n * - Groups consecutive leaf directives into DirectivesStack wrappers\n * - Filters incomplete streaming directives\n * - Converts directive names to PascalCase component names\n */\nfunction remarkDirectivesTransform() {\n  return (tree: Node) => {\n    // Remove invalid directive nodes (e.g., \":02\" in \"14:02\")\n    visit(\n      tree,\n      DIRECTIVE_TYPES,\n      (node: Node, index: number | undefined, parent: Node | undefined) => {\n        if (!isDirectiveNode(node)) {\n          const parentNode = parent as DirectiveNode | undefined\n          if (parentNode?.children && typeof index === 'number') {\n            const nodeName = 'name' in node ? String((node as DirectiveNode).name) : ''\n            parentNode.children[index] = {\n              type: 'text' as DirectiveType,\n              name: '',\n              value: `:${nodeName}`,\n            } as DirectiveNode\n          }\n        }\n      },\n    )\n\n    // Extract directives from list items\n    visit(\n      tree,\n      'list',\n      (node: Node, index: number | undefined, parent: Node | undefined): number | undefined => {\n        const listNode = node as DirectiveNode\n        if (!listNode.children) return undefined\n\n        const transformed: DirectiveNode[] = []\n        let hasTransformed = false\n\n        for (const child of listNode.children) {\n          if (isListItemWithOnlyDirective(child) && child.children?.[0]) {\n            transformed.push(child.children[0])\n            hasTransformed = true\n          } else {\n            transformed.push(child)\n          }\n        }\n\n        const parentNode = parent as DirectiveNode | undefined\n        if (hasTransformed && transformed.every((n) => isDirectiveNode(n))) {\n          if (parentNode?.children && typeof index === 'number') {\n            parentNode.children.splice(index, 1, ...transformed)\n            return index + transformed.length\n          }\n        }\n        return undefined\n      },\n    )\n\n    // Group consecutive leaf directives into DirectivesStack\n    visit(tree, (node: Node) => {\n      const dirNode = node as DirectiveNode\n      if (!dirNode.children?.length || dirNode.data?.hName === 'DirectivesStack') return\n\n      const newChildren: DirectiveNode[] = []\n      let group: DirectiveNode[] = []\n\n      for (const child of dirNode.children) {\n        if (isDirectiveNode(child) && child.type === 'leafDirective') {\n          group.push(child)\n        } else {\n          if (group.length > 0) {\n            newChildren.push({\n              type: 'leafDirective',\n              name: 'DirectivesStack',\n              data: { hName: 'DirectivesStack' },\n              children: group,\n            })\n            group = []\n          }\n          newChildren.push(child)\n        }\n      }\n\n      if (group.length > 0) {\n        newChildren.push({\n          type: 'leafDirective',\n          name: 'DirectivesStack',\n          data: { hName: 'DirectivesStack' },\n          children: group,\n        })\n      }\n\n      dirNode.children = newChildren\n    })\n\n    // Filter incomplete streaming directives\n    visit(tree, 'text', (node: Node) => {\n      const textNode = node as DirectiveNode\n      if (typeof textNode.value === 'string') {\n        if (textNode.value.match(/::?\\w+[{[]/) && !textNode.value.match(/::?\\w+[{[].+[}\\]]/)) {\n          textNode.value = ''\n        }\n      }\n    })\n\n    // Transform directives to React components\n    visit(tree, DIRECTIVE_TYPES, (node: Node) => {\n      if (!isDirectiveNode(node)) return\n\n      node.data = node.data || {}\n      node.data.hName = pascalCase(node.name)\n      node.data.hProperties = {\n        ...node.attributes,\n        isInline: node.type === 'textDirective',\n      }\n    })\n  }\n}\n\ninterface RemarkData {\n  micromarkExtensions?: unknown[]\n  fromMarkdownExtensions?: unknown[]\n  toMarkdownExtensions?: unknown[]\n}\n\n/**\n * Remark plugin for agent directive support.\n * Parses and transforms directive syntax into React components.\n *\n * @example\n * ```tsx\n * import { remarkAgentDirectives } from '@sanity/agent-directives/react'\n *\n * <ReactMarkdown remarkPlugins={[remarkAgentDirectives]}>\n *   {content}\n * </ReactMarkdown>\n * ```\n */\nexport function remarkAgentDirectives(this: Processor) {\n  const data = this.data() as RemarkData\n\n  if (!data.micromarkExtensions) data.micromarkExtensions = []\n  if (!data.fromMarkdownExtensions) data.fromMarkdownExtensions = []\n  if (!data.toMarkdownExtensions) data.toMarkdownExtensions = []\n\n  data.micromarkExtensions.push(directive())\n  data.fromMarkdownExtensions.push(directiveFromMarkdown())\n  data.toMarkdownExtensions.push(directiveToMarkdown())\n\n  return remarkDirectivesTransform()\n}\n\n// ============================================================================\n// Directive Kit\n// ============================================================================\n\nexport interface DirectiveKitOptions<TApplication> {\n  useApplication?: (source: string | undefined) => TApplication | undefined\n}\n\n/**\n * Creates a directive kit with application injection.\n *\n * @example\n * ```tsx\n * // kit.ts\n * export const { defineDirective } = createDirectiveKit<Application>({\n *   useApplication: (source) => useThreadApplication(source),\n * })\n *\n * // Document.tsx\n * export const DocumentDirective = defineDirective('document', ({ id, application }) => {\n *   return <DocumentCard id={id} app={application} />\n * })\n * ```\n */\nexport function createDirectiveKit<TApplication = undefined>(\n  options: DirectiveKitOptions<TApplication> = {},\n) {\n  const { useApplication } = options\n\n  function defineDirective<\n    TName extends DirectiveName,\n    TRequiresApplication extends boolean = true,\n  >(\n    name: TName,\n    render: (props: DirectiveRenderProps<TName, TApplication, TRequiresApplication>) => ReactNode,\n    directiveOptions: DefineDirectiveOptions = {},\n  ): ComponentType<DirectiveComponentProps<TName>> {\n    const requiresContext =\n      directiveOptions.requiresContext ?? directiveOptions.requiresApplication ?? true\n\n    function Directive(props: DirectiveComponentProps<TName>): ReactNode {\n      const { node, source, ...rest } = props\n\n      const application = useApplication?.(source)\n      if (requiresContext && useApplication && !application) return null\n\n      const merged = { ...(node?.properties ?? {}), ...rest }\n\n      const schema = DirectiveSchemas[name]\n      const result = schema.safeParse(merged)\n      if (!result.success) {\n        console.error(`Directive \"${name}\" validation error:`, result.error.format())\n        return null\n      }\n\n      const renderProps = {\n        ...(result.data as DirectiveProps<TName>),\n        ...(requiresContext && useApplication ? { application } : {}),\n      } as DirectiveRenderProps<TName, TApplication, TRequiresApplication>\n\n      return render(renderProps)\n    }\n\n    Directive.displayName = `Directive(${name})`\n    return Directive\n  }\n\n  return { defineDirective }\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"react.js","sources":["../../src/lib/react.tsx"],"sourcesContent":["import { pascalCase } from 'es-toolkit'\nimport { directiveFromMarkdown, directiveToMarkdown } from 'mdast-util-directive'\nimport { directive } from 'micromark-extension-directive'\nimport type { ComponentType, ReactNode } from 'react'\nimport type { Processor } from 'unified'\nimport type { Node } from 'unist'\nimport { visit } from 'unist-util-visit'\nimport {\n  type DefineDirectiveOptions,\n  DIRECTIVE_TYPES,\n  type DirectiveName,\n  type DirectivePropsMap,\n  DirectiveSchemas,\n  type DirectiveType,\n} from '../_internal'\n\n// ============================================================================\n// Types\n// ============================================================================\n\ntype DirectiveProps<T extends DirectiveName> = DirectivePropsMap[T]\n\nexport interface NodeProps {\n  node?: { properties?: Record<string, unknown> }\n}\n\nexport type DirectiveRenderProps<\n  TName extends DirectiveName,\n  TApplication = undefined,\n  TRequiresApplication extends boolean = true,\n> = DirectiveProps<TName> & {\n  isInline: boolean\n} & (TRequiresApplication extends true\n    ? TApplication extends undefined\n      ? {}\n      : { application: TApplication }\n    : {})\n\nexport type { DefineDirectiveOptions }\n\nexport type DirectiveComponentProps<TName extends DirectiveName> = DirectiveProps<TName> & {\n  source?: string\n} & NodeProps\n\n// ============================================================================\n// Remark Plugin Types\n// ============================================================================\n\ninterface DirectiveNode extends Node {\n  type: 'textDirective' | 'leafDirective' | 'containerDirective'\n  name: string\n  attributes?: Record<string, string>\n  children?: DirectiveNode[]\n  value?: string\n  data?: {\n    hName?: string\n    hProperties?: Record<string, unknown>\n  }\n}\n\nconst isDirectiveNode = (node: Node): node is DirectiveNode =>\n  'name' in node &&\n  typeof (node as DirectiveNode).name === 'string' &&\n  /^[a-zA-Z-]+$/.test((node as DirectiveNode).name) &&\n  DIRECTIVE_TYPES.includes(node.type as DirectiveType)\n\nconst isListItemWithOnlyDirective = (node: Node): boolean => {\n  if (node.type !== 'listItem') return false\n  const children = (node as DirectiveNode).children || []\n  return children.length === 1 && children[0].type === 'leafDirective'\n}\n\n// ============================================================================\n// Remark Plugin\n// ============================================================================\n\n/**\n * Remark plugin that transforms directive syntax into React components.\n *\n * - Validates directive names (letters and hyphens only)\n * - Extracts directives from list items\n * - Groups consecutive leaf directives into DirectivesStack wrappers\n * - Filters incomplete streaming directives\n * - Converts directive names to PascalCase component names\n */\nfunction remarkDirectivesTransform() {\n  return (tree: Node) => {\n    // Remove invalid directive nodes (e.g., \":02\" in \"14:02\")\n    visit(\n      tree,\n      DIRECTIVE_TYPES,\n      (node: Node, index: number | undefined, parent: Node | undefined) => {\n        if (!isDirectiveNode(node)) {\n          const parentNode = parent as DirectiveNode | undefined\n          if (parentNode?.children && typeof index === 'number') {\n            const nodeName = 'name' in node ? String((node as DirectiveNode).name) : ''\n            parentNode.children[index] = {\n              type: 'text' as DirectiveType,\n              name: '',\n              value: `:${nodeName}`,\n            } as DirectiveNode\n          }\n        }\n      },\n    )\n\n    // Extract directives from list items\n    visit(\n      tree,\n      'list',\n      (node: Node, index: number | undefined, parent: Node | undefined): number | undefined => {\n        const listNode = node as DirectiveNode\n        if (!listNode.children) return undefined\n\n        const transformed: DirectiveNode[] = []\n        let hasTransformed = false\n\n        for (const child of listNode.children) {\n          if (isListItemWithOnlyDirective(child) && child.children?.[0]) {\n            transformed.push(child.children[0])\n            hasTransformed = true\n          } else {\n            transformed.push(child)\n          }\n        }\n\n        const parentNode = parent as DirectiveNode | undefined\n        if (hasTransformed && transformed.every((n) => isDirectiveNode(n))) {\n          if (parentNode?.children && typeof index === 'number') {\n            parentNode.children.splice(index, 1, ...transformed)\n            return index + transformed.length\n          }\n        }\n        return undefined\n      },\n    )\n\n    // Group consecutive leaf directives into DirectivesStack\n    visit(tree, (node: Node) => {\n      const dirNode = node as DirectiveNode\n      if (!dirNode.children?.length || dirNode.data?.hName === 'DirectivesStack') return\n\n      const newChildren: DirectiveNode[] = []\n      let group: DirectiveNode[] = []\n\n      for (const child of dirNode.children) {\n        if (isDirectiveNode(child) && child.type === 'leafDirective') {\n          group.push(child)\n        } else {\n          if (group.length > 0) {\n            newChildren.push({\n              type: 'leafDirective',\n              name: 'DirectivesStack',\n              data: { hName: 'DirectivesStack' },\n              children: group,\n            })\n            group = []\n          }\n          newChildren.push(child)\n        }\n      }\n\n      if (group.length > 0) {\n        newChildren.push({\n          type: 'leafDirective',\n          name: 'DirectivesStack',\n          data: { hName: 'DirectivesStack' },\n          children: group,\n        })\n      }\n\n      dirNode.children = newChildren\n    })\n\n    // Filter incomplete streaming directives\n    visit(tree, 'text', (node: Node) => {\n      const textNode = node as DirectiveNode\n      if (typeof textNode.value === 'string') {\n        if (textNode.value.match(/::?\\w+[{[]/) && !textNode.value.match(/::?\\w+[{[].+[}\\]]/)) {\n          textNode.value = ''\n        }\n      }\n    })\n\n    // Transform directives to React components\n    visit(tree, DIRECTIVE_TYPES, (node: Node) => {\n      if (!isDirectiveNode(node)) return\n\n      node.data = node.data || {}\n      node.data.hName = pascalCase(node.name)\n      node.data.hProperties = {\n        ...node.attributes,\n        isInline: node.type === 'textDirective',\n      }\n    })\n  }\n}\n\ninterface RemarkData {\n  micromarkExtensions?: unknown[]\n  fromMarkdownExtensions?: unknown[]\n  toMarkdownExtensions?: unknown[]\n}\n\n/**\n * Remark plugin for agent directive support.\n * Parses and transforms directive syntax into React components.\n *\n * @example\n * ```tsx\n * import { remarkAgentDirectives } from '@sanity/agent-directives/react'\n *\n * <ReactMarkdown remarkPlugins={[remarkAgentDirectives]}>\n *   {content}\n * </ReactMarkdown>\n * ```\n */\nexport function remarkAgentDirectives(this: Processor) {\n  const data = this.data() as RemarkData\n\n  if (!data.micromarkExtensions) data.micromarkExtensions = []\n  if (!data.fromMarkdownExtensions) data.fromMarkdownExtensions = []\n  if (!data.toMarkdownExtensions) data.toMarkdownExtensions = []\n\n  data.micromarkExtensions.push(directive())\n  data.fromMarkdownExtensions.push(directiveFromMarkdown())\n  data.toMarkdownExtensions.push(directiveToMarkdown())\n\n  return remarkDirectivesTransform()\n}\n\n// ============================================================================\n// Directive Kit\n// ============================================================================\n\nexport interface DirectiveKitOptions<TApplication> {\n  useApplication?: (source: string | undefined) => TApplication | undefined\n}\n\n/**\n * Creates a directive kit with application injection.\n *\n * @example\n * ```tsx\n * // kit.ts\n * export const { defineDirective } = createDirectiveKit<Application>({\n *   useApplication: (source) => useThreadApplication(source),\n * })\n *\n * // Document.tsx\n * export const DocumentDirective = defineDirective('document', ({ id, application }) => {\n *   return <DocumentCard id={id} app={application} />\n * })\n * ```\n */\nexport function createDirectiveKit<TApplication = undefined>(\n  options: DirectiveKitOptions<TApplication> = {},\n) {\n  const { useApplication } = options\n\n  function defineDirective<\n    TName extends DirectiveName,\n    TRequiresApplication extends boolean = true,\n  >(\n    name: TName,\n    render: (props: DirectiveRenderProps<TName, TApplication, TRequiresApplication>) => ReactNode,\n    directiveOptions: DefineDirectiveOptions = {},\n  ): ComponentType<DirectiveComponentProps<TName>> {\n    const requiresContext =\n      directiveOptions.requiresContext ?? directiveOptions.requiresApplication ?? true\n\n    function Directive(props: DirectiveComponentProps<TName>): ReactNode {\n      const { node, source, ...rest } = props\n\n      const application = useApplication?.(source)\n      if (requiresContext && useApplication && !application) return null\n\n      const merged = { ...(node?.properties ?? {}), ...rest }\n\n      const schema = DirectiveSchemas[name]\n      const result = schema.safeParse(merged)\n      if (!result.success) {\n        console.error(`Directive \"${name}\" validation error:`, result.error.format())\n        return null\n      }\n\n      const renderProps = {\n        ...(result.data as DirectiveProps<TName>),\n        ...(requiresContext && useApplication ? { application } : {}),\n        isInline: merged.isInline === true,\n      } as DirectiveRenderProps<TName, TApplication, TRequiresApplication>\n\n      return render(renderProps)\n    }\n\n    Directive.displayName = `Directive(${name})`\n    return Directive\n  }\n\n  return { defineDirective }\n}\n"],"names":[],"mappings":"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"}

package/dist/lib/{string.d.ts → server.d.ts}

@@ -44,7 +44,9 @@ declare function createDirectiveKit<TContext, TOutput>(): {
   registry: DirectiveRegistry<TContext, TOutput>;
 };
 interface DirectiveRenderResult<TBlock = unknown> {
+  /** Markdown text to parse and insert (e.g., `[title](url)` becomes a link) */
   text?: string;
+  /** Blocks to collect (e.g., Slack buttons) */
   blocks?: TBlock[];
 }
 type DirectiveOutput<TBlock = unknown> = string | DirectiveRenderResult<TBlock> | null;
@@ -68,5 +70,37 @@ type RenderFn<TContext, TOutput> = (node: DirectiveNode, context: TContext) => P
  * ```
  */
 declare function createRemarkRenderer<TContext, TBlock>(renderDirective: RenderFn<TContext, DirectiveRenderResult<TBlock> | null>): (context: TContext, collector: BlockCollector<TBlock>) => (tree: Root) => Promise<void>;
-export { BlockCollector, type DefineDirectiveOptions, type DirectiveName, DirectiveNode, DirectiveOutput, DirectiveRenderFn, DirectiveRenderProps, DirectiveRenderResult, RegisteredDirective, createDirectiveKit, createRemarkRenderer, normalizeOutput };
-//# sourceMappingURL=string.d.ts.map
+interface ProcessDirectivesResult<TBlock> {
+  /** Processed markdown with directives replaced */
+  markdown: string;
+  /** Collected blocks from directive outputs (e.g., Slack buttons, Teams cards) */
+  blocks: TBlock[];
+}
+/**
+ * Process markdown containing directives and return the result.
+ *
+ * This is a convenience function that assembles the remark pipeline for you.
+ * Use this instead of manually creating the pipeline with createRemarkRenderer.
+ *
+ * @example
+ * ```ts
+ * // Slack client
+ * const { markdown, blocks } = await processDirectives(
+ *   input,
+ *   context,
+ *   renderDirective
+ * )
+ * return { text: slackifyMarkdown(markdown), blocks }
+ *
+ * // MS Teams client
+ * const { markdown, blocks } = await processDirectives(
+ *   input,
+ *   context,
+ *   renderDirective
+ * )
+ * return { text: markdown, cards: blocks }
+ * ```
+ */
+declare function processDirectives<TContext, TBlock>(input: string, context: TContext, renderFn: RenderFn<TContext, DirectiveRenderResult<TBlock> | null>): Promise<ProcessDirectivesResult<TBlock>>;
+export { BlockCollector, type DefineDirectiveOptions, type DirectiveName, DirectiveNode, DirectiveOutput, DirectiveRenderFn, DirectiveRenderProps, DirectiveRenderResult, ProcessDirectivesResult, RegisteredDirective, createDirectiveKit, createRemarkRenderer, normalizeOutput, processDirectives };
+//# sourceMappingURL=server.d.ts.map

package/dist/lib/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","names":[],"sources":["../../src/lib/server.ts"],"mappings":";;KAqBK,cAAA,WAAyB,aAAA,IAAiB,iBAAA,CAAkB,CAAA;AAAA,UAEhD,aAAA;EACf,IAAA;EACA,IAAA;EACA,UAAA,GAAa,MAAA;EACb,QAAA;AAAA;AAAA,UAGe,oBAAA,eAAmC,aAAA;EAClD,KAAA,EAAO,cAAA,CAAe,KAAA;EACtB,OAAA,EAAS,QAAA;EACT,QAAA;EACA,QAAA;AAAA;AAAA,KAGU,iBAAA,eAAgC,aAAA,wBAC1C,IAAA,EAAM,oBAAA,CAAqB,KAAA,EAAO,QAAA,MAC/B,OAAA,UAAiB,OAAA,CAAQ,OAAA;AAAA,UAQb,mBAAA;EACf,IAAA,EAAM,aAAA;EACN,MAAA,EAAQ,iBAAA,CAAkB,aAAA,EAAe,QAAA,EAAU,OAAA;EACnD,OAAA,EAAS,sBAAA;AAAA;AAAA,KAGN,iBAAA,sBAAuC,MAAA,SAAe,mBAAA,CAAoB,QAAA,EAAU,OAAA;;;;;AAvBzF;;;;;;;;;;;;;;iBA8DgB,kBAAA,mBAAA,CAAA;kCAGyB,aAAA,EAAa,IAAA,EAC5C,KAAA,EAAK,MAAA,EACH,iBAAA,CAAkB,KAAA,EAAO,QAAA,EAAU,OAAA,GAAQ,OAAA,GAC1C,sBAAA,KAAsB,mBAAA,CAAA,QAAA,EAAA,OAAA;0BAWI,aAAA,EAAa,OAAA,EAAW,QAAA,KAAW,OAAA,CAAQ,OAAA;;;UA4BjE,qBAAA;EAvGP;EAyGR,IAAA;EAtG2B;EAwG3B,MAAA,GAAS,MAAA;AAAA;AAAA,KAGC,eAAA,8BAA6C,qBAAA,CAAsB,MAAA;AAAA,iBAE/D,eAAA,QAAA,CACd,MAAA,EAAQ,eAAA,CAAgB,MAAA,IACvB,qBAAA,CAAsB,MAAA;AAAA,UAoCR,cAAA;EACf,MAAA,EAAQ,MAAA;AAAA;AAAA,KAGL,QAAA,uBACH,IAAA,EAAM,aAAA,EACN,OAAA,EAAS,QAAA,KACN,OAAA,CAAQ,OAAA;;;;;;;;;;;;;;;iBAgBG,oBAAA,kBAAA,CACd,eAAA,EAAiB,QAAA,CAAS,QAAA,EAAU,qBAAA,CAAsB,MAAA,aAEnB,OAAA,EAAS,QAAA,EAAU,SAAA,EAAW,cAAA,CAAe,MAAA,OACpE,IAAA,EAAM,IAAA,KAAO,OAAA;AAAA,UA2Dd,uBAAA;EA/NmB;EAiOlC,QAAA;EAhOM;EAkON,MAAA,EAAQ,MAAA;AAAA;;;;;;;;;;;;;;;;;;;AA/NT;;;;;;;iBA2PqB,iBAAA,kBAAA,CACpB,KAAA,UACA,OAAA,EAAS,QAAA,EACT,QAAA,EAAU,QAAA,CAAS,QAAA,EAAU,qBAAA,CAAsB,MAAA,YAClD,OAAA,CAAQ,uBAAA,CAAwB,MAAA"}

package/dist/lib/{string.js → server.js}

@@ -1,5 +1,9 @@
+import remarkDirective from "remark-directive";
+import remarkParse from "remark-parse";
+import remarkStringify from "remark-stringify";
+import { unified } from "unified";
 import { visit } from "unist-util-visit";
-import { DirectiveSchemas } from "../index.js";
+import { DIRECTIVE_TYPES, DirectiveSchemas } from "../_chunks-es/formatters.js";
 function extractChildren(node) {
   if (!node.children || !Array.isArray(node.children))
     return "";
@@ -36,7 +40,9 @@ function createDirectiveKit() {
 function normalizeOutput(output) {
   return output === null ? null : typeof output == "string" ? { text: output } : output;
 }
-const DIRECTIVE_TYPES = ["textDirective", "leafDirective", "containerDirective"];
+function parseMarkdown(markdown) {
+  return unified().use(remarkParse).parse(markdown);
+}
 function isDirectiveNode(node) {
   return typeof node == "object" && node !== null && "type" in node && typeof node.type == "string" && DIRECTIVE_TYPES.includes(node.type) && "name" in node && typeof node.name == "string";
 }
@@ -56,10 +62,16 @@ function createRemarkRenderer(renderDirective) {
       for (let i = replacements.length - 1; i >= 0; i--) {
         const { node, index, parent, output } = replacements[i];
         if (output?.blocks && collector.blocks.unshift(...output.blocks), output?.text) {
-          parent.children.splice(index, 1, {
-            type: "paragraph",
-            children: [{ type: "text", value: output.text }]
-          });
+          const parsed = parseMarkdown(output.text);
+          if (node.type === "textDirective") {
+            const firstNode = parsed.children[0];
+            if (firstNode?.type === "paragraph") {
+              const paragraph = firstNode;
+              parent.children.splice(index, 1, ...paragraph.children);
+            } else
+              parent.children.splice(index, 1, ...parsed.children);
+          } else
+            parent.children.splice(index, 1, ...parsed.children);
           continue;
         }
         if (node.type === "containerDirective" && node.children && node.children.length > 0) {
@@ -72,9 +84,17 @@ function createRemarkRenderer(renderDirective) {
     };
   };
 }
+async function processDirectives(input, context, renderFn) {
+  const collector = { blocks: [] }, remarkRenderDirectives = createRemarkRenderer(renderFn), file = await unified().use(remarkParse).use(remarkDirective).use(remarkRenderDirectives, context, collector).use(remarkStringify).process(input);
+  return {
+    markdown: String(file),
+    blocks: collector.blocks
+  };
+}
 export {
   createDirectiveKit,
   createRemarkRenderer,
-  normalizeOutput
+  normalizeOutput,
+  processDirectives
 };
-//# sourceMappingURL=string.js.map
+//# sourceMappingURL=server.js.map

package/dist/lib/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sources":["../../src/lib/server.ts"],"sourcesContent":["import type { Paragraph, Parent, Root, RootContent } from 'mdast'\nimport type { ContainerDirective } from 'mdast-util-directive'\nimport remarkDirective from 'remark-directive'\nimport remarkParse from 'remark-parse'\nimport remarkStringify from 'remark-stringify'\nimport { unified } from 'unified'\nimport { visit } from 'unist-util-visit'\nimport {\n  type DefineDirectiveOptions,\n  DIRECTIVE_TYPES,\n  type DirectiveName,\n  type DirectivePropsMap,\n  DirectiveSchemas,\n} from '../_internal'\n\nexport type { DirectiveName }\n\n// ============================================================================\n// Types\n// ============================================================================\n\ntype DirectiveProps<T extends DirectiveName> = DirectivePropsMap[T]\n\nexport interface DirectiveNode {\n  type: 'textDirective' | 'leafDirective' | 'containerDirective'\n  name: string\n  attributes?: Record<string, string | null | undefined>\n  children?: unknown[]\n}\n\nexport interface DirectiveRenderProps<TName extends DirectiveName, TContext> {\n  props: DirectiveProps<TName>\n  context: TContext\n  children: string\n  isInline: boolean\n}\n\nexport type DirectiveRenderFn<TName extends DirectiveName, TContext, TOutput> = (\n  args: DirectiveRenderProps<TName, TContext>,\n) => TOutput | null | Promise<TOutput | null>\n\nexport type { DefineDirectiveOptions }\n\n// ============================================================================\n// Directive Kit\n// ============================================================================\n\nexport interface RegisteredDirective<TContext, TOutput> {\n  name: DirectiveName\n  render: DirectiveRenderFn<DirectiveName, TContext, TOutput>\n  options: DefineDirectiveOptions\n}\n\ntype DirectiveRegistry<TContext, TOutput> = Record<string, RegisteredDirective<TContext, TOutput>>\n\nfunction extractChildren(node: DirectiveNode): string {\n  if (!node.children || !Array.isArray(node.children)) {\n    return ''\n  }\n\n  function extractText(n: unknown): string {\n    if (!n || typeof n !== 'object') return ''\n    if ('type' in n && n.type === 'text' && 'value' in n && typeof n.value === 'string') {\n      return n.value\n    }\n    if ('children' in n && Array.isArray(n.children)) {\n      return n.children.map(extractText).join('')\n    }\n    return ''\n  }\n\n  return node.children.map(extractText).join('')\n}\n\n/**\n * Creates a directive kit for server-side rendering.\n *\n * @example\n * ```ts\n * // kit.ts\n * export const { defineDirective, renderDirective } = createDirectiveKit<\n *   SlackContext,\n *   SlackOutput\n * >()\n *\n * // document.ts\n * defineDirective('document', async ({ props, context }) => {\n *   const doc = await fetchDocument(props.id, context.accessToken)\n *   return { blocks: [linkButton(doc.title, url)] }\n * })\n * ```\n */\nexport function createDirectiveKit<TContext, TOutput>() {\n  const registry: DirectiveRegistry<TContext, TOutput> = {}\n\n  function defineDirective<TName extends DirectiveName>(\n    name: TName,\n    render: DirectiveRenderFn<TName, TContext, TOutput>,\n    options: DefineDirectiveOptions = {},\n  ) {\n    const directive: RegisteredDirective<TContext, TOutput> = {\n      name,\n      render: render as DirectiveRenderFn<DirectiveName, TContext, TOutput>,\n      options,\n    }\n    registry[name] = directive\n    return directive\n  }\n\n  async function renderDirective(node: DirectiveNode, context: TContext): Promise<TOutput | null> {\n    const directive = registry[node.name]\n    if (!directive) return null\n\n    const schema = DirectiveSchemas[node.name as DirectiveName]\n    if (!schema) return null\n\n    const result = schema.safeParse(node.attributes ?? {})\n    if (!result.success) {\n      console.error(`Directive \"${node.name}\" validation error:`, result.error.format())\n      return null\n    }\n\n    return directive.render({\n      props: result.data as DirectiveProps<DirectiveName>,\n      context,\n      children: extractChildren(node),\n      isInline: node.type === 'textDirective',\n    })\n  }\n\n  return { defineDirective, renderDirective, registry }\n}\n\n// ============================================================================\n// Output Utilities\n// ============================================================================\n\nexport interface DirectiveRenderResult<TBlock = unknown> {\n  /** Markdown text to parse and insert (e.g., `[title](url)` becomes a link) */\n  text?: string\n  /** Blocks to collect (e.g., Slack buttons) */\n  blocks?: TBlock[]\n}\n\nexport type DirectiveOutput<TBlock = unknown> = string | DirectiveRenderResult<TBlock> | null\n\nexport function normalizeOutput<TBlock>(\n  output: DirectiveOutput<TBlock>,\n): DirectiveRenderResult<TBlock> | null {\n  if (output === null) return null\n  if (typeof output === 'string') return { text: output }\n  return output\n}\n\n/**\n * Parse a markdown string into AST nodes.\n * Used to convert directive text output into proper AST.\n */\nfunction parseMarkdown(markdown: string): Root {\n  return unified().use(remarkParse).parse(markdown)\n}\n\n// ============================================================================\n// Remark Plugin\n// ============================================================================\n\nfunction isDirectiveNode(node: unknown): node is DirectiveNode {\n  return (\n    typeof node === 'object' &&\n    node !== null &&\n    'type' in node &&\n    typeof node.type === 'string' &&\n    DIRECTIVE_TYPES.includes(node.type as (typeof DIRECTIVE_TYPES)[number]) &&\n    'name' in node &&\n    typeof node.name === 'string'\n  )\n}\n\ninterface DirectiveLocation {\n  node: DirectiveNode\n  index: number\n  parent: Parent\n}\n\nexport interface BlockCollector<TBlock = unknown> {\n  blocks: TBlock[]\n}\n\ntype RenderFn<TContext, TOutput> = (\n  node: DirectiveNode,\n  context: TContext,\n) => Promise<TOutput | null>\n\n/**\n * Creates a remark plugin that renders directives and collects output blocks.\n *\n * @example\n * ```ts\n * const remarkRenderDirectives = createRemarkRenderer<SlackContext, SlackBlock>(renderDirective)\n *\n * unified()\n *   .use(remarkParse)\n *   .use(remarkDirective)\n *   .use(remarkRenderDirectives, context, collector)\n *   .use(remarkStringify)\n * ```\n */\nexport function createRemarkRenderer<TContext, TBlock>(\n  renderDirective: RenderFn<TContext, DirectiveRenderResult<TBlock> | null>,\n) {\n  return function remarkRenderDirectives(context: TContext, collector: BlockCollector<TBlock>) {\n    return async (tree: Root): Promise<void> => {\n      const locations: DirectiveLocation[] = []\n\n      visit(tree, DIRECTIVE_TYPES, (node, index, parent) => {\n        if (!isDirectiveNode(node)) return\n        if (!parent || typeof index !== 'number') return\n        locations.push({ node, index, parent })\n      })\n\n      const replacements = await Promise.all(\n        locations.map(async (loc) => ({\n          ...loc,\n          output: normalizeOutput(await renderDirective(loc.node, context)),\n        })),\n      )\n\n      for (let i = replacements.length - 1; i >= 0; i--) {\n        const { node, index, parent, output } = replacements[i]\n\n        if (output?.blocks) {\n          collector.blocks.unshift(...output.blocks)\n        }\n\n        if (output?.text) {\n          // Parse the markdown text into AST nodes\n          const parsed = parseMarkdown(output.text)\n\n          if (node.type === 'textDirective') {\n            // For inline directives, extract inline content from the parsed paragraph\n            const firstNode = parsed.children[0]\n            if (firstNode?.type === 'paragraph') {\n              const paragraph = firstNode as Paragraph\n              parent.children.splice(index, 1, ...paragraph.children)\n            } else {\n              parent.children.splice(index, 1, ...parsed.children)\n            }\n          } else {\n            // For block directives, insert all parsed nodes\n            parent.children.splice(index, 1, ...parsed.children)\n          }\n          continue\n        }\n\n        if (node.type === 'containerDirective' && node.children && node.children.length > 0) {\n          const containerNode = node as unknown as ContainerDirective\n          parent.children.splice(index, 1, ...(containerNode.children as RootContent[]))\n          continue\n        }\n\n        parent.children.splice(index, 1)\n      }\n    }\n  }\n}\n\n// ============================================================================\n// Process Directives Helper\n// ============================================================================\n\nexport interface ProcessDirectivesResult<TBlock> {\n  /** Processed markdown with directives replaced */\n  markdown: string\n  /** Collected blocks from directive outputs (e.g., Slack buttons, Teams cards) */\n  blocks: TBlock[]\n}\n\n/**\n * Process markdown containing directives and return the result.\n *\n * This is a convenience function that assembles the remark pipeline for you.\n * Use this instead of manually creating the pipeline with createRemarkRenderer.\n *\n * @example\n * ```ts\n * // Slack client\n * const { markdown, blocks } = await processDirectives(\n *   input,\n *   context,\n *   renderDirective\n * )\n * return { text: slackifyMarkdown(markdown), blocks }\n *\n * // MS Teams client\n * const { markdown, blocks } = await processDirectives(\n *   input,\n *   context,\n *   renderDirective\n * )\n * return { text: markdown, cards: blocks }\n * ```\n */\nexport async function processDirectives<TContext, TBlock>(\n  input: string,\n  context: TContext,\n  renderFn: RenderFn<TContext, DirectiveRenderResult<TBlock> | null>,\n): Promise<ProcessDirectivesResult<TBlock>> {\n  const collector: BlockCollector<TBlock> = { blocks: [] }\n  const remarkRenderDirectives = createRemarkRenderer(renderFn)\n\n  const processor = unified()\n    .use(remarkParse)\n    .use(remarkDirective)\n    .use(remarkRenderDirectives, context, collector)\n    .use(remarkStringify)\n\n  const file = await processor.process(input)\n\n  return {\n    markdown: String(file),\n    blocks: collector.blocks,\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/lib/streaming.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Streaming utilities for handling directive syntax during real-time text streaming.
+ *
+ * When streaming text that contains directives (e.g., `::document{id="123"}`),
+ * we need to buffer potential directive content and strip complete directives
+ * from the streamed output, since they'll be rendered as blocks/components
+ * at the end of the stream.
+ *
+ * @example
+ * ```ts
+ * import { createDirectiveStreamBuffer } from '@sanity/agent-directives/streaming'
+ *
+ * const buffer = createDirectiveStreamBuffer()
+ *
+ * for await (const chunk of stream) {
+ *   const textToStream = buffer.process(chunk)
+ *   if (textToStream) {
+ *     await sendToClient(textToStream)
+ *   }
+ * }
+ *
+ * // Flush any remaining content when stream ends
+ * const remaining = buffer.flush()
+ * if (remaining) {
+ *   await sendToClient(remaining)
+ * }
+ * ```
+ */
+interface DirectiveStreamBuffer {
+  /**
+   * Process incoming text chunk and return text safe to stream.
+   * Directives are buffered and stripped from output.
+   *
+   * @param chunk - Incoming text chunk
+   * @returns Text safe to stream (directives removed)
+   */
+  process(chunk: string): string;
+  /**
+   * Flush any remaining buffered content.
+   * Call this when streaming is complete.
+   *
+   * @returns Any remaining text (with complete directives stripped)
+   */
+  flush(): string;
+  /**
+   * Reset the buffer to initial state.
+   */
+  reset(): void;
+}
+/**
+ * Parsed directive information passed to the processor callback.
+ */
+interface ParsedDirective {
+  name: string;
+  attributes: Record<string, string>;
+  children: string;
+}
+/**
+ * Callback function for processing a complete directive.
+ * Returns the text to insert in place of the directive syntax.
+ */
+type DirectiveProcessor = (directive: ParsedDirective) => Promise<string>;
+/**
+ * A streaming processor that transforms directives using a callback.
+ * Unlike DirectiveStreamBuffer which strips directives, this processes them.
+ */
+interface DirectiveStreamProcessor {
+  /**
+   * Process incoming text chunk and return text with directives transformed.
+   * Complete directives are passed to the processor callback.
+   *
+   * @param chunk - Incoming text chunk
+   * @returns Text with complete directives replaced by processor output
+   */
+  process(chunk: string): Promise<string>;
+  /**
+   * Flush any remaining buffered content.
+   * Call this when streaming is complete.
+   *
+   * @returns Any remaining text with directives processed
+   */
+  flush(): Promise<string>;
+  /**
+   * Reset the processor to initial state.
+   */
+  reset(): void;
+}
+/**
+ * Creates a buffer for handling directive syntax during streaming.
+ *
+ * Directives have the pattern: `::name{prop="value" prop2="value2"}`
+ *
+ * During streaming, the buffer:
+ * 1. Streams non-directive text immediately
+ * 2. Buffers potential directive content until it can determine if it's complete
+ * 3. Strips complete directives from output (they'll be rendered as blocks at the end)
+ *
+ * This approach is similar to the React implementation which filters incomplete
+ * directives using pattern matching, but adapted for incremental streaming where
+ * we can't "unsend" text that was already streamed.
+ */
+declare function createDirectiveStreamBuffer(): DirectiveStreamBuffer;
+/**
+ * Creates a streaming processor that transforms directives using a callback.
+ *
+ * Unlike `createDirectiveStreamBuffer` which strips directives from output,
+ * this processor passes complete directives to a callback and replaces them
+ * with the callback's return value. This enables clients to render directives
+ * as links, cards, or other formats during streaming.
+ *
+ * @example
+ * ```ts
+ * import { createDirectiveStreamProcessor } from '@sanity/agent-directives/streaming'
+ *
+ * // Slack client example
+ * const processor = createDirectiveStreamProcessor(async ({ name, attributes }) => {
+ *   if (name === 'document') {
+ *     const doc = await fetchDocument(attributes.id)
+ *     return `[${doc.title}](${doc.url})`
+ *   }
+ *   return `[${name}]`
+ * })
+ *
+ * for await (const chunk of llmStream) {
+ *   const text = await processor.process(chunk)
+ *   if (text) {
+ *     await streamToClient(text)
+ *   }
+ * }
+ *
+ * const remaining = await processor.flush()
+ * if (remaining) {
+ *   await streamToClient(remaining)
+ * }
+ * ```
+ */
+declare function createDirectiveStreamProcessor(processDirective: DirectiveProcessor): DirectiveStreamProcessor;
+export { DirectiveProcessor, DirectiveStreamBuffer, DirectiveStreamProcessor, ParsedDirective, createDirectiveStreamBuffer, createDirectiveStreamProcessor };
+//# sourceMappingURL=streaming.d.ts.map

package/dist/lib/streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.d.ts","names":[],"sources":["../../src/lib/streaming.ts"],"mappings":"AA6BA;;;;;;;;;;AA2BA;;;;;;;;;;AAUA;;;;;;;;AArCA,UAAiB,qBAAA;EA2CA;;;;;;;EAnCf,OAAA,CAAQ,KAAA;EAmDC;;;;AAsBX;;EAjEE,KAAA;EAiE6C;;AA0M/C;EAtQE,KAAA;AAAA;;;;UAMe,eAAA;EACf,IAAA;EACA,UAAA,EAAY,MAAA;EACZ,QAAA;AAAA;;;;;KAOU,kBAAA,IAAsB,SAAA,EAAW,eAAA,KAAoB,OAAA;;;;;UAMhD,wBAAA;;;;;;;;EAQf,OAAA,CAAQ,KAAA,WAAgB,OAAA;;;;;;;EAQxB,KAAA,IAAS,OAAA;;;;EAKT,KAAA;AAAA;;;;;;;;;;;;;;;iBAiBc,2BAAA,CAAA,GAA+B,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0M/B,8BAAA,CACd,gBAAA,EAAkB,kBAAA,GACjB,wBAAA"}

package/dist/lib/streaming.js

@@ -0,0 +1,185 @@
+function createDirectiveStreamBuffer() {
+  let buffer = "";
+  function process(chunk) {
+    return buffer += chunk, extractStreamableText();
+  }
+  function flush() {
+    const remaining = buffer;
+    return buffer = "", stripCompleteDirectives(remaining);
+  }
+  function reset() {
+    buffer = "";
+  }
+  function extractStreamableText() {
+    let output = "";
+    for (; buffer.length > 0; ) {
+      const colonIndex = buffer.indexOf(":");
+      if (colonIndex === -1) {
+        output += buffer, buffer = "";
+        break;
+      }
+      if (colonIndex > 0 && (output += buffer.slice(0, colonIndex), buffer = buffer.slice(colonIndex)), buffer === ":")
+        break;
+      if (buffer.startsWith("::")) {
+        if (!looksLikeBlockDirectiveStart(buffer)) {
+          output += "::", buffer = buffer.slice(2);
+          continue;
+        }
+        const blockMatch = buffer.match(BLOCK_DIRECTIVE);
+        if (blockMatch) {
+          buffer = buffer.slice(blockMatch[0].length);
+          continue;
+        }
+        if (isDefinitelyNotBlockDirective(buffer)) {
+          output += buffer.slice(0, 2), buffer = buffer.slice(2);
+          continue;
+        }
+        break;
+      }
+      if (looksLikeInlineDirectiveStart(buffer)) {
+        const inlineMatch = buffer.match(INLINE_DIRECTIVE);
+        if (inlineMatch) {
+          buffer = buffer.slice(inlineMatch[0].length);
+          continue;
+        }
+        if (isDefinitelyNotInlineDirective(buffer)) {
+          output += ":", buffer = buffer.slice(1);
+          continue;
+        }
+        break;
+      }
+      output += ":", buffer = buffer.slice(1);
+    }
+    return output;
+  }
+  function stripCompleteDirectives(text) {
+    return text.replace(new RegExp(BLOCK_DIRECTIVE.source, "g"), "").replace(new RegExp(INLINE_DIRECTIVE.source, "g"), "");
+  }
+  return {
+    process,
+    flush,
+    reset
+  };
+}
+function parseDirectiveAttributes(attrString) {
+  const attrs = {};
+  for (const match of attrString.matchAll(/(\w+)="([^"]*)"/g))
+    attrs[match[1]] = match[2];
+  return attrs;
+}
+const BLOCK_DIRECTIVE = /::([a-zA-Z]\w*)(?:\[([^\]]*)\])?\{([^}]*)\}/, INLINE_DIRECTIVE = /:([a-zA-Z]\w*)\[([^\]]*)\]\{([^}]*)\}/;
+function looksLikeBlockDirectiveStart(text) {
+  return text.startsWith("::") ? text.length === 2 ? !0 : /[a-zA-Z[{]/.test(text[2]) : !1;
+}
+function looksLikeInlineDirectiveStart(text) {
+  return text.length === 1 ? !0 : /[a-zA-Z]/.test(text[1]);
+}
+function isDefinitelyNotBlockDirective(text) {
+  const nameMatch = text.match(/^::([a-zA-Z]\w*)/);
+  return nameMatch ? isDefinitelyNotDirectiveAfterName(text.slice(nameMatch[0].length), !1) : text.length > 2 && !/[a-zA-Z]/.test(text[2]);
+}
+function isDefinitelyNotInlineDirective(text) {
+  const nameMatch = text.match(/^:([a-zA-Z]\w*)/);
+  return nameMatch ? isDefinitelyNotDirectiveAfterName(text.slice(nameMatch[0].length), !0) : text.length > 1 && !/[a-zA-Z]/.test(text[1]);
+}
+function isDefinitelyNotDirectiveAfterName(afterName, requireBrackets) {
+  if (afterName.length === 0) return !1;
+  if (afterName[0] === "{") return requireBrackets;
+  if (afterName[0] === "[") {
+    const bracketEnd = afterName.indexOf("]");
+    if (bracketEnd === -1) return !1;
+    const afterBracket = afterName.slice(bracketEnd + 1);
+    return afterBracket.length === 0 ? !1 : afterBracket[0] !== "{";
+  }
+  return !0;
+}
+function createDirectiveStreamProcessor(processDirective) {
+  let buffer = "";
+  async function process(chunk) {
+    buffer += chunk;
+    let output = "";
+    for (; buffer.length > 0; ) {
+      const colonIndex = buffer.indexOf(":");
+      if (colonIndex === -1) {
+        output += buffer, buffer = "";
+        break;
+      }
+      if (colonIndex > 0 && (output += buffer.slice(0, colonIndex), buffer = buffer.slice(colonIndex)), buffer === ":") break;
+      if (buffer.startsWith("::")) {
+        if (!looksLikeBlockDirectiveStart(buffer)) {
+          output += "::", buffer = buffer.slice(2);
+          continue;
+        }
+        const blockMatch = buffer.match(BLOCK_DIRECTIVE);
+        if (blockMatch) {
+          const [fullMatch, name, children, attrString] = blockMatch, attributes = parseDirectiveAttributes(attrString);
+          output += await processDirective({ name, attributes, children: children ?? "" }), buffer = buffer.slice(fullMatch.length);
+          continue;
+        }
+        if (isDefinitelyNotBlockDirective(buffer)) {
+          output += buffer.slice(0, 2), buffer = buffer.slice(2);
+          continue;
+        }
+        break;
+      }
+      if (looksLikeInlineDirectiveStart(buffer)) {
+        const inlineMatch = buffer.match(INLINE_DIRECTIVE);
+        if (inlineMatch) {
+          const [fullMatch, name, children, attrString] = inlineMatch, attributes = parseDirectiveAttributes(attrString);
+          output += await processDirective({ name, attributes, children }), buffer = buffer.slice(fullMatch.length);
+          continue;
+        }
+        if (isDefinitelyNotInlineDirective(buffer)) {
+          output += ":", buffer = buffer.slice(1);
+          continue;
+        }
+        break;
+      }
+      output += ":", buffer = buffer.slice(1);
+    }
+    return output;
+  }
+  async function flush() {
+    const remaining = buffer;
+    buffer = "";
+    let output = "", text = remaining;
+    for (; text.length > 0; ) {
+      const inlineMatch = text.match(INLINE_DIRECTIVE), blockMatch = text.match(BLOCK_DIRECTIVE), inlineIdx = inlineMatch?.index ?? 1 / 0, blockIdx = blockMatch?.index ?? 1 / 0;
+      if (inlineIdx === 1 / 0 && blockIdx === 1 / 0) {
+        output += text;
+        break;
+      }
+      if (inlineIdx <= blockIdx && inlineMatch) {
+        output += text.slice(0, inlineMatch.index);
+        const attributes = parseDirectiveAttributes(inlineMatch[3]);
+        output += await processDirective({
+          name: inlineMatch[1],
+          attributes,
+          children: inlineMatch[2]
+        }), text = text.slice(inlineMatch.index + inlineMatch[0].length);
+      } else if (blockMatch) {
+        output += text.slice(0, blockMatch.index);
+        const attributes = parseDirectiveAttributes(blockMatch[3]);
+        output += await processDirective({
+          name: blockMatch[1],
+          attributes,
+          children: blockMatch[2] ?? ""
+        }), text = text.slice(blockMatch.index + blockMatch[0].length);
+      }
+    }
+    return output;
+  }
+  function reset() {
+    buffer = "";
+  }
+  return {
+    process,
+    flush,
+    reset
+  };
+}
+export {
+  createDirectiveStreamBuffer,
+  createDirectiveStreamProcessor
+};
+//# sourceMappingURL=streaming.js.map

package/dist/lib/streaming.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.js","sources":["../../src/lib/streaming.ts"],"sourcesContent":["/**\n * Streaming utilities for handling directive syntax during real-time text streaming.\n *\n * When streaming text that contains directives (e.g., `::document{id=\"123\"}`),\n * we need to buffer potential directive content and strip complete directives\n * from the streamed output, since they'll be rendered as blocks/components\n * at the end of the stream.\n *\n * @example\n * ```ts\n * import { createDirectiveStreamBuffer } from '@sanity/agent-directives/streaming'\n *\n * const buffer = createDirectiveStreamBuffer()\n *\n * for await (const chunk of stream) {\n *   const textToStream = buffer.process(chunk)\n *   if (textToStream) {\n *     await sendToClient(textToStream)\n *   }\n * }\n *\n * // Flush any remaining content when stream ends\n * const remaining = buffer.flush()\n * if (remaining) {\n *   await sendToClient(remaining)\n * }\n * ```\n */\n\nexport interface DirectiveStreamBuffer {\n  /**\n   * Process incoming text chunk and return text safe to stream.\n   * Directives are buffered and stripped from output.\n   *\n   * @param chunk - Incoming text chunk\n   * @returns Text safe to stream (directives removed)\n   */\n  process(chunk: string): string\n\n  /**\n   * Flush any remaining buffered content.\n   * Call this when streaming is complete.\n   *\n   * @returns Any remaining text (with complete directives stripped)\n   */\n  flush(): string\n\n  /**\n   * Reset the buffer to initial state.\n   */\n  reset(): void\n}\n\n/**\n * Parsed directive information passed to the processor callback.\n */\nexport interface ParsedDirective {\n  name: string\n  attributes: Record<string, string>\n  children: string\n}\n\n/**\n * Callback function for processing a complete directive.\n * Returns the text to insert in place of the directive syntax.\n */\nexport type DirectiveProcessor = (directive: ParsedDirective) => Promise<string>\n\n/**\n * A streaming processor that transforms directives using a callback.\n * Unlike DirectiveStreamBuffer which strips directives, this processes them.\n */\nexport interface DirectiveStreamProcessor {\n  /**\n   * Process incoming text chunk and return text with directives transformed.\n   * Complete directives are passed to the processor callback.\n   *\n   * @param chunk - Incoming text chunk\n   * @returns Text with complete directives replaced by processor output\n   */\n  process(chunk: string): Promise<string>\n\n  /**\n   * Flush any remaining buffered content.\n   * Call this when streaming is complete.\n   *\n   * @returns Any remaining text with directives processed\n   */\n  flush(): Promise<string>\n\n  /**\n   * Reset the processor to initial state.\n   */\n  reset(): void\n}\n\n/**\n * Creates a buffer for handling directive syntax during streaming.\n *\n * Directives have the pattern: `::name{prop=\"value\" prop2=\"value2\"}`\n *\n * During streaming, the buffer:\n * 1. Streams non-directive text immediately\n * 2. Buffers potential directive content until it can determine if it's complete\n * 3. Strips complete directives from output (they'll be rendered as blocks at the end)\n *\n * This approach is similar to the React implementation which filters incomplete\n * directives using pattern matching, but adapted for incremental streaming where\n * we can't \"unsend\" text that was already streamed.\n */\nexport function createDirectiveStreamBuffer(): DirectiveStreamBuffer {\n  let buffer = ''\n\n  function process(chunk: string): string {\n    buffer += chunk\n    return extractStreamableText()\n  }\n\n  function flush(): string {\n    const remaining = buffer\n    buffer = ''\n    // Strip any complete directives from remaining text\n    return stripCompleteDirectives(remaining)\n  }\n\n  function reset(): void {\n    buffer = ''\n  }\n\n  function extractStreamableText(): string {\n    let output = ''\n\n    while (buffer.length > 0) {\n      // Find potential directive start (colon that might become ::)\n      const colonIndex = buffer.indexOf(':')\n\n      if (colonIndex === -1) {\n        // No colon found - safe to output everything\n        output += buffer\n        buffer = ''\n        break\n      }\n\n      // Output text before the colon\n      if (colonIndex > 0) {\n        output += buffer.slice(0, colonIndex)\n        buffer = buffer.slice(colonIndex)\n      }\n\n      // Now buffer starts with ':'\n      // If buffer is just a single ':', keep it buffered - might become '::' with next chunk\n      if (buffer === ':') {\n        break\n      }\n\n      // Block directive (::name{...})\n      if (buffer.startsWith('::')) {\n        if (!looksLikeBlockDirectiveStart(buffer)) {\n          output += '::'\n          buffer = buffer.slice(2)\n          continue\n        }\n        const blockMatch = buffer.match(BLOCK_DIRECTIVE)\n        if (blockMatch) {\n          buffer = buffer.slice(blockMatch[0].length)\n          continue\n        }\n        if (isDefinitelyNotBlockDirective(buffer)) {\n          output += buffer.slice(0, 2)\n          buffer = buffer.slice(2)\n          continue\n        }\n        break\n      }\n\n      // Inline directive (:name[content]{...})\n      if (looksLikeInlineDirectiveStart(buffer)) {\n        const inlineMatch = buffer.match(INLINE_DIRECTIVE)\n        if (inlineMatch) {\n          buffer = buffer.slice(inlineMatch[0].length)\n          continue\n        }\n        if (isDefinitelyNotInlineDirective(buffer)) {\n          output += ':'\n          buffer = buffer.slice(1)\n          continue\n        }\n        break\n      }\n\n      // Not a directive\n      output += ':'\n      buffer = buffer.slice(1)\n    }\n\n    return output\n  }\n\n  function stripCompleteDirectives(text: string): string {\n    return text\n      .replace(new RegExp(BLOCK_DIRECTIVE.source, 'g'), '')\n      .replace(new RegExp(INLINE_DIRECTIVE.source, 'g'), '')\n  }\n\n  return {\n    process,\n    flush,\n    reset,\n  }\n}\n\n/**\n * Parses directive attributes from a string like: id=\"123\" type=\"post\"\n */\nfunction parseDirectiveAttributes(attrString: string): Record<string, string> {\n  const attrs: Record<string, string> = {}\n  for (const match of attrString.matchAll(/(\\w+)=\"([^\"]*)\"/g)) {\n    attrs[match[1]] = match[2]\n  }\n  return attrs\n}\n\n// ============================================================================\n// Directive regex patterns\n// ============================================================================\n\n// Matches block directives: ::name{attrs} or ::name[label]{attrs}\n// Captures: (1) name, (2) label or undefined, (3) attribute string\nconst BLOCK_DIRECTIVE = /::([a-zA-Z]\\w*)(?:\\[([^\\]]*)\\])?\\{([^}]*)\\}/\n\n// Matches inline directives: :name[label]{attrs}\n// Captures: (1) name, (2) label, (3) attribute string\nconst INLINE_DIRECTIVE = /:([a-zA-Z]\\w*)\\[([^\\]]*)\\]\\{([^}]*)\\}/\n\n// ============================================================================\n// Streaming detection helpers\n// ============================================================================\n\nfunction looksLikeBlockDirectiveStart(text: string): boolean {\n  if (!text.startsWith('::')) return false\n  if (text.length === 2) return true\n  return /[a-zA-Z[{]/.test(text[2])\n}\n\nfunction looksLikeInlineDirectiveStart(text: string): boolean {\n  if (text.length === 1) return true\n  return /[a-zA-Z]/.test(text[1])\n}\n\nfunction isDefinitelyNotBlockDirective(text: string): boolean {\n  const nameMatch = text.match(/^::([a-zA-Z]\\w*)/)\n  if (!nameMatch) return text.length > 2 && !/[a-zA-Z]/.test(text[2])\n  return isDefinitelyNotDirectiveAfterName(text.slice(nameMatch[0].length), false)\n}\n\nfunction isDefinitelyNotInlineDirective(text: string): boolean {\n  const nameMatch = text.match(/^:([a-zA-Z]\\w*)/)\n  if (!nameMatch) return text.length > 1 && !/[a-zA-Z]/.test(text[1])\n  return isDefinitelyNotDirectiveAfterName(text.slice(nameMatch[0].length), true)\n}\n\n/**\n * Checks whether text after a directive name can still form a valid directive.\n * Block directives accept `{` (attrs) or `[` (label). Inline requires `[`.\n */\nfunction isDefinitelyNotDirectiveAfterName(afterName: string, requireBrackets: boolean): boolean {\n  if (afterName.length === 0) return false\n  if (afterName[0] === '{') return requireBrackets\n  if (afterName[0] === '[') {\n    const bracketEnd = afterName.indexOf(']')\n    if (bracketEnd === -1) return false\n    const afterBracket = afterName.slice(bracketEnd + 1)\n    if (afterBracket.length === 0) return false\n    return afterBracket[0] !== '{'\n  }\n  return true\n}\n\n/**\n * Creates a streaming processor that transforms directives using a callback.\n *\n * Unlike `createDirectiveStreamBuffer` which strips directives from output,\n * this processor passes complete directives to a callback and replaces them\n * with the callback's return value. This enables clients to render directives\n * as links, cards, or other formats during streaming.\n *\n * @example\n * ```ts\n * import { createDirectiveStreamProcessor } from '@sanity/agent-directives/streaming'\n *\n * // Slack client example\n * const processor = createDirectiveStreamProcessor(async ({ name, attributes }) => {\n *   if (name === 'document') {\n *     const doc = await fetchDocument(attributes.id)\n *     return `[${doc.title}](${doc.url})`\n *   }\n *   return `[${name}]`\n * })\n *\n * for await (const chunk of llmStream) {\n *   const text = await processor.process(chunk)\n *   if (text) {\n *     await streamToClient(text)\n *   }\n * }\n *\n * const remaining = await processor.flush()\n * if (remaining) {\n *   await streamToClient(remaining)\n * }\n * ```\n */\nexport function createDirectiveStreamProcessor(\n  processDirective: DirectiveProcessor,\n): DirectiveStreamProcessor {\n  let buffer = ''\n\n  async function process(chunk: string): Promise<string> {\n    buffer += chunk\n    let output = ''\n\n    while (buffer.length > 0) {\n      const colonIndex = buffer.indexOf(':')\n\n      if (colonIndex === -1) {\n        output += buffer\n        buffer = ''\n        break\n      }\n\n      if (colonIndex > 0) {\n        output += buffer.slice(0, colonIndex)\n        buffer = buffer.slice(colonIndex)\n      }\n\n      if (buffer === ':') break\n\n      // Block directive (::name{...})\n      if (buffer.startsWith('::')) {\n        if (!looksLikeBlockDirectiveStart(buffer)) {\n          output += '::'\n          buffer = buffer.slice(2)\n          continue\n        }\n        const blockMatch = buffer.match(BLOCK_DIRECTIVE)\n        if (blockMatch) {\n          const [fullMatch, name, children, attrString] = blockMatch\n          const attributes = parseDirectiveAttributes(attrString)\n          output += await processDirective({ name, attributes, children: children ?? '' })\n          buffer = buffer.slice(fullMatch.length)\n          continue\n        }\n        if (isDefinitelyNotBlockDirective(buffer)) {\n          output += buffer.slice(0, 2)\n          buffer = buffer.slice(2)\n          continue\n        }\n        break\n      }\n\n      // Inline directive (:name[content]{...})\n      if (looksLikeInlineDirectiveStart(buffer)) {\n        const inlineMatch = buffer.match(INLINE_DIRECTIVE)\n        if (inlineMatch) {\n          const [fullMatch, name, children, attrString] = inlineMatch\n          const attributes = parseDirectiveAttributes(attrString)\n          output += await processDirective({ name, attributes, children })\n          buffer = buffer.slice(fullMatch.length)\n          continue\n        }\n        if (isDefinitelyNotInlineDirective(buffer)) {\n          output += ':'\n          buffer = buffer.slice(1)\n          continue\n        }\n        break\n      }\n\n      // Not a directive\n      output += ':'\n      buffer = buffer.slice(1)\n    }\n\n    return output\n  }\n\n  async function flush(): Promise<string> {\n    const remaining = buffer\n    buffer = ''\n    let output = ''\n    let text = remaining\n\n    while (text.length > 0) {\n      const inlineMatch = text.match(INLINE_DIRECTIVE)\n      const blockMatch = text.match(BLOCK_DIRECTIVE)\n\n      const inlineIdx = inlineMatch?.index ?? Infinity\n      const blockIdx = blockMatch?.index ?? Infinity\n\n      if (inlineIdx === Infinity && blockIdx === Infinity) {\n        output += text\n        break\n      }\n\n      if (inlineIdx <= blockIdx && inlineMatch) {\n        output += text.slice(0, inlineMatch.index)\n        const attributes = parseDirectiveAttributes(inlineMatch[3])\n        output += await processDirective({\n          name: inlineMatch[1],\n          attributes,\n          children: inlineMatch[2],\n        })\n        text = text.slice(inlineMatch.index! + inlineMatch[0].length)\n      } else if (blockMatch) {\n        output += text.slice(0, blockMatch.index)\n        const attributes = parseDirectiveAttributes(blockMatch[3])\n        output += await processDirective({\n          name: blockMatch[1],\n          attributes,\n          children: blockMatch[2] ?? '',\n        })\n        text = text.slice(blockMatch.index! + blockMatch[0].length)\n      }\n    }\n\n    return output\n  }\n\n  function reset(): void {\n    buffer = ''\n  }\n\n  return {\n    process,\n    flush,\n    reset,\n  }\n}\n"],"names":[],"mappings":"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"}