akanjs 3.0.0-alpha.10 → 3.0.0-alpha.12

package/base/symbols.ts

@@ -13,6 +13,10 @@ 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. */
+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");
 export const SERVER_VALUE = Symbol.for("akan.value.server");
 export const CLIENT_VALUE = Symbol.for("akan.value.client");
 export const DEFAULT_VALUE = Symbol.for("akan.value.default");

package/common/index.ts

@@ -27,6 +27,16 @@ export {
   resolveAkanI18nConfig,
 } from "./localeConfig";
 export { lowerlize } from "./lowerlize";
+export {
+  isMcpDescribableArg,
+  type McpExposureEndpoint,
+  type McpExposureHints,
+  type McpExposureOption,
+  mcpBaseVerbOf,
+  mcpHintsOf,
+  mcpPromptRefusalOf,
+  mcpRefusalOf,
+} from "./mcpExposure";
 export { mergeVersion } from "./mergeVersion";
 export { objectify } from "./objectify";
 export { pathGet } from "./pathGet";

package/common/mcpExposure.ts

@@ -0,0 +1,106 @@
+import { capitalize } from "./capitalize";
+
+/**
+ * What MCP says about one endpoint: whether it is published, why it is not, and the hints it carries.
+ *
+ * Structurally typed like the rest of `common/` so the same rules answer on both sides — the server builds its
+ * catalogue from them and the browser API explorer badges an endpoint from them. A second implementation would
+ * 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.
+ */
+export interface McpExposureEndpoint {
+  type: string;
+  returns: { refName: string };
+  args: { name: string; refName: string; type: string; arrDepth?: number; nullable?: boolean }[];
+  guards?: string[];
+  fileUpload?: boolean;
+}
+
+export interface McpExposureOption {
+  /**
+   * The read-only deployment valve, which is server configuration. The browser explorer cannot know it and so
+   * badges what the code decided; the boot log is where a read-only deployment says what it dropped.
+   */
+  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.
+ */
+export const mcpBaseVerbOf = (refName: string, key: string) => {
+  const cap = capitalize(refName);
+  if (key === refName || key === `light${cap}`) return "get" as const;
+  if (key === `create${cap}`) return "create" as const;
+  if (key === `update${cap}`) return "update" as const;
+  if (key === `remove${cap}`) return "remove" as const;
+  return null;
+};
+
+/**
+ * The hints a client renders beside a tool. Hints only — clients are told to distrust them, so they inform a UI
+ * 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));
+  return {
+    readOnlyHint: readOnly,
+    destructiveHint: destructive,
+    idempotentHint: mcp.idempotent ?? (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.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.`;
+  if (readOnly && endpoint.type !== "query")
+    return "this deployment is read-only, which drops every endpoint that is not a query.";
+  if (endpoint.returns.refName === "Any" || endpoint.returns.refName === "Upload")
+    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"))
+    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)
+    return `its required argument \`${opaque.name}\` is typed \`Any\`, which is left out of the published schema — expose a named filter slice instead.`;
+  return null;
+};
+
+/**
+ * A prompt is a read exposed on the same terms as a query, so every rejection here is one thing: an argument
+ * `prompts/get` cannot carry. Its `arguments` is a flat string map — one string per name, and no schema beside it
+ * — which rules out the argument *kinds* the builder already refuses and, just as surely, two argument *types* it
+ * accepts. A tool escapes both because it publishes a real JSON Schema.
+ */
+export const mcpPromptRefusalOf = (endpoint: McpExposureEndpoint): string | null => {
+  const carried = endpoint.args.find((arg) => arg.type === "body" || arg.type === "msg" || arg.type === "room");
+  if (carried)
+    return `a prompt's arguments travel as a flat string map, so its \`${carried.type}\` argument \`${carried.name}\` cannot be carried.`;
+
+  const list = endpoint.args.find((arg) => arg.arrDepth);
+  if (list)
+    return `a prompt argument is one string, so its list argument \`${list.name}\` could never carry more than one value.`;
+
+  const opaque = endpoint.args.find((arg) => !isMcpDescribableArg(arg));
+  if (opaque)
+    return `its argument \`${opaque.name}\` is typed \`Any\`, and a prompt has no schema in which to describe one.`;
+  return null;
+};

package/constant/immerify.ts

@@ -9,7 +9,7 @@ export const immerify = <T extends object>(modelRef: ConstantModelRef, objOrArr:
   }) as Record<string, unknown>;
   const objRecord = objOrArr as Record<string, unknown>;
   Object.entries(modelRef[FIELD_META]).forEach(([key, field]) => {
-    if (field.isScalar && field.isClass && !!objRecord[key])
+    if (field.isScalar && field.isClass && objRecord[key])
       immeredObj[key] = immerify(field.modelRef, objRecord[key] as object);
   });
   return immeredObj as T;

