@agent-native/core 0.167.0 → 0.167.1

package/corpus/templates/clips/CHANGELOG.md

@@ -7,6 +7,7 @@ from the command menu (Cmd+K → "What's new") or from Settings.
 
 ### Improved
 
+- Recording preparation now uses a centered full-screen overlay that transitions smoothly into the 3-2-1 countdown.
 - Clip viewers now make Share the primary action and keep the overflow control compact and vertical.
 - Recording controls now follow you across browser tabs and page navigations.
 

package/dist/changelog/parse.js

@@ -237,6 +237,213 @@ function normalizedChangelogText(value) {
         .replace(/\s+/g, " ")
         .trim();
 }
+function stripHtmlComments(line, inComment, initialInlineCodeMarker) {
+    let cursor = 0;
+    let visibleLine = "";
+    const comments = [];
+    let inlineCodeMarker = initialInlineCodeMarker;
+    while (cursor < line.length) {
+        if (inComment) {
+            const commentEnd = line.indexOf("-->", cursor);
+            if (commentEnd === -1) {
+                return {
+                    line: visibleLine,
+                    inComment: true,
+                    inlineCodeMarker,
+                    comments,
+                };
+            }
+            cursor = commentEnd + 3;
+            inComment = false;
+            continue;
+        }
+        if (inlineCodeMarker) {
+            const codeEnd = line.indexOf(inlineCodeMarker, cursor);
+            if (codeEnd === -1) {
+                visibleLine += line.slice(cursor);
+                break;
+            }
+            visibleLine += line.slice(cursor, codeEnd + inlineCodeMarker.length);
+            cursor = codeEnd + inlineCodeMarker.length;
+            inlineCodeMarker = undefined;
+            continue;
+        }
+        const commentStart = line.indexOf("<!--", cursor);
+        const codeStartIndex = line.indexOf("`", cursor);
+        if (codeStartIndex !== -1 &&
+            (commentStart === -1 || codeStartIndex < commentStart)) {
+            visibleLine += line.slice(cursor, codeStartIndex);
+            const codeStart = /^`+/.exec(line.slice(codeStartIndex))?.[0] ?? "`";
+            visibleLine += codeStart;
+            cursor = codeStartIndex + codeStart.length;
+            inlineCodeMarker = codeStart;
+            continue;
+        }
+        if (commentStart === -1) {
+            visibleLine += line.slice(cursor);
+            break;
+        }
+        visibleLine += line.slice(cursor, commentStart);
+        const commentEnd = line.indexOf("-->", commentStart + 4);
+        if (commentEnd !== -1) {
+            comments.push(line.slice(commentStart, commentEnd + 3));
+        }
+        cursor = commentStart + 4;
+        inComment = true;
+    }
+    return { line: visibleLine, inComment, inlineCodeMarker, comments };
+}
+function splitChangelogBodyGroups(body) {
+    const matches = [];
+    let offset = 0;
+    let fenceMarker;
+    let htmlComment = false;
+    let inlineCodeMarker;
+    for (const line of body.split(/\r?\n/)) {
+        const lineEnd = offset + line.length;
+        if (fenceMarker) {
+            const fence = /^\s*(`{3,}|~{3,})(.*)$/.exec(line)?.[1];
+            const closingFence = /^\s*(`{3,}|~{3,})\s*$/.exec(line)?.[1];
+            if (fence &&
+                closingFence &&
+                fenceMarker.character === fence[0] &&
+                closingFence.length >= fenceMarker.length) {
+                fenceMarker = undefined;
+            }
+        }
+        else {
+            let visibleLine;
+            let headingComments = [];
+            if (!htmlComment && !inlineCodeMarker) {
+                const fence = /^\s*(`{3,}|~{3,})(.*)$/.exec(line)?.[1];
+                if (fence) {
+                    fenceMarker = { character: fence[0], length: fence.length };
+                }
+                else {
+                    const commentResult = stripHtmlComments(line, false, inlineCodeMarker);
+                    htmlComment = commentResult.inComment;
+                    inlineCodeMarker = commentResult.inlineCodeMarker;
+                    visibleLine = commentResult.line;
+                    headingComments = commentResult.comments;
+                }
+            }
+            else {
+                const commentResult = stripHtmlComments(line, htmlComment, inlineCodeMarker);
+                htmlComment = commentResult.inComment;
+                inlineCodeMarker = commentResult.inlineCodeMarker;
+                visibleLine = commentResult.line;
+                headingComments = commentResult.comments;
+            }
+            if (visibleLine !== undefined && !fenceMarker) {
+                const fence = /^\s*(`{3,}|~{3,})(.*)$/.exec(visibleLine)?.[1];
+                if (fence) {
+                    fenceMarker = { character: fence[0], length: fence.length };
+                }
+                else {
+                    const heading = /^ {0,3}###\s+(.+?)(?:\s+#+)?\s*$/.exec(visibleLine);
+                    if (heading &&
+                        CHANGELOG_GROUP_ORDER.some((type) => GROUP_LABELS[type].toLowerCase() ===
+                            heading[1].trim().toLowerCase())) {
+                        matches.push({
+                            title: heading[1].trim(),
+                            headingComments,
+                            start: offset,
+                            headingEnd: lineEnd,
+                        });
+                    }
+                }
+            }
+        }
+        const newlineLength = body.startsWith("\r\n", lineEnd)
+            ? 2
+            : lineEnd < body.length
+                ? 1
+                : 0;
+        offset = lineEnd + newlineLength;
+    }
+    if (matches.length === 0)
+        return { prefix: body.trim(), groups: [] };
+    const prefix = body.slice(0, matches[0].start).trim();
+    const groups = matches.map((match, index) => {
+        const end = matches[index + 1]?.start ?? body.length;
+        return {
+            title: match.title,
+            headingComments: match.headingComments,
+            body: body.slice(match.headingEnd, end).trim(),
+            index,
+        };
+    });
+    return { prefix, groups };
+}
+function changelogBodyGroupOrder(title) {
+    const normalizedTitle = title.toLowerCase();
+    const index = CHANGELOG_GROUP_ORDER.findIndex((type) => GROUP_LABELS[type].toLowerCase() === normalizedTitle);
+    return index === -1 ? CHANGELOG_GROUP_ORDER.length : index;
+}
+function normalizeChangelogBody(body) {
+    const { prefix, groups } = splitChangelogBodyGroups(body);
+    if (groups.length < 2)
+        return body.trim();
+    const uniqueGroups = new Map();
+    for (const group of groups) {
+        const key = group.title.toLowerCase();
+        const current = uniqueGroups.get(key);
+        const headingComments = current
+            ? [
+                ...current.headingComments,
+                ...group.headingComments.filter((comment) => !current.headingComments.includes(comment)),
+            ]
+            : group.headingComments;
+        uniqueGroups.set(key, {
+            title: current?.title ?? group.title,
+            headingComments,
+            body: [current?.body, group.body].filter(Boolean).join("\n"),
+            index: current?.index ?? group.index,
+        });
+    }
+    const renderedGroups = [...uniqueGroups.values()]
+        .sort((a, b) => changelogBodyGroupOrder(a.title) - changelogBodyGroupOrder(b.title) ||
+        a.index - b.index)
+        .map((group) => `### ${group.title}${group.headingComments.length ? ` ${group.headingComments.join(" ")}` : ""}\n\n${group.body}`);
+    return [prefix, ...renderedGroups].filter(Boolean).join("\n\n");
+}
+function mergeChangelogBodies(pendingBody, existingBody) {
+    const pending = splitChangelogBodyGroups(pendingBody);
+    const existing = splitChangelogBodyGroups(existingBody);
+    if (pending.groups.length === 0) {
+        return normalizeChangelogBody(existingBody);
+    }
+    if (existing.groups.length === 0) {
+        return [pendingBody, existingBody]
+            .map((body) => body.trim())
+            .filter(Boolean)
+            .join("\n\n");
+    }
+    const groups = new Map();
+    for (const group of [...pending.groups, ...existing.groups]) {
+        const key = group.title.toLowerCase();
+        const current = groups.get(key);
+        const headingComments = current
+            ? [
+                ...current.headingComments,
+                ...group.headingComments.filter((comment) => !current.headingComments.includes(comment)),
+            ]
+            : group.headingComments;
+        groups.set(key, {
+            title: current?.title ?? group.title,
+            headingComments,
+            body: [current?.body, group.body].filter(Boolean).join("\n"),
+            index: current?.index ?? group.index,
+        });
+    }
+    const prefix = [pending.prefix, existing.prefix].filter(Boolean).join("\n\n");
+    return normalizeChangelogBody([
+        prefix,
+        ...[...groups.values()].map((group) => `### ${group.title}${group.headingComments.length ? ` ${group.headingComments.join(" ")}` : ""}\n\n${group.body}`),
+    ]
+        .filter(Boolean)
+        .join("\n\n"));
+}
 /**
  * Render an app-facing changelog that includes both released CHANGELOG.md
  * sections and adjacent folder-backed `changelog/*.md` entries. This is pure
@@ -246,10 +453,19 @@ function normalizedChangelogText(value) {
 export function mergePendingChangelog(existing, pending) {
     const cleanExisting = stripChangelogArchiveNotes(existing);
     const existingEntries = parseChangelog(cleanExisting);
+    const pendingSeen = new Set();
     const pendingWithText = pending.filter((entry) => {
         const text = entry.text.trim();
         if (!text)
             return false;
+        const pendingKey = [
+            entry.date ?? "",
+            entry.type,
+            normalizedChangelogText(text),
+        ].join("\u0000");
+        if (pendingSeen.has(pendingKey))
+            return false;
+        pendingSeen.add(pendingKey);
         return !existingEntries.some((existingEntry) => {
             if (entry.date &&
                 existingEntry.date &&
@@ -261,7 +477,7 @@ export function mergePendingChangelog(existing, pending) {
     });
     if (pendingWithText.length === 0) {
         const sections = existingEntries
-            .map((entry) => `## ${entry.title}\n\n${cleanChangelogBody(entry.body)}`)
+            .map((entry) => `## ${entry.title}\n\n${normalizeChangelogBody(cleanChangelogBody(entry.body))}`)
             .join("\n\n");
         return `${changelogHeader(cleanExisting)}${sections ? `\n\n${sections}` : ""}\n\n${CHANGELOG_ARCHIVE_NOTE}\n`;
     }
@@ -273,7 +489,7 @@ export function mergePendingChangelog(existing, pending) {
     const sections = existingEntries.map((entry) => ({
         title: entry.title,
         date: entry.date,
-        body: cleanChangelogBody(entry.body),
+        body: normalizeChangelogBody(cleanChangelogBody(entry.body)),
     }));
     for (const title of [...pendingByTitle.keys()].sort(pendingSectionSort)) {
         const body = renderReleaseBody(pendingByTitle.get(title) ?? []);
@@ -283,12 +499,7 @@ export function mergePendingChangelog(existing, pending) {
             return entry.date === title || entry.title === title;
         });
         if (existingIndex !== -1) {
-            sections[existingIndex].body = [
-                body,
-                cleanChangelogBody(sections[existingIndex].body),
-            ]
-                .filter(Boolean)
-                .join("\n\n");
+            sections[existingIndex].body = mergeChangelogBodies(body, cleanChangelogBody(sections[existingIndex].body));
             continue;
         }
         const newSection = { title, date: title.match(ISO_DATE)?.[1], body };

package/dist/collab/awareness.d.ts

@@ -62,11 +62,11 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 /**
  * GET /_agent-native/collab/:docId/users
@@ -77,9 +77,9 @@ export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/notifications/routes.d.ts

@@ -11,14 +11,14 @@
  *   DELETE /_agent-native/notifications/:id         — delete
  */
 export declare function createNotificationsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<"" | import("./types.js").Notification[] | {
-    error?: undefined;
     count: number;
     updated?: undefined;
+    error?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     count?: undefined;
     updated: number;
+    error?: undefined;
     ok?: undefined;
 } | {
     count?: undefined;
@@ -26,8 +26,8 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     count?: undefined;
     updated?: undefined;
+    error?: undefined;
     ok: boolean;
 }>>;

package/dist/observability/routes.d.ts

@@ -41,23 +41,23 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    ok?: undefined;
     error?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
-} | {
     ok?: undefined;
+} | {
     error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id: string;
-} | {
     ok?: undefined;
+} | {
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     error: any;
+    ok?: undefined;
 } | {
     error?: undefined;
     summary?: undefined;

package/dist/secrets/routes.d.ts

@@ -34,37 +34,37 @@ export declare function createListSecretsHandler(): import("h3").EventHandlerWit
 /** POST /_agent-native/secrets/:key — write a secret. */
 export declare function createWriteSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    ok?: undefined;
     status?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     status: string;
+    error?: undefined;
 } | {
-    ok?: undefined;
     error: string;
     removed?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;
 /**
  * POST /_agent-native/secrets/:key/test — validate an optional candidate value
  * or the current stored value without changing anything.
  */
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
     note?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     note?: undefined;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     note: string;
+    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -95,11 +95,11 @@ export interface AdHocSecretPayload {
 export declare function createAdHocSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<AdHocSecretPayload[] | {
     error: string;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.167.0",
+  "version": "0.167.1",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {