akanjs 3.0.0-alpha.14 → 3.0.0-alpha.16

package/base/symbols.ts

@@ -13,7 +13,7 @@ export const STATE_META = Symbol.for("akan.state");
 export const STATE_INIT_META = Symbol.for("akan.state.init");
 export const STATE_DERIVED_META = Symbol.for("akan.state.derived");
 export const ACTION_META = Symbol.for("akan.action");
-/** Which module declared each action, which is the dictionary node its words are written in. */
+/** Which module declared each action. See `ActionOwner`. */
 export const ACTION_OWNER_META = Symbol.for("akan.action.owner");
 /** What a dispatcher does, carried on the function so a component handed one can annotate the DOM with it. */
 export const ACTION_TAG = Symbol.for("akan.action.tag");

package/common/index.ts

@@ -30,7 +30,6 @@ export { lowerlize } from "./lowerlize";
 export {
   isMcpDescribableArg,
   type McpExposureEndpoint,
-  type McpExposureHints,
   type McpExposureOption,
   mcpBaseVerbOf,
   mcpHintsOf,

package/common/mcpExposure.ts

@@ -8,7 +8,7 @@ import { capitalize } from "./capitalize";
  * eventually disagree, and an audit surface that disagrees with the catalogue is worse than none.
  *
  * Every rejection returns the sentence an author reads, at boot in the server log and in the explorer. Fail-closed
- * with no reason is what left a deliberate `mcp: { expose: true }` vanishing with nowhere to look but the source.
+ * with no reason leaves an author whose endpoint is missing from the catalogue nowhere to look but the source.
  */
 export interface McpExposureEndpoint {
   type: string;
@@ -26,20 +26,10 @@ export interface McpExposureOption {
   readOnly?: boolean;
 }
 
-/** The author's overrides for the hints derived below. */
-export interface McpExposureHints {
-  readOnly?: boolean;
-  destructive?: boolean;
-  idempotent?: boolean;
-}
-
 /** `Any` publishes as the empty schema, which tells a model nothing — so it is left out rather than described. */
 export const isMcpDescribableArg = (arg: { refName: string }) => arg.refName !== "Any";
 
-/**
- * Which slice-level verb opts in each CRUD endpoint a model generates. They carry no signal option of their own,
- * so `mcp: { get: true }` on the slice is the only place their exposure can be written.
- */
+/** Which CRUD verb a generated endpoint key is, or `null` when the key is not one of the five. */
 export const mcpBaseVerbOf = (refName: string, key: string) => {
   const cap = capitalize(refName);
   if (key === refName || key === `light${cap}`) return "get" as const;
@@ -54,19 +44,22 @@ export const mcpBaseVerbOf = (refName: string, key: string) => {
  * and never stand in for a guard. `openWorldHint` is always false: every endpoint reaches this app's own
  * database, not the wider internet.
  */
-export const mcpHintsOf = (key: string, endpoint: { type: string }, mcp: McpExposureHints = {}) => {
-  const readOnly = mcp.readOnly ?? endpoint.type === "query";
-  const destructive = mcp.destructive ?? (!readOnly && /^(remove|delete)/.test(key));
+export const mcpHintsOf = (key: string, endpoint: { type: string }) => {
+  const readOnly = endpoint.type === "query";
+  const destructive = !readOnly && /^(remove|delete)/.test(key);
   return {
     readOnlyHint: readOnly,
     destructiveHint: destructive,
-    idempotentHint: mcp.idempotent ?? (readOnly || /^(set|update)/.test(key)),
+    idempotentHint: readOnly || /^(set|update)/.test(key),
     openWorldHint: false,
   };
 };
 
 /** The sentence explaining why this endpoint is not in the catalogue, or `null` when it is. */
 export const mcpRefusalOf = (endpoint: McpExposureEndpoint, { readOnly }: McpExposureOption = {}): string | null => {
+
+  if (!endpoint.guards?.length)
+    return "it declares no guards, and exposure follows them — write `guards: [Public]` if anonymous access is the intent.";
   if (endpoint.type === "prompt") return mcpPromptRefusalOf(endpoint);
   if (endpoint.type === "pubsub" || endpoint.type === "message")
     return `\`${endpoint.type}\` rides the websocket, and its internal arguments read a socket an MCP request does not have.`;
@@ -76,7 +69,7 @@ export const mcpRefusalOf = (endpoint: McpExposureEndpoint, { readOnly }: McpExp
     return `a return typed \`${endpoint.returns.refName}\` cannot be described to a model.`;
   if (endpoint.fileUpload || endpoint.args.some((arg) => arg.refName === "Upload"))
     return "a file upload has no MCP representation.";
-  if (endpoint.type === "mutation" && !endpoint.guards?.some((name) => name !== "Public"))
+  if (endpoint.type === "mutation" && !endpoint.guards.some((name) => name !== "Public"))
     return "a mutation needs a real guard — `[Public]` is having none, spelled out.";
   const opaque = endpoint.args.find((arg) => !isMcpDescribableArg(arg) && arg.type !== "search" && !arg.nullable);
   if (opaque)

package/constant/purify.ts

@@ -31,18 +31,24 @@ type Purified<O> = O extends BaseObject
       : O extends object
         ? PurifiedModel<O>
         : O;
-type PurifiedWithObjectToId<T, StateKeys extends keyof GetStateObject<T> = keyof GetStateObject<T>> = {
-  [K in StateKeys as null extends T[K] ? never : K]: Purified<T[K]>;
-} & {
-  [K in StateKeys as null extends T[K] ? K : never]?: Purified<T[K]> | undefined;
-};
-export type PurifiedModel<T> = T extends (infer S)[]
-  ? PurifiedModel<S>[]
-  : T extends string | number | boolean | Dayjs | File
+type PurifiedWithObjectToId<T, StateKeys extends keyof GetStateObject<T> = keyof GetStateObject<T>> =
+  
+  unknown extends T
     ? T
-    : T extends Map<infer K, infer V>
-      ? Map<K, PurifiedModel<V>>
-      : PurifiedWithObjectToId<T>;
+    : {
+        [K in StateKeys as null extends T[K] ? never : K]: Purified<T[K]>;
+      } & {
+        [K in StateKeys as null extends T[K] ? K : never]?: Purified<T[K]> | undefined;
+      };
+export type PurifiedModel<T> = unknown extends T
+  ? T
+  : T extends (infer S)[]
+    ? PurifiedModel<S>[]
+    : T extends string | number | boolean | Dayjs | File
+      ? T
+      : T extends Map<infer K, infer V>
+        ? Map<K, PurifiedModel<V>>
+        : PurifiedWithObjectToId<T>;
 
 export type UploadableClientArg<T> = [T] extends [File[]] ? File[] | FileList : T;
 

package/constant/types.ts

@@ -14,18 +14,20 @@ type ObjectToId<O> = O extends BaseObject
         ? DocumentModel<O>
         : O;
 
-type Docify<T, _StateKeys extends keyof GetStateObject<T> = keyof GetStateObject<T>> = {
-  [K in _StateKeys as null extends T[K] ? never : K]-?: ObjectToId<NonNullable<T[K]>>;
-} & {
-  [K in _StateKeys as null extends T[K] ? K : never]?: ObjectToId<NonNullable<T[K]>> | undefined;
-};
-export type DocumentModel<T> = T extends (infer S)[]
-  ? DocumentModel<S>[]
-  : T extends string | number | boolean | Dayjs | File
-    ? T
-    : T extends Map<infer K, infer V>
-      ? Map<K, DocumentModel<V>>
-      : Docify<T>;
+type Docify<T, _StateKeys extends keyof GetStateObject<T> = keyof GetStateObject<T>> = unknown extends T
+  ? T
+  : { [K in _StateKeys as null extends T[K] ? never : K]-?: ObjectToId<NonNullable<T[K]>> } & {
+      [K in _StateKeys as null extends T[K] ? K : never]?: ObjectToId<NonNullable<T[K]>> | undefined;
+    };
+export type DocumentModel<T> = unknown extends T
+  ? T
+  : T extends (infer S)[]
+    ? DocumentModel<S>[]
+    : T extends string | number | boolean | Dayjs | File
+      ? T
+      : T extends Map<infer K, infer V>
+        ? Map<K, DocumentModel<V>>
+        : Docify<T>;
 
 export type FieldState<T> = T extends { id: string } ? T | null : T;
 export type DefaultOf<S> = GetStateObject<{ [K in keyof S]: FieldState<S[K]> }>;

package/dictionary/dictInfo.ts

@@ -56,17 +56,6 @@ type DictEndpointShape<Endpoint> =
         : Endpoint extends Record<string, EndpointInfo>
           ? EndpointCompactShape<Endpoint>
           : Record<never, never>;
-/**
- * The actions of a store, which is every method on it that dispatches.
- *
- * Derived from the shape rather than from a marker like `ENDPOINT_DICT_SHAPE`, because a store's custom actions
- * are declared on the subclass — after `store()` has already returned, so there is nothing for it to stamp. What
- * makes the shape readable anyway is that `st.do.<action>()` is typed `void`: an action returns nothing, so the
- * void-returning methods are exactly the actions and `get` / `pick` / `slice` fall out on their own.
- */
-type DictStoreShape<Store> = {
-  [K in keyof Store as Store[K] extends (...args: never[]) => void | Promise<void> ? K & string : never]: true;
-};
 type DictArgNames<ArgNames> = ArgNames extends readonly string[] ? ArgNames[number] : never;
 type DictFilterQuery<Filter> = DictFilterShape<Filter>["query"];
 type DictFilterSort<Filter> = DictFilterShape<Filter>["sort"];
@@ -151,7 +140,6 @@ export class ModelDictInfo<
   BaseSignalKey extends string = never,
   SliceKey extends string = "",
   EndpointKey extends string = never,
-  StoreKey extends string = never,
   ErrorKey extends string = never,
   EtcKey extends string = never,
 > {
@@ -257,9 +245,6 @@ export class ModelDictInfo<
   endpointDictionary: { [K in EndpointKey]: FunctionTranslation<Languages> } = {} as {
     [K in EndpointKey]: FunctionTranslation<Languages>;
   };
-  storeDictionary: { [K in StoreKey]: FieldTranslation<Languages> } = {} as {
-    [K in StoreKey]: FieldTranslation<Languages>;
-  };
   errorDictionary: { [K in ErrorKey]: Languages } = {} as {
     [K in ErrorKey]: Languages;
   };
@@ -293,7 +278,6 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
-      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -318,7 +302,6 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
-      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -344,7 +327,6 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
-      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -369,7 +351,6 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
-      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -394,7 +375,6 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
-      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -420,7 +400,6 @@ export class ModelDictInfo<
       BaseSignalKey,
       keyof DictSliceShape<Slice> & string,
       EndpointKey,
-      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -446,41 +425,6 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       keyof DictEndpointShape<Endpoint> & string,
-      StoreKey,
-      ErrorKey,
-      EtcKey
-    >;
-  }
-  /**
-   * What a store's custom actions are called, in the words a person would use.
-   *
-   * Optional, and the only stage that is: an action whose name matches the endpoint it wraps already reads as
-   * that endpoint's `.desc()`, which is most of them — the house naming rule (`st.do.X` reads the same as
-   * `fetch.X`) is what makes that true. This stage is for the rest, where inheriting the endpoint's words would
-   * be actively wrong: nine `getSummaryListIn*` actions that all call one endpoint, or `logout` over
-   * `signoutUser`, where the store name is the verb a user would say and the endpoint name is the verb the API
-   * has. `akan quality scan` names those and no others.
-   *
-   * Labels only, no `.arg()`. Parameter names are not in a class's type the way an endpoint builder's are, and an
-   * action mostly takes none anyway — its data comes from the form state the user already filled in.
-   */
-  store<Store>(
-    translate: (t: (trans: Languages) => FieldTranslation<Languages>) => Partial<{
-      [K in keyof DictStoreShape<Store>]: FieldTranslation<Languages>;
-    }>,
-  ) {
-    Object.assign(this.storeDictionary, translate(FieldTranslation.translate));
-    return this as unknown as ModelDictInfo<
-      Languages,
-      ModelKey,
-      InsightKey,
-      QueryKey,
-      SortKey,
-      EnumKey,
-      BaseSignalKey,
-      SliceKey,
-      EndpointKey,
-      StoreKey | (keyof DictStoreShape<Store> & string),
       ErrorKey,
       EtcKey
     >;
@@ -497,7 +441,6 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
-      StoreKey,
       ErrorKey | (keyof ErrorDict & string),
       EtcKey
     >;
@@ -514,7 +457,6 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
-      StoreKey,
       ErrorKey,
       EtcKey | (keyof EtcDict & string)
     >;
@@ -531,7 +473,6 @@ export class ModelDictInfo<
       GetBaseSignalKey<RefName>,
       SliceKey,
       EndpointKey,
-      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -555,7 +496,6 @@ export class ModelDictInfo<
     this.#registerBaseSignalToRoot(refName, rootDict);
     this.#registerSliceToRoot(refName, rootDict);
     this.#registerEndpointToRoot(refName, rootDict);
-    this.#registerStoreToRoot(refName, rootDict);
     this.#registerErrorToRoot(refName, rootDict);
     this.#registerModelToRoot(refName, rootDict);
     this.#registerEtcToRoot(refName, rootDict);
@@ -838,22 +778,6 @@ export class ModelDictInfo<
     });
   }
   /** Under its own `store` node rather than beside `signal`, because the two hold the same key by design. */
-  #registerStoreToRoot(refName: string, rootDict: RootDictionary) {
-    this.languages.forEach((language) => {
-      ensureNode(getRootModelNode(rootDict, language, refName), "store");
-    });
-    Object.entries(this.storeDictionary as { [key: string]: FieldTranslation<Languages> }).forEach(([key, value]) => {
-      value.trans.forEach((t, idx) => {
-        ensureNode(ensureNode(getTranslatedRootModelNode(rootDict, this.languages, idx, refName), "store"), key).t = t;
-      });
-      value.descTrans?.forEach((t, idx) => {
-        ensureNode(
-          ensureNode(ensureNode(getTranslatedRootModelNode(rootDict, this.languages, idx, refName), "store"), key),
-          "desc",
-        ).t = t;
-      });
-    });
-  }
   #registerErrorToRoot(refName: string, rootDict: RootDictionary) {
     this.languages.forEach((language) => {
       ensureNode(getRootModelNode(rootDict, language, refName), "error");
@@ -883,12 +807,11 @@ export class ModelDictInfo<
 /**
  * Every parameter of `ModelDictInfo` is listed here positionally, so a parameter added to the class has to be
  * added to all three lists below in the same slot. Omitting one does not fail to compile — inference silently
- * shifts, so the last parameter falls off the end and becomes its default `never`: adding `StoreKey` before
- * `ErrorKey` once cost an extending app the whole of the lib's `EtcKey` (`.translate()`) union, which reads at
- * the call site as `l("<model>.<key>")` no longer existing.
+ * shifts, so the last parameter falls off the end and becomes its default `never`, which reads at the call site
+ * as `l("<model>.<key>")` no longer existing.
  */
 
-type AnyModelDictInfo = ModelDictInfo<any, any, any, any, any, any, any, any, any, any, any, any>;
+type AnyModelDictInfo = ModelDictInfo<any, any, any, any, any, any, any, any, any, any, any>;
 
 type MergeTwoModelDicts<ModelDict1, ModelDict2> =
   ModelDict1 extends ModelDictInfo<
@@ -901,7 +824,6 @@ type MergeTwoModelDicts<ModelDict1, ModelDict2> =
     infer BaseSignalKey1,
     infer SliceKey1,
     infer EndpointKey1,
-    infer StoreKey1,
     infer ErrorKey1,
     infer EtcKey1
   >
@@ -915,7 +837,6 @@ type MergeTwoModelDicts<ModelDict1, ModelDict2> =
         infer BaseSignalKey2,
         infer SliceKey2,
         infer EndpointKey2,
-        infer StoreKey2,
         infer ErrorKey2,
         infer EtcKey2
       >
@@ -929,7 +850,6 @@ type MergeTwoModelDicts<ModelDict1, ModelDict2> =
           BaseSignalKey1 | BaseSignalKey2,
           SliceKey1 | SliceKey2,
           EndpointKey1 | EndpointKey2,
-          StoreKey1 | StoreKey2,
           ErrorKey1 | ErrorKey2,
           EtcKey1 | EtcKey2
         >

package/dictionary/locale.ts

@@ -168,14 +168,6 @@ export type ModelTrans<
     }>;
   error: { [K in ErrorKey]: Trans };
 } & { [K in EtcKey]: Trans };
-/**
- * Store action labels, keyed off the resolved `.store()` keys rather than off the store class.
- *
- * The endpoint half needs the class because it reads argument names out of it. A store entry is a label and a
- * description with no arguments to name, so the keys the stage already resolved are the whole of it — which is
- * also why a generated `dict.ts` passes no store type at all.
- */
-export type StoreTranslatorKey<T extends string, StoreKey extends string> = `${T}.store.${StoreKey}${"" | ".desc"}`;
 export type ModelTranslatorKey<T extends string, Model, Insight, Filter, Slice, Endpoint, EtcKey extends string> =
   | `${T}.modelName`
   | `${T}.modelDesc`
@@ -242,14 +234,11 @@ export const registerModelTrans = <
   infer _BaseSignalKey,
   infer _SliceKey,
   infer _EndpointKey,
-  infer StoreKey,
   infer ErrorKey,
   infer EtcKey
 >
   ? DictModule<
-      | ModelTranslatorKey<RefName, Model, Insight, Filter, Slice, Endpoint, EtcKey>
-      | EnumTranslatorKey<EnumKey>
-      | StoreTranslatorKey<RefName, StoreKey>,
+      ModelTranslatorKey<RefName, Model, Insight, Filter, Slice, Endpoint, EtcKey> | EnumTranslatorKey<EnumKey>,
       `${RefName}.error.${ErrorKey}`
     >
   : never => {
@@ -263,14 +252,11 @@ export const registerModelTrans = <
     infer _BaseSignalKey,
     infer _SliceKey,
     infer _EndpointKey,
-    infer StoreKey,
     infer ErrorKey,
     infer EtcKey
   >
     ? DictModule<
-        | ModelTranslatorKey<RefName, Model, Insight, Filter, Slice, Endpoint, EtcKey>
-        | EnumTranslatorKey<EnumKey>
-        | StoreTranslatorKey<RefName, StoreKey>,
+        ModelTranslatorKey<RefName, Model, Insight, Filter, Slice, Endpoint, EtcKey> | EnumTranslatorKey<EnumKey>,
         `${RefName}.error.${ErrorKey}`
       >
     : never;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-alpha.14",
+  "version": "3.0.0-alpha.16",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/akanServer.ts

@@ -38,16 +38,16 @@ export interface AkanServerProps extends AkanLibProps {
 
 export interface AkanServerOptions {
   openapi?: boolean;
-  /** `true` mounts `/mcp` with everything its endpoints opted into; the object form adds the read-only valve. */
+  /** `/mcp` is mounted by default; `false` takes it off, and the object form carries the rest of its settings. */
   mcp?: boolean | McpServerOption;
 }
 
 export interface McpServerOption {
   enabled?: boolean;
   /**
-   * Drops every mutation from the catalogue whatever it opted into — for a deployment that must not be able to
-   * write, such as a read replica or a demo. Off by default: `mcp: { expose: true }` plus the endpoint's guards
-   * are the decision, and this switch cannot tell its author why their endpoint vanished.
+   * Drops every mutation from the catalogue whatever its guards allow — for a deployment that must not be able to
+   * write, such as a read replica or a demo. Off by default, and reported per endpoint in the boot log, because a
+   * switch that silently unlists a published endpoint cannot tell its author why it vanished.
    */
   readOnly?: boolean;
   /**
@@ -116,7 +116,7 @@ export class AkanServer {
   prefix = "/api";
   websocketPrefix = "/ws";
   openapi = AkanServer.#isOpenApiEnvEnabled();
-  mcp = AkanServer.#isEnvEnabled("AKAN_MCP", "AKAN_PUBLIC_MCP");
+  mcp = AkanServer.#isEnvOn("AKAN_MCP", "AKAN_PUBLIC_MCP");
   mcpReadOnly = AkanServer.#isEnvEnabled("AKAN_MCP_READONLY", "AKAN_PUBLIC_MCP_READONLY");
   mcpAuth: McpAuthOption = AkanServer.#mcpAuthFromEnv();
   mcpOption: Omit<McpServerOption, "enabled" | "readOnly" | "auth"> = AkanServer.#mcpOptionFromEnv();
@@ -593,6 +593,17 @@ export class AkanServer {
     return names.some((name) => process.env[name] === "true" || process.env[name] === "1");
   }
 
+  /**
+   * On unless the env says otherwise, which is the opposite of `#isEnvEnabled`.
+   *
+   * MCP exposure follows an endpoint's guards rather than an opt-in, so there is nothing an app has to declare for
+   * its catalogue to be right — and a switch that must be found before anything works is a switch most deployments
+   * never find. `AKAN_MCP=false` is the way off.
+   */
+  static #isEnvOn(...names: string[]) {
+    return !names.some((name) => process.env[name] === "false" || process.env[name] === "0");
+  }
+
   /** Both differ per environment, so they belong in env rather than in the app's source alongside the switch. */
   static #mcpAuthFromEnv(): McpAuthOption {
     const authorizationServers = AkanServer.#envList("AKAN_MCP_AUTH_SERVERS");

package/server/mcp/McpRouter.ts

@@ -118,47 +118,34 @@ export class McpRouter {
   }
 
   /**
-   * Says once, at boot, what this build actually published — and names every endpoint whose author opted in and
-   * was kept out anyway.
+   * Says once, at boot, what this build actually published — and names every endpoint that was kept out.
    *
-   * The rejections behind those are fail-closed by design: an endpoint MCP cannot carry is simply not in the
-   * catalogue. That is the right default and the wrong silence — a deliberate `mcp: { expose: true }` that
-   * vanished left its author nowhere to look but the framework source, and the read-only valve had the same hole
-   * called out when it was given its default. A refusal turns on a resolved return type, and on whether a guard
-   * list holds anything more than `Public`, so it is the one class of these that reads only from here.
+   * The rejections are fail-closed by design: an endpoint MCP cannot carry, or whose guards do not admit it, is
+   * simply not in the catalogue. That is the right default and the wrong silence, and it matters more now that
+   * exposure follows the guards — nobody wrote an opt-in whose absence would explain a missing tool, so this log
+   * is the only place the answer exists. A refusal turns on a resolved return type and a resolved guard list, so
+   * it reads only from here.
    *
-   * An entry published with no description rides here because the scanner finds only a literal
-   * `mcp: { expose: true }` inside a builder call — never a hoisted option, an `expose: flag`, or a slice's verb
-   * map — and the text every generated entry borrows is a *model* `.desc()`, which no source rule would read as
-   * that entry's description. This holds the resolved catalogue, so it can simply look.
-   *
-   * So does an entry that declares no guards. Its access is what an explicit `[Public]` would grant, so it is not
-   * a refusal — but nobody decided it, and a named slice inherits no `get:` from the slice call, which is the way
-   * that happens without anyone writing it down. `akan quality scan` names that shape too
-   * (`akan.mcp.unguarded-exposure`), the omission being syntactic; what is left for here is every exposure the
-   * scanner cannot read as a literal, and the generated entries it skips.
+   * An entry published with no description rides here for the same reason: the text every generated entry borrows
+   * is a *model* `.desc()`, which no source rule would read as that entry's description. This holds the resolved
+   * catalogue, so it can simply look.
    *
    * Called by whatever mounts the router rather than from `createRoutes`, so building a router to answer one
    * request — which tests and tooling do — does not narrate a catalogue nobody asked about.
    */
   report() {
     try {
-      const { tools, prompts, resourceTemplates, refusals, undescribed, unguarded } = this.#getDocument();
+      const { tools, prompts, resourceTemplates, refusals, undescribed } = this.#getDocument();
       const counts = `tools=${tools.length} prompts=${prompts.length} resourceTemplates=${resourceTemplates.length}`;
       McpRouter.logger.info(`MCP catalogue: ${counts}${this.#props.readOnly ? " (read-only deployment)" : ""}`);
 
       if (!tools.length && !prompts.length)
         McpRouter.logger.warn(
-          "MCP is enabled but nothing opted in. Add `mcp: { expose: true }` to an endpoint, or `mcp: { get: true }` to a slice.",
+          "MCP is enabled but published nothing. Every candidate was refused; see the reasons below.",
         );
       for (const { key, reason } of refusals) McpRouter.logger.warn(`MCP did not expose "${key}": ${reason}`);
       for (const { key, reason } of undescribed)
         McpRouter.logger.warn(`MCP exposed "${key}" with no description: ${reason}`);
-      for (const key of unguarded)
-        McpRouter.logger.warn(
-          `MCP exposed "${key}", which declares no guards. Write \`guards: [Public]\` if anonymous reads are the intent — ` +
-            `a slice's \`guards: { get: … }\` reaches base CRUD and the root slice, never a named slice.`,
-        );
     } catch (error) {
 
       McpRouter.logger.warn(

package/signal/guard.ts

@@ -10,17 +10,19 @@ export interface Guard {
  * with no arguments — which is what lets a catalogue hide what the caller certainly cannot use. `resource` needs
  * the call's arguments and fails closed without them, so evaluating one early would erase legitimate entries.
  *
- * Unmarked means `resource`. That is the safe default for listing (the entry stays visible and is stopped at
- * call time), and it is why the marker can be retrofitted one guard at a time.
+ * Required, with no default. Exposure is decided by a guard rather than by an opt-in, so an unmarked guard would
+ * silently take the `resource` path and list its endpoint to every caller — the whole guarded surface's names,
+ * refused only at call time. There is no safe guess here, so the author states it.
  */
 export type GuardScope = "account" | "resource";
 
-export type GuardCls<Name extends string = string> = Cls<Guard, { readonly name: Name; readonly scope?: GuardScope }>;
+export type GuardCls<Name extends string = string> = Cls<Guard, { readonly name: Name; readonly scope: GuardScope }>;
 
 /** Creates a named guard base class for signal access checks. */
 export const guard = <T extends string>(name: T): GuardCls<T> => {
   return class Guard {
     static name = name;
+    static scope: GuardScope = "account";
     canPass(context: SignalContext): PromiseOrObject<boolean> {
       return true;
     }