package/constant/index.ts

@@ -5,6 +5,7 @@ export * from "./deserialize";
 export * from "./fieldInfo";
 export * from "./getDefault";
 export * from "./immerify";
+export * from "./mask";
 export * from "./purify";
 export * from "./serialize";
 export * from "./textFieldPathSet";

package/constant/mask.ts

@@ -0,0 +1,60 @@
+import { FIELD_META } from "akanjs/base";
+
+/**
+ * A model as masking reads it — the constructor, for the field metadata it carries at runtime.
+ *
+ * Structural rather than `ConstantModelRef` so that anything holding the class can name it, and read through
+ * `FIELD_META` the way `resolveReturn` reads it.
+ */
+export interface MaskModel {
+  name: string;
+}
+
+/** The part of a field's metadata masking turns on. Mirrors what `resolveReturn` branches over. */
+interface MaskField {
+  fieldType?: string;
+  isClass?: boolean;
+  modelRef?: MaskModel;
+}
+
+export const maskFieldsOf = (model: MaskModel): Record<string, MaskField> | null => {
+  const fields = (model as unknown as { [key: symbol]: unknown })[FIELD_META];
+  return fields && typeof fields === "object" ? (fields as Record<string, MaskField>) : null;
+};
+
+/** The `hidden` and `secret` field names of `model` that `value` still carries populated. */
+export const leakingFieldsOf = (model: MaskModel, value: Record<string, unknown>): string[] => {
+  const fields = maskFieldsOf(model);
+  if (!fields) return [];
+  return Object.entries(fields)
+    .filter(([key, field]) => (field.fieldType === "hidden" || field.fieldType === "secret") && key in value)
+    .map(([key]) => key);
+};
+
+/**
+ * Strips what a model marks `hidden` or `secret`, by the model the caller names rather than by the one the value
+ * happens to still carry.
+ *
+ * That distinction is the whole point. A check that reads the class off the value can only mask what arrives as an
+ * instance, so a `{ ...doc }` spread, a `toJSON()`, an `immerify()`, or a round-trip through `JSON.stringify` reaches
+ * its destination with the metadata already gone and nothing can be done about it. A named model is metadata the
+ * value cannot lose, so a hydrated document and a plain object copied out of one mask identically.
+ *
+ * This is the field half of `resolveReturn` and deliberately not the whole of it. That one also loads every relation
+ * it walks past, which is right for a query's return value and wrong here, where the value is already in hand.
+ *
+ * Returns `unknown` rather than the argument's type, because what comes back is missing fields that type promises.
+ */
+export const mask = (model: MaskModel, value: unknown): unknown => {
+  if (value === null || value === undefined || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((item: unknown) => mask(model, item));
+  const fields = maskFieldsOf(model);
+  if (!fields) return value;
+  const source = value as Record<string, unknown>;
+  const masked: Record<string, unknown> = {};
+  for (const [key, field] of Object.entries(fields)) {
+    if (field.fieldType === "hidden" || field.fieldType === "secret" || !(key in source)) continue;
+    masked[key] = field.isClass && field.modelRef ? mask(field.modelRef, source[key]) : source[key];
+  }
+  return masked;
+};

package/dictionary/DictionaryLookup.ts

@@ -0,0 +1,30 @@
+import { pathGet } from "akanjs/common";
+import { DictionaryRegistry } from "./dictionaryRegistry";
+import type { DictionaryNode } from "./trans";
+
+/**
+ * Reads translated text out of the merged dictionary tree by dotted key (`user.signal.createUser.arg.data.desc`).
+ *
+ * Unlike `translate`, a missing key resolves to `undefined` rather than echoing the key back: callers here are
+ * document generators (OpenAPI, MCP) that must omit an absent description instead of emitting `"user.signal.…"`
+ * as if it were prose. The merged root is snapshotted once per instance, so build a fresh one per document.
+ */
+export class DictionaryLookup {
+  readonly language: string;
+  readonly #models: Record<string, DictionaryNode>;
+  constructor(language?: string) {
+    const root = DictionaryRegistry.getRoot();
+    this.language = language && root[language] ? language : (Object.keys(root).at(0) ?? "en");
+    this.#models = root[this.language] ?? {};
+  }
+
+  /** A bare refName names the model node itself, which holds no text of its own — its label is `<refName>.modelName`. */
+  text(key: string): string | undefined {
+    const [refName, ...rest] = key.split(".");
+    if (!refName) return undefined;
+    const model = this.#models[refName];
+    const node = (rest.length ? pathGet(rest.join("."), model) : model) as { t?: unknown } | null;
+    const text = node?.t;
+    return typeof text === "string" && text.length ? text : undefined;
+  }
+}

package/dictionary/dictInfo.ts

@@ -56,6 +56,17 @@ 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"];
@@ -140,6 +151,7 @@ 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,
 > {
@@ -245,6 +257,9 @@ 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;
   };
@@ -278,6 +293,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -302,6 +318,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -327,6 +344,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -351,6 +369,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -375,6 +394,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -400,6 +420,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       keyof DictSliceShape<Slice> & string,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -425,6 +446,41 @@ 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
     >;
@@ -441,6 +497,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey | (keyof ErrorDict & string),
       EtcKey
     >;
@@ -457,6 +514,7 @@ export class ModelDictInfo<
       BaseSignalKey,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey | (keyof EtcDict & string)
     >;
@@ -473,6 +531,7 @@ export class ModelDictInfo<
       GetBaseSignalKey<RefName>,
       SliceKey,
       EndpointKey,
+      StoreKey,
       ErrorKey,
       EtcKey
     >;
@@ -496,6 +555,7 @@ 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);
@@ -777,6 +837,23 @@ 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");
@@ -803,7 +880,15 @@ export class ModelDictInfo<
   }
 }
 
