@seed-hypermedia/client 0.0.3 → 0.0.4

package/dist/blocks-to-markdown.d.ts

@@ -31,3 +31,30 @@ export declare function emitFrontmatter(metadata: HMMetadata): string;
  * as placeholder links (not resolved).
  */
 export declare function blocksToMarkdown(doc: HMDocument, options?: BlocksToMarkdownOptions): string;
+/**
+ * Convert a title string into a URL-safe slug.
+ *
+ * - Lowercases the string
+ * - Replaces non-alphanumeric characters with hyphens
+ * - Trims leading/trailing hyphens
+ * - Truncates to 60 characters
+ */
+export declare function slugify(title: string): string;
+/**
+ * Build a draft filename from a slug and nanoid.
+ * Format: `<slug>_<nanoid>.md` — human-readable + collision-safe.
+ * If the slug is empty, the filename is just `<nanoid>.md`.
+ */
+export declare function draftFilename(slug: string, id: string): string;
+/**
+ * Extract the draft ID (nanoid) from a draft filename.
+ *
+ * Handles both formats:
+ * - `<slug>_<nanoid>.md` → returns the nanoid part
+ * - `<nanoid>.md` → returns the nanoid (legacy/no-slug)
+ * - `<nanoid>.json` → returns the nanoid (legacy JSON)
+ */
+export declare function parseDraftFilename(filename: string): {
+    id: string;
+    ext: string;
+};

package/dist/{chunk-X57BIZUK.mjs → chunk-YIND2WNJ.mjs}

