@agent-native/core 0.197.0-nightly-20260929172956 → 0.197.0

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 10665
+- template files: 10675

package/corpus/templates/analytics/CHANGELOG.md

@@ -3,10 +3,20 @@
 All notable user-facing changes to Agent-Native Analytics are documented here. Open it any
 time from the command menu (Cmd+K → "What's new") or from Settings.
 
+## 2026-09-29
+
+### Improved
+
+- Settings pages now share the account layout, with dated updates that load in batches.
+
 ## 2026-09-28
 
 ### Improved
 
+- Analytics starts faster on hosted serverless deployments.
+- The app canvas now meets the right chat sidebar without a dark seam or rounded corner.
+- Settings now opens in the new layout, with Account, Connections, Agent, Organization, and app sections.
+- The chat sidebar matches the app navigation color, with tighter composer spacing.
 - Ask Analytics now starts with a focused title.
 
 ## 2026-09-27

package/corpus/templates/assets/CHANGELOG.md

@@ -3,10 +3,18 @@
 All notable user-facing changes to Assets are documented here. Open it any
 time from the command menu (Cmd+K → "What's new") or from Settings.
 
+## 2026-09-29
+
+### Improved
+
+- Settings pages now share the account layout, with dated updates that load in batches.
+
 ## 2026-09-28
 
 ### Improved
 
+- The app canvas now meets the right chat sidebar without a dark seam or rounded corner.
+- Settings now opens in the new layout, with Account, Connections, Agent, Organization, and app sections.
 - Create starter prompts now appear below the composer.
 
 ## 2026-09-27

package/corpus/templates/calendar/CHANGELOG.md

@@ -3,6 +3,24 @@
 All notable user-facing changes to Agent-Native Calendar are documented here. Open it any
 time from the command menu (Cmd+K → "What's new") or from Settings.
 
+## 2026-09-29
+
+### Improved
+
+- Settings pages now share the account layout, with dated updates that load in batches.
+
+## 2026-09-28
+
+### Improved
+
+- The app canvas now meets the right chat sidebar without a dark seam or rounded corner.
+- Booking link host, custom-field, visibility, and delete controls now live in a collapsible Advanced section.
+- Settings now opens in the new layout, with Account, Connections, Agent, Organization, and app sections.
+
+### Fixed
+
+- Public booking pages no longer get stuck loading.
+
 ## 2026-09-27
 
 ### Improved

package/corpus/templates/clips/CHANGELOG.md

@@ -3,14 +3,33 @@
 All notable user-facing changes to Clips are documented here. Open it any time
 from the command menu (Cmd+K → "What's new") or from Settings.
 
+## 2026-09-29
+
+### Improved
+
+- Settings pages now share the account layout, with dated updates that load in batches.
+
 ## 2026-09-28
 
+### Added
+
+- Clips can capture screenshots, annotate them, redact sensitive details, and share them.
+
 ### Improved
 
+- The app canvas now meets the right chat sidebar without a dark seam or rounded corner.
+- Settings now opens in the new layout, with Account, Connections, Agent, Organization, and app sections.
+- The chat sidebar matches the app navigation color, with tighter composer spacing.
+- The recording viewer keeps Agent, comments, and transcripts together, and the app sidebar now moves the full page.
 - Viewers can share recordings with agents from shared recording menus
 
 ### Fixed
 
+- Clip share previews show a branded image while the recording thumbnail is unavailable.
+- Meeting and feature-flag polling resumes after your session is accepted again
+- Older recording links preserve the selected viewer tab when panel and Agent sidebar state are both present
+- Opening Agent from a recording keeps the latest selected text attached to your prompt.
+- Stop repeated Clips requests after session expiry
 - Agent links stay valid when clip details change
 
 ### Security

package/corpus/templates/content/CHANGELOG.md

@@ -3,8 +3,24 @@
 All notable user-facing changes to Agent-Native Content are documented here. Open it any
 time from the command menu (Cmd+K → "What's new").
 
+## 2026-09-29
+
+### Improved
+
+- Related pages can be loaded past the first 25 results
+
+## 2026-09-28
+
+### Added
+
+- Link rows across collections with relation properties
+
 ## 2026-09-26
 
+### Improved
+
+- Command search now shows matching titles instantly from documents already loaded in the sidebar, filling in richer results as the server responds.
+
 ### Fixed
 
 - An empty Recent list now loads without an error after first run.

package/corpus/templates/content/actions/_database-property-setup.ts

@@ -23,6 +23,7 @@ import {
   setupGuardSchema,
 } from "./_database-setup-mutation.js";
 import { nanoid } from "./_property-utils.js";
+import { assertRelationTargetDatabase } from "./_relation-values.js";
 
 export const ordinaryPropertyTypes = [
   "text",
@@ -40,6 +41,12 @@ export const ordinaryPropertyTypes = [
   "phone",
 ] as const;
 
+/** Types an agent can create through property setup. */
+export const setupPropertyTypes = [
+  ...ordinaryPropertyTypes,
+  "relation",
+] as const;
+
 const optionPropertyTypes = ["select", "multi_select", "status"] as const;
 const nonOptionPropertyTypes = [
   "number",
@@ -97,6 +104,17 @@ const createDefinitionSchema = z.discriminatedUnion("type", [
   propertyDefinitionBase
     .extend({ type: z.enum(nonOptionPropertyTypes) })
     .strict(),
+  propertyDefinitionBase
+    .extend({
+      type: z.literal("relation"),
+      relatedDatabaseId: z
+        .string()
+        .min(1)
+        .describe(
+          "Exact ID of the collection this relation links to, in the same Content space (may be this collection)",
+        ),
+    })
+    .strict(),
 ]);
 
 const optionEditSchema = z.discriminatedUnion("operation", [
@@ -449,8 +467,21 @@ export async function runConfigureDocumentProperty(
       if (input.operation === "create") {
         const propertyId = nanoid();
         const definition = input.definition;
-        const options =
-          "options" in definition ? { options: definition.options ?? [] } : {};
+        const options: DocumentPropertyOptions =
+          definition.type === "relation"
+            ? {
+                relation: {
+                  databaseId: (
+                    await assertRelationTargetDatabase(tx, {
+                      sourceDatabase: context.database,
+                      targetDatabaseId: definition.relatedDatabaseId,
+                    })
+                  ).id,
+                },
+              }
+            : "options" in definition
+              ? { options: definition.options ?? [] }
+              : {};
         if ("options" in definition) validateOptions(definition.options ?? []);
         const [maxPosition] = await tx
           .select({ max: sql<unknown>`COALESCE(MAX(position), -1)` })

package/corpus/templates/content/actions/_database-setup-discovery.ts

@@ -5,7 +5,7 @@ import type {
   ContentDatabaseMutationContract,
   ContentDatabaseSetupContract,
 } from "../shared/api.js";
-import { ordinaryPropertyTypes } from "./_database-property-setup.js";
+import { setupPropertyTypes } from "./_database-property-setup.js";
 import { parseDatabaseViewConfig } from "./_property-utils.js";
 
 export async function getDatabaseSetupContract(
@@ -30,14 +30,14 @@ export async function getDatabaseSetupContract(
       viewId: view.id,
       url: `${databaseUrl}?viewId=${encodeURIComponent(view.id)}`,
     })),
-    supportedPropertyTypes: [...ordinaryPropertyTypes],
+    supportedPropertyTypes: [...setupPropertyTypes],
     canEditSchema: canEdit,
     canEditViews: canEdit,
     canManageLifecycle:
       (role === "admin" || role === "owner") && !database.ownerDocumentId,
     sourceComposition: "unsupported",
     properties: mutationContract.properties.map((property) => {
-      const ordinary = ordinaryPropertyTypes.some(
+      const ordinary = setupPropertyTypes.some(
         (type) => type === property.type,
       );
       const reason = !canEdit
@@ -45,7 +45,7 @@ export async function getDatabaseSetupContract(
         : property.sourceManaged
           ? "Source-managed definition"
           : !ordinary
-            ? "Blocks, computed and relationship definitions use their own actions"
+            ? "Blocks and computed definitions use their own actions"
             : null;
       return { propertyId: property.id, editable: reason === null, reason };
     }),

package/corpus/templates/content/actions/_property-utils.ts

@@ -58,6 +58,7 @@ import {
   propertyDefinitionsPositionScope,
   withPositionLock,
 } from "./_position-utils.js";
+import { withRelationTargets } from "./_relation-values.js";
 
 type DocumentRow = InferSelectModel<typeof schema.documents>;
 type ContentDatabaseRow = InferSelectModel<typeof schema.contentDatabases>;
@@ -810,7 +811,9 @@ export async function listPropertiesForDatabase(
     }
   }
 
-  return nextProperties;
+  if (!includeContainerDerivedValues) return nextProperties;
+  const [withTargets] = await withRelationTargets(db, [nextProperties]);
+  return withTargets;
 }
 
 function serializePropertyDefinition(
@@ -1020,6 +1023,11 @@ export async function listPropertiesForDatabaseDocuments(
     result.set(document.id, nextProperties);
   }
 
+  const documentIdsInOrder = [...result.keys()];
+  const withTargets = await withRelationTargets(db, [...result.values()]);
+  documentIdsInOrder.forEach((documentId, index) => {
+    result.set(documentId, withTargets[index]!);
+  });
   return result;
 }
 

package/corpus/templates/content/actions/_relation-values.ts

@@ -0,0 +1,291 @@
+import { ActionContractError } from "@agent-native/core/action";
+import { accessFilter, resolveAccess } from "@agent-native/core/sharing";
+import { and, eq, exists, inArray, isNull, or } from "drizzle-orm";
+
+import { schema } from "../server/db/index.js";
+import type {
+  DocumentProperty,
+  DocumentPropertyRelationTarget,
+} from "../shared/api.js";
+import {
+  MAX_RELATION_TARGETS,
+  normalizeRelationIds,
+  parsePropertyOptions,
+} from "../shared/properties.js";
+import { chunks } from "./_batch-utils.js";
+
+// Relation values are stored as a JSON array of row document IDs. Every read
+// and write of them goes through this module so a canonical relationship edge
+// store (docs/product/capabilities/content.relationship.edge.md) can replace
+// the array later without touching callers.
+
+type Db = any;
+type ContentDatabaseRow = typeof schema.contentDatabases.$inferSelect;
+
+function relationError(
+  errorCode: string,
+  message: string,
+  details?: Record<string, unknown>,
+): never {
+  throw new ActionContractError(message, {
+    errorCode,
+    statusCode: 400,
+    details,
+  });
+}
+
+async function liveDatabase(
+  db: Db,
+  databaseId: string,
+): Promise<ContentDatabaseRow | null> {
+  const [database] = await db
+    .select()
+    .from(schema.contentDatabases)
+    .where(
+      and(
+        eq(schema.contentDatabases.id, databaseId),
+        isNull(schema.contentDatabases.deletedAt),
+      ),
+    )
+    .limit(1);
+  return database ?? null;
+}
+
+async function canReadDatabase(database: ContentDatabaseRow) {
+  return !!(await resolveAccess("document", database.documentId));
+}
+
+/**
+ * Check that `targetDatabaseId` may be the target of a relation property on
+ * `sourceDatabase`: it must be a live, ordinary database the caller can read,
+ * in the same space. Linking a database to itself is allowed.
+ */
+export async function assertRelationTargetDatabase(
+  db: Db,
+  {
+    sourceDatabase,
+    targetDatabaseId,
+  }: {
+    sourceDatabase: Pick<ContentDatabaseRow, "id" | "spaceId" | "orgId">;
+    targetDatabaseId: string | null | undefined;
+  },
+): Promise<ContentDatabaseRow> {
+  if (!targetDatabaseId) {
+    relationError("RELATION_TARGET_MISSING", "Choose a related database first");
+  }
+  const target = await liveDatabase(db, targetDatabaseId);
+  if (!target || target.systemRole || !(await canReadDatabase(target))) {
+    relationError(
+      "INVALID_RELATION_TARGET_DATABASE",
+      "The related database was not found",
+    );
+  }
+  if (
+    (target.spaceId ?? null) !== (sourceDatabase.spaceId ?? null) ||
+    (target.orgId ?? null) !== (sourceDatabase.orgId ?? null)
+  ) {
+    relationError(
+      "RELATION_TARGET_OTHER_SPACE",
+      "A relation can only link to a database in the same space",
+    );
+  }
+  return target;
+}
+
+/**
+ * Resolve linked row IDs to titles the current viewer may see. A row is
+ * visible when the viewer can read the row itself, or can read the target
+ * database and the row is a live member of it. Unknown, trashed and
+ * restricted rows are simply absent from the result.
+ */
+export async function resolveRelationTargets(
+  db: Db,
+  {
+    targetDatabaseId,
+    documentIds,
+  }: { targetDatabaseId: string; documentIds: string[] },
+): Promise<Map<string, DocumentPropertyRelationTarget>> {
+  const result = new Map<string, DocumentPropertyRelationTarget>();
+  const ids = normalizeRelationIds(documentIds);
+  if (ids.length === 0) return result;
+  const target = await liveDatabase(db, targetDatabaseId);
+  if (!target || target.systemRole) return result;
+  const targetReadable = await canReadDatabase(target);
+  const membership = exists(
+    db
+      .select({ id: schema.contentDatabaseItems.id })
+      .from(schema.contentDatabaseItems)
+      .where(
+        and(
+          eq(schema.contentDatabaseItems.databaseId, target.id),
+          eq(schema.contentDatabaseItems.documentId, schema.documents.id),
+        ),
+      ),
+  );
+  const visible = accessFilter(schema.documents, schema.documentShares);
+
+  for (const chunk of chunks(ids, 200)) {
+    const rows = await db
+      .select({
+        id: schema.documents.id,
+        title: schema.documents.title,
+        icon: schema.documents.icon,
+      })
+      .from(schema.documents)
+      .where(
+        and(
+          inArray(schema.documents.id, chunk),
+          isNull(schema.documents.trashedAt),
+          targetReadable ? or(visible, membership) : visible,
+        ),
+      );
+    for (const row of rows) {
+      result.set(row.id, {
+        documentId: row.id,
+        title: row.title || "Untitled",
+        icon: row.icon ?? null,
+        databaseId: targetReadable ? target.id : null,
+        databaseDocumentId: targetReadable ? target.documentId : null,
+      });
+    }
+  }
+  return result;
+}
+
+/** The relation target database configured on a property definition. */
+export function relationTargetDatabaseId(definition: {
+  optionsJson?: string | null;
+}): string | null {
+  return (
+    parsePropertyOptions(definition.optionsJson).relation?.databaseId ?? null
+  );
+}
+
+/**
+ * Validate and normalize a relation value before it is stored. IDs that were
+ * already stored are kept without re-checking, so an editor who cannot see
+ * some links does not silently drop them. Newly added IDs must be live rows of
+ * the target database, which the caller must be able to read.
+ */
+export async function validateRelationWrite(
+  db: Db,
+  {
+    definition,
+    nextValue,
+    previousValue,
+  }: {
+    definition: { optionsJson?: string | null };
+    nextValue: unknown;
+    previousValue: unknown;
+  },
+): Promise<string[] | null> {
+  const targetDatabaseId = relationTargetDatabaseId(definition);
+  if (!targetDatabaseId) {
+    relationError("RELATION_TARGET_MISSING", "Choose a related database first");
+  }
+  const ids = normalizeRelationIds(nextValue);
+  if (ids.length === 0) return null;
+  if (ids.length > MAX_RELATION_TARGETS) {
+    relationError(
+      "RELATION_LIMIT_EXCEEDED",
+      `A relation can link to at most ${MAX_RELATION_TARGETS} pages`,
+    );
+  }
+  const previous = new Set(normalizeRelationIds(previousValue));
+  const added = ids.filter((id) => !previous.has(id));
+  if (added.length === 0) return ids;
+
+  const target = await liveDatabase(db, targetDatabaseId);
+  if (
+    !target ||
+    target.systemRole ||
+    !(await resolveAccess("document", target.documentId))
+  ) {
+    relationError(
+      "INVALID_RELATION_TARGET",
+      "The related database is not available",
+      { invalidIds: added },
+    );
+  }
+  const found = new Set<string>();
+  for (const chunk of chunks(added, 200)) {
+    const rows = await db
+      .select({ id: schema.documents.id })
+      .from(schema.documents)
+      .innerJoin(
+        schema.contentDatabaseItems,
+        eq(schema.contentDatabaseItems.documentId, schema.documents.id),
+      )
+      .where(
+        and(
+          inArray(schema.documents.id, chunk),
+          eq(schema.contentDatabaseItems.databaseId, target.id),
+          isNull(schema.documents.trashedAt),
+        ),
+      );
+    for (const row of rows) found.add(row.id);
+  }
+  const invalidIds = added.filter((id) => !found.has(id));
+  if (invalidIds.length > 0) {
+    relationError(
+      "INVALID_RELATION_TARGET",
+      "Some linked pages are not rows of the related database",
+      { invalidIds },
+    );
+  }
+  return ids;
+}
+
+/**
+ * Attach `relationTargets` to every relation property in `propertyLists`
+ * (one list per row). Linked rows are resolved with one lookup per target
+ * database across all rows, so a table view does not query per cell.
+ */
+export async function withRelationTargets(
+  db: Db,
+  propertyLists: DocumentProperty[][],
+): Promise<DocumentProperty[][]> {
+  const idsByTarget = new Map<string, Set<string>>();
+  for (const properties of propertyLists) {
+    for (const property of properties) {
+      if (property.definition.type !== "relation") continue;
+      const targetId = property.definition.options.relation?.databaseId;
+      if (!targetId) continue;
+      const ids = normalizeRelationIds(property.value);
+      if (ids.length === 0) continue;
+      let set = idsByTarget.get(targetId);
+      if (!set) idsByTarget.set(targetId, (set = new Set()));
+      for (const id of ids) set.add(id);
+    }
+  }
+  if (idsByTarget.size === 0) return propertyLists;
+
+  const resolvedByTarget = new Map<
+    string,
+    Map<string, DocumentPropertyRelationTarget>
+  >();
+  for (const [targetDatabaseId, ids] of idsByTarget) {
+    resolvedByTarget.set(
+      targetDatabaseId,
+      await resolveRelationTargets(db, {
+        targetDatabaseId,
+        documentIds: [...ids],
+      }),
+    );
+  }
+
+  return propertyLists.map((properties) =>
+    properties.map((property) => {
+      if (property.definition.type !== "relation") return property;
+      const targetId = property.definition.options.relation?.databaseId;
+      const resolved = targetId ? resolvedByTarget.get(targetId) : undefined;
+      return {
+        ...property,
+        relationTargets: normalizeRelationIds(property.value).flatMap((id) => {
+          const target = resolved?.get(id);
+          return target ? [target] : [];
+        }),
+      };
+    }),
+  );
+}

package/corpus/templates/content/actions/configure-document-property.ts

@@ -1,3 +1,4 @@
+import { ActionContractError } from "@agent-native/core";
 import { defineAction } from "@agent-native/core/action";
 import { writeAppState } from "@agent-native/core/application-state";
 import { iconValueSchema, serializeIconValue } from "@agent-native/core/icons";
@@ -40,6 +41,7 @@ import {
   optionsForNewProperty,
   resolvePropertyDatabaseForDocument,
 } from "./_property-utils.js";
+import { assertRelationTargetDatabase } from "./_relation-values.js";
 
 const legacyConfigureDocumentPropertySchema = z
   .object({
@@ -157,7 +159,7 @@ export default defineAction({
     const name = args.name.trim();
     const type = args.type as DocumentPropertyType;
     const propertyId = args.id ?? nanoid();
-    const optionsJson = optionsForNewProperty(type, args.options as any);
+    let optionsJson = optionsForNewProperty(type, args.options as any);
     const database = await resolvePropertyDatabaseForDocument(
       document,
       args.databaseId,
@@ -168,6 +170,42 @@ export default defineAction({
         "Properties belong to databases. Create or open a database before adding properties.",
       );
     }
+    let requestedRelationTarget = args.options?.relation?.databaseId;
+    if (type === "relation" && !requestedRelationTarget && args.id) {
+      // Metadata-only updates (rename, visibility) keep the existing target.
+      const [current] = await db
+        .select({
+          type: schema.documentPropertyDefinitions.type,
+          optionsJson: schema.documentPropertyDefinitions.optionsJson,
+        })
+        .from(schema.documentPropertyDefinitions)
+        .where(
+          and(
+            eq(schema.documentPropertyDefinitions.id, args.id),
+            eq(
+              schema.documentPropertyDefinitions.ownerEmail,
+              document.ownerEmail,
+            ),
+            eq(schema.documentPropertyDefinitions.databaseId, database.id),
+          ),
+        );
+      if (current?.type === "relation") {
+        requestedRelationTarget = parsePropertyOptions(current.optionsJson)
+          .relation?.databaseId;
+      }
+    }
+    const relationTarget =
+      type === "relation"
+        ? await assertRelationTargetDatabase(db, {
+            sourceDatabase: database,
+            targetDatabaseId: requestedRelationTarget,
+          })
+        : null;
+    if (relationTarget) {
+      optionsJson = serializePropertyOptions({
+        relation: { databaseId: relationTarget.id },
+      });
+    }
     if (args.naturalKey === true && type !== "text") {
       throw new Error(
         "A database natural key must be an ordinary text property.",
@@ -240,6 +278,20 @@ export default defineAction({
         const lockedOptions = parsePropertyOptions(
           lockedDefinition.optionsJson,
         );
+        const lockedRelationTarget =
+          lockedDefinition.type === "relation"
+            ? (lockedOptions.relation?.databaseId ?? null)
+            : null;
+        if (
+          relationTarget &&
+          lockedRelationTarget &&
+          lockedRelationTarget !== relationTarget.id
+        ) {
+          throw new ActionContractError(
+            "Create a new relation property to link a different database.",
+            { errorCode: "RELATION_TARGET_IMMUTABLE", statusCode: 400 },
+          );
+        }
         const lockedIsPrimaryBlocks =
           isBlocksPropertyType(lockedDefinition.type as DocumentPropertyType) &&
           isPrimaryBlocksField(lockedOptions);