-type AnyModelDictInfo = ModelDictInfo<any, any, any, any, any, any, any, any, any, any, any>;
+/**
+ * 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.
+ */
+
+type AnyModelDictInfo = ModelDictInfo<any, any, any, any, any, any, any, any, any, any, any, any>;
 
 type MergeTwoModelDicts<ModelDict1, ModelDict2> =
   ModelDict1 extends ModelDictInfo<
@@ -816,6 +901,7 @@ type MergeTwoModelDicts<ModelDict1, ModelDict2> =
     infer BaseSignalKey1,
     infer SliceKey1,
     infer EndpointKey1,
+    infer StoreKey1,
     infer ErrorKey1,
     infer EtcKey1
   >
@@ -829,6 +915,7 @@ type MergeTwoModelDicts<ModelDict1, ModelDict2> =
         infer BaseSignalKey2,
         infer SliceKey2,
         infer EndpointKey2,
+        infer StoreKey2,
         infer ErrorKey2,
         infer EtcKey2
       >
@@ -842,6 +929,7 @@ type MergeTwoModelDicts<ModelDict1, ModelDict2> =
           BaseSignalKey1 | BaseSignalKey2,
           SliceKey1 | SliceKey2,
           EndpointKey1 | EndpointKey2,
+          StoreKey1 | StoreKey2,
           ErrorKey1 | ErrorKey2,
           EtcKey1 | EtcKey2
         >

package/dictionary/index.ts

