@agent-native/core 0.224.0-nightly-20261104194955 → 0.224.0

package/dist/framework-package-versions.json

@@ -1,17 +1,17 @@
 {
-  "@agent-native/agentkit": "0.224.0-nightly-20261104194955",
+  "@agent-native/agentkit": "0.224.0",
   "@agent-native/code-agents-ui": "0.1.75",
-  "@agent-native/core": "0.224.0-nightly-20261104194955",
-  "@agent-native/core-corpus": "0.224.0-nightly-20261104194955",
-  "@agent-native/creative-context": "0.8.63",
-  "@agent-native/dispatch": "0.42.0-nightly-20261104194955",
+  "@agent-native/core": "0.224.0",
+  "@agent-native/core-corpus": "0.224.0",
+  "@agent-native/creative-context": "0.8.65",
+  "@agent-native/dispatch": "0.42.0",
   "@agent-native/embedding": "0.2.0",
   "@agent-native/migrate": "0.0.7",
-  "@agent-native/otel": "0.1.30",
-  "@agent-native/pinpoint": "0.1.106",
-  "@agent-native/recap-cli": "0.5.94",
-  "@agent-native/scheduling": "0.2.51-nightly-20261104194955",
+  "@agent-native/otel": "0.1.32",
+  "@agent-native/pinpoint": "0.1.108",
+  "@agent-native/recap-cli": "0.5.96",
+  "@agent-native/scheduling": "0.2.52",
   "@agent-native/shared-app-config": "0.1.2",
-  "@agent-native/skills": "0.4.0-nightly-20261104194955",
-  "@agent-native/toolkit": "0.224.0-nightly-20261104194955"
+  "@agent-native/skills": "0.4.0",
+  "@agent-native/toolkit": "0.224.0"
 }

package/dist/mcp/analytics.js

@@ -1,7 +1,7 @@
 import { getAppConfig } from "../app-config/store.js";
 import { safeValue } from "../tracking/redaction.js";
 import { listTrackingProviders, track } from "../tracking/registry.js";
