@jant/core 0.1.2 → 0.2.0

package/dist/lib/markdown.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Markdown Rendering
+ *
+ * Uses marked with minimal configuration
+ */
+/**
+ * Renders Markdown content to HTML using the marked library.
+ *
+ * Configured with GitHub Flavored Markdown (GFM) support and line breaks enabled.
+ * Uses synchronous parsing for simplicity and consistency in server-side rendering.
+ *
+ * @param markdown - The Markdown string to convert to HTML
+ * @returns The rendered HTML string
+ *
+ * @example
+ * ```ts
+ * const html = render("# Hello\n\nThis is **bold** text.");
+ * // Returns: "<h1>Hello</h1>\n<p>This is <strong>bold</strong> text.</p>"
+ * ```
+ */
+export declare function render(markdown: string): string;
+/**
+ * Converts Markdown to plain text by stripping all formatting syntax.
+ *
+ * Removes Markdown syntax including headers, bold, italic, links, images, code blocks,
+ * blockquotes, lists, and converts newlines to spaces. Useful for generating text excerpts,
+ * meta descriptions, or search indexes.
+ *
+ * @param markdown - The Markdown string to convert to plain text
+ * @returns The plain text string with all Markdown syntax removed
+ *
+ * @example
+ * ```ts
+ * const plain = toPlainText("## Hello\n\nThis is **bold** and [a link](url).");
+ * // Returns: "Hello This is bold and a link."
+ * ```
+ */
+export declare function toPlainText(markdown: string): string;
+/**
+ * Extracts a title from Markdown content by taking the first sentence or line.
+ *
+ * Converts Markdown to plain text first, then takes the first sentence (split by `.!?`)
+ * or truncates to the specified maximum length. Useful for generating automatic titles
+ * from post content when no explicit title is provided.
+ *
+ * @param markdown - The Markdown string to extract a title from
+ * @param maxLength - Maximum length of the extracted title (default: 120)
+ * @returns The extracted title string, with "..." appended if truncated
+ *
+ * @example
+ * ```ts
+ * const title = extractTitle("This is the first sentence. And another one.", 50);
+ * // Returns: "This is the first sentence"
+ *
+ * const title = extractTitle("A very long sentence that exceeds the maximum length...", 30);
+ * // Returns: "A very long sentence that ex..."
+ * ```
+ */
+export declare function extractTitle(markdown: string, maxLength?: number): string;
+//# sourceMappingURL=markdown.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../src/lib/markdown.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAUH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAYpD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,SAAM,GAAG,MAAM,CAStE"}

package/{src/lib/markdown.ts → dist/lib/markdown.js}

@@ -2,16 +2,12 @@
  * Markdown Rendering
  *
  * Uses marked with minimal configuration
- */
-
-import { marked } from "marked";
-
+ */ import { marked } from "marked";
 // Configure marked for security and simplicity
 marked.setOptions({
-  gfm: true,
-  breaks: true,
+    gfm: true,
+    breaks: true
 });