@@ -1,3 +1,4 @@
+export * from "./DictionaryLookup";
 export * from "./dictInfo";
 export {
   __Dict_Key__,

package/dictionary/locale.ts

@@ -168,6 +168,14 @@ 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`
@@ -234,11 +242,14 @@ 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>,
+      | ModelTranslatorKey<RefName, Model, Insight, Filter, Slice, Endpoint, EtcKey>
+      | EnumTranslatorKey<EnumKey>
+      | StoreTranslatorKey<RefName, StoreKey>,
       `${RefName}.error.${ErrorKey}`
     >
   : never => {
@@ -252,11 +263,14 @@ 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>,
+        | ModelTranslatorKey<RefName, Model, Insight, Filter, Slice, Endpoint, EtcKey>
+        | EnumTranslatorKey<EnumKey>
+        | StoreTranslatorKey<RefName, StoreKey>,
         `${RefName}.error.${ErrorKey}`
       >
     : never;

package/document/index.ts

@@ -7,5 +7,6 @@ export * from "./documentSchema";
 export * from "./filterMeta";
 export * from "./into";
 export * from "./loaderInfo";
+export * from "./noDocumentError";
 export * from "./schema";
 export * from "./types";

package/document/noDocumentError.ts

@@ -0,0 +1,12 @@
+/**
+ * A `pick` or a `get` that matched nothing. Typed so a caller can tell "you asked for something that is not
+ * there" from "we broke" — an agent-facing transport in particular must not log a stack and answer "the server
+ * failed" every time a model guesses an id.
+ *
+ * The message is unchanged from the bare `Error` this replaces, because callers already match on it, and the
+ * `statusCode` does not reach the HTTP layer: `isExceptionLike` wants a `toJSON` too, so a missing document
+ * stays a 500 there until someone decides framework-wide that it should be a 404.
+ */
+export class NoDocumentError extends Error {
+  readonly statusCode = 404;
+}

package/fetch/client/fetchClient.ts

@@ -86,6 +86,15 @@ export class FetchClient {
     this.handler = this.#makeHandlerProxy();
     this.applySignal(serializedSignal);
   }
+  /**
+   * Every signal any client in this process has applied, which is the whole callable surface of the app.
+   *
+   * A copy, because this is the registry each client merges its own signals into and a reader that mutated it
+   * would change what the next client applies. Read by the agent catalogue, which needs the argument schemas.
+   */
+  static get sharedSerializedSignal(): { [key: string]: SerializedSignal } {
+    return { ...FetchClient.#sharedSerializedSignal };
+  }
   static resetSharedRegistry() {
     FetchClient.#sharedSerializedSignal = {};
     FetchClient.#sharedRegistryVersion++;
@@ -246,6 +255,8 @@ export class FetchClient {
     const parseReturn = this.#makeReturnParser(endpoint.returns);
     const { bodyArgs, uploadArgs } = FetchClient.classifyHttpArgs(endpoint.args);
     switch (endpoint.type) {
+      
+      case "prompt":
       case "query": {
         const queryFn = async (...argData: unknown[]) => {
           const args = argData.slice(0, argLength);
@@ -286,6 +297,7 @@ export class FetchClient {
   }
   #registerEndpoint(key: string, endpoint: SerializedEndpoint, prefix?: string) {
     switch (endpoint.type) {
+      case "prompt":
       case "query": {
         this.#setHandlerFactory(key, () => this.#makeHttpFn(key, endpoint, prefix));
         return;

package/fetch/fetchType/endpointFetch.type.ts

@@ -7,6 +7,7 @@ import type {
   EndpInfoReqType,
   EndpointCls,
   EndpointInfo,
+  PromptMessage,
   SlceCnstFull,
   SlceCnstInsight,
   SlceCnstLight,
@@ -40,6 +41,9 @@ type QueryOrMutationFetchFn<E, SlceCls extends SliceCls | never> = (
   ...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]
 ) => Promise<EndpInfoReturns<E, SlceCls>>;
 
+/** Typed off `PromptResult` rather than the endpoint's return ref, which is the `Any` carrier a prompt rides on. */
+type PromptFetchFn<E> = (...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]) => Promise<PromptMessage[]>;
+
 type MessageEmitFn<E> = (...args: EndpInfoArgs<E>) => void;
 
 type MessageListenFn<E, SlceCls extends SliceCls | never> = (
@@ -58,12 +62,14 @@ type PubsubSubscribeFn<E, SlceCls extends SliceCls | never> = (
 type PrimaryFetchFn<E, SlceCls extends SliceCls | never> =
   EndpInfoReqType<E> extends "query" | "mutation"
     ? QueryOrMutationFetchFn<E, SlceCls>
-    : EndpInfoReqType<E> extends "message"
-      ? MessageEmitFn<E>
-      : never;
+    : EndpInfoReqType<E> extends "prompt"
+      ? PromptFetchFn<E>
+      : EndpInfoReqType<E> extends "message"
+        ? MessageEmitFn<E>
+        : never;
 
 type PrimaryFetchType<EInfoObj extends { [key: string]: EndpointInfo }, SlceCls extends SliceCls | never> = {
-  [K in keyof EInfoObj as EndpInfoReqType<EInfoObj[K]> extends "query" | "mutation" | "message"
+  [K in keyof EInfoObj as EndpInfoReqType<EInfoObj[K]> extends "query" | "mutation" | "prompt" | "message"
     ? K
     : never]: PrimaryFetchFn<EInfoObj[K], SlceCls>;
 };

package/package.json

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