akanjs 3.0.0-alpha.11 → 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/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/dictInfo.ts

@@ -880,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<
@@ -893,6 +901,7 @@ type MergeTwoModelDicts<ModelDict1, ModelDict2> =
     infer BaseSignalKey1,
     infer SliceKey1,
     infer EndpointKey1,
+    infer StoreKey1,
     infer ErrorKey1,
     infer EtcKey1
   >
@@ -906,6 +915,7 @@ type MergeTwoModelDicts<ModelDict1, ModelDict2> =
         infer BaseSignalKey2,
         infer SliceKey2,
         infer EndpointKey2,
+        infer StoreKey2,
         infer ErrorKey2,
         infer EtcKey2
       >
@@ -919,6 +929,7 @@ type MergeTwoModelDicts<ModelDict1, ModelDict2> =
           BaseSignalKey1 | BaseSignalKey2,
           SliceKey1 | SliceKey2,
           EndpointKey1 | EndpointKey2,
+          StoreKey1 | StoreKey2,
           ErrorKey1 | ErrorKey2,
           EtcKey1 | EtcKey2
         >

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++;

package/package.json

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

package/server/akanApp.ts

@@ -82,6 +82,8 @@ export class AkanApp {
   /** Hosted by `akan start`: crash loops should yield to the dev host, which restarts on file edits. */
   readonly #devHosted = process.env.AKAN_COMMAND_TYPE === "start";
   readonly #healthTimeoutMs = AkanApp.#parseHealthTimeoutMs();
+  /** Child stderr is bundler/runtime noise the gateway cannot act on; it still reaches the rotating log file. */
+  readonly #printChildStderr = process.env.AKAN_CHILD_STDERR === "1";
   readonly #serverPath: string;
   readonly #artifactDir: string;
   readonly #replica: AkanReplicaConfig;
@@ -1249,7 +1251,7 @@ export class AkanApp {
 
   #writeChildOutputLineRaw(idx: number, role: AkanChildRole, type: "stdout" | "stderr", line: string) {
     const prefixedLine = `[child:${idx} ${role}] [${type}] ${line}`;
-    process[type].write(prefixedLine);
+    if (type === "stdout" || this.#printChildStderr) process[type].write(prefixedLine);
     this.#logWriter?.write(`${idx}-${role}`, AkanApp.#stripAnsi(prefixedLine));
   }
 

package/service/predefinedAdaptor/index.ts

@@ -1,6 +1,7 @@
 export * from "./cache.adaptor";
 export * from "./compress.adaptor";
 export * from "./database.adaptor";
+export * from "./insightQuery";
 export * from "./logging.adaptor";
 export * from "./queue.adaptor";
 export * from "./role.adaptor";

package/service/predefinedAdaptor/insightQuery.ts

@@ -0,0 +1,183 @@
+import type { AkanSqlClient } from "./database.adaptor";
+
+export interface InsightQueryOptions {
+  /** Rows to return at most. Clamped to `InsightQuery.maxRows`, which no caller can raise. */
+  limit?: number;
+  /** How long to wait for the driver, in ms. See the note on `#raced` for which dialects this can actually stop. */
+  timeoutMs?: number;
+}
+
+export interface InsightQueryResult {
+  columns: string[];
+  rows: Record<string, unknown>[];
+  /** The ceiling cut the answer short, so the caller knows not to read it as complete. */
+  truncated: boolean;
+}
+
+/**
+ * One read-only SQL statement, for an agent or an operator asking a question the domain endpoints cannot express.
+ *
+ * This is the layer-bypassing read, and every safeguard the framework has is bypassed with it — guards, soft delete,
+ * cascade, `_postRemove`, and the `hidden`/`secret` masking every other response path performs. So it is read-only
+ * by construction rather than by convention, and it is deliberately *not* wired to an endpoint here: the framework
+ * owns no guard strong enough to sit in front of it. An app that wants it writes the endpoint with its own
+ * `SuperAdmin`, the same way guards ship with the library that owns the model.
+ *
+ * Three things enforce read-only, and only the third is ours:
+ *
+ * 1. The statement is wrapped as a derived table — `SELECT * FROM (<sql>) AS "akanInsight" LIMIT ?`. Nothing but a
+ *    query is legal in that position, in either dialect, so a write is a syntax error from the engine rather than a
+ *    pattern this code had to recognise. A second statement smuggled behind `;` is a syntax error for the same
+ *    reason, and the row ceiling rides along on the same wrapper.
+ * 2. A rejection before execution, so the caller reads why rather than a syntax error. It runs on the statement with
+ *    comments and string literals removed, because that is what makes `-- ` and `'…'` unable to hide anything.
+ * 3. **`_doc` never crosses the boundary.** Every non-base field lives in that one JSON column, which is where the
+ *    plan's "re-apply schema-based masking" runs into the fact that an arbitrary SELECT has no model to mask by. So
+ *    the enforceable rule is the column itself: unnameable in the statement, dropped from the rows, and any cell
+ *    that still arrives holding a JSON object or array is refused. An insight is made of scalars; a value that is
+ *    not one is either a document or indistinguishable from it.
+ *
+ * What that costs is real and worth saying: this answers "how many, since when, grouped how" over base columns and
+ * the search mirror, and it cannot read a domain field. Field-level reads go through the domain tools, which mask.
+ */
+export class InsightQuery {
+  /** Not an option. A caller asking for more gets this, because the point is that no caller sets the ceiling. */
+  static readonly maxRows = 1000;
+  static readonly #allowedFirstKeywords = new Set(["select", "with"]);
+  /**
+   * Words that cannot appear anywhere in a read, checked so read-only does not rest on a dialect's own rule.
+   *
+   * `WITH` has to be allowed as a first keyword — a CTE is how a real question gets asked — and Postgres lets a CTE
+   * modify data. That it is illegal *inside* the derived table this wraps the statement in is true and is what would
+   * stop it, but it is one sentence of another project's documentation away from not being true. This does not
+   * depend on it. Word-boundary matched on the comment- and literal-stripped statement, so `deleted_at` is fine and
+   * a column that is genuinely named `update` is refused — the wrong answer in the safe direction.
+   */
+  static readonly #forbidden =
+    /\b(insert|update|delete|drop|alter|create|truncate|replace|grant|revoke|attach|detach|vacuum|reindex|pragma)\b/i;
+  /** The column every document's non-base fields live in. See the class note. */
+  static readonly #documentColumn = "_doc";
+
+  readonly #client: AkanSqlClient;
+
+  constructor(client: AkanSqlClient) {
+    this.#client = client;
+  }
+
+  async run(sql: string, { limit = InsightQuery.maxRows, timeoutMs = 10_000 }: InsightQueryOptions = {}) {
+    const statement = InsightQuery.#assertReadable(sql);
+    const rows = Math.max(1, Math.min(limit, InsightQuery.maxRows));
+    
+    const wrapped = `SELECT * FROM (${statement}) AS "akanInsight" LIMIT ${rows + 1}`;
+    const found = await InsightQuery.#raced(this.#client.prepare(wrapped).all(), timeoutMs);
+    const truncated = found.length > rows;
+    const kept = truncated ? found.slice(0, rows) : found;
+    return {
+      columns: InsightQuery.#columnsOf(kept),
+      rows: kept.map((row) => InsightQuery.#readable(row)),
+      truncated,
+    } satisfies InsightQueryResult;
+  }
+
+  /**
+   * Stops waiting; does not stop the query.
+   *
+   * With libsql or Postgres the driver call is genuinely asynchronous, so the caller is freed and the connection
+   * finishes on its own. With `bun:sqlite` it is synchronous and holds the event loop, so this timer cannot fire
+   * until the query is already done — the ceiling is what limits that case, not the clock. Do not read the timeout
+   * as protection against an expensive statement.
+   */
+  static async #raced<T>(work: Promise<T[]>, timeoutMs: number): Promise<T[]> {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const expiry = new Promise<never>((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`Insight query exceeded ${timeoutMs}ms.`)), timeoutMs);
+    });
+    try {
+      return await Promise.race([work, expiry]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  /** Returns the statement with a trailing `;` removed, or throws naming what is wrong with it. */
+  static #assertReadable(sql: string) {
+    const statement = sql.trim().replace(/;\s*$/, "");
+    if (!statement) throw new Error("An insight query needs a statement.");
+    const bare = InsightQuery.#stripLiterals(statement);
+    if (bare.includes(";")) throw new Error("An insight query is one statement. Remove the `;`.");
+    const first = /[a-z]+/.exec(bare.toLowerCase())?.[0];
+    if (!first || !InsightQuery.#allowedFirstKeywords.has(first))
+      throw new Error(
+        `An insight query reads: it starts with SELECT or WITH, not ${first ? first.toUpperCase() : "that"}.`,
+      );
+    const forbidden = InsightQuery.#forbidden.exec(bare)?.[0];
+    if (forbidden) throw new Error(`An insight query reads: ${forbidden.toUpperCase()} has no place in one.`);
+    if (new RegExp(`\\b${InsightQuery.#documentColumn}\\b`).test(bare))
+      throw new Error(
+        `An insight query cannot read \`${InsightQuery.#documentColumn}\`: every field a model marks hidden or secret is inside it, and an arbitrary statement names no model to mask it by. Read base columns, or use the model's own endpoint.`,
+      );
+    return statement;
+  }
+
+  /**
+   * Blanks out comments and string literals so the checks above read only what the engine would treat as syntax.
+   *
+   * Replaced with spaces rather than deleted, so nothing that was two tokens becomes one — `a/**\/b` must not read
+   * as the identifier `ab`. Dollar-quoting is not handled: it is Postgres function-body syntax, and a statement
+   * that begins with SELECT or WITH has nowhere legal to put one.
+   *
+   * A double-quoted span is **unquoted, not blanked**. It is an identifier in both dialects, not a literal, so
+   * blanking it was what let `SELECT "_doc"` through the column check while `SELECT _doc` was refused. Keeping the
+   * contents means SQLite's fallback — a double-quoted string, where no such column exists — is read as an
+   * identifier too, which errs toward refusing a statement rather than toward reading the column.
+   */
+  static #stripLiterals(sql: string) {
+    return sql
+      .replace(/\/\*[\s\S]*?(\*\/|$)/g, (match) => " ".repeat(match.length))
+      .replace(/--[^\n]*/g, (match) => " ".repeat(match.length))
+      .replace(/'(?:''|[^'])*'/g, (match) => " ".repeat(match.length))
+      .replace(/"(?:""|[^"])*"/g, (match) => ` ${match.slice(1, -1)} `);
+  }
+
+  static #columnsOf(rows: Record<string, unknown>[]) {
+    const columns = new Set<string>();
+    for (const row of rows) for (const key of Object.keys(row)) columns.add(key);
+    columns.delete(InsightQuery.#documentColumn);
+    return [...columns];
+  }
+
+  /**
+   * Drops the document column and refuses anything else shaped like one.
+   *
+   * The column has to be dropped here as well as rejected in the statement, because `SELECT * FROM "user"` returns
+   * it without ever naming it. The JSON check is for the ways a dialect can hand back a whole row under another
+   * name — `row_to_json(u)` — which no list of forbidden function names would keep up with.
+   */
+  static #readable(row: Record<string, unknown>) {
+    const readable: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(row)) {
+      if (key === InsightQuery.#documentColumn) continue;
+      if (InsightQuery.#isDocumentShaped(value))
+        throw new Error(
+          `Column "${key}" of the insight query holds an object, which may be a document with its hidden or secret fields intact. Select the values you need instead.`,
+        );
+      readable[key] = value;
+    }
+    return readable;
+  }
+
+  static #isDocumentShaped(value: unknown): boolean {
+    if (value === null || value === undefined) return false;
+    if (value instanceof Date) return false;
+    if (typeof value === "object") return true;
+    if (typeof value !== "string") return false;
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return false;
+    try {
+      return typeof JSON.parse(trimmed) === "object";
+    } catch {
+      
+      return false;
+    }
+  }
+}

