akanjs 3.0.0-alpha.91 → 3.0.0-alpha.93

package/constant/cascadePaths.ts

@@ -19,8 +19,10 @@ export interface CascadeWithPath {
   readonly refName: string | null;
   /** Set when the field declares `refPath`: the sibling field holding the owner's refName. */
   readonly typeKey: string | null;
-  /** The refNames `typeKey` may hold. Empty unless the field is polymorphic. */
+  /** The refNames `typeKey` may hold. Empty unless the field is polymorphic over an enum. */
   readonly typeValues: readonly string[];
+  /** Set by `polymorphic: "any"`: `typeKey` is free-form, so the owner is whatever refName the row holds. */
+  readonly anyOwner: boolean;
 }
 
 const idNames = new Set(["ID", "String"]);
@@ -33,6 +35,7 @@ export class CascadePaths {
 
   collect(fieldMap: FieldObject) {
     for (const [key, field] of Object.entries(fieldMap)) {
+      this.#assertPolymorphicIsWiredUp(key, field);
       if (!field.cascade) continue;
       this.#assertKnownAction(key, field.cascade);
       if (field.cascade === "removeRef") this.removeRef.set(key, this.#readOwnedRelation(key, field));
@@ -41,6 +44,16 @@ export class CascadePaths {
     return this;
   }
 
+  /** `polymorphic` widens one thing and nothing else, so anywhere else it is a declaration that does nothing. */
+  #assertPolymorphicIsWiredUp(key: string, field: ConstantField) {
+    if (!field.polymorphic) return;
+    if (field.cascade === "removeWith" && field.refPath) return;
+    throw new Error(
+      `Field "${key}" declares polymorphic: "${field.polymorphic}", which only widens a ` +
+        `cascade: "removeWith" field that names its owner type with refPath`,
+    );
+  }
+
   #assertKnownAction(key: string, action: CascadeAction) {
 
     if (!cascadeActions.includes(action)) {
@@ -64,10 +77,10 @@ export class CascadePaths {
     if (field.refPath) return this.#readPolymorphicOwner(key, field, fieldMap);
     if (field.ref) {
       this.#assertHoldsId(key, field);
-      return { key, modelRef: null, refName: field.ref, typeKey: null, typeValues: [] };
+      return { key, modelRef: null, refName: field.ref, typeKey: null, typeValues: [], anyOwner: false };
     }
     if (field.isClass && !field.isScalar) {
-      return { key, modelRef: field.modelRef, refName: null, typeKey: null, typeValues: [] };
+      return { key, modelRef: field.modelRef, refName: null, typeKey: null, typeValues: [], anyOwner: false };
     }
     throw new Error(
       `Cascade field "${key}" declares cascade: "removeWith" but names no owner; make it a model reference, ` +
@@ -81,23 +94,44 @@ export class CascadePaths {
     const typeKey = field.refPath as string;
     const typeField = fieldMap[typeKey];
     if (!typeField) throw new Error(`Cascade field "${key}" declares refPath: "${typeKey}", which is not a field`);
+    if (field.polymorphic === "any") return this.#readAnyOwner(key, typeKey, typeField);
 
     if (!typeField.enum) {
       throw new Error(
         `Cascade field "${key}" declares refPath: "${typeKey}", which must be an enumOf(...) naming the owner ` +
-          `refNames it may hold`,
+          `refNames it may hold; declare polymorphic: "any" to pay for a sweep on every removal instead`,
       );
     }
     const typeValues = typeField.enum.values.map((value) => String(value));
-    return { key, modelRef: null, refName: null, typeKey, typeValues };
+    return { key, modelRef: null, refName: null, typeKey, typeValues, anyOwner: false };
+  }
+
+  #readAnyOwner(key: string, typeKey: string, typeField: ConstantField): CascadeWithPath {
+    
+    if (typeField.enum) {
+      throw new Error(
+        `Cascade field "${key}" declares polymorphic: "any" and a refPath naming an enumOf(...); keep one`,
+      );
+    }
+
+    if (this.#primitiveNameOf(typeField) !== "String") {
+      throw new Error(
+        `Cascade field "${key}" declares polymorphic: "any", so refPath: "${typeKey}" must be a String field ` +
+          `holding the owner's refName`,
+      );
+    }
+    return { key, modelRef: null, refName: null, typeKey, typeValues: [], anyOwner: true };
   }
 
   #assertHoldsId(key: string, field: ConstantField) {
-    const modelRef = field.modelRef as unknown as Cls;
-    const refName = PrimitiveRegistry.has(modelRef)
-      ? PrimitiveRegistry.getName(modelRef as unknown as typeof PrimitiveScalar)
-      : null;
+    const refName = this.#primitiveNameOf(field);
     if (refName && idNames.has(refName)) return;
     throw new Error(`Cascade field "${key}" declares ref or refPath and must hold an ID`);
   }
+
+  #primitiveNameOf(field: ConstantField) {
+    const modelRef = field.modelRef as unknown as Cls;
+    if (!PrimitiveRegistry.has(modelRef)) return null;
+    return PrimitiveRegistry.getName(modelRef as unknown as typeof PrimitiveScalar);
+  }
 }

package/constant/fieldInfo.ts

@@ -106,6 +106,11 @@ export interface ConstantFieldProps<
   validate?: (value: FieldValue, model: any) => boolean;
   text?: TextFieldRole;
   cascade?: CascadeAction;
+  /**
+   * Widens a `cascade: "removeWith"` field whose `refPath` names a free-form `String` instead of an `enumOf`:
+   * the owner is whatever refName the row happens to hold, found by sweeping at removal time.
+   */
+  polymorphic?: "any";
   /**
    * Renders on the page, never reaches an agent. Stripped wherever a value is masked for an AI caller — the
    * in-page agent's reads and every MCP result — and left untouched everywhere else, so a `File`'s blur
@@ -204,6 +209,7 @@ interface ConstantFieldBuildProps<
   validate?: (value: FieldValue, model: any) => boolean;
   text?: TextFieldRole;
   cascade?: CascadeAction;
+  polymorphic?: "any";
   visual: boolean;
   modelRef: ConstantModelRef;
   arrDepth: number;
@@ -329,6 +335,7 @@ export class ConstantField<
   readonly validate?: (value: FieldValue, model: any) => boolean;
   readonly text?: TextFieldRole;
   readonly cascade?: CascadeAction;
+  readonly polymorphic?: "any";
   readonly visual: boolean;
   readonly modelRef: ConstantModelRef;
   readonly arrDepth: number;
@@ -362,6 +369,7 @@ export class ConstantField<
     this.validate = props.validate;
     this.text = props.text;
     this.cascade = props.cascade;
+    this.polymorphic = props.polymorphic;
     this.visual = props.visual;
     this.modelRef = props.modelRef;
     this.arrDepth = props.arrDepth;
@@ -442,6 +450,7 @@ export class ConstantField<
       validate: option.validate,
       text: option.text,
       cascade: option.cascade,
+      polymorphic: option.polymorphic,
       visual: option.visual ?? false,
       modelRef,
       arrDepth: arrDepth,
@@ -489,6 +498,7 @@ export class ConstantField<
       validate: this.validate,
       text: this.text,
       cascade: this.cascade,
+      polymorphic: this.polymorphic,
       visual: this.visual,
       modelRef: this.modelRef,
       arrDepth: this.arrDepth,

package/package.json

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

package/server/di/utils.ts

@@ -71,7 +71,8 @@ export const getModuleDependencyRefNames = (mod: DatabaseModule | ServiceModule)
 /**
  * The modules a cascade edge forces this one to be mounted with: a `removeRef` target and a monomorphic
  * `removeWith` owner both fail `CascadeRunner.seal` when they are absent, so they are boot dependencies the
- * inject graph cannot see. A polymorphic owner list is exempt — it spans optional modules by design.
+ * inject graph cannot see. A polymorphic owner is exempt — an enum list spans optional modules by design, and
+ * `polymorphic: "any"` names no module at all.
  */
 export const getModuleCascadeRefNames = (mod: DatabaseModule | ServiceModule) => {
   const dependencies = new Set<string>();
@@ -79,7 +80,7 @@ export const getModuleCascadeRefNames = (mod: DatabaseModule | ServiceModule) =>
   const { cascade } = mod.constant.full;
   for (const modelRef of cascade.removeRef.values()) dependencies.add(ConstantRegistry.getRefName(modelRef));
   for (const path of cascade.removeWith.values()) {
-    if (path.typeValues.length) continue;
+    if (path.anyOwner || path.typeValues.length) continue;
     dependencies.add(path.refName ?? ConstantRegistry.getRefName(path.modelRef as never));
   }
   return dependencies;

package/server/resolver/CascadeRunner.ts

@@ -43,6 +43,8 @@ const drainSize = 200;
 export class CascadeRunner {
   readonly #modules = new Map<string, CascadeModule>();
   readonly #plans = new Map<string, CascadePlan>();
+  /** `polymorphic: "any"` edges: the owner is unknowable at boot, so every model's removal has to sweep them. */
+  readonly #anyEdges: WithEdge[] = [];
   readonly #bulk = new Set<string>();
   readonly #context = new AsyncLocalStorage<CascadeContext>();
   readonly #logger = new Logger("Cascade");
@@ -71,7 +73,8 @@ export class CascadeRunner {
 
   async run(refName: string, doc: Record<string, unknown>) {
     const plan = this.#plans.get(refName);
-    if (!plan?.refEdges.length && !plan?.withEdges.length) return;
+    if (!plan) return;
+    if (!plan.refEdges.length && !plan.withEdges.length && !this.#anyEdges.length) return;
     const parent = this.#context.getStore();
     const seen = parent?.seen ?? new Set<string>();
     const depth = (parent?.depth ?? 0) + 1;
@@ -83,7 +86,9 @@ export class CascadeRunner {
     }
     await this.#context.run({ seen, depth }, async () => {
       for (const edge of plan.refEdges) await this.#removeRef(edge, doc, seen);
-      if (id) for (const edge of plan.withEdges) await this.#removeWith(edge, refName, id, seen);
+      if (!id) return;
+      for (const edge of plan.withEdges) await this.#removeWith(edge, refName, id, seen);
+      for (const edge of this.#anyEdges) await this.#removeWith(edge, refName, id, seen);
     });
   }
 
@@ -136,6 +141,10 @@ export class CascadeRunner {
 
   #collectWithEdges(childRef: string, mod: CascadeModule) {
     for (const [key, path] of mod.constant.full.cascade.removeWith) {
+      if (path.anyOwner) {
+        this.#anyEdges.push({ refName: childRef, key, typeKey: path.typeKey });
+        continue;
+      }
       for (const owner of this.#resolveOwners(childRef, key, path)) {
         this.#plans.get(owner)?.withEdges.push({ refName: childRef, key, typeKey: path.typeKey });
       }
@@ -163,6 +172,8 @@ export class CascadeRunner {
   #hasRemoveSideEffect(refName: string) {
     const mod = this.#modules.get(refName);
     if (!mod) return true;
+
+    if (this.#anyEdges.length) return true;
     if (mod.schema.preHooks.get("remove")?.length || mod.schema.postHooks.get("remove")?.length) return true;
     if ((mod.srvRef as unknown as { [LIBS_REMOVE_HOOK]?: boolean })[LIBS_REMOVE_HOOK]) return true;
     const proto = mod.srvRef.prototype as { _preRemove?: unknown; _postRemove?: unknown };
@@ -184,10 +195,20 @@ export class CascadeRunner {
         lines.push(`${refName} removeWith ${edge.refName}.${path} (${this.#strategy(edge.refName)})`);
       }
     }
+    for (const edge of this.#anyEdges) {
+      lines.push(`<any> removeWith ${edge.refName}.${edge.key}+${edge.typeKey} (${this.#strategy(edge.refName)})`);
+    }
     if (!lines.length) return;
     const bulk = lines.filter((line) => line.endsWith("(bulk)")).length;
     this.#logger.verbose(`${lines.length} cascade edge(s), ${bulk} in one query`);
     for (const line of lines) this.#logger.verbose(line);
+
+    if (!this.#anyEdges.length) return;
+    const wildcards = this.#anyEdges.map((edge) => `${edge.refName}.${edge.key}`).join(", ");
+    this.#logger.info(
+      `${this.#anyEdges.length} wildcard removeWith edge(s) (${wildcards}): every removal probes them, ` +
+        `and no cascade removes in one query`,
+    );
   }
 
   #strategy(refName: string) {

package/server/resolver/signal.resolver.ts

@@ -374,9 +374,11 @@ export class SignalResolver {
                 `and opening it would put every model on a live socket by default.`,
             );
           SignalResolver.#assertLiveSort(refName, key, sliceInfo);
+          SignalResolver.#assertLivePauseOn(refName, key, sliceInfo);
           const liveKey = `${refName}Live${capitalizedKey}`;
+
           const liveBuilder = (builder as any).pubsub(Any, {
-            guards: sliceCls.getGuards,
+            ...sliceInfo.signalOption,
             mcp: false,
             live: {
               refName,
@@ -384,6 +386,7 @@ export class SignalResolver {
               sort: sliceInfo.liveOption.sort,
               fallback: sliceInfo.liveOption.fallback,
               payload: sliceInfo.liveOption.payload,
+              pauseOn: sliceInfo.liveOption.pauseOn,
             } satisfies LiveEndpointOption,
           });
           endpointObj[liveKey] = liveBuilder
@@ -482,6 +485,44 @@ export class SignalResolver {
       }
     }
   }
+  /** Refuses a subscribe carrying an argument the slice named in `pauseOn`, naming the argument it refused on. */
+  static #assertNotPaused(
+    key: string,
+    liveOption: LiveEndpointOption,
+    endpointInfo: EndpointInfo,
+    context: SignalContext,
+  ) {
+    for (const name of liveOption.pauseOn) {
+      const idx = endpointInfo.args.findIndex((arg) => arg.name === name);
+      if (idx < 0 || context.args[idx] == null) continue;
+      throw new Error(
+        `Live room "${key}" is paused while "${name}" carries a value: the slice declared it in ` +
+          `.live({ pauseOn }), so this window updates by refetching instead of subscribing.`,
+      );
+    }
+  }
+  /**
+   * That every argument `pauseOn` names is one this slice has, and one that can actually be empty.
+   *
+   * A name that is not an argument would do nothing at all, and a `param` — which is never nullable, so it is
+   * present on every call — would switch the room off for good rather than while a box is filled. Both are the
+   * kind of mistake whose only symptom is a list that never updates, so neither is allowed to boot.
+   */
+  static #assertLivePauseOn(refName: string, key: string, sliceInfo: SliceInfo) {
+    for (const name of sliceInfo.liveOption?.pauseOn ?? []) {
+      const arg = sliceInfo.args.find((candidate) => candidate.name === name);
+      if (!arg)
+        throw new Error(
+          `Live slice "${refName}.${key}" declares pauseOn "${name}", which is not one of its arguments ` +
+            `(${sliceInfo.args.map((candidate) => candidate.name).join(", ") || "none"}).`,
+        );
+      if (!arg.option?.nullable)
+        throw new Error(
+          `Live slice "${refName}.${key}" declares pauseOn "${name}", which is a required ${arg.type} and is ` +
+            `therefore always present — the room would never open. Only a nullable argument can pause live sync.`,
+        );
+    }
+  }
   /**
    * The model's field metadata, which membership routing reads for one thing: whether a path is an array, because
    * a bare value on an array field means membership rather than equality.
@@ -649,6 +690,8 @@ export class SignalResolver {
 
               const requestRoomId = context.getRoomId(key);
               if (subscribe) {
+
+                if (liveOption) SignalResolver.#assertNotPaused(key, liveOption, endpointInfo, context);
                 const query = await context.exec();
                 const roomId = liveOption ? context.getLiveRoomId(key) : requestRoomId;
                 if (liveOption)

package/service/injectInfo.ts

@@ -1,4 +1,4 @@
-import { type BackendEnv, type Cls, INJECT_META } from "akanjs/base";
+import { type BackendEnv, type Cls, INJECT_META, PrimitiveRegistry } from "akanjs/base";
 import {
   type ConstantFieldTypeInput,
   ConstantRegistry,
@@ -389,6 +389,9 @@ export const injectionBuilder = (parentRefName: string) => ({
       throw new Error("get and set should be both provided or not provided");
     const isMap = modelRef === Map;
     if (isMap && !opts.of) throw new Error("of should be provided when modelRef is Map");
+    const valueRef = (isMap ? opts.of : modelRef) as Cls;
+
+    const isStructured = Array.isArray(valueRef) || !PrimitiveRegistry.has(valueRef);
     type FieldValue = never extends GetFn ? GetFieldValue<ValueRef, ExplicitType, MapValue> : ReturnType<GetFn>;
     type MapFieldValue = never extends GetFn ? FieldToValue<MapValue> : ReturnType<GetFn>;
     type IsNullable = DefaultValue extends never ? true : false;
@@ -425,16 +428,14 @@ export const injectionBuilder = (parentRefName: string) => ({
     >("memory", {
       local: opts.local,
       get: (serializedValue: never) => {
-        const rawValue = serializedValue as object | null;
-        return (
-          ConstantRegistry.deserialize(isMap ? (opts.of as Cls) : (modelRef as Cls), rawValue ?? opts.default, true) ??
-          null
-        );
+        const stored = serializedValue as unknown;
+        
+        const rawValue = isStructured && typeof stored === "string" ? JSON.parse(stored) : stored;
+        return ConstantRegistry.deserialize(valueRef, (rawValue as object | null) ?? opts.default, true) ?? null;
       },
       set: (value: never) => {
-        return (
-          ConstantRegistry.serialize(isMap ? (opts.of as Cls) : (modelRef as Cls), value, true) ?? opts.default ?? null
-        );
+        const serialized = ConstantRegistry.serialize(valueRef, value, true) ?? opts.default ?? null;
+        return isStructured ? JSON.stringify(serialized) : serialized;
       },
       default: opts.default as unknown,
       isMap,

package/signal/serializer/fetch.serializer.ts

@@ -110,7 +110,14 @@ export class FetchSerializer {
       ...(sliceInfo.signalOption.path ? { path: sliceInfo.signalOption.path } : {}),
       ...(guards?.length ? { guards } : {}),
       ...(sliceInfo.signalOption.mcp === false ? { mcp: false as const } : {}),
-      ...(sliceInfo.liveOption ? { live: { sort: sliceInfo.liveOption.sort } } : {}),
+      ...(sliceInfo.liveOption
+        ? {
+            live: {
+              sort: sliceInfo.liveOption.sort,
+              ...(sliceInfo.liveOption.pauseOn.length ? { pauseOn: sliceInfo.liveOption.pauseOn } : {}),
+            },
+          }
+        : {}),
     };
   }
 

package/signal/sliceInfo.ts

@@ -27,7 +27,7 @@ import type { CnstFull, CnstInput, CnstInsight, CnstLight, DbFilter, SignalOptio
  * What a slice declares when it opts into live sync. Nothing here is required — `.live()` on its own is the whole
  * opt-in, and every default below is the conservative reading.
  */
-export interface LiveSliceOption {
+export interface LiveSliceOption<ArgName extends string = string> {
   /**
    * The sort keys a client may reproduce well enough to place a row itself. Anything else falls back to a refetch,
    * because the client would otherwise have to guess where a new row goes.
@@ -45,12 +45,28 @@ export interface LiveSliceOption {
   fallback?: "invalidate";
   /** `light` sends the row and costs nothing to apply; `id` sends the id alone for a room where the row is bulky. */
   payload?: "light" | "id";
+  /**
+   * The arguments that switch live sync off for as long as they carry a value, named for this slice.
+   *
+   * A filter often builds a different query shape depending on what it was handed — `search ? q.search(text) : {}`
+   * is the common one — so the same slice is routable blank and unroutable with text in the box. Naming the
+   * argument makes that explicit: the client opens no room while it is filled and the window updates by
+   * refetching, which is what a slice with no `.live()` at all does. Clearing it opens the room again.
+   *
+   * Only a nullable argument can be named, which in practice means a `search`: a `param` is always present, so
+   * naming one would switch live off for good. That is refused at boot rather than left to be discovered.
+   *
+   * This is not `fallback`. `fallback: "invalidate"` keeps the room and gives up precision — every write on the
+   * model tells the room to refetch. `pauseOn` gives up the room and keeps precision everywhere else.
+   */
+  pauseOn?: ArgName[];
 }
 
 export interface ResolvedLiveSliceOption {
   sort: string[];
   fallback: "invalidate" | null;
   payload: "light" | "id";
+  pauseOn: string[];
 }
 
 export class SliceInfo<
@@ -193,13 +209,14 @@ export class SliceInfo<
     >;
   }
   /** Opts this slice into live sync. Declaring nothing at all is what keeps a slice out of it entirely. */
-  live(option: LiveSliceOption = {}) {
+  live(option: LiveSliceOption<ArgNames[number]> = {}) {
     if (this.execFn) throw new Error("Query function is already set");
     if (this.liveOption) throw new Error("Live option is already set");
     this.liveOption = {
       sort: option.sort ?? ["latest"],
       fallback: option.fallback ?? null,
       payload: option.payload ?? "light",
+      pauseOn: (option.pauseOn as string[] | undefined) ?? [],
     };
     return this;
   }

package/signal/types.ts

@@ -69,6 +69,8 @@ export interface LiveEndpointOption {
   sort: string[];
   fallback: "invalidate" | null;
   payload: "light" | "id";
+  /** Room arguments that must be empty for the room to exist at all. Enforced here as well as in the client. */
+  pauseOn: string[];
 }
 
 export interface SignalOption<Response = any, Nullable extends boolean = false, _Key = keyof UnCls<Response>>
@@ -143,9 +145,10 @@ interface SerializedSignalOption {
 export interface SerializedSlice extends SerializedSignalOption {
   /**
    * Present when the slice declared `.live()`. `sort` is the allowlist of sort keys a subscriber may place a new
-   * row under itself; on any other sort an insertion refetches instead of guessing where the row goes.
+   * row under itself; on any other sort an insertion refetches instead of guessing where the row goes. `pauseOn`
+   * names the arguments that switch the room off while they carry a value, and travels only when there are any.
    */
-  live?: { sort: string[] };
+  live?: { sort: string[]; pauseOn?: string[] };
 }
 
 export interface SerializedReturns {

package/store/action.ts

@@ -1018,6 +1018,10 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
     const requests = new SliceRequest();
 
     let liveWatch: { signature: string; dispose: () => void } | null = null;
+    
+    const livePauseIdxs = (slice.live?.pauseOn ?? [])
+      .map((name) => slice.args.findIndex((arg) => arg.name === name))
+      .filter((idx) => idx >= 0);
     const namesOfSlice: { [key in SliceActionKey | SliceStateKey | "modelList"]: string } = {
       defaultModel: SliceName.replace(names.Model, names.defaultModel),
       modelInsight: sliceName.replace(names.model, names.modelInsight),
@@ -1395,12 +1399,14 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
       [namesOfSlice.watchLiveModel]: function (this: SetGet, queryArgs: unknown[] | null) {
         if (!slice.live) return;
         const args = queryArgs ? expandQueryArgs(normalizeQueryArgs(queryArgs, slice.args), slice.args) : null;
-        const signature = args ? JSON.stringify(args) : null;
+
+        const paused = !!args && livePauseIdxs.some((idx) => args[idx] != null);
+        const signature = args && !paused ? JSON.stringify(args) : null;
         if (liveWatch && signature !== liveWatch.signature) {
           liveWatch.dispose();
           liveWatch = null;
         }
-        if (!args || liveWatch) return;
+        if (!args || paused || liveWatch) return;
         const self = this as unknown as DynamicRecord;
         const apply = self[namesOfSlice.applyLiveModel] as (event: unknown) => void;
         const refresh = self[namesOfSlice.refreshModel] as (form: object) => Promise<void>;

package/types/constant/cascadePaths.d.ts

@@ -16,8 +16,10 @@ export interface CascadeWithPath {
     readonly refName: string | null;
     /** Set when the field declares `refPath`: the sibling field holding the owner's refName. */
     readonly typeKey: string | null;
-    /** The refNames `typeKey` may hold. Empty unless the field is polymorphic. */
+    /** The refNames `typeKey` may hold. Empty unless the field is polymorphic over an enum. */
     readonly typeValues: readonly string[];
+    /** Set by `polymorphic: "any"`: `typeKey` is free-form, so the owner is whatever refName the row holds. */
+    readonly anyOwner: boolean;
 }
 export declare class CascadePaths {
     #private;

package/types/constant/fieldInfo.d.ts

@@ -47,6 +47,11 @@ export interface ConstantFieldProps<FieldType extends ConstantFieldKind = Consta
     validate?: (value: FieldValue, model: any) => boolean;
     text?: TextFieldRole;
     cascade?: CascadeAction;
+    /**
+     * Widens a `cascade: "removeWith"` field whose `refPath` names a free-form `String` instead of an `enumOf`:
+     * the owner is whatever refName the row happens to hold, found by sweeping at removal time.
+     */
+    polymorphic?: "any";
     /**
      * Renders on the page, never reaches an agent. Stripped wherever a value is masked for an AI caller — the
      * in-page agent's reads and every MCP result — and left untouched everywhere else, so a `File`'s blur
@@ -101,6 +106,7 @@ interface ConstantFieldBuildProps<FieldType extends ConstantFieldKind = any, Fie
     validate?: (value: FieldValue, model: any) => boolean;
     text?: TextFieldRole;
     cascade?: CascadeAction;
+    polymorphic?: "any";
     visual: boolean;
     modelRef: ConstantModelRef;
     arrDepth: number;
@@ -147,6 +153,7 @@ export declare class ConstantField<FieldType extends ConstantFieldKind = Constan
     readonly validate?: (value: FieldValue, model: any) => boolean;
     readonly text?: TextFieldRole;
     readonly cascade?: CascadeAction;
+    readonly polymorphic?: "any";
     readonly visual: boolean;
     readonly modelRef: ConstantModelRef;
     readonly arrDepth: number;

package/types/server/di/utils.d.ts

@@ -18,7 +18,8 @@ export declare const getModuleDependencyRefNames: (mod: DatabaseModule | Service
 /**
  * The modules a cascade edge forces this one to be mounted with: a `removeRef` target and a monomorphic
  * `removeWith` owner both fail `CascadeRunner.seal` when they are absent, so they are boot dependencies the
- * inject graph cannot see. A polymorphic owner list is exempt — it spans optional modules by design.
+ * inject graph cannot see. A polymorphic owner is exempt — an enum list spans optional modules by design, and
+ * `polymorphic: "any"` names no module at all.
  */
 export declare const getModuleCascadeRefNames: (mod: DatabaseModule | ServiceModule) => Set<string>;
 export interface Registration {

package/types/signal/sliceInfo.d.ts

@@ -9,7 +9,7 @@ import type { CnstFull, CnstInput, CnstInsight, CnstLight, DbFilter, SignalOptio
  * What a slice declares when it opts into live sync. Nothing here is required — `.live()` on its own is the whole
  * opt-in, and every default below is the conservative reading.
  */
-export interface LiveSliceOption {
+export interface LiveSliceOption<ArgName extends string = string> {
     /**
      * The sort keys a client may reproduce well enough to place a row itself. Anything else falls back to a refetch,
      * because the client would otherwise have to guess where a new row goes.
@@ -27,11 +27,27 @@ export interface LiveSliceOption {
     fallback?: "invalidate";
     /** `light` sends the row and costs nothing to apply; `id` sends the id alone for a room where the row is bulky. */
     payload?: "light" | "id";
+    /**
+     * The arguments that switch live sync off for as long as they carry a value, named for this slice.
+     *
+     * A filter often builds a different query shape depending on what it was handed — `search ? q.search(text) : {}`
+     * is the common one — so the same slice is routable blank and unroutable with text in the box. Naming the
+     * argument makes that explicit: the client opens no room while it is filled and the window updates by
+     * refetching, which is what a slice with no `.live()` at all does. Clearing it opens the room again.
+     *
+     * Only a nullable argument can be named, which in practice means a `search`: a `param` is always present, so
+     * naming one would switch live off for good. That is refused at boot rather than left to be discovered.
+     *
+     * This is not `fallback`. `fallback: "invalidate"` keeps the room and gives up precision — every write on the
+     * model tells the room to refetch. `pauseOn` gives up the room and keeps precision everywhere else.
+     */
+    pauseOn?: ArgName[];
 }
 export interface ResolvedLiveSliceOption {
     sort: string[];
     fallback: "invalidate" | null;
     payload: "light" | "id";
+    pauseOn: string[];
 }
 export declare class SliceInfo<RefName extends string = string, Input = any, Full = any, Light = any, Insight = any, Filter extends FilterInstance = any, Srvs extends {
     [key: string]: any;
@@ -56,7 +72,7 @@ export declare class SliceInfo<RefName extends string = string, Input = any, Ful
     search<ArgName extends string, ExplicitType = unknown, Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, _ArgType = unknown extends ExplicitType ? FieldToValue<Arg> : ExplicitType, _ClientArg = PurifiedModel<_ArgType>, _ServerArg = DocumentModel<_ArgType>>(name: ArgName, arg: Arg, option?: Omit<EndpointArgProps, "nullable">): SliceInfo<RefName, Input, Full, Light, Insight, Filter, Srvs, [...ArgNames, ArgName], [...Args, arg?: _ClientArg | null], InternalArgs, [...ServerArgs, arg: _ServerArg | undefined]>;
     with<ArgType, Optional extends boolean = false>(argRef: InternalArgCls<ArgType>, option?: InternalArgProps<Optional>): SliceInfo<RefName, Input, Full, Light, Insight, Filter, Srvs, ArgNames, Args, [...InternalArgs, arg: NonNullable<ArgType> | (Optional extends true ? null : never)], ServerArgs>;
     /** Opts this slice into live sync. Declaring nothing at all is what keeps a slice out of it entirely. */
-    live(option?: LiveSliceOption): this;
+    live(option?: LiveSliceOption<ArgNames[number]>): this;
     exec(query: (this: {
         [K in keyof Srvs as K extends string ? Uncapitalize<K> : never]: Srvs[K];
     }, ...args: [...ServerArgs, ...InternalArgs]) => PromiseOrObject<QueryOf<DocumentModel<Full>>>): this;

package/types/signal/types.d.ts

@@ -60,6 +60,8 @@ export interface LiveEndpointOption {
     sort: string[];
     fallback: "invalidate" | null;
     payload: "light" | "id";
+    /** Room arguments that must be empty for the room to exist at all. Enforced here as well as in the client. */
+    pauseOn: string[];
 }
 export interface SignalOption<Response = any, Nullable extends boolean = false, _Key = keyof UnCls<Response>> extends InitOption, TimerOption {
     nullable?: Nullable;
@@ -129,10 +131,12 @@ interface SerializedSignalOption {
 export interface SerializedSlice extends SerializedSignalOption {
     /**
      * Present when the slice declared `.live()`. `sort` is the allowlist of sort keys a subscriber may place a new
-     * row under itself; on any other sort an insertion refetches instead of guessing where the row goes.
+     * row under itself; on any other sort an insertion refetches instead of guessing where the row goes. `pauseOn`
+     * names the arguments that switch the room off while they carry a value, and travels only when there are any.
      */
     live?: {
         sort: string[];
+        pauseOn?: string[];
     };
 }
 export interface SerializedReturns {

package/ui/Load/Units.tsx

@@ -161,12 +161,13 @@ function Render<RefName extends string, Light extends { id: string }>({
     loadedQueryArgs.current = initQueryArgs;
   }, [initSignature]);
 
+  const queryArgsSignature = JSON.stringify(storeUse[namesOfSlice.queryArgsOfModel]());
   useEffect(() => {
-    void storeDo[namesOfSlice.watchLiveModel](initQueryArgs);
+    void storeDo[namesOfSlice.watchLiveModel](storeGet<object[]>()[namesOfSlice.queryArgsOfModel] ?? initQueryArgs);
     return () => {
       void storeDo[namesOfSlice.watchLiveModel](null);
     };
-  }, [initSignature]);
+  }, [initSignature, queryArgsSignature]);
 
   useEffect(() => {
     const modelStaleAt = storeGet<Date>()[namesOfSlice.modelStaleAt];