-
 /**
  * Renders Markdown content to HTML using the marked library.
  *
@@ -26,11 +22,11 @@ marked.setOptions({
  * const html = render("# Hello\n\nThis is **bold** text.");
  * // Returns: "<h1>Hello</h1>\n<p>This is <strong>bold</strong> text.</p>"
  * ```
- */
-export function render(markdown: string): string {
-  return marked.parse(markdown, { async: false }) as string;
+ */ export function render(markdown) {
+    return marked.parse(markdown, {
+        async: false
+    });
 }
-
 /**
  * Converts Markdown to plain text by stripping all formatting syntax.
  *
@@ -46,10 +42,8 @@ export function render(markdown: string): string {
  * const plain = toPlainText("## Hello\n\nThis is **bold** and [a link](url).");
  * // Returns: "Hello This is bold and a link."
  * ```
- */
-export function toPlainText(markdown: string): string {
-  return markdown
-    .replace(/#{1,6}\s+/g, "") // Remove headers
+ */ export function toPlainText(markdown) {
+    return markdown.replace(/#{1,6}\s+/g, "") // Remove headers
     .replace(/\*\*(.+?)\*\*/g, "$1") // Bold
     .replace(/\*(.+?)\*/g, "$1") // Italic
     .replace(/\[(.+?)\]\(.+?\)/g, "$1") // Links
@@ -60,7 +54,6 @@ export function toPlainText(markdown: string): string {
     .replace(/\n+/g, " ") // Newlines
     .trim();
 }
-
 /**
  * Extracts a title from Markdown content by taking the first sentence or line.
  *
@@ -80,14 +73,11 @@ export function toPlainText(markdown: string): string {
  * const title = extractTitle("A very long sentence that exceeds the maximum length...", 30);
  * // Returns: "A very long sentence that ex..."
  * ```
- */
-export function extractTitle(markdown: string, maxLength = 120): string {
-  const plain = toPlainText(markdown);
-  const firstLine = plain.split(/[.!?]/)[0] ?? plain;
-
-  if (firstLine.length <= maxLength) {
-    return firstLine;
-  }
-
-  return plain.slice(0, maxLength).trim() + "...";
+ */ export function extractTitle(markdown, maxLength = 120) {
+    const plain = toPlainText(markdown);
+    const firstLine = plain.split(/[.!?]/)[0] ?? plain;
+    if (firstLine.length <= maxLength) {
+        return firstLine;
+    }
+    return plain.slice(0, maxLength).trim() + "...";
 }

package/dist/lib/schemas.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Shared Zod schemas for validation
+ *
+ * These schemas ensure type-safe validation of user input
+ * from forms, API requests, and other external sources.
+ *
+ * IMPORTANT: Types are defined in types.ts as the single source of truth.
+ * This file only defines Zod validation schemas based on those types.
+ */
+import { z } from "zod";
+/**
+ * Post type enum schema
+ * Based on POST_TYPES from types.ts
+ */
+export declare const PostTypeSchema: z.ZodEnum<{
+    note: "note";
+    article: "article";
+    link: "link";
+    quote: "quote";
+    image: "image";
+    page: "page";
+}>;
+/**
+ * Visibility enum schema
+ * Based on VISIBILITY_LEVELS from types.ts
+ */
+export declare const VisibilitySchema: z.ZodEnum<{
+    featured: "featured";
+    quiet: "quiet";
+    unlisted: "unlisted";
+    draft: "draft";
+}>;
+/**
+ * Redirect type enum schema
+ * Form input validation for redirect type (stored as number in DB)
+ */
+export declare const RedirectTypeSchema: z.ZodEnum<{
+    301: "301";
+    302: "302";
+}>;
+/**
+ * API request body schema for creating a post
+ */
+export declare const CreatePostSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        note: "note";
+        article: "article";
+        link: "link";
+        quote: "quote";
+        image: "image";
+        page: "page";
+    }>;
+    title: z.ZodOptional<z.ZodString>;
+    content: z.ZodString;
+    visibility: z.ZodEnum<{
+        featured: "featured";
+        quiet: "quiet";
+        unlisted: "unlisted";
+        draft: "draft";
+    }>;
+    sourceUrl: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    sourceName: z.ZodOptional<z.ZodString>;
+    path: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    replyToId: z.ZodOptional<z.ZodString>;
+    publishedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * API request body schema for updating a post
+ */
+export declare const UpdatePostSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodEnum<{
+        note: "note";
+        article: "article";
+        link: "link";
+        quote: "quote";
+        image: "image";
+        page: "page";
+    }>>;
+    title: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    content: z.ZodOptional<z.ZodString>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        featured: "featured";
+        quiet: "quiet";
+        unlisted: "unlisted";
+        draft: "draft";
+    }>>;
+    sourceUrl: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>>;
+    sourceName: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    path: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>>;
+    replyToId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    publishedAt: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+/**
+ * Form data helper: safely parse a FormData value with a schema
+ *
+ * @example
+ * ```ts
+ * const type = parseFormData(formData, "type", PostTypeSchema);
+ * // type is PostType, throws if invalid
+ * ```
+ */
+export declare function parseFormData<T>(formData: FormData, key: string, schema: z.ZodSchema<T>): T;
+/**
+ * Form data helper: safely parse optional FormData value with a schema
+ *
+ * @example
+ * ```ts
+ * const slug = parseFormDataOptional(formData, "slug", z.string());
+ * // slug is string | undefined
+ * ```
+ */
+export declare function parseFormDataOptional<T>(formData: FormData, key: string, schema: z.ZodSchema<T>): T | undefined;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/lib/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;EAAqB,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;EAA4B,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;EAAyB,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;iBAU3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;iBAA6B,CAAC;AAE3D;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GACrB,CAAC,CAMH;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GACrB,CAAC,GAAG,SAAS,CAMf"}

package/dist/lib/schemas.js

@@ -0,0 +1,71 @@
+/**
+ * Shared Zod schemas for validation
+ *
+ * These schemas ensure type-safe validation of user input
+ * from forms, API requests, and other external sources.
+ *
+ * IMPORTANT: Types are defined in types.ts as the single source of truth.
+ * This file only defines Zod validation schemas based on those types.
+ */ import { z } from "zod";
+import { POST_TYPES, VISIBILITY_LEVELS } from "../types.js";
+/**
+ * Post type enum schema
+ * Based on POST_TYPES from types.ts
+ */ export const PostTypeSchema = z.enum(POST_TYPES);
+/**
+ * Visibility enum schema
+ * Based on VISIBILITY_LEVELS from types.ts
+ */ export const VisibilitySchema = z.enum(VISIBILITY_LEVELS);
+/**
+ * Redirect type enum schema
+ * Form input validation for redirect type (stored as number in DB)
+ */ export const RedirectTypeSchema = z.enum([
+    "301",
+    "302"
+]);
+/**
+ * API request body schema for creating a post
+ */ export const CreatePostSchema = z.object({
+    type: PostTypeSchema,
+    title: z.string().optional(),
+    content: z.string(),
+    visibility: VisibilitySchema,
+    sourceUrl: z.string().url().optional().or(z.literal("")),
+    sourceName: z.string().optional(),
+    path: z.string().regex(/^[a-z0-9-]*$/).optional().or(z.literal("")),
+    replyToId: z.string().optional(),
+    publishedAt: z.number().int().positive().optional()
+});
+/**
+ * API request body schema for updating a post
+ */ export const UpdatePostSchema = CreatePostSchema.partial();
+/**
+ * Form data helper: safely parse a FormData value with a schema
+ *
+ * @example
+ * ```ts
+ * const type = parseFormData(formData, "type", PostTypeSchema);
+ * // type is PostType, throws if invalid
+ * ```
+ */ export function parseFormData(formData, key, schema) {
+    const value = formData.get(key);
+    if (value === null) {
+        throw new Error(`Missing required field: ${key}`);
+    }
+    return schema.parse(value);
+}
+/**
+ * Form data helper: safely parse optional FormData value with a schema
+ *
+ * @example
+ * ```ts
+ * const slug = parseFormDataOptional(formData, "slug", z.string());
+ * // slug is string | undefined
+ * ```
+ */ export function parseFormDataOptional(formData, key, schema) {
+    const value = formData.get(key);
+    if (value === null || value === "") {
+        return undefined;
+    }
+    return schema.parse(value);
+}

package/dist/lib/sqid.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Sqids - Short unique IDs for URLs
+ *
+ * Encodes numeric IDs to short strings like "jR3k"
+ */
+/**
+ * Encodes a numeric database ID to a short, URL-friendly string.
+ *
+ * Uses the Sqids library to generate short unique identifiers with a minimum length of 4 characters.
+ * These are used in URLs (e.g., `/p/jR3k`) to obscure sequential integer IDs while maintaining
+ * uniqueness and reversibility.
+ *
+ * @param id - The numeric database ID to encode
+ * @returns A short string representation of the ID (minimum 4 characters)
+ *
+ * @example
+ * ```ts
+ * const sqid = encode(123);
+ * // Returns: "jR3k" (or similar short string)
+ * ```
+ */
+export declare function encode(id: number): string;
+/**
+ * Decodes a sqid string back to the original numeric database ID.
+ *
+ * Attempts to decode a sqid string generated by the `encode()` function. Returns the original
+ * numeric ID if valid, or `null` if the string is not a valid sqid. This is used to extract
+ * database IDs from URL parameters.
+ *
+ * @param str - The sqid string to decode
+ * @returns The original numeric ID if valid, or `null` if decoding fails
+ *
+ * @example
+ * ```ts
+ * const id = decode("jR3k");
+ * // Returns: 123
+ *
+ * const invalid = decode("invalid");
+ * // Returns: null
+ * ```
+ */
+export declare function decode(str: string): number | null;
+/**
+ * Checks if a string is a valid sqid that can be decoded.
+ *
+ * Validates whether a string can be successfully decoded to a numeric ID.
+ * Useful for route validation and input sanitization.
+ *
+ * @param str - The string to validate
+ * @returns `true` if the string is a valid sqid, `false` otherwise
+ *
+ * @example
+ * ```ts
+ * if (isValidSqid("jR3k")) {
+ *   // Process the valid sqid
+ * }
+ * ```
+ */
+export declare function isValidSqid(str: string): boolean;
+//# sourceMappingURL=sqid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sqid.d.ts","sourceRoot":"","sources":["../../src/lib/sqid.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOjD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEhD"}

package/{src/lib/sqid.ts → dist/lib/sqid.js}

@@ -2,14 +2,10 @@
  * Sqids - Short unique IDs for URLs
  *
  * Encodes numeric IDs to short strings like "jR3k"
- */
-
-import Sqids from "sqids";
-
+ */ import Sqids from "sqids";
 const sqids = new Sqids({
-  minLength: 4,
+    minLength: 4
 });
-
 /**
  * Encodes a numeric database ID to a short, URL-friendly string.
  *
@@ -25,11 +21,11 @@ const sqids = new Sqids({
  * const sqid = encode(123);
  * // Returns: "jR3k" (or similar short string)
  * ```
- */
-export function encode(id: number): string {
-  return sqids.encode([id]);
+ */ export function encode(id) {
+    return sqids.encode([
+        id
+    ]);
 }
-
 /**
  * Decodes a sqid string back to the original numeric database ID.
  *
@@ -48,16 +44,14 @@ export function encode(id: number): string {
  * const invalid = decode("invalid");
  * // Returns: null
  * ```
- */
-export function decode(str: string): number | null {
-  try {
-    const ids = sqids.decode(str);
-    return ids[0] ?? null;
-  } catch {
-    return null;
-  }
+ */ export function decode(str) {
+    try {
+        const ids = sqids.decode(str);
+        return ids[0] ?? null;
+    } catch  {
+        return null;
+    }
 }
-
 /**
  * Checks if a string is a valid sqid that can be decoded.
  *
@@ -73,7 +67,6 @@ export function decode(str: string): number | null {
  *   // Process the valid sqid
  * }
  * ```
- */
-export function isValidSqid(str: string): boolean {
-  return decode(str) !== null;
+ */ export function isValidSqid(str) {
+    return decode(str) !== null;
 }

package/dist/lib/sse.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Server-Sent Events (SSE) utilities for Datastar
+ *
+ * Provides helpers for streaming SSE responses that Datastar can consume.
+ * Datastar uses SSE for real-time UI updates without page reloads.
+ *
+ * @see https://data-star.dev/
+ *
+ * @example
+ * ```ts
+ * app.post("/api/example", (c) => {
+ *   return sse(c, async (stream) => {
+ *     await stream.patchSignals({ loading: false });
+ *     await stream.patchElements("#result", "<div>Done!</div>");
+ *   });
+ * });
+ * ```
+ */
+import type { Context } from "hono";
+/**
+ * Patch modes for DOM updates
+ */
+export type PatchMode = "morph" | "inner" | "outer" | "append" | "prepend" | "remove";
+/**
+ * SSE stream writer for Datastar events
+ */
+export interface SSEStream {
+    /**
+     * Update reactive signals on the client
+     *
+     * @param signals - Object containing signal values to update
+     *
+     * @example
+     * ```ts
+     * await stream.patchSignals({ count: 42, loading: false });
+     * ```
+     */
+    patchSignals(signals: Record<string, unknown>): Promise<void>;
+    /**
+     * Update DOM elements
+     *
+     * @param html - HTML content (must include element with id for targeting)
+     * @param options - Optional mode and selector
+     *
+     * @example
+     * ```ts
+     * // Replace element with matching id (default: morph)
+     * await stream.patchElements('<div id="content">New content</div>');
+     *
+     * // Append to a container
+     * await stream.patchElements('<div>New item</div>', {
+     *   mode: 'append',
+     *   selector: '#list'
+     * });
+     * ```
+     */
+    patchElements(html: string, options?: {
+        mode?: PatchMode;
+        selector?: string;
+    }): Promise<void>;
+    /**
+     * Execute JavaScript on the client
+     *
+     * @param script - JavaScript code to execute
+     *
+     * @example
+     * ```ts
+     * await stream.executeScript('console.log("Hello from server")');
+     * ```
+     */
+    executeScript(script: string): Promise<void>;
+}
+/**
+ * Create an SSE response for Datastar
+ *
+ * @param c - Hono context
+ * @param handler - Async function that writes to the SSE stream
+ * @returns Response with SSE content-type
+ *
+ * @example
+ * ```ts
+ * app.post("/api/upload", (c) => {
+ *   return sse(c, async (stream) => {
+ *     // Process upload...
+ *     await stream.patchSignals({ uploading: false });
+ *     await stream.patchElements('<div id="new-item">...</div>', {
+ *       mode: 'append',
+ *       selector: '#items'
+ *     });
+ *   });
+ * });
+ * ```
+ */
+export declare function sse(c: Context, handler: (stream: SSEStream) => Promise<void>): Response;
+//# sourceMappingURL=sse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../src/lib/sse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEtF;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB;;;;;;;;;OASG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9D;;;;;;;;;;;;;;;;;OAiBG;IACH,aAAa,CACX,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,SAAS,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAChD,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB;;;;;;;;;OASG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,GAAG,CACjB,CAAC,EAAE,OAAO,EACV,OAAO,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,GAC5C,QAAQ,CAiDV"}

package/dist/lib/sse.js

@@ -0,0 +1,81 @@
+/**
+ * Server-Sent Events (SSE) utilities for Datastar
+ *
+ * Provides helpers for streaming SSE responses that Datastar can consume.
+ * Datastar uses SSE for real-time UI updates without page reloads.
+ *
+ * @see https://data-star.dev/
+ *
+ * @example
+ * ```ts
+ * app.post("/api/example", (c) => {
+ *   return sse(c, async (stream) => {
+ *     await stream.patchSignals({ loading: false });
+ *     await stream.patchElements("#result", "<div>Done!</div>");
+ *   });
+ * });
+ * ```
+ */ /**
+ * Create an SSE response for Datastar
+ *
+ * @param c - Hono context
+ * @param handler - Async function that writes to the SSE stream
+ * @returns Response with SSE content-type
+ *
+ * @example
+ * ```ts
+ * app.post("/api/upload", (c) => {
+ *   return sse(c, async (stream) => {
+ *     // Process upload...
+ *     await stream.patchSignals({ uploading: false });
+ *     await stream.patchElements('<div id="new-item">...</div>', {
+ *       mode: 'append',
+ *       selector: '#items'
+ *     });
+ *   });
+ * });
+ * ```
+ */ export function sse(c, handler) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start (controller) {
+            const write = (data)=>{
+                controller.enqueue(encoder.encode(data));
+            };
+            const sseStream = {
+                async patchSignals (signals) {
+                    write(`event: datastar-patch-signals\n`);
+                    write(`data: signals ${JSON.stringify(signals)}\n\n`);
+                },
+                async patchElements (html, options = {}) {
+                    write(`event: datastar-patch-elements\n`);
+                    if (options.mode) {
+                        write(`data: mode ${options.mode}\n`);
+                    }
+                    if (options.selector) {
+                        write(`data: selector ${options.selector}\n`);
+                    }
+                    // Escape newlines in HTML for SSE format
+                    const escapedHtml = html.replace(/\n/g, "\ndata: ");
+                    write(`data: elements ${escapedHtml}\n\n`);
+                },
+                async executeScript (script) {
+                    write(`event: datastar-execute-script\n`);
+                    write(`data: script ${script}\n\n`);
+                }
+            };
+            try {
+                await handler(sseStream);
+            } finally{
+                controller.close();
+            }
+        }
+    });
+    return new Response(stream, {
+        headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+        }
+    });
+}