package/signal/mcp/Msg.ts

@@ -1,4 +1,4 @@
-import { FIELD_META } from "akanjs/base";
+import { leakingFieldsOf, type MaskModel, mask } from "akanjs/constant";
 import type { JsonSchema } from "../schema";
 
 export type PromptRole = "user" | "assistant";
@@ -68,18 +68,9 @@ export interface PromptFileSource {
 
 /**
  * A model class, named by the caller so an attachment can be masked by what it *is* rather than by what it still
- * carries at runtime. Structural, and read through `FIELD_META` the way `resolveReturn` reads it.
+ * carries at runtime. The same model any other audience masks by — see `mask` in `akanjs/constant`.
  */
-export interface PromptModel {
-  name: string;
-}
-
-/** The part of a field's metadata masking turns on. Mirrors what `resolveReturn` branches over. */
-interface PromptField {
-  fieldType?: string;
-  isClass?: boolean;
-  modelRef?: PromptModel;
-}
+export type PromptModel = MaskModel;
 
 /**
  * The string fields each block type must carry, and the set of legal types at once.
@@ -205,17 +196,7 @@ export class Msg {
    * promises. The value's only destination is a JSON payload, so nothing downstream wanted the type anyway.
    */
   static mask(model: PromptModel, value: unknown): unknown {
-    if (value === null || value === undefined || typeof value !== "object") return value;
-    if (Array.isArray(value)) return value.map((item: unknown) => Msg.mask(model, item));
-    const fields = Msg.#fieldsOf(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 ? Msg.mask(field.modelRef, source[key]) : source[key];
-    }
-    return masked;
+    return mask(model, value);
   }
 
   /**
@@ -316,22 +297,13 @@ export class Msg {
 
   static #assertSample(uri: string, sample: Record<string, unknown>) {
     const model = sample.constructor as PromptModel | undefined;
-    const fields = model ? Msg.#fieldsOf(model) : null;
-    if (!fields) return;
-    const leaking = Object.entries(fields)
-      .filter(([key, field]) => (field.fieldType === "hidden" || field.fieldType === "secret") && key in sample)
-      .map(([key]) => key);
+    const leaking = model ? leakingFieldsOf(model, sample) : [];
     if (!leaking.length) return;
     throw new Error(
       `Msg.resource("${uri}") embeds ${model?.name} with its hidden/secret fields populated: ${leaking.join(", ")}. Name the model so they are stripped — Msg.resource(uri, value, { model: cnst.${model?.name} }), or Msg.mask(cnst.${model?.name}, value) for one piece of an assembled payload.`,
     );
   }
 
-  static #fieldsOf(model: PromptModel): Record<string, PromptField> | null {
-    const fields = (model as unknown as { [key: symbol]: unknown })[FIELD_META];
-    return fields && typeof fields === "object" ? (fields as Record<string, PromptField>) : null;
-  }
-
   /**
    * An empty annotation object is dropped rather than emitted: a block carrying `annotations: {}` reads to a
    * client as a deliberate "no audience, no priority", which is not the same as saying nothing.

package/store/action.ts

@@ -5,7 +5,6 @@ import {
   type FetchPolicy,
   isQueryEqual,
   Logger,
-  lowerlize,
   pathSet,
   resolveFileUploadCapability,
 } from "akanjs/common";
@@ -33,18 +32,12 @@ import type {
   SlceDbSort,
   SliceCls,
 } from "akanjs/signal";
+import { tagAction } from "./actionTag";
+import { formSetterNames } from "./formSetterNames";
+import type { SliceActionKey } from "./sliceRole";
 import type { SliceStateKey } from "./state";
 import type { SetGet, StoreSliceArgs, StoreSliceMap, StoreSliceSuffixCap } from "./types";
 
-type SliceActionKey =
-  | "initModel"
-  | "refreshModel"
-  | "selectModel"
-  | "setPageOfModel"
-  | "addPageOfModel"
-  | "setLimitOfModel"
-  | "setQueryArgsOfModel"
-  | "setSortOfModel";
 type _SliceMap<S extends SliceCls> = StoreSliceMap<S>;
 type _ActionRefName<S extends SliceCls> = SlceCnstRefName<S>;
 type _ActionCap<S extends SliceCls> = SlceCnstCapitalizedRefName<S>;
@@ -311,16 +304,7 @@ export const makeFormSetter = (refName: string, fetch: FetchProxy<any>) => {
     },
   };
   const fieldSetAction = Object.entries(modelRef[FIELD_META]).reduce((acc, [key, field]) => {
-    const [fieldKeyName, classKeyName] = [lowerlize(key), capitalize(key)];
-    const namesOfField = {
-      field: fieldKeyName,
-      Field: classKeyName,
-      setFieldOnModel: `set${classKeyName}On${className}`,
-      addFieldOnModel: `add${classKeyName}On${className}`,
-      subFieldOnModel: `sub${classKeyName}On${className}`,
-      addOrSubFieldOnModel: `addOrSub${classKeyName}On${className}`,
-      uploadFieldOnModel: `upload${classKeyName}On${className}`,
-    };
+    const namesOfField = formSetterNames(className, key);
     const singleFieldSetAction = {
       [namesOfField.setFieldOnModel]: function (this: SetGet, value: any | null) {
         this.set((state: { [key: string]: any }) => {
@@ -427,6 +411,11 @@ export const makeFormSetter = (refName: string, fetch: FetchProxy<any>) => {
           }
         : {}),
     };
+
+    tagAction(singleFieldSetAction[namesOfField.setFieldOnModel] as (...args: never[]) => unknown, {
+      action: namesOfField.setFieldOnModel,
+      state: `${names.modelForm}.${namesOfField.field}`,
+    });
     return Object.assign(acc, singleFieldSetAction);
   }, {});
   return Object.assign(fieldSetAction, baseSetAction);

package/store/actionTag.ts

@@ -0,0 +1,28 @@
+import { ACTION_TAG } from "akanjs/base";
+
+export interface ActionTag {
+  /** The `st.do` key this function is. */
+  action: string;
+  /** The state path it writes, when it writes exactly one — `userForm.name` for a field setter. */
+  state?: string;
+}
+
+/**
+ * Marks a dispatcher with what it does, so a component handed one by reference can say so in the DOM.
+ *
+ * `onChange={st.do.setNameOnUser}` is the house form for every model field, which means the component already holds
+ * everything an annotation needs — it just has no way to read it off a function. This is that way, and it is why
+ * `data-akan-*` costs an app no code at all: nobody writes the attribute, the setter carries its own name.
+ *
+ * Non-enumerable, so it survives neither `{...fn}` nor `JSON.stringify` and shows up in no spread.
+ */
+export const tagAction = <T extends (...args: never[]) => unknown>(fn: T, tag: ActionTag): T => {
+  Object.defineProperty(fn, ACTION_TAG, { value: tag, configurable: true });
+  return fn;
+};
+
+export const actionTagOf = (value: unknown): ActionTag | undefined => {
+  if (typeof value !== "function") return undefined;
+  const tag = (value as unknown as { [key: symbol]: unknown })[ACTION_TAG];
+  return tag && typeof tag === "object" ? (tag as ActionTag) : undefined;
+};