@@ -604,7 +604,11 @@ var HMDraftMetaBaseSchema = z.object({
   editUid: z.string().optional(),
   editPath: z.array(z.string()).optional(),
   metadata: HMDocumentMetadataSchema,
-  visibility: HMResourceVisibilitySchema.optional().default("PUBLIC")
+  visibility: HMResourceVisibilitySchema.optional().default("PUBLIC"),
+  // deps and navigation live in the index entry for .md drafts
+  // (for .json drafts they come from the content file for backwards compat)
+  deps: z.array(z.string().min(1)).default([]),
+  navigation: z.array(HMNavigationItemSchema).optional()
 });
 var draftLocationRefinement = (data) => data.editUid || data.locationUid;
 var HMDraftMetaSchema = HMDraftMetaBaseSchema.refine(draftLocationRefinement, {

package/dist/editor-types.d.ts

@@ -0,0 +1,157 @@
+import { HMBlockChildrenType } from './hm-types';
+export type EditorBlock = EditorParagraphBlock | EditorHeadingBlock | EditorCodeBlock | EditorImageBlock | EditorVideoBlock | EditorFileBlock | EditorButtonBlock | EditorEmbedBlock | EditorWebEmbedBlock | EditorMathBlock | EditorNostrBlock | EditorQueryBlock | EditorUnknownBlock;
+export type HMInlineContent = EditorText | EditorInlineEmbed | EditorLink;
+export interface EditorBaseBlock {
+    id: string;
+    props: EditorBlockProps;
+    children: Array<EditorBlock>;
+}
+export interface EditorBlockProps {
+    childrenType?: HMBlockChildrenType;
+    columnCount?: string;
+    listLevel?: string;
+    level?: number | string;
+    ref?: string;
+    revision?: string;
+}
+export interface EditorParagraphBlock extends EditorBaseBlock {
+    type: 'paragraph';
+    content: Array<HMInlineContent>;
+}
+export interface EditorHeadingBlock extends EditorBaseBlock {
+    type: 'heading';
+    content: Array<HMInlineContent>;
+}
+export interface EditorCodeBlock extends EditorBaseBlock {
+    type: 'code-block';
+    content: Array<HMInlineContent>;
+    props: EditorBlockProps & {
+        language?: string;
+    };
+}
+export interface DraftMediaRef {
+    draftId: string;
+    mediaId: string;
+    name: string;
+    mime: string;
+    size: number;
+}
+export interface MediaBlockProps extends EditorBlockProps {
+    url?: string;
+    src?: string;
+    displaySrc?: string;
+    fileBinary?: Uint8Array | number[];
+    mediaRef?: DraftMediaRef;
+    name?: string;
+    width?: string;
+    defaultOpen?: string;
+    size?: string;
+    alignment?: string;
+}
+export interface EditorImageBlock extends EditorBaseBlock {
+    type: 'image';
+    props: MediaBlockProps;
+    content: Array<HMInlineContent>;
+}
+export interface EditorVideoBlock extends EditorBaseBlock {
+    type: 'video';
+    props: MediaBlockProps;
+    content: Array<HMInlineContent>;
+}
+export interface EditorFileBlock extends EditorBaseBlock {
+    type: 'file';
+    props: MediaBlockProps;
+    content: Array<HMInlineContent>;
+}
+export interface EditorButtonBlock extends EditorBaseBlock {
+    type: 'button';
+    props: MediaBlockProps;
+    content: Array<HMInlineContent>;
+}
+export interface EditorEmbedBlock extends EditorBaseBlock {
+    type: 'embed';
+    props: EditorBlockProps & {
+        view: 'Content' | 'Card';
+        url: string;
+    };
+    content: Array<HMInlineContent>;
+}
+export interface EditorMathBlock extends EditorBaseBlock {
+    type: 'math';
+    content: Array<HMInlineContent>;
+}
+export type EditorWebEmbedBlock = EditorBaseBlock & {
+    type: 'web-embed';
+    props: EditorBlockProps & {
+        url?: string;
+    };
+    content: Array<HMInlineContent>;
+};
+export type EditorNostrBlock = EditorBaseBlock & {
+    type: 'nostr';
+    props: EditorBlockProps & {
+        name?: string;
+        url?: string;
+        text?: string;
+        size?: string;
+    };
+    content: Array<HMInlineContent>;
+};
+export type EditorQueryBlock = EditorBaseBlock & {
+    type: 'query';
+    props: EditorBlockProps & {
+        style: 'Card' | 'List';
+        columnCount?: '1' | '2' | '3';
+        queryLimit?: string;
+        queryIncludes?: string;
+        querySort?: string;
+        banner?: 'true' | 'false';
+    };
+    content: Array<HMInlineContent>;
+};
+export type EditorUnknownBlock = EditorBaseBlock & {
+    type: 'unknown';
+    props: EditorBlockProps & {
+        originalType: string;
+        originalData: string;
+    };
+    content: Array<HMInlineContent>;
+};
+export interface EditorText {
+    type: 'text';
+    text: string;
+    styles: EditorInlineStyles;
+}
+export interface EditorLink {
+    type: 'link';
+    href: string;
+    content: Array<HMInlineContent>;
+}
+export interface EditorInlineEmbed {
+    type: 'inline-embed';
+    link: string;
+    styles: EditorInlineStyles | {};
+}
+export interface EditorInlineStyles {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strike?: boolean;
+    code?: boolean;
+    math?: boolean;
+    range?: boolean;
+}
+export type EditorAnnotationType = 'bold' | 'italic' | 'underline' | 'strike' | 'code' | 'link' | 'inline-embed' | 'range';
+export type EditorBlockType = EditorBlock['type'];
+export type SearchResult = {
+    key: string;
+    title: string;
+    subtitle?: string;
+    icon?: string;
+    path?: string[] | null;
+    versionTime?: string;
+    searchQuery?: string;
+    onSelect?: () => void | Promise<void>;
+    onFocus: () => void;
+    onMouseEnter: () => void;
+};

package/dist/editorblock-to-hmblock.d.ts

@@ -0,0 +1,12 @@
+import { EditorBlock } from './editor-types';
+import { HMBlock, HMBlockNode } from './hm-types';
+/** Convert a single BlockNote EditorBlock into an HMBlock. */
+export declare function editorBlockToHMBlock(editorBlock: EditorBlock): HMBlock;
+/**
+ * Convert an array of BlockNote EditorBlocks into an HMBlockNode tree.
+ *
+ * This is the tree-level wrapper around `editorBlockToHMBlock` that recursively
+ * converts children. Useful when serializing editor content to the HM block format
+ * (e.g. for saving drafts as markdown or publishing documents).
+ */
+export declare function editorBlocksToHMBlockNodes(editorBlocks: EditorBlock[]): HMBlockNode[];

package/dist/hm-types.d.ts

@@ -12314,6 +12314,23 @@ export declare const HMDraftMetaSchema: z.ZodEffects<z.ZodObject<{
         importTags?: string | undefined;
     }>;
     visibility: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "PUBLIC" | "PRIVATE", string | number>>>;
+    deps: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    navigation: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"Link">;
+        id: z.ZodString;
+        text: z.ZodString;
+        link: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }, {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     id: string;
     visibility: "PUBLIC" | "PRIVATE";
@@ -12338,6 +12355,13 @@ export declare const HMDraftMetaSchema: z.ZodEffects<z.ZodObject<{
         importCategories?: string | undefined;
         importTags?: string | undefined;
     };
+    deps: string[];
+    navigation?: {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }[] | undefined;
     locationUid?: string | undefined;
     locationPath?: string[] | undefined;
     editUid?: string | undefined;
@@ -12366,6 +12390,13 @@ export declare const HMDraftMetaSchema: z.ZodEffects<z.ZodObject<{
         importTags?: string | undefined;
     };
     visibility?: string | number | undefined;
+    deps?: string[] | undefined;
+    navigation?: {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }[] | undefined;
     locationUid?: string | undefined;
     locationPath?: string[] | undefined;
     editUid?: string | undefined;
@@ -12394,6 +12425,13 @@ export declare const HMDraftMetaSchema: z.ZodEffects<z.ZodObject<{
         importCategories?: string | undefined;
         importTags?: string | undefined;
     };
+    deps: string[];
+    navigation?: {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }[] | undefined;
     locationUid?: string | undefined;
     locationPath?: string[] | undefined;
     editUid?: string | undefined;
@@ -12422,6 +12460,13 @@ export declare const HMDraftMetaSchema: z.ZodEffects<z.ZodObject<{
         importTags?: string | undefined;
     };
     visibility?: string | number | undefined;
+    deps?: string[] | undefined;
+    navigation?: {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }[] | undefined;
     locationUid?: string | undefined;
     locationPath?: string[] | undefined;
     editUid?: string | undefined;
@@ -12433,6 +12478,8 @@ type HMDraftMetaBase = {
     editPath?: string[];
     metadata: HMMetadata;
     visibility: HMResourceVisibility;
+    deps: string[];
+    navigation?: HMNavigationItem[];
 };
 export type HMDraftMeta = HMDraftMetaBase & ({
     editUid: string;
@@ -12513,6 +12560,23 @@ export declare const HMListedDraftSchema: z.ZodEffects<z.ZodObject<{
         importTags?: string | undefined;
     }>;
     visibility: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "PUBLIC" | "PRIVATE", string | number>>>;
+    deps: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    navigation: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"Link">;
+        id: z.ZodString;
+        text: z.ZodString;
+        link: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }, {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }>, "many">>;
 } & {
     lastUpdateTime: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
@@ -12540,6 +12604,13 @@ export declare const HMListedDraftSchema: z.ZodEffects<z.ZodObject<{
         importTags?: string | undefined;
     };
     lastUpdateTime: number;
+    deps: string[];
+    navigation?: {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }[] | undefined;
     locationUid?: string | undefined;
     locationPath?: string[] | undefined;
     editUid?: string | undefined;
@@ -12569,6 +12640,13 @@ export declare const HMListedDraftSchema: z.ZodEffects<z.ZodObject<{
     };
     lastUpdateTime: number;
     visibility?: string | number | undefined;
+    deps?: string[] | undefined;
+    navigation?: {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }[] | undefined;
     locationUid?: string | undefined;
     locationPath?: string[] | undefined;
     editUid?: string | undefined;
@@ -12598,6 +12676,13 @@ export declare const HMListedDraftSchema: z.ZodEffects<z.ZodObject<{
         importTags?: string | undefined;
     };
     lastUpdateTime: number;
+    deps: string[];
+    navigation?: {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }[] | undefined;
     locationUid?: string | undefined;
     locationPath?: string[] | undefined;
     editUid?: string | undefined;
@@ -12627,6 +12712,13 @@ export declare const HMListedDraftSchema: z.ZodEffects<z.ZodObject<{
     };
     lastUpdateTime: number;
     visibility?: string | number | undefined;
+    deps?: string[] | undefined;
+    navigation?: {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }[] | undefined;
     locationUid?: string | undefined;
     locationPath?: string[] | undefined;
     editUid?: string | undefined;
@@ -12704,6 +12796,23 @@ export declare const HMListedDraftReadSchema: z.ZodObject<{
         importTags?: string | undefined;
     }>;
     visibility: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "PUBLIC" | "PRIVATE", string | number>>>;
+    deps: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    navigation: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"Link">;
+        id: z.ZodString;
+        text: z.ZodString;
+        link: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }, {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }>, "many">>;
 } & {
     lastUpdateTime: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
@@ -12731,6 +12840,13 @@ export declare const HMListedDraftReadSchema: z.ZodObject<{
         importTags?: string | undefined;
     };
     lastUpdateTime: number;
+    deps: string[];
+    navigation?: {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }[] | undefined;
     locationUid?: string | undefined;
     locationPath?: string[] | undefined;
     editUid?: string | undefined;
@@ -12760,6 +12876,13 @@ export declare const HMListedDraftReadSchema: z.ZodObject<{
     };
     lastUpdateTime: number;
     visibility?: string | number | undefined;
+    deps?: string[] | undefined;
+    navigation?: {
+        link: string;
+        type: "Link";
+        id: string;
+        text: string;
+    }[] | undefined;
     locationUid?: string | undefined;
     locationPath?: string[] | undefined;
     editUid?: string | undefined;

package/dist/hm-types.mjs

@@ -156,7 +156,7 @@ import {
   toNumber,
   unpackHmId,
   unpackedHmIdSchema
-} from "./chunk-X57BIZUK.mjs";
+} from "./chunk-YIND2WNJ.mjs";
 export {
   BlockRangeSchema,
   BoldAnnotationSchema,

package/dist/hmblock-to-editorblock.d.ts

@@ -0,0 +1,23 @@
+import { EditorBlock } from './editor-types';
+import { HMBlock, HMBlockChildrenType, HMBlockNode } from './hm-types';
+import type { SpanAnnotation } from './unicode';
+type ServerToEditorRecursiveOpts = {
+    level?: number;
+};
+/** Convert an array of HMBlockNode trees into BlockNote EditorBlock arrays. */
+export declare function hmBlocksToEditorContent(blocks: HMBlockNode[], opts?: ServerToEditorRecursiveOpts & {
+    childrenType?: HMBlockChildrenType;
+    listLevel?: string;
+    start?: string;
+}): Array<EditorBlock>;
+/** Convert a single HMBlock into a BlockNote EditorBlock. */
+export declare function hmBlockToEditorBlock(block: HMBlock): EditorBlock;
+/**
+ * Checks if a position expressed in code points is within any span
+ * of this annotation.
+ *
+ * Assumes starts and ends arrays are sorted (binary search).
+ * Returns the index of the matching span, or -1.
+ */
+export declare function annotationContains(annotation: SpanAnnotation, pos: number): number;
+export {};

package/dist/index.d.ts

@@ -24,9 +24,9 @@ export { codePointLength, entityQueryPathToHmIdPath, getHMQueryString, hmIdPathT
 export type { HMRequest, HMSigner, UnpackedHypermediaId } from './hm-types';
 export { fileToIpfsBlobs, filesToIpfsBlobs, resolveFileLinksInBlocks, hasFileLinks } from './file-to-ipfs';
 export type { CollectedBlob } from './file-to-ipfs';
-export { parseMarkdown, flattenToOperations, parseInlineFormatting, parseFrontmatter } from './markdown-to-blocks';
+export { parseMarkdown, flattenToOperations, parseInlineFormatting, parseFrontmatter, markdownBlockNodesToHMBlockNodes, } from './markdown-to-blocks';
 export type { BlockNode, SeedBlock, Annotation } from './markdown-to-blocks';
-export { blocksToMarkdown, emitFrontmatter } from './blocks-to-markdown';
+export { blocksToMarkdown, emitFrontmatter, slugify, draftFilename, parseDraftFilename } from './blocks-to-markdown';
 export type { BlocksToMarkdownOptions } from './blocks-to-markdown';
 export { createBlocksMap, matchBlockIds, computeReplaceOps, hmBlockNodeToBlockNode } from './block-diff';
 export type { APIBlockNode, APIBlock } from './block-diff';
@@ -34,3 +34,8 @@ export { autoLinkChildToParent, createAutoLinkOps, documentContainsLinkToChild,
 export type { AutoLinkChildToParentOptions } from './auto-link';
 export { resolveDocumentState } from './document-state';
 export type { DocumentState } from './document-state';
+export { editorBlockToHMBlock, editorBlocksToHMBlockNodes } from './editorblock-to-hmblock';
+export { hmBlocksToEditorContent, hmBlockToEditorBlock, annotationContains } from './hmblock-to-editorblock';
+export { AnnotationSet, addSpanToAnnotation, pushSpanToAnnotation } from './unicode';
+export type { MutableAnnotation, SpanAnnotation } from './unicode';
+export type { EditorBlock, EditorBaseBlock, EditorBlockProps, EditorBlockType, EditorParagraphBlock, EditorHeadingBlock, EditorCodeBlock, EditorImageBlock, EditorVideoBlock, EditorFileBlock, EditorButtonBlock, EditorEmbedBlock, EditorWebEmbedBlock, EditorMathBlock, EditorNostrBlock, EditorQueryBlock, EditorUnknownBlock, EditorText, EditorLink, EditorInlineEmbed, EditorInlineStyles, EditorAnnotationType, HMInlineContent, MediaBlockProps, DraftMediaRef, SearchResult, } from './editor-types';

package/dist/index.mjs

@@ -1,5 +1,7 @@
 import {
   HMActionSchema,
+  HMBlockButtonAlignmentSchema,
+  HMBlockSchema,
   HMRequestSchema,
   HYPERMEDIA_SCHEME,
   codePointLength,
@@ -12,8 +14,9 @@ import {
   parseCustomURL,
   parseFragment,
   serializeBlockRange,
+  toNumber,
   unpackHmId
-} from "./chunk-X57BIZUK.mjs";
+} from "./chunk-YIND2WNJ.mjs";
 
 // src/capability.ts
 import { encode as cborEncode2 } from "@ipld/dag-cbor";
@@ -2517,6 +2520,37 @@ function parseMarkdown(markdown) {
   }
   return { tree: rootNodes, metadata };
 }
+function markdownBlockNodesToHMBlockNodes(nodes) {
+  return nodes.map((node) => {
+    const { block } = node;
+    const attributes = {};
+    if (block.childrenType !== void 0) {
+      attributes.childrenType = block.childrenType;
+    }
+    if (block.language !== void 0) {
+      attributes.language = block.language;
+    }
+    const hmBlock = {
+      type: block.type,
+      id: block.id,
+      text: block.text,
+      annotations: block.annotations.map((a) => ({
+        type: a.type,
+        starts: a.starts,
+        ends: a.ends,
+        ...a.link !== void 0 ? { link: a.link } : {}
+      })),
+      attributes
+    };
+    if (block.link !== void 0) {
+      hmBlock.link = block.link;
+    }
+    return {
+      block: hmBlock,
+      children: node.children.length > 0 ? markdownBlockNodesToHMBlockNodes(node.children) : void 0
+    };
+  });
+}
 function flattenToOperations(tree, parentId = "") {
   const ops = [];
   const blockIds = [];
@@ -2777,6 +2811,23 @@ function formatMediaUrl(url, useGateway) {
 function indent(depth) {
   return "  ".repeat(depth);
 }
+function slugify(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
+function draftFilename(slug, id) {
+  if (!slug) return `${id}.md`;
+  return `${slug}_${id}.md`;
+}
+function parseDraftFilename(filename) {
+  const lastDot = filename.lastIndexOf(".");
+  const ext = lastDot >= 0 ? filename.slice(lastDot) : "";
+  const base = lastDot >= 0 ? filename.slice(0, lastDot) : filename;
+  const lastUnderscore = base.lastIndexOf("_");
+  if (lastUnderscore >= 0 && ext === ".md") {
+    return { id: base.slice(lastUnderscore + 1), ext };
+  }
+  return { id: base, ext };
+}
 
 // src/block-diff.ts
 function createBlocksMap(nodes, parentId = "") {
@@ -3140,12 +3191,640 @@ function generateBlockId5() {
   }
   return id;
 }
+
+// src/unicode.ts
+var AnnotationSet = class {
+  annotations;
+  constructor() {
+    this.annotations = /* @__PURE__ */ new Map();
+  }
+  addSpan(type, attributes, start, end) {
+    const id = this._annotationId(type, attributes);
+    let annotation = this.annotations.get(id);
+    if (!annotation) {
+      const annAttrs = attributes ? { ...attributes } : {};
+      let link;
+      if (type == "Link" || type == "Embed") {
+        link = attributes == null ? void 0 : attributes.link;
+        delete annAttrs.link;
+      }
+      annotation = {
+        type,
+        attributes: annAttrs,
+        link: link || "",
+        starts: [],
+        ends: []
+      };
+      this.annotations.set(id, annotation);
+    }
+    addSpanToAnnotation(annotation, start, end);
+  }
+  _annotationId(type, attributes) {
+    if (attributes) {
+      if (attributes.link) {
+        return `${type}-${attributes.link}`;
+      }
+      if (attributes.href) {
+        return `${type}-${attributes.href}`;
+      }
+    }
+    return type;
+  }
+  list() {
+    const keys = Array.from(this.annotations.keys()).sort();
+    let out = new Array(keys.length);
+    for (let i in keys) {
+      const annotation = this.annotations.get(keys[i]);
+      if (annotation) out[i] = annotation;
+    }
+    out = out.sort((a, b) => {
+      let startA = a.starts[0];
+      let startB = b.starts[0];
+      return (startA || 0) - (startB || 0);
+    });
+    return out;
+  }
+};
+function addSpanToAnnotation(annotation, start, end) {
+  if (!annotation.starts) {
+    annotation.starts = [];
+  }
+  if (!annotation.ends) {
+    annotation.ends = [];
+  }
+  if (annotation.starts.length == 0) {
+    pushSpanToAnnotation(annotation, start, end);
+    return;
+  }
+  const lastIdx = annotation.starts.length - 1;
+  if (annotation.ends[lastIdx] == start) {
+    annotation.ends[lastIdx] = end;
+    return;
+  }
+  pushSpanToAnnotation(annotation, start, end);
+}
+function pushSpanToAnnotation(annotation, start, end) {
+  annotation.starts.push(start);
+  annotation.ends.push(end);
+}
+
+// src/editorblock-to-hmblock.ts
+function toHMBlockType(editorBlockType) {
+  if (editorBlockType === "heading") return "Heading";
+  if (editorBlockType === "paragraph") return "Paragraph";
+  if (editorBlockType === "code-block") return "Code";
+  if (editorBlockType === "math") return "Math";
+  if (editorBlockType === "image") return "Image";
+  if (editorBlockType === "video") return "Video";
+  if (editorBlockType === "file") return "File";
+  if (editorBlockType === "button") return "Button";
+  if (editorBlockType === "embed") return "Embed";
+  if (editorBlockType === "web-embed") return "WebEmbed";
+  if (editorBlockType === "query") return "Query";
+  return void 0;
+}
+function editorBlockToHMBlock(editorBlock) {
+  var _a, _b, _c, _d, _e, _f;
+  const blockType = toHMBlockType(editorBlock.type);
+  if (!blockType) throw new Error("Unsupported block type " + editorBlock.type);
+  let block = {
+    id: editorBlock.id,
+    type: blockType,
+    attributes: {},
+    text: "",
+    annotations: []
+  };
+  let leaves = flattenLeaves(editorBlock.content);
+  if (editorBlock.props.childrenType == "Group") {
+    block.attributes.childrenType = "Group";
+  } else if (editorBlock.props.childrenType == "Unordered") {
+    block.attributes.childrenType = "Unordered";
+  } else if (editorBlock.props.childrenType == "Ordered") {
+    block.attributes.childrenType = "Ordered";
+  } else if (editorBlock.props.childrenType == "Blockquote") {
+    block.attributes.childrenType = "Blockquote";
+  } else if (editorBlock.props.childrenType == "Grid") {
+    block.attributes.childrenType = "Grid";
+    if (editorBlock.props.columnCount) {
+      block.attributes.columnCount = Number(editorBlock.props.columnCount);
+    }
+  }
+  const annotations = new AnnotationSet();
+  let pos = 0;
+  for (let leaf of leaves) {
+    const start = pos;
+    const charCount = codePointLength(leaf.text);
+    const end = start + charCount;
+    if ((_a = leaf.styles) == null ? void 0 : _a.bold) {
+      annotations.addSpan("Bold", null, start, end);
+    }
+    if ((_b = leaf.styles) == null ? void 0 : _b.italic) {
+      annotations.addSpan("Italic", null, start, end);
+    }
+    if ((_c = leaf.styles) == null ? void 0 : _c.underline) {
+      annotations.addSpan("Underline", null, start, end);
+    }
+    if ((_d = leaf.styles) == null ? void 0 : _d.strike) {
+      annotations.addSpan("Strike", null, start, end);
+    }
+    if ((_e = leaf.styles) == null ? void 0 : _e.code) {
+      annotations.addSpan("Code", null, start, end);
+    }
+    if ((_f = leaf.styles) == null ? void 0 : _f.math) {
+      annotations.addSpan("Math", null, start, end);
+    }
+    if (leaf.type == "inline-embed") {
+      annotations.addSpan("Embed", { link: leaf.link }, start, end);
+    }
+    if (leaf.type == "link") {
+      annotations.addSpan("Link", { link: leaf.href }, start, end);
+    }
+    block.text += leaf.text;
+    pos += charCount;
+  }
+  let outAnnotations = annotations.list();
+  if (outAnnotations) {
+    block.annotations = outAnnotations;
+  }
+  const blockCode = block.type === "Code" ? block : void 0;
+  if (blockCode && editorBlock.type == "code-block") {
+    blockCode.attributes.language = editorBlock.props.language;
+  }
+  const blockImage = block.type === "Image" ? block : void 0;
+  if (blockImage && editorBlock.type == "image") {
+    if (editorBlock.props.url && !editorBlock.props.mediaRef) {
+      blockImage.link = editorBlock.props.url;
+    } else if (editorBlock.props.mediaRef) {
+      blockImage.link = "";
+    } else if (editorBlock.props.displaySrc) {
+      blockImage.link = editorBlock.props.displaySrc;
+    } else if (editorBlock.props.src) {
+      blockImage.link = editorBlock.props.src;
+    } else {
+      blockImage.link = "";
+    }
+    const width = toNumber(editorBlock.props.width);
+    if (width) {
+      blockImage.attributes.width = width;
+    }
+  }
+  const blockVideo = block.type === "Video" ? block : void 0;
+  if (blockVideo && editorBlock.type == "video") {
+    blockVideo.text = "";
+    if (editorBlock.props.url && !editorBlock.props.mediaRef) {
+      blockVideo.link = editorBlock.props.url;
+    } else if (editorBlock.props.mediaRef) {
+      blockVideo.link = "";
+    }
+    const width = toNumber(editorBlock.props.width);
+    if (width) blockVideo.attributes.width = width;
+    if (editorBlock.props.name) {
+      blockVideo.attributes.name = editorBlock.props.name;
+    }
+  }
+  const blockFile = block.type === "File" ? block : void 0;
+  if (blockFile && editorBlock.type == "file") {
+    if (editorBlock.props.url && !editorBlock.props.mediaRef) {
+      blockFile.link = editorBlock.props.url;
+    } else if (editorBlock.props.mediaRef) {
+      blockFile.link = "";
+    }
+    if (editorBlock.props.name) blockFile.attributes.name = editorBlock.props.name;
+    const size = toNumber(editorBlock.props.size);
+    if (size) blockFile.attributes.size = size;
+  }
+  const blockButton = block.type === "Button" ? block : void 0;
+  if (blockButton && editorBlock.type == "button") {
+    if (editorBlock.props.url) blockButton.link = editorBlock.props.url;
+    if (editorBlock.props.name) blockButton.attributes.name = editorBlock.props.name;
+    if (editorBlock.props.alignment)
+      blockButton.attributes.alignment = HMBlockButtonAlignmentSchema.parse(editorBlock.props.alignment);
+  }
+  const blockWebEmbed = block.type === "WebEmbed" ? block : void 0;
+  if (blockWebEmbed && editorBlock.type == "web-embed" && editorBlock.props.url) {
+    blockWebEmbed.link = editorBlock.props.url;
+  }
+  const blockEmbed = block.type === "Embed" ? block : void 0;
+  if (blockEmbed && editorBlock.type == "embed") {
+    block.text = "";
+    if (editorBlock.props.url) blockEmbed.link = editorBlock.props.url;
+    if (editorBlock.props.view) blockEmbed.attributes.view = editorBlock.props.view;
+  }
+  const blockQuery = block.type === "Query" ? block : void 0;
+  if (blockQuery && editorBlock.type == "query") {
+    blockQuery.attributes.style = editorBlock.props.style;
+    blockQuery.attributes.columnCount = Number(editorBlock.props.columnCount);
+    const query = {
+      includes: [],
+      sort: []
+    };
+    if (editorBlock.props.queryIncludes) query.includes = JSON.parse(editorBlock.props.queryIncludes);
+    if (editorBlock.props.querySort) query.sort = JSON.parse(editorBlock.props.querySort);
+    if (editorBlock.props.queryLimit) query.limit = Number(editorBlock.props.queryLimit);
+    blockQuery.attributes.query = query;
+    blockQuery.attributes.banner = editorBlock.props.banner == "true";
+  }
+  const blockParse = HMBlockSchema.safeParse(block);
+  if (blockParse.success) {
+    return blockParse.data;
+  }
+  const failedParse = blockParse;
+  console.error("Failed to validate block for writing", block, failedParse.error);
+  throw new Error("Failed to validate block for writing " + JSON.stringify(failedParse.error));
+}
+function editorBlocksToHMBlockNodes(editorBlocks) {
+  return editorBlocks.map((block) => {
+    var _a, _b;
+    try {
+      return {
+        block: editorBlockToHMBlock(block),
+        children: ((_a = block.children) == null ? void 0 : _a.length) ? editorBlocksToHMBlockNodes(block.children) : void 0
+      };
+    } catch {
+      return {
+        block: {
+          id: block.id || "unknown",
+          type: "Paragraph",
+          text: `[Unsupported block type: ${block.type}]`,
+          annotations: [],
+          attributes: {}
+        },
+        children: ((_b = block.children) == null ? void 0 : _b.length) ? editorBlocksToHMBlockNodes(block.children) : void 0
+      };
+    }
+  }).filter(Boolean);
+}
+function flattenLeaves(content) {
+  let result = [];
+  for (let i = 0; i < content.length; i++) {
+    const leaf = content[i];
+    if (!leaf) continue;
+    if (leaf.type == "link") {
+      let nestedLeaves = flattenLeaves(leaf.content).map(
+        (l) => ({
+          ...l,
+          href: leaf.href,
+          type: "link"
+        })
+      );
+      result.push(...nestedLeaves);
+    }
+    if (leaf.type == "inline-embed") {
+      result.push({
+        ...leaf,
+        text: "\uFFFC",
+        link: leaf.link
+      });
+    }
+    if (leaf.type == "text") {
+      result.push(leaf);
+    }
+  }
+  return result;
+}
+
+// src/hmblock-to-editorblock.ts
+function toEditorBlockType(hmBlockType) {
+  if (hmBlockType === "Heading") return "heading";
+  if (hmBlockType === "Paragraph") return "paragraph";
+  if (hmBlockType === "Code") return "code-block";
+  if (hmBlockType === "Math") return "math";
+  if (hmBlockType === "Image") return "image";
+  if (hmBlockType === "Video") return "video";
+  if (hmBlockType === "File") return "file";
+  if (hmBlockType === "Button") return "button";
+  if (hmBlockType === "Embed") return "embed";
+  if (hmBlockType === "WebEmbed") return "web-embed";
+  if (hmBlockType === "Nostr") return "nostr";
+  if (hmBlockType === "Query") return "query";
+  return "unknown";
+}
+function hmBlocksToEditorContent(blocks, opts = { level: 1 }) {
+  const childRecursiveOpts = {
+    level: opts.level || 0
+  };
+  return blocks.map((hmBlock) => {
+    var _a, _b, _c;
+    let res = hmBlock.block ? hmBlockToEditorBlock(hmBlock.block) : null;
+    if (res && ((_a = hmBlock.children) == null ? void 0 : _a.length)) {
+      const childrenType = (_c = ((_b = hmBlock.block) == null ? void 0 : _b.attributes) || {}) == null ? void 0 : _c.childrenType;
+      const validChildrenType = childrenType === "Group" || childrenType === "Ordered" || childrenType === "Unordered" || childrenType === "Blockquote" || childrenType === "Grid" ? childrenType : "Group";
+      res.children = hmBlocksToEditorContent(hmBlock.children, {
+        level: childRecursiveOpts.level ? childRecursiveOpts.level + 1 : 1,
+        childrenType: validChildrenType
+      });
+    }
+    return res;
+  }).filter((block) => block !== null);
+}
+function hmBlockToEditorBlock(block) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const blockType = toEditorBlockType(block.type);
+  if (blockType === "unknown") {
+    return {
+      id: block.id,
+      type: "unknown",
+      content: [],
+      props: {
+        revision: block.revision,
+        originalType: block.type,
+        originalData: JSON.stringify(block)
+      },
+      children: []
+    };
+  }
+  let out = {
+    id: block.id,
+    type: blockType,
+    content: [],
+    props: {
+      revision: block.revision
+    },
+    children: []
+  };
+  const attributes = block.attributes || {};
+  if ("childrenType" in attributes && attributes.childrenType) {
+    const childrenType = attributes.childrenType;
+    if (childrenType === "Group" || childrenType === "Ordered" || childrenType === "Unordered" || childrenType === "Blockquote" || childrenType === "Grid") {
+      ;
+      out.props.childrenType = childrenType;
+    }
+    if (childrenType === "Grid" && attributes.columnCount != null) {
+      ;
+      out.props.columnCount = String(attributes.columnCount);
+    }
+  }
+  if (["code-block", "video", "image", "file", "button", "embed", "web-embed", "math", "nostr"].includes(blockType)) {
+    if (block.link) {
+      ;
+      out.props.url = block.link;
+    }
+    if (blockType == "code-block") {
+      out.type = "code-block";
+    }
+    if (block.attributes) {
+      Object.entries(block.attributes).forEach(([key, value]) => {
+        if (value !== void 0) {
+          if (key == "width" || key == "size") {
+            if (typeof value == "number") {
+              ;
+              out.props[key] = String(value);
+            }
+          } else {
+            ;
+            out.props[key] = value;
+          }
+        }
+      });
+    }
+  }
+  if (block.type === "Query") {
+    const queryProps = out.props;
+    queryProps.style = (_a = block.attributes) == null ? void 0 : _a.style;
+    queryProps.columnCount = String(((_b = block.attributes) == null ? void 0 : _b.columnCount) || "");
+    queryProps.queryIncludes = JSON.stringify(((_d = (_c = block.attributes) == null ? void 0 : _c.query) == null ? void 0 : _d.includes) || []);
+    queryProps.querySort = JSON.stringify(((_f = (_e = block.attributes) == null ? void 0 : _e.query) == null ? void 0 : _f.sort) || {});
+    queryProps.banner = ((_g = block.attributes) == null ? void 0 : _g.banner) ? "true" : "false";
+    queryProps.queryLimit = String(((_i = (_h = block.attributes) == null ? void 0 : _h.query) == null ? void 0 : _i.limit) || "");
+  }
+  const blockText = block.text || "";
+  const leaves = out.content;
+  let leaf = null;
+  let inlineBlockContent = null;
+  let textStart = 0;
+  let i = 0;
+  const stopPoint = block.text ? block.text.length - 1 : 0;
+  let pos = 0;
+  const leafAnnotations = /* @__PURE__ */ new Set();
+  if (blockText == "") {
+    leaves.push({ type: "text", text: blockText, styles: {} });
+    return out;
+  }
+  while (i < blockText.length) {
+    let ul = 1;
+    let annotationsChanged = trackPosAnnotations(pos);
+    let surrogate = isSurrogate(blockText, i);
+    if (surrogate) {
+      ul++;
+      let onlyOneSurrogate = pos + ul;
+      if (onlyOneSurrogate == blockText.length) {
+        if (!leaf) {
+          startLeaf(leafAnnotations);
+        }
+        finishLeaf(textStart, i + 2);
+        if (inlineBlockContent) {
+          const lastLeaf = leaves[leaves.length - 1];
+          if (lastLeaf && !isText(lastLeaf)) {
+          }
+          leaves.push(inlineBlockContent);
+          inlineBlockContent = null;
+        }
+        return out;
+      }
+    }
+    if (stopPoint < 0) {
+      console.warn("STOP IS LESS THAN ZERO", block);
+    }
+    if (i == stopPoint) {
+      if (annotationsChanged) {
+        if (leaf) {
+          finishLeaf(textStart, i);
+        }
+        startLeaf(leafAnnotations);
+      } else {
+        startLeaf(leafAnnotations);
+      }
+      finishLeaf(textStart, i + 1);
+      if (inlineBlockContent) {
+        const lastLeaf = leaves[leaves.length - 1];
+        if (lastLeaf && !isText(lastLeaf)) {
+        }
+        leaves.push(inlineBlockContent);
+        inlineBlockContent = null;
+      }
+      return out;
+    }
+    if (!leaf) {
+      startLeaf(leafAnnotations);
+      advance(ul);
+      continue;
+    }
+    if (annotationsChanged) {
+      finishLeaf(textStart, i);
+      startLeaf(leafAnnotations);
+    }
+    advance(ul);
+    if (i == blockText.length) {
+      finishLeaf(textStart, i);
+      return out;
+    }
+  }
+  throw Error("BUG: should not get here");
+  function advance(codeUnits) {
+    pos++;
+    i += codeUnits;
+  }
+  function startLeaf(posAnnotations) {
+    const newLeaf = {
+      type: "text",
+      text: "",
+      styles: {}
+    };
+    leaf = newLeaf;
+    let linkAnnotation = null;
+    for (const l of Array.from(posAnnotations)) {
+      const annotationData = l;
+      if (annotationData.type === "Link") {
+        linkAnnotation = {
+          type: "Link",
+          href: annotationData.link || ""
+        };
+      }
+      if (annotationData.type === "Embed") {
+        linkAnnotation = {
+          type: "Embed",
+          link: annotationData.link || ""
+        };
+      }
+      if (["Bold", "Italic", "Strike", "Underline", "Code", "Range"].includes(annotationData.type)) {
+        const styleKey = annotationData.type.toLowerCase();
+        newLeaf.styles[styleKey] = true;
+      }
+    }
+    if (linkAnnotation) {
+      if (linkAnnotation.type === "Embed") {
+        leaves.push({
+          type: "inline-embed",
+          styles: {},
+          link: linkAnnotation.link || ""
+        });
+        textStart = i + 1;
+      } else if (inlineBlockContent) {
+        if (linkChangedIdentity(linkAnnotation)) {
+          leaves.push(inlineBlockContent);
+          if (linkAnnotation.type === "Link") {
+            inlineBlockContent = {
+              type: "link",
+              content: [],
+              href: linkAnnotation.href || ""
+            };
+          } else {
+            inlineBlockContent = {
+              type: "inline-embed",
+              styles: {},
+              link: linkAnnotation.link || ""
+            };
+          }
+        }
+      } else {
+        if (linkAnnotation.type === "Link") {
+          inlineBlockContent = {
+            type: "link",
+            content: [],
+            href: linkAnnotation.href || ""
+          };
+        } else {
+          inlineBlockContent = {
+            type: "inline-embed",
+            styles: {},
+            link: linkAnnotation.link || ""
+          };
+        }
+      }
+    } else {
+      if (inlineBlockContent) {
+        leaves.push(inlineBlockContent);
+        inlineBlockContent = null;
+      }
+    }
+  }
+  function linkChangedIdentity(annotation) {
+    if (!inlineBlockContent) return false;
+    let currentLink = inlineBlockContent.link || inlineBlockContent.href;
+    return currentLink != annotation.link && currentLink != annotation.href;
+  }
+  function finishLeaf(low, high) {
+    let newValue = blockText.substring(low, high);
+    if (leaf) leaf.text = newValue;
+    textStart = high;
+    if (inlineBlockContent) {
+      if (leaf && inlineBlockContent.type == "link") {
+        ;
+        inlineBlockContent.content.push(leaf);
+      } else if (inlineBlockContent.type == "inline-embed" && leaf) {
+      } else if (leaf) {
+        const typedLeaf = {
+          type: "text",
+          text: "",
+          styles: leaf.styles
+        };
+        inlineBlockContent.content.push(typedLeaf);
+      }
+    } else {
+      if (leaf && !(leaf.type === "text" && leaf.text === "" && Object.keys(leaf.styles).length === 0)) {
+        leaves.push(leaf);
+      }
+    }
+  }
+  function trackPosAnnotations(pos2) {
+    let annotationsChanged = false;
+    if (!block.annotations) {
+      return false;
+    }
+    const blockAnnotations = block.annotations;
+    blockAnnotations.forEach((l) => {
+      let spanIdx = annotationContains(l, pos2);
+      if (spanIdx === -1) {
+        if (leafAnnotations.delete(l)) {
+          annotationsChanged = true;
+        }
+        return;
+      }
+      if (leafAnnotations.has(l)) {
+        return;
+      }
+      leafAnnotations.add(l);
+      annotationsChanged = true;
+    });
+    return annotationsChanged;
+  }
+}
+function annotationContains(annotation, pos) {
+  let low = 0;
+  let high = annotation.starts.length - 1;
+  let mid = 0;
+  while (low <= high) {
+    mid = Math.floor((low + high) / 2);
+    const endAtMid = annotation.ends[mid];
+    if (endAtMid === void 0) break;
+    if (endAtMid <= pos) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  if (low == annotation.starts.length) {
+    return -1;
+  }
+  const startAtLow = annotation.starts[low];
+  const endAtLow = annotation.ends[low];
+  if (startAtLow !== void 0 && endAtLow !== void 0 && startAtLow <= pos && pos < endAtLow) {
+    return low;
+  }
+  return -1;
+}
+function isText(entry) {
+  return (entry == null ? void 0 : entry.type) && entry.type == "text" && typeof entry.text == "string";
+}
 export {
+  AnnotationSet,
   DEFAULT_GROBID_URL,
   HYPERMEDIA_SCHEME,
   SeedClientError,
   SeedNetworkError,
   SeedValidationError,
+  addSpanToAnnotation,
+  annotationContains,
   autoLinkChildToParent,
   blocksToMarkdown,
   codePointLength,
@@ -3170,6 +3849,9 @@ export {
   deleteContact,
   documentContainsLinkToChild,
   documentHasSelfQuery,
+  draftFilename,
+  editorBlockToHMBlock,
+  editorBlocksToHMBlockNodes,
   embeddedPdfToBlocks,
   emitFrontmatter,
   entityQueryPathToHmIdPath,
@@ -3179,25 +3861,31 @@ export {
   getHMQueryString,
   hasFileLinks,
   hmBlockNodeToBlockNode,
+  hmBlockToEditorBlock,
+  hmBlocksToEditorContent,
   hmIdPathToEntityQueryPath,
   isGrobidAvailable,
   isSurrogate,
+  markdownBlockNodesToHMBlockNodes,
   matchBlockIds,
   packBaseId,
   packHmId,
   parseCustomURL,
+  parseDraftFilename,
   parseFragment,
   parseFrontmatter,
   parseInlineFormatting,
   parseMarkdown,
   pdfToBlocks,
   processFulltextDocument,
+  pushSpanToAnnotation,
   resolveDocumentState,
   resolveFileLinksInBlocks,
   serializeBlockRange,
   shouldAutoLinkParent,
   signDocumentChange,
   signPreparedChange,
+  slugify,
   teiToBlocks,
   trimTrailingEmptyBlocks,
   unpackHmId,

package/dist/markdown-to-blocks.d.ts

@@ -13,7 +13,7 @@
  *   - Block ID preservation via <!-- id:XXXXXXXX --> HTML comments
  *   - `title:` as backward-compatible alias for `name:` in frontmatter
  */
-import type { HMMetadata } from './hm-types';
+import type { HMBlockNode, HMMetadata } from './hm-types';
 import type { DocumentOperation } from './change';
 export type Annotation = {
     type: string;
@@ -74,6 +74,15 @@ export declare function parseMarkdown(markdown: string): {
     tree: BlockNode[];
     metadata: HMMetadata;
 };
+/**
+ * Convert the markdown parser's BlockNode tree into HMBlockNode tree.
+ *
+ * Maps flat SeedBlock properties (childrenType, language) into the
+ * HMBlock attributes object, and annotations into the HMAnnotation shape.
+ * The resulting tree can be fed into `hmBlocksToEditorContent()` to get
+ * BlockNote editor blocks.
+ */
+export declare function markdownBlockNodesToHMBlockNodes(nodes: BlockNode[]): HMBlockNode[];
 /**
  * Flattens a block tree into Seed document operations.
  *

package/dist/unicode.d.ts

@@ -0,0 +1,35 @@
+import type { HMAnnotations } from './hm-types';
+/**
+ * Mutable annotation shape used during construction.
+ * Structurally compatible with HMAnnotation but uses plain objects
+ * instead of protobuf classes.
+ */
+export interface MutableAnnotation {
+    type: string;
+    link?: string;
+    attributes?: Record<string, unknown>;
+    starts: number[];
+    ends: number[];
+}
+/** Minimal annotation shape required by span-position helpers. */
+export interface SpanAnnotation {
+    starts: number[];
+    ends: number[];
+}
+export declare class AnnotationSet {
+    annotations: Map<string, MutableAnnotation>;
+    constructor();
+    addSpan(type: string, attributes: {
+        [key: string]: string;
+    } | null, start: number, end: number): void;
+    _annotationId(type: string, attributes: {
+        [key: string]: string;
+    } | null): string;
+    list(): HMAnnotations;
+}
+/** Append a span to an annotation, merging with the previous span if adjacent. */
+export declare function addSpanToAnnotation(annotation: SpanAnnotation, start: number, end: number): void;
+/** Push a span to an annotation without checking adjacency. */
+export declare function pushSpanToAnnotation(annotation: SpanAnnotation, start: number, end: number): void;
+/** @deprecated Import from `@seed-hypermedia/client/hm-types` instead. */
+export { codePointLength, isSurrogate } from './hm-types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seed-hypermedia/client",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/seed-hypermedia/seed",

package/src/index.ts

@@ -54,9 +54,15 @@ export type {HMRequest, HMSigner, UnpackedHypermediaId} from './hm-types'
 export {fileToIpfsBlobs, filesToIpfsBlobs, resolveFileLinksInBlocks, hasFileLinks} from './file-to-ipfs'
 export type {CollectedBlob} from './file-to-ipfs'
 
-export {parseMarkdown, flattenToOperations, parseInlineFormatting, parseFrontmatter} from './markdown-to-blocks'
+export {
+  parseMarkdown,
+  flattenToOperations,
+  parseInlineFormatting,
+  parseFrontmatter,
+  markdownBlockNodesToHMBlockNodes,
+} from './markdown-to-blocks'
 export type {BlockNode, SeedBlock, Annotation} from './markdown-to-blocks'
-export {blocksToMarkdown, emitFrontmatter} from './blocks-to-markdown'
+export {blocksToMarkdown, emitFrontmatter, slugify, draftFilename, parseDraftFilename} from './blocks-to-markdown'
 export type {BlocksToMarkdownOptions} from './blocks-to-markdown'
 
 export {createBlocksMap, matchBlockIds, computeReplaceOps, hmBlockNodeToBlockNode} from './block-diff'
@@ -72,3 +78,36 @@ export {
 export type {AutoLinkChildToParentOptions} from './auto-link'
 export {resolveDocumentState} from './document-state'
 export type {DocumentState} from './document-state'
+
+export {editorBlockToHMBlock, editorBlocksToHMBlockNodes} from './editorblock-to-hmblock'
+export {hmBlocksToEditorContent, hmBlockToEditorBlock, annotationContains} from './hmblock-to-editorblock'
+export {AnnotationSet, addSpanToAnnotation, pushSpanToAnnotation} from './unicode'
+export type {MutableAnnotation, SpanAnnotation} from './unicode'
+export type {
+  EditorBlock,
+  EditorBaseBlock,
+  EditorBlockProps,
+  EditorBlockType,
+  EditorParagraphBlock,
+  EditorHeadingBlock,
+  EditorCodeBlock,
+  EditorImageBlock,
+  EditorVideoBlock,
+  EditorFileBlock,
+  EditorButtonBlock,
+  EditorEmbedBlock,
+  EditorWebEmbedBlock,
+  EditorMathBlock,
+  EditorNostrBlock,
+  EditorQueryBlock,
+  EditorUnknownBlock,
+  EditorText,
+  EditorLink,
+  EditorInlineEmbed,
+  EditorInlineStyles,
+  EditorAnnotationType,
+  HMInlineContent,
+  MediaBlockProps,
+  DraftMediaRef,
+  SearchResult,
+} from './editor-types'