fix(core): type the posture slice's access as unknown, grade the changeset minor

The coverage step reads access.default off each allSchemas entry. Typing the
member unknown keeps every call that compiled before compiling; the element
type still gains an optional member, a type widening, so the changeset is
graded minor.

Claude-Session: https://claude.ai/code/session_01Bvd69VPa6puiNzzPUroDBx
Co-authored-by: Claude <noreply@anthropic.com>

Author: claude

.changeset/20083-effective-map-plain-wildcard.md

@@ -1,5 +1,5 @@
 ---
-'@objectstack/core': patch
+'@objectstack/core': minor
 ---
 
 fix(core): the effective object-permission map covers what a plain `'*'` grant covers, so `current_user.can()` agrees with the server for a wall-less org admin (#20083)
@@ -16,7 +16,7 @@ The population it hit: `organization_admin_no_bypass`, which a deployment withou
 - only `true` grant bits are copied; a wildcard's `false` or unset bit adds nothing;
 - an object the step would add, but whose entry grants no verb on its own, is left out.
 
-The step reads `name` and `access.default` off the `allSchemas` entries, so a direct caller of `buildEffectiveObjectPermissions` passes the registered schemas themselves there, as both in-repo callers do; an entry without `access` reads as public, exactly as the server reads it.
+The step reads `name` and `access.default` off the `allSchemas` entries, so the element type of `allSchemas` on `buildEffectiveObjectPermissions`' schema source gains an optional `access?: unknown` member (the package exports no new name for it). That is a type widening only: every call that compiled before still compiles, and a schema literal carrying `access` now does too. A direct caller passes the registered schemas themselves there, as both in-repo callers do; an entry without `access` reads as public, exactly as the server reads it.
 
 **What a reader of `/auth/me/permissions` sees.** For a subject holding a plain wildcard, `objects` gains an entry for every registered public object the wildcard covers that had none, annotated with `apiOperations` by the same rule as every other entry. An entry that was already there may gain `true` bits. Nothing is removed. For a subject holding no plain wildcard — `admin_full_access`, a walled `organization_admin`, `member_default` alone — the response is byte-identical to before. The response shape, its keys and the route are unchanged.
 

packages/core/src/security/effective-object-permissions.ts

@@ -184,7 +184,18 @@ export interface ApiExposureSchemaLike {
  */
 export interface ObjectAccessPostureLike {
   name?: string;
-  access?: { default?: unknown } | null;
+  /**
+   * The registered schema's own `access` block, passed through as it is. Typed
+   * `unknown` so that any schema a caller already hands over still type-checks;
+   * the one read is `access.default === 'private'`.
+   */
+  access?: unknown;
+}
+
+/** `access.default === 'private'` off a registered schema — the evaluator's own test. */
+function isPrivatePosture(schema: ObjectAccessPostureLike | null | undefined): boolean {
+  const access = schema?.access;
+  return typeof access === 'object' && access !== null && (access as { default?: unknown }).default === 'private';
 }
 
 /** The `allow*` bits {@link objectPermissionGrants} reads, i.e. every bit a `can()` verb resolves to. */
@@ -251,7 +262,7 @@ function materializePlainWildcardCoverage(
   for (const schema of allSchemas) {
     const name = schema?.name;
     if (!name || name === '*') continue;
-    if (schema.access?.default === 'private') continue;
+    if (isPrivatePosture(schema)) continue;
     const had = Object.prototype.hasOwnProperty.call(objects, name);
     const acc: Record<string, unknown> = had ? objects[name] : {};
     let touched = false;