-import { DATABASE_FAILURE_MESSAGE, isDatabaseQueryFailure, } from "./embed-redaction.js";
+import { databaseFailureCode, databaseFailureMessage, isDatabaseQueryFailure, } from "./embed-redaction.js";
 const CLIENT_INFO_META_KEY = "io.modelcontextprotocol/clientInfo";
 const PROTOCOL_VERSION_META_KEY = "io.modelcontextprotocol/protocolVersion";
 export const MCP_ANALYTICS_EVENTS = {
@@ -206,8 +206,8 @@ export function trackMcpOAuthLoginWallShown(ctx, args) {
 export function describeMcpError(err) {
     if (isDatabaseQueryFailure(err)) {
         return {
-            errorType: "DrizzleQueryError",
-            errorMessage: DATABASE_FAILURE_MESSAGE,
+            errorType: databaseFailureCode(err) ?? "DrizzleQueryError",
+            errorMessage: databaseFailureMessage(err),
         };
     }
     if (err && typeof err === "object") {

package/dist/mcp/direct-action-call.js

@@ -8,7 +8,7 @@ import { getRequestContext, getRequestOrgId, getRequestUserEmail, } from "../ser
 import { describeMcpError } from "./analytics.js";
 import { actionApprovalError, actionApprovalReviewResult, buildLinkArtifacts, conciseMcpAppToolText, conciseToolResultText, getMcpDirectoryWidgetResourceUri, hasVerifiedMcpUserIdentity, MCP_ACTION_APPROVAL_INPUT_KEY, mcpAppEmbedOpenLinkMeta, mcpAppOnlyEmbedStartMeta, mcpAppStructuredContent, mcpAppWidgetsEnabledForIdentity, mcpDirectoryWidgetCapabilityForTool, mcpDirectoryWidgetSourceMeta, mcpResponseStructuredContent, mcpResultHasContent, metadataObject, modelVisibleToolResponse, openAiToolResultMeta, PRESERVE_MCP_OBJECT_RESULT, resolveMcpAppResourceSafely, returnsQueryPayload, textPagingInputs, upstreamStatusText, withheldWriteResponse, withoutMcpAppEmbedTicket, withServerMintedMcpAppEmbedStart, } from "./build-server.js";
 import { mcpCallAttribution } from "./call-attribution.js";
-import { DATABASE_FAILURE_MESSAGE, describeThrownForLog, HIDDEN_EMBED_URL, isDatabaseQueryFailure, isEmbedStartUrl, redactEmbedText, } from "./embed-redaction.js";
+import { databaseFailureMessage, describeThrownForLog, HIDDEN_EMBED_URL, isDatabaseQueryFailure, isEmbedStartUrl, redactEmbedText, } from "./embed-redaction.js";
 import { embedCredentialSources, mcpActionErrorCode, redactEmbedCredentials, returnedResult, runMcpActionCallUnredacted, toJsonData, UnreadableResultError, } from "./execute-action-call.js";
 import { mcpResponseOutputCheck } from "./output-contract.js";
 export function createDirectActionCall(scope) {
@@ -45,7 +45,7 @@ export function createDirectActionCall(scope) {
             : callableActions[name]?.mcpOutputContract;
         const errorText = (err) => {
             if (isDatabaseQueryFailure(err))
-                return DATABASE_FAILURE_MESSAGE;
+                return databaseFailureMessage(err);
             const projectedError = directoryCatalog && config.directoryProfile?.projectResult
                 ? config.directoryProfile.projectResult(name, err.message)
                 : err.message;

package/dist/mcp/embed-redaction.d.ts

@@ -13,6 +13,14 @@ export declare const HIDDEN_EMBED_URL = "[hidden embed URL]";
 export declare const DATABASE_FAILURE_MESSAGE = "The database rejected the request.";
 /** Drizzle puts a failed query's SQL and bound parameters in its message. */
 export declare function isDatabaseQueryFailure(error: unknown): boolean;
+export declare function databaseFailureCode(error: unknown): string | undefined;
+/**
+ * The client-safe text for a failure `isDatabaseQueryFailure` recognizes. It
+ * names the code without saying what it means, because one code has several
+ * causes: 57014 is any cancellation, and CONNECT_TIMEOUT is `withDbTimeout` or
+ * the driver's wait for a connection.
+ */
+export declare function databaseFailureMessage(error: unknown): string;
 /** Replaces a value already being serialized higher up the same result. */
 export declare const CIRCULAR_RESULT = "[circular result]";
 /** Keys removed from every result object, whatever their value. */

package/dist/mcp/embed-redaction.js

@@ -16,6 +16,27 @@ export const DATABASE_FAILURE_MESSAGE = "The database rejected the request.";
 export function isDatabaseQueryFailure(error) {
     return error instanceof Error && error.message.startsWith("Failed query:");
 }
+// A driver's error code names the failure without any of the query's values.
+// Anything else in that field stays hidden along with the message.
+const DATABASE_ERROR_CODE = /^[A-Z0-9_]{1,40}$/;
+export function databaseFailureCode(error) {
+    const code = error.cause?.code;
+    return typeof code === "string" && DATABASE_ERROR_CODE.test(code)
+        ? code
+        : undefined;
+}
+/**
+ * The client-safe text for a failure `isDatabaseQueryFailure` recognizes. It
+ * names the code without saying what it means, because one code has several
+ * causes: 57014 is any cancellation, and CONNECT_TIMEOUT is `withDbTimeout` or
+ * the driver's wait for a connection.
+ */
+export function databaseFailureMessage(error) {
+    const code = databaseFailureCode(error);
+    return code
+        ? `The database request failed (${code}).`
+        : DATABASE_FAILURE_MESSAGE;
+}
 /** Replaces a value already being serialized higher up the same result. */
 export const CIRCULAR_RESULT = "[circular result]";
 /** Keys removed from every result object, whatever their value. */

package/dist/mcp/execute-action-call.js

@@ -6,7 +6,7 @@ import { MCP_ACTION_RESULT_MARKER, isMcpActionResult, mcpActionResultText, } fro
 import { assertServicePrincipalMayCall, assertServicePrincipalMayRun, recordServicePrincipalDenial, ServicePrincipalRefusedError, } from "../org/service-principal-guard.js";
 import { getRequestOrgId, getRequestUserEmail, } from "../server/request-context.js";
 import { answerMcpApprovalPrompt, consumeMcpApprovalGrant, consumeReviewedMcpApprovalGrant, createMcpApprovalGrant, findRecentMcpApprovalRun, storedApprovalArguments, recordMcpApprovalRun, } from "./approval-store.js";
-import { CIRCULAR_RESULT, EMBED_RESULT_SENSITIVE_KEYS, DATABASE_FAILURE_MESSAGE, HIDDEN_EMBED_URL, IMAGE_BYTES, isDatabaseQueryFailure, isEmbedCredentialKey, readString, redactEmbedText, } from "./embed-redaction.js";
+import { CIRCULAR_RESULT, EMBED_RESULT_SENSITIVE_KEYS, databaseFailureMessage, HIDDEN_EMBED_URL, IMAGE_BYTES, isDatabaseQueryFailure, isEmbedCredentialKey, readString, redactEmbedText, } from "./embed-redaction.js";
 import { hasMcpOAuthScope } from "./oauth-token.js";
 /**
  * The authorization, approval, execution and result-sanitizing steps of an
@@ -504,7 +504,7 @@ function failedOutcome(stage, error) {
     let errorCode;
     try {
         const raw = isDatabaseQueryFailure(error)
-            ? DATABASE_FAILURE_MESSAGE
+            ? databaseFailureMessage(error)
             : error instanceof Error
                 ? error.message
                 : error;

package/dist/server/action-routes.js

@@ -1447,9 +1447,11 @@ function webMcpManifestEtag(manifest) {
 function ifNoneMatchIncludes(header, etag) {
     if (!header)
         return false;
+    // A compressed response reaches the browser with "-df" on its tag (seen on
+    // our Netlify hosts), and the browser sends that tag back as it received it.
     return header
         .split(",")
-        .some((tag) => tag.trim().replace(/^W\//, "") === etag);
+        .some((tag) => tag.trim().replace(/^W\//, "").replace(/-df"$/, '"') === etag);
 }
 export function mountWebMcpActionRoutes(nitroApp, actions, options) {
     const eligible = Object.fromEntries(Object.entries(actions).filter(([name, entry]) => /^[A-Za-z0-9_.-]{1,128}$/.test(name) &&

package/dist/sharing/access.d.ts

@@ -56,6 +56,20 @@ export declare function resolveAccess(resourceType: string, resourceId: string,
 export declare function resolveAccess(resourceType: string, resourceId: string, rawCtx: AccessContext | undefined, options: {
     skipResourceBody: true;
 }): Promise<ResolvedAccessProjected | null>;
+/**
+ * {@link resolveAccess} for a list of resources of one type: the ids the
+ * viewer can open, mapped to their access. Each decision is the same one
+ * `resolveAccess` makes. What changes is the reads: one query loads the rows,
+ * one loads their shares, and org membership, group membership, and a
+ * registration's `canManageAccessKey` answers are looked up once, not once per
+ * resource. Ids that do not exist or that the viewer cannot open are left out.
+ */
+export declare function resolveAccessMany(resourceType: string, resourceIds: string[], rawCtx?: AccessContext, options?: {
+    skipResourceBody?: false;
+}): Promise<Map<string, ResolvedAccess>>;
+export declare function resolveAccessMany(resourceType: string, resourceIds: string[], rawCtx: AccessContext | undefined, options: {
+    skipResourceBody: true;
+}): Promise<Map<string, ResolvedAccessProjected>>;
 /**
  * Host hook: for resources that live inside another product (a design bound
  * to a Builder project), the host is the authority on who may open them. The

package/dist/sharing/access.js

@@ -1,4 +1,4 @@
-import { and, eq, isNull, or, sql } from "drizzle-orm";
+import { and, eq, inArray, isNull, or, sql } from "drizzle-orm";
 import { drizzle as drizzleProxy } from "drizzle-orm/pg-proxy";
 import { getScopedDbExec, withDbExec } from "../db/client.js";
 import { evaluateFeatureFlagStrict } from "../feature-flags/store.js";
@@ -389,7 +389,7 @@ export function isResourceAvailable(reg, resource) {
 function hasDynamicPublicAccessRoleResolver(reg) {
     return typeof reg.publicAccessRole === "function";
 }
-async function loadResourceForAccess(reg, resourceId, options = {}) {
+async function loadRowsForAccess(reg, where, options = {}) {
     const db = reg.getDb();
     // Hooks that receive the row may read any column, so they get all of it.
     const useProjection = options.skipResourceBody === true &&
@@ -402,10 +402,7 @@ async function loadResourceForAccess(reg, resourceId, options = {}) {
             const query = !projectedColumns && omittedColumnNames.size === 0
                 ? db.select()
                 : db.select(selectExistingColumns(projectedColumns ?? reg.resourceTable, omittedColumnNames));
-            const [resource] = await query
-                .from(reg.resourceTable)
-                .where(eq(reg.resourceTable.id, resourceId));
-            return resource ?? null;
+            return await query.from(reg.resourceTable).where(where);
         }
         catch (err) {
             const missing = missingColumnName(err);
@@ -415,7 +412,7 @@ async function loadResourceForAccess(reg, resourceId, options = {}) {
             console.warn(`[sharing] ${reg.type} access lookup omitted missing column ${missing}`);
         }
     }
-    throw new Error(`Could not load ${reg.type} ${resourceId}: too many missing resource columns`);
+    throw new Error(`Could not load ${reg.type} rows: too many missing resource columns`);
 }
 export async function resolveAccess(resourceType, resourceId, rawCtx = currentAccess(), options = {}) {
     const { access } = await inAccessTransaction(rawCtx, () => loadAndResolveAccess(resourceType, resourceId, rawCtx, options));
@@ -424,7 +421,7 @@ export async function resolveAccess(resourceType, resourceId, rawCtx = currentAc
 function inAccessTransaction(ctx, run) {
     return ctx.transaction ? withDbExec(ctx.transaction, run) : run();
 }
-async function loadAndResolveAccess(resourceType, resourceId, rawCtx, options) {
+function scopeAccess(resourceType, rawCtx) {
     const registered = requireShareableResource(resourceType);
     const transaction = rawCtx.transaction ?? getScopedDbExec();
     const transactionDb = transaction
@@ -437,8 +434,11 @@ async function loadAndResolveAccess(resourceType, resourceId, rawCtx, options) {
     const reg = transactionDb
         ? { ...registered, getDb: () => transactionDb }
         : registered;
-    const ctx = resolveRegisteredAccessContext(reg, transactionCtx);
-    const resource = await loadResourceForAccess(reg, resourceId, options);
+    return { reg, ctx: resolveRegisteredAccessContext(reg, transactionCtx) };
+}
+async function loadAndResolveAccess(resourceType, resourceId, rawCtx, options) {
+    const { reg, ctx } = scopeAccess(resourceType, rawCtx);
+    const [resource] = await loadRowsForAccess(reg, eq(reg.resourceTable.id, resourceId), options);
     if (!resource)
         return { access: null, resource: null, reg };
     return {
@@ -447,6 +447,76 @@ async function loadAndResolveAccess(resourceType, resourceId, rawCtx, options) {
         reg,
     };
 }
+const RESOLVE_MANY_ROW_CHUNK = 500;
+const RESOLVE_MANY_CONCURRENCY = 8;
+export async function resolveAccessMany(resourceType, resourceIds, rawCtx = currentAccess(), options = {}) {
+    return inAccessTransaction(rawCtx, async () => {
+        const { reg, ctx } = scopeAccess(resourceType, rawCtx);
+        const ids = [...new Set(resourceIds)];
+        const resources = [];
+        for (let start = 0; start < ids.length; start += RESOLVE_MANY_ROW_CHUNK) {
+            resources.push(...(await loadRowsForAccess(reg, inArray(reg.resourceTable.id, ids.slice(start, start + RESOLVE_MANY_ROW_CHUNK)), options)));
+        }
+        const batch = {
+            memberships: new Map(),
+            groupMemberships: new Map(),
+            managers: new Map(),
+            shares: await loadSharesForAccess(reg, resources.map((resource) => resource.id), ctx),
+        };
+        const access = new Map();
+        for (let start = 0; start < resources.length; start += RESOLVE_MANY_CONCURRENCY) {
+            await Promise.all(resources
+                .slice(start, start + RESOLVE_MANY_CONCURRENCY)
+                .map(async (resource) => {
+                const resolved = await accessToResource(reg, resource.id, resource, ctx, batch);
+                if (resolved)
+                    access.set(resource.id, resolved);
+            }));
+        }
+        return access;
+    });
+}
+/**
+ * The grants {@link highestShareRole} reads, for many resources at once: the
+ * viewer's own user grants, their org's grants, and every group grant.
+ */
+async function loadSharesForAccess(reg, resourceIds, ctx) {
+    const byResource = new Map();
+    const normalizedUserEmail = normalizeEmailForAccess(ctx.userEmail);
+    const principalClauses = principalShareClauses(reg, ctx);
+    if (reg.supportsGroupShares && normalizedUserEmail) {
+        principalClauses.push(eq(reg.sharesTable.principalType, "group"));
+    }
+    if (resourceIds.length === 0 || principalClauses.length === 0) {
+        return byResource;
+    }
+    const db = reg.getDb();
+    for (let start = 0; start < resourceIds.length; start += RESOLVE_MANY_ROW_CHUNK) {
+        const rows = (await db
+            .select({
+            resourceId: reg.sharesTable.resourceId,
+            principalType: reg.sharesTable.principalType,
+            principalId: reg.sharesTable.principalId,
+            role: reg.sharesTable.role,
+        })
+            .from(reg.sharesTable)
+            .where(and(inArray(reg.sharesTable.resourceId, resourceIds.slice(start, start + RESOLVE_MANY_ROW_CHUNK)), or(...principalClauses))));
+        for (const row of rows) {
+            const list = byResource.get(row.resourceId) ?? [];
+            list.push(row);
+            byResource.set(row.resourceId, list);
+        }
+    }
+    return byResource;
+}
+function memoized(cache, key, load) {
+    let value = cache.get(key);
+    if (!value) {
+        value = load();
+        cache.set(key, value);
+    }
+    return value;
+}
 const hostAccessResolvers = new Map();
 export function registerHostAccessResolver(resourceType, resolver, options) {
     if (resolver) {
@@ -459,21 +529,27 @@ export function registerHostAccessResolver(resourceType, resolver, options) {
         hostAccessResolvers.delete(resourceType);
     }
 }
-async function ownerOrAdminRole(reg, resource, ctx, normalizedUserEmail) {
+async function ownerOrAdminRole(reg, resource, ctx, normalizedUserEmail, batch) {
     if (normalizedUserEmail &&
         normalizeEmailForAccess(resource.ownerEmail) === normalizedUserEmail &&
         ownerMatchesActiveScope(reg, resource, ctx)) {
         return "owner";
     }
-    if (reg.canManageAccess && (await reg.canManageAccess(resource, ctx))) {
-        return "admin";
+    if (reg.canManageAccess) {
+        const manage = reg.canManageAccess;
+        const key = batch && reg.canManageAccessKey?.(resource, ctx);
+        const manages = batch && key != null
+            ? await memoized(batch.managers, key, async () => Boolean(await manage(resource, ctx)))
+            : await manage(resource, ctx);
+        if (manages)
+            return "admin";
     }
     return undefined;
 }
-async function accessToResource(reg, resourceId, resource, ctx) {
+async function accessToResource(reg, resourceId, resource, ctx, batch) {
     const { userEmail } = ctx;
     const normalizedUserEmail = normalizeEmailForAccess(userEmail);
-    const memberships = new Map();
+    const memberships = batch?.memberships ?? new Map();
     const isOrgMember = (orgId) => {
         let membership = memberships.get(orgId);
         if (!membership) {
@@ -492,12 +568,12 @@ async function accessToResource(reg, resourceId, resource, ctx) {
         : undefined;
     if (hosted === null)
         return null;
-    const managingRole = await ownerOrAdminRole(reg, resource, ctx, normalizedUserEmail);
+    const managingRole = await ownerOrAdminRole(reg, resource, ctx, normalizedUserEmail, batch);
     if (managingRole)
         return { role: managingRole, resource };
     if (hosted !== undefined)
         return { role: hosted, resource };
-    const role = await highestShareRole(reg, resourceId, ctx, resource, isOrgMember);
+    const role = await highestShareRole(reg, resourceId, ctx, resource, isOrgMember, batch);
     const shareRole = role === "admin" && reg.canManageAccess ? "editor" : role;
     if (resource.visibility === "public" && reg.allowPublic !== false) {
         const publicRole = await publicAccessRoleForResource(reg, resource, ctx);
@@ -545,7 +621,18 @@ export async function resolveAccessStatus(resourceType, resourceId, ctx = curren
         return { state: available ? "allowed" : "trashed", role: access.role };
     });
 }
-async function highestShareRole(reg, resourceId, ctx, resource, isOrgMember) {
+function principalShareClauses(reg, ctx) {
+    const normalizedUserEmail = normalizeEmailForAccess(ctx.userEmail);
+    const clauses = [];
+    if (normalizedUserEmail) {
+        clauses.push(and(eq(reg.sharesTable.principalType, "user"), emailColumnMatches(reg.sharesTable.principalId, normalizedUserEmail)));
+    }
+    if (ctx.orgId) {
+        clauses.push(and(eq(reg.sharesTable.principalType, "org"), eq(reg.sharesTable.principalId, ctx.orgId)));
+    }
+    return clauses;
+}
+async function highestShareRole(reg, resourceId, ctx, resource, isOrgMember, batch) {
     const { userEmail, orgId } = ctx;
     const normalizedUserEmail = normalizeEmailForAccess(userEmail);
     if (!normalizedUserEmail && !orgId)
@@ -553,23 +640,20 @@ async function highestShareRole(reg, resourceId, ctx, resource, isOrgMember) {
     if (!explicitSharesAllowedForResource(reg, resource, ctx))
         return null;
     const db = reg.getDb();
-    const principalClauses = [];
-    if (normalizedUserEmail) {
-        principalClauses.push(and(eq(reg.sharesTable.principalType, "user"), emailColumnMatches(reg.sharesTable.principalId, normalizedUserEmail)));
-    }
-    if (orgId) {
-        principalClauses.push(and(eq(reg.sharesTable.principalType, "org"), eq(reg.sharesTable.principalId, orgId)));
-    }
+    const principalClauses = principalShareClauses(reg, ctx);
     if (principalClauses.length === 0)
         return null;
-    const rows = await db
-        .select({
-        role: reg.sharesTable.role,
-        principalType: reg.sharesTable.principalType,
-    })
-        .from(reg.sharesTable)
-        .where(and(eq(reg.sharesTable.resourceId, resourceId), or(...principalClauses)))
-        .limit(10);
+    const prefetched = batch?.shares.get(resourceId) ?? [];
+    const rows = batch
+        ? prefetched.filter((row) => row.principalType !== "group")
+        : await db
+            .select({
+            role: reg.sharesTable.role,
+            principalType: reg.sharesTable.principalType,
+        })
+            .from(reg.sharesTable)
+            .where(and(eq(reg.sharesTable.resourceId, resourceId), or(...principalClauses)))
+            .limit(10);
     let best = null;
     const grantRows = rows;
     for (const row of grantRows) {
@@ -588,18 +672,23 @@ async function highestShareRole(reg, resourceId, ctx, resource, isOrgMember) {
         }
     }
     if (reg.supportsGroupShares && normalizedUserEmail && resource.orgId) {
-        const groupRows = await db
-            .select({
-            principalId: reg.sharesTable.principalId,
-            role: reg.sharesTable.role,
-        })
-            .from(reg.sharesTable)
-            .where(and(eq(reg.sharesTable.resourceId, resourceId), eq(reg.sharesTable.principalType, "group")));
+        const groupRows = batch
+            ? prefetched.filter((row) => row.principalType === "group")
+            : await db
+                .select({
+                principalId: reg.sharesTable.principalId,
+                role: reg.sharesTable.role,
+            })
+                .from(reg.sharesTable)
+                .where(and(eq(reg.sharesTable.resourceId, resourceId), eq(reg.sharesTable.principalType, "group")));
         if (groupRows.length > 0 && (await isOrgMember(resource.orgId))) {
             for (const row of groupRows) {
-                if (await workspaceUserGroupsIncludeUser(resource.orgId, [row.principalId], normalizedUserEmail)) {
+                const includesUser = () => workspaceUserGroupsIncludeUser(resource.orgId, [row.principalId], normalizedUserEmail);
+                const member = batch
+                    ? await memoized(batch.groupMemberships, `${resource.orgId}\u0000${row.principalId}`, includesUser)
+                    : await includesUser();
+                if (member)
                     best = higherShareRole(row.role, best);
-                }
             }
         }
     }

package/dist/sharing/index.d.ts

@@ -1,5 +1,5 @@
 export { ownableColumns, createSharesTable, roleSatisfies, ROLE_RANK, type Visibility, type ShareRole, type PrincipalType, } from "./schema.js";
 export { registerShareableResource, getShareableResource, requireShareableResource, listShareableResources, type ShareableResourceRegistration, type ShareEmailExtras, } from "./registry.js";
-export { accessFilter, resolveAccess, assertAccess, currentAccess, ForbiddenError, isResourceAvailable, resolveAccessStatus, registerHostAccessResolver, type HostAccessResolver, type AccessContext, type ResolvedAccess, type ResourceAccessState, type ResourceAccessStatus, } from "./access.js";
+export { accessFilter, resolveAccess, resolveAccessMany, assertAccess, currentAccess, ForbiddenError, isResourceAvailable, resolveAccessStatus, registerHostAccessResolver, type HostAccessResolver, type AccessContext, type ResolvedAccess, type ResourceAccessState, type ResourceAccessStatus, } from "./access.js";
 export { ACCESS_REQUEST_NOTE_MAX_LENGTH, accessRequestReviewPath, approveAccessRequest, declineAccessRequest, getAccessRequestReview, listResourceAccessRequests, requestResourceAccess, resolveLinkStatus, type AccessGrantedEmail, type AccessRequestReview, type RequestResourceAccessResult, type ResourceAccessRequestList, type ResourceLinkStatus, type ViewerAccessRequest, } from "./access-requests.js";
 export { filterRecipientsByResourceAccess, type FilterRecipientsInput, } from "./recipients.js";

package/dist/sharing/index.js

@@ -1,5 +1,5 @@
 export { ownableColumns, createSharesTable, roleSatisfies, ROLE_RANK, } from "./schema.js";
 export { registerShareableResource, getShareableResource, requireShareableResource, listShareableResources, } from "./registry.js";
-export { accessFilter, resolveAccess, assertAccess, currentAccess, ForbiddenError, isResourceAvailable, resolveAccessStatus, registerHostAccessResolver, } from "./access.js";
+export { accessFilter, resolveAccess, resolveAccessMany, assertAccess, currentAccess, ForbiddenError, isResourceAvailable, resolveAccessStatus, registerHostAccessResolver, } from "./access.js";
 export { ACCESS_REQUEST_NOTE_MAX_LENGTH, accessRequestReviewPath, approveAccessRequest, declineAccessRequest, getAccessRequestReview, listResourceAccessRequests, requestResourceAccess, resolveLinkStatus, } from "./access-requests.js";
 export { filterRecipientsByResourceAccess, } from "./recipients.js";

package/dist/sharing/registry.d.ts

@@ -86,6 +86,17 @@ export interface ShareableResourceRegistration {
         userEmail?: string;
         orgId?: string;
     }) => boolean | Promise<boolean>;
+    /**
+     * Resources that return the same key get the same `canManageAccess` answer
+     * for the same viewer, so `resolveAccessMany` asks once per key. Return
+     * `undefined` for a resource whose answer depends on more than the key.
+     */
+    canManageAccessKey?: (resource: {
+        orgId?: string | null;
+    }, ctx: {
+        userEmail?: string;
+        orgId?: string;
+    }) => string | undefined;
     resolveAccessContext?: (ctx: {
         userEmail?: string;
         orgId?: string;

package/dist/templates/chat/.agents/skills/sharing/SKILL.md

@@ -174,6 +174,10 @@ For delete actions use `"admin"` (or fold in `"owner"` to require the real owner
 
 `authorize` is a different axis, not an alternative: it gates whether the caller may run the operation at all, while `assertAccess` scopes which row they may touch. A write action restricted to some teammates needs both — `authorize: appAccess.requireAny(...)` on the action, `assertAccess` inside `run`.
 
+## Check many resources at once
+
+Never call `resolveAccess` in a loop over a list: each call runs several queries, so a page that checks every row pays that per row. When rows come from somewhere `accessFilter` cannot reach (a manifest, a gateway response), use `resolveAccessMany("deck", ids, ctx, { skipResourceBody: true })`. It returns a `Map` of the ids the viewer can open, makes the same decision as `resolveAccess`, and reads rows, shares, org membership, and group membership once. Give a registration that uses `canManageAccess` a `canManageAccessKey` (for example `resource.orgId`) so the manager check is asked once per key, not once per row.
+
 ## Create actions must set owner
 
 When inserting a new row, fill `ownerEmail` and `orgId` from the request context:

package/dist/templates/default/.agents/skills/sharing/SKILL.md

@@ -174,6 +174,10 @@ For delete actions use `"admin"` (or fold in `"owner"` to require the real owner
 
 `authorize` is a different axis, not an alternative: it gates whether the caller may run the operation at all, while `assertAccess` scopes which row they may touch. A write action restricted to some teammates needs both — `authorize: appAccess.requireAny(...)` on the action, `assertAccess` inside `run`.
 
+## Check many resources at once
+
+Never call `resolveAccess` in a loop over a list: each call runs several queries, so a page that checks every row pays that per row. When rows come from somewhere `accessFilter` cannot reach (a manifest, a gateway response), use `resolveAccessMany("deck", ids, ctx, { skipResourceBody: true })`. It returns a `Map` of the ids the viewer can open, makes the same decision as `resolveAccess`, and reads rows, shares, org membership, and group membership once. Give a registration that uses `canManageAccess` a `canManageAccessKey` (for example `resource.orgId`) so the manager check is asked once per key, not once per row.
+
 ## Create actions must set owner
 
 When inserting a new row, fill `ownerEmail` and `orgId` from the request context:

package/dist/templates/headless/.agents/skills/sharing/SKILL.md

@@ -174,6 +174,10 @@ For delete actions use `"admin"` (or fold in `"owner"` to require the real owner
 
 `authorize` is a different axis, not an alternative: it gates whether the caller may run the operation at all, while `assertAccess` scopes which row they may touch. A write action restricted to some teammates needs both — `authorize: appAccess.requireAny(...)` on the action, `assertAccess` inside `run`.
 
+## Check many resources at once
+
+Never call `resolveAccess` in a loop over a list: each call runs several queries, so a page that checks every row pays that per row. When rows come from somewhere `accessFilter` cannot reach (a manifest, a gateway response), use `resolveAccessMany("deck", ids, ctx, { skipResourceBody: true })`. It returns a `Map` of the ids the viewer can open, makes the same decision as `resolveAccess`, and reads rows, shares, org membership, and group membership once. Give a registration that uses `canManageAccess` a `canManageAccessKey` (for example `resource.orgId`) so the manager check is asked once per key, not once per row.
+
 ## Create actions must set owner
 
 When inserting a new row, fill `ownerEmail` and `orgId` from the request context:

package/dist/templates/workspace-core/.agents/skills/sharing/SKILL.md

@@ -174,6 +174,10 @@ For delete actions use `"admin"` (or fold in `"owner"` to require the real owner
 
 `authorize` is a different axis, not an alternative: it gates whether the caller may run the operation at all, while `assertAccess` scopes which row they may touch. A write action restricted to some teammates needs both — `authorize: appAccess.requireAny(...)` on the action, `assertAccess` inside `run`.
 
+## Check many resources at once
+
+Never call `resolveAccess` in a loop over a list: each call runs several queries, so a page that checks every row pays that per row. When rows come from somewhere `accessFilter` cannot reach (a manifest, a gateway response), use `resolveAccessMany("deck", ids, ctx, { skipResourceBody: true })`. It returns a `Map` of the ids the viewer can open, makes the same decision as `resolveAccess`, and reads rows, shares, org membership, and group membership once. Give a registration that uses `canManageAccess` a `canManageAccessKey` (for example `resource.orgId`) so the manager check is asked once per key, not once per row.
+
 ## Create actions must set owner
 
 When inserting a new row, fill `ownerEmail` and `orgId` from the request context:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.224.0-nightly-20261104194955",
+  "version": "0.224.0",
   "description": "The agentic application framework for building autonomous agents with intuitive UIs",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -760,8 +760,8 @@
     "yaml": "^2.9.0",
     "yjs": "^13.6.33",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.224.0-nightly-20261104194955",
-    "@agent-native/recap-cli": "^0.5.94"
+    "@agent-native/recap-cli": "^0.5.96",
+    "@agent-native/agentkit": "^0.224.0"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.71",
@@ -833,7 +833,7 @@
     "xlsx": "^0.18.5"
   },
   "peerDependencies": {
-    "@agent-native/core-corpus": "0.224.0-nightly-20261104194955",
+    "@agent-native/core-corpus": ">=0.196.0",
     "@ai-sdk/anthropic": ">=3",
     "@ai-sdk/cohere": ">=3",
     "@ai-sdk/google": ">=3",

package/src/templates/chat/.agents/skills/sharing/SKILL.md

@@ -174,6 +174,10 @@ For delete actions use `"admin"` (or fold in `"owner"` to require the real owner
 
 `authorize` is a different axis, not an alternative: it gates whether the caller may run the operation at all, while `assertAccess` scopes which row they may touch. A write action restricted to some teammates needs both — `authorize: appAccess.requireAny(...)` on the action, `assertAccess` inside `run`.
 
+## Check many resources at once
+
+Never call `resolveAccess` in a loop over a list: each call runs several queries, so a page that checks every row pays that per row. When rows come from somewhere `accessFilter` cannot reach (a manifest, a gateway response), use `resolveAccessMany("deck", ids, ctx, { skipResourceBody: true })`. It returns a `Map` of the ids the viewer can open, makes the same decision as `resolveAccess`, and reads rows, shares, org membership, and group membership once. Give a registration that uses `canManageAccess` a `canManageAccessKey` (for example `resource.orgId`) so the manager check is asked once per key, not once per row.
+
 ## Create actions must set owner
 
 When inserting a new row, fill `ownerEmail` and `orgId` from the request context:

package/src/templates/default/.agents/skills/sharing/SKILL.md

@@ -174,6 +174,10 @@ For delete actions use `"admin"` (or fold in `"owner"` to require the real owner
 
 `authorize` is a different axis, not an alternative: it gates whether the caller may run the operation at all, while `assertAccess` scopes which row they may touch. A write action restricted to some teammates needs both — `authorize: appAccess.requireAny(...)` on the action, `assertAccess` inside `run`.
 
+## Check many resources at once
+
+Never call `resolveAccess` in a loop over a list: each call runs several queries, so a page that checks every row pays that per row. When rows come from somewhere `accessFilter` cannot reach (a manifest, a gateway response), use `resolveAccessMany("deck", ids, ctx, { skipResourceBody: true })`. It returns a `Map` of the ids the viewer can open, makes the same decision as `resolveAccess`, and reads rows, shares, org membership, and group membership once. Give a registration that uses `canManageAccess` a `canManageAccessKey` (for example `resource.orgId`) so the manager check is asked once per key, not once per row.
+
 ## Create actions must set owner
 
 When inserting a new row, fill `ownerEmail` and `orgId` from the request context:

package/src/templates/headless/.agents/skills/sharing/SKILL.md

@@ -174,6 +174,10 @@ For delete actions use `"admin"` (or fold in `"owner"` to require the real owner
 
 `authorize` is a different axis, not an alternative: it gates whether the caller may run the operation at all, while `assertAccess` scopes which row they may touch. A write action restricted to some teammates needs both — `authorize: appAccess.requireAny(...)` on the action, `assertAccess` inside `run`.
 
+## Check many resources at once
+
+Never call `resolveAccess` in a loop over a list: each call runs several queries, so a page that checks every row pays that per row. When rows come from somewhere `accessFilter` cannot reach (a manifest, a gateway response), use `resolveAccessMany("deck", ids, ctx, { skipResourceBody: true })`. It returns a `Map` of the ids the viewer can open, makes the same decision as `resolveAccess`, and reads rows, shares, org membership, and group membership once. Give a registration that uses `canManageAccess` a `canManageAccessKey` (for example `resource.orgId`) so the manager check is asked once per key, not once per row.
+
 ## Create actions must set owner
 
 When inserting a new row, fill `ownerEmail` and `orgId` from the request context:

package/src/templates/workspace-core/.agents/skills/sharing/SKILL.md

@@ -174,6 +174,10 @@ For delete actions use `"admin"` (or fold in `"owner"` to require the real owner
 
 `authorize` is a different axis, not an alternative: it gates whether the caller may run the operation at all, while `assertAccess` scopes which row they may touch. A write action restricted to some teammates needs both — `authorize: appAccess.requireAny(...)` on the action, `assertAccess` inside `run`.
 
+## Check many resources at once
+
+Never call `resolveAccess` in a loop over a list: each call runs several queries, so a page that checks every row pays that per row. When rows come from somewhere `accessFilter` cannot reach (a manifest, a gateway response), use `resolveAccessMany("deck", ids, ctx, { skipResourceBody: true })`. It returns a `Map` of the ids the viewer can open, makes the same decision as `resolveAccess`, and reads rows, shares, org membership, and group membership once. Give a registration that uses `canManageAccess` a `canManageAccessKey` (for example `resource.orgId`) so the manager check is asked once per key, not once per row.
+
 ## Create actions must set owner
 
 When inserting a new row, fill `ownerEmail` and `orgId` from the request context: