@object-ui/data-objectstack 17.2.0 → 17.3.0

package/CHANGELOG.md

@@ -1,5 +1,108 @@
 # @object-ui/data-objectstack
 
+## 17.3.0
+
+### Minor Changes
+
+- d22ae31: Track `@objectstack/spec` 17.0.0-rc.2 (objectui#3235, #3208, #3287, #3264).
+
+  The pin moves from `^17.0.0-rc.1` to `^17.0.0-rc.2` across the workspace, and
+  the sibling `@objectstack/*` packages (`client` / `core` / `formula` / `lint`)
+  move with it — they pin `@objectstack/spec` **exactly**, so leaving them behind
+  kept a second copy of the spec in the tree and would have had `@objectstack/lint`
+  validating against rc.1 schemas that still accept keys rc.2 retires.
+
+  Breaking semantics, in FROM → TO form:
+
+  - **`app.homePageId` is retired — an app's landing page is now its first
+    navigation item.** An app that pinned a landing page with `homePageId` will
+    open on the first reachable navigation entry (by `order`) instead; the root
+    landing still follows `isDefault`. To restore a specific landing page, reorder
+    `navigation` so the intended entry comes first. Stored metadata is migrated by
+    `os migrate meta --from 16`. The key is a hard error now, not a stripped one:
+    the spec ships a tombstone that names the migration.
+    Upstream retired it because of its SHAPE, not its usage — it was an ID
+    cross-reference with no referential integrity, so a `homePageId` that pointed
+    at nothing silently fell back to the first navigation item anyway
+    (objectstack#4667, premise corrected in #4709). If the capability returns, it
+    returns as a flag on the navigation item itself, which cannot dangle.
+  - **`@object-ui/types`' `HttpMethod` now resolves to the spec's
+    `HttpMethodType`.** Shape is verbatim identical — the same 5-value UI subset —
+    and `@object-ui/types` still exports it as `HttpMethod`, so no consumer
+    changes. The spec renamed its `./ui` export because `HttpMethod` named two
+    different types depending on the import path (`./shared` / `./api` carry a
+    7-value enum including `HEAD` / `OPTIONS`); objectui deliberately keeps the
+    5-value one (objectstack#4691).
+  - **`AppContextSelector.includeAll` / `placement` are gone.** Neither ever did
+    anything in this renderer: context selectors are mandatory-scope, so no "All"
+    row was ever rendered, and `placement: 'topbar'` put nothing in the topbar.
+    Both carried schema defaults, which is why the liveness lint structurally
+    could not flag them — removal was the only channel that reaches an author
+    (framework#4509).
+  - **`NavigationArea.visible` / `order` / `requiredPermissions` are gone.** An
+    area is a layout grouping, not an access boundary. Gating moved down to the
+    navigation ITEM, where `visible` and `requiredPermissions` are unchanged and
+    still enforced. `AppSchemaRenderer`'s area switcher no longer hides an area, so
+    an area whose items are all gated away renders as visible-but-empty rather
+    than disappearing.
+  - **`@object-ui/core` no longer exports `NotificationProtocol`**
+    (`resolveNotificationConfig`, `specNotificationToToast`, `mapSeverityToVariant`,
+    `mapPosition`, `ToastNotification`). It bridged `@objectstack/spec/ui`'s
+    `Notification` / `NotificationConfig`, which objectstack#4610 deleted with no
+    successor. Use `resolveNotificationConfig` from `@object-ui/react`
+    (`NotificationContext`), which owns the live `NotificationSystemConfig` and is
+    what every notification surface already read. Note that the spec's _other_
+    `Notification` — `@objectstack/spec/api` — is the REST inbox row, a different
+    contract, and is deliberately NOT aliased in as a replacement.
+  - **The `email_template` client-side validator now uses
+    `EmailTemplateDefinitionSchema`.** It was pointing at the removed
+    `EmailTemplateSchema`, so authored templates were being checked against the
+    wrong contract: the live one is keyed `name` + `locale` (not `id`) and splits
+    the body into `bodyHtml` / `bodyText` (not `body` + `bodyType`)
+    (objectstack#4616 / #4807).
+
+  Fixes that are not breaking, but were only found because rc.2 stopped being
+  lenient — each had been passing vacuously:
+
+  - **`view` drafts are actually validated now.** The client validator named the
+    aggregated container schema while this admin authors first-class `ViewItem`s,
+    and the container used to strip `viewKind` / `config` in silence — so no view
+    draft ever had one of its own keys checked. It now validates each shape
+    against its own schema (objectui#3312).
+  - **The console's worked examples were wrong**, and being stripped rather than
+    refused: `view.list.object` (the container root already declares it),
+    `job.concurrency` / `job.timeoutMs` (no such keys; the spelling is `timeout`,
+    already in ms), `email_template.from` / `.to` (a template is not a send —
+    the sender override is `fromOverride`, an object), and
+    `datasource.capabilities` / `.healthCheck` (objectstack#4583 removed the
+    former; the latter was never a datasource key). These are the drafts an
+    author — or a model generating metadata — copies.
+  - Action key inventory re-derived: `ActionSchema` gained the package-lock
+    envelope (`_lock*` / `_package*` / `_provenance`), so a packaged action no
+    longer reports them as unknown keys.
+  - The schema-diff panel labels the new `default_mismatch` finding.
+  - Test fixtures pinning the retired `managedBy: 'system'` bucket now use
+    `engine-owned`. Protocol 17 split that value (objectstack#3355), so it
+    resolved to the default-writable fallback and a batch of "stays locked"
+    assertions had quietly stopped asserting anything.
+
+### Patch Changes
+
+- Updated dependencies [18cd432]
+- Updated dependencies [d915c47]
+- Updated dependencies [5781fb1]
+- Updated dependencies [9e9e9a9]
+- Updated dependencies [23018cc]
+- Updated dependencies [d915c47]
+- Updated dependencies [f44d872]
+- Updated dependencies [509104a]
+- Updated dependencies [a4cff5b]
+- Updated dependencies [f833d3a]
+- Updated dependencies [2a9513d]
+- Updated dependencies [d22ae31]
+  - @object-ui/core@17.3.0
+  - @object-ui/types@17.3.0
+
 ## 17.2.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -76,6 +76,7 @@ function errorCodeIsAnyOf(err, codes) {
 }
 
 // ../core/src/utils/filter-converter.ts
+var import_ui = require("@objectstack/spec/ui");
 var FilterOperatorError = class extends Error {
   constructor(message) {
     super(message);
@@ -1504,7 +1505,7 @@ var FILTER_OPERATOR_ALIASES = {
   before: "<",
   after: ">"
 };
-function normalizeFilterOperator(op) {
+function normalizeFilterOperator2(op) {
   if (typeof op !== "string") return null;
   const lower = op.toLowerCase();
   return FILTER_OPERATOR_ALIASES[lower] ?? FILTER_OPERATOR_ALIASES[op] ?? op;
@@ -1533,7 +1534,7 @@ function objectFilterEntryToAST(entry) {
   if (!entry || typeof entry !== "object") return null;
   const field = entry.field;
   const rawOp = entry.operator ?? entry.op ?? "=";
-  const op = normalizeFilterOperator(rawOp);
+  const op = normalizeFilterOperator2(rawOp);
   if (!field || !op) return null;
   return [String(field), op, entry.value];
 }
@@ -1751,6 +1752,31 @@ function stableStringify(value) {
   const keys = Object.keys(obj).sort();
   return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
 }
+function sameWireValue(a, b) {
+  if (a === b) return true;
+  const aEmpty = a === null || a === void 0;
+  const bEmpty = b === null || b === void 0;
+  if (aEmpty || bEmpty) return aEmpty && bEmpty;
+  return stableStringify(a) === stableStringify(b);
+}
+function withoutNoOpDrops(droppedFields, sent, stored) {
+  if (!sent || !stored || typeof sent !== "object" || typeof stored !== "object") {
+    return droppedFields;
+  }
+  const out = [];
+  for (const e of droppedFields) {
+    const kept = e.fields.filter((f) => {
+      if (!Object.prototype.hasOwnProperty.call(sent, f)) return true;
+      if (!Object.prototype.hasOwnProperty.call(stored, f)) return true;
+      return !sameWireValue(
+        sent[f],
+        stored[f]
+      );
+    });
+    if (kept.length > 0) out.push({ ...e, fields: kept });
+  }
+  return out;
+}
 var ObjectStackAdapter = class {
   constructor(config) {
     __publicField(this, "client");
@@ -2127,12 +2153,14 @@ var ObjectStackAdapter = class {
    * whose response type predates `droppedFields`: the field is read structurally
    * and validated, so an older client (or a backend that never drops) is a no-op.
    */
-  notifyDroppedFields(operation, resource, result, id) {
+  notifyDroppedFields(operation, resource, result, id, sent) {
     const dropped = result?.droppedFields;
     if (!Array.isArray(dropped) || dropped.length === 0) return;
-    const droppedFields = dropped.filter(
+    const valid = dropped.filter(
       (e) => !!e && typeof e === "object" && Array.isArray(e.fields) && e.fields.length > 0
     );
+    const stored = result?.record;
+    const droppedFields = withoutNoOpDrops(valid, sent, stored);
     if (droppedFields.length === 0) return;
     this.emitWriteWarning({ operation, resource, ...id !== void 0 ? { id } : {}, droppedFields });
   }
@@ -2151,17 +2179,25 @@ var ObjectStackAdapter = class {
   notifyBatchDroppedFields(operations, payload) {
     const dropped = payload?.droppedFields;
     if (!Array.isArray(dropped) || dropped.length === 0) return;
+    const results = payload?.results;
     for (const entry of dropped) {
       if (!entry || typeof entry !== "object") continue;
       const e = entry;
       if (!Array.isArray(e.fields) || e.fields.length === 0) continue;
       const op = typeof e.index === "number" ? operations[e.index] : void 0;
+      const stored = typeof e.index === "number" && Array.isArray(results) ? results[e.index] : void 0;
+      const [live] = withoutNoOpDrops(
+        [{ object: e.object, fields: e.fields, reason: e.reason }],
+        op?.data,
+        stored
+      );
+      if (!live) continue;
       const operation = (op?.action ?? "create") === "create" ? "create" : "update";
       this.emitWriteWarning({
         operation,
         resource: e.object ?? op?.object ?? "",
         ...op?.id !== void 0 && op?.id !== null ? { id: op.id } : {},
-        droppedFields: [{ object: e.object, fields: e.fields, reason: e.reason }]
+        droppedFields: [live]
       });
     }
   }
@@ -2181,7 +2217,13 @@ var ObjectStackAdapter = class {
     try {
       const result = await this.client.data.create(resource, data);
       this.emitMutation({ type: "create", resource, record: { ...result.record } });
-      this.notifyDroppedFields("create", resource, result, result.record?.id);
+      this.notifyDroppedFields(
+        "create",
+        resource,
+        result,
+        result.record?.id,
+        data
+      );
       return result.record;
     } catch (err) {
       throw normaliseClientError(err);
@@ -2208,7 +2250,7 @@ var ObjectStackAdapter = class {
         opts?.ifMatch ? { ifMatch: opts.ifMatch } : void 0
       );
       this.emitMutation({ type: "update", resource, id, record: { ...result.record } });
-      this.notifyDroppedFields("update", resource, result, id);
+      this.notifyDroppedFields("update", resource, result, id, data);
       return result.record;
     } catch (err) {
       throw normaliseClientError(err);

package/dist/index.js

@@ -23,6 +23,7 @@ function errorCodeIsAnyOf(err, codes) {
 }
 
 // ../core/src/utils/filter-converter.ts
+import { normalizeFilterOperator } from "@objectstack/spec/ui";
 var FilterOperatorError = class extends Error {
   constructor(message) {
     super(message);
@@ -1451,7 +1452,7 @@ var FILTER_OPERATOR_ALIASES = {
   before: "<",
   after: ">"
 };
-function normalizeFilterOperator(op) {
+function normalizeFilterOperator2(op) {
   if (typeof op !== "string") return null;
   const lower = op.toLowerCase();
   return FILTER_OPERATOR_ALIASES[lower] ?? FILTER_OPERATOR_ALIASES[op] ?? op;
@@ -1480,7 +1481,7 @@ function objectFilterEntryToAST(entry) {
   if (!entry || typeof entry !== "object") return null;
   const field = entry.field;
   const rawOp = entry.operator ?? entry.op ?? "=";
-  const op = normalizeFilterOperator(rawOp);
+  const op = normalizeFilterOperator2(rawOp);
   if (!field || !op) return null;
   return [String(field), op, entry.value];
 }
@@ -1698,6 +1699,31 @@ function stableStringify(value) {
   const keys = Object.keys(obj).sort();
   return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
 }
+function sameWireValue(a, b) {
+  if (a === b) return true;
+  const aEmpty = a === null || a === void 0;
+  const bEmpty = b === null || b === void 0;
+  if (aEmpty || bEmpty) return aEmpty && bEmpty;
+  return stableStringify(a) === stableStringify(b);
+}
+function withoutNoOpDrops(droppedFields, sent, stored) {
+  if (!sent || !stored || typeof sent !== "object" || typeof stored !== "object") {
+    return droppedFields;
+  }
+  const out = [];
+  for (const e of droppedFields) {
+    const kept = e.fields.filter((f) => {
+      if (!Object.prototype.hasOwnProperty.call(sent, f)) return true;
+      if (!Object.prototype.hasOwnProperty.call(stored, f)) return true;
+      return !sameWireValue(
+        sent[f],
+        stored[f]
+      );
+    });
+    if (kept.length > 0) out.push({ ...e, fields: kept });
+  }
+  return out;
+}
 var ObjectStackAdapter = class {
   constructor(config) {
     __publicField(this, "client");
@@ -2074,12 +2100,14 @@ var ObjectStackAdapter = class {
    * whose response type predates `droppedFields`: the field is read structurally
    * and validated, so an older client (or a backend that never drops) is a no-op.
    */
-  notifyDroppedFields(operation, resource, result, id) {
+  notifyDroppedFields(operation, resource, result, id, sent) {
     const dropped = result?.droppedFields;
     if (!Array.isArray(dropped) || dropped.length === 0) return;
-    const droppedFields = dropped.filter(
+    const valid = dropped.filter(
       (e) => !!e && typeof e === "object" && Array.isArray(e.fields) && e.fields.length > 0
     );
+    const stored = result?.record;
+    const droppedFields = withoutNoOpDrops(valid, sent, stored);
     if (droppedFields.length === 0) return;
     this.emitWriteWarning({ operation, resource, ...id !== void 0 ? { id } : {}, droppedFields });
   }
@@ -2098,17 +2126,25 @@ var ObjectStackAdapter = class {
   notifyBatchDroppedFields(operations, payload) {
     const dropped = payload?.droppedFields;
     if (!Array.isArray(dropped) || dropped.length === 0) return;
+    const results = payload?.results;
     for (const entry of dropped) {
       if (!entry || typeof entry !== "object") continue;
       const e = entry;
       if (!Array.isArray(e.fields) || e.fields.length === 0) continue;
       const op = typeof e.index === "number" ? operations[e.index] : void 0;
+      const stored = typeof e.index === "number" && Array.isArray(results) ? results[e.index] : void 0;
+      const [live] = withoutNoOpDrops(
+        [{ object: e.object, fields: e.fields, reason: e.reason }],
+        op?.data,
+        stored
+      );
+      if (!live) continue;
       const operation = (op?.action ?? "create") === "create" ? "create" : "update";
       this.emitWriteWarning({
         operation,
         resource: e.object ?? op?.object ?? "",
         ...op?.id !== void 0 && op?.id !== null ? { id: op.id } : {},
-        droppedFields: [{ object: e.object, fields: e.fields, reason: e.reason }]
+        droppedFields: [live]
       });
     }
   }
@@ -2128,7 +2164,13 @@ var ObjectStackAdapter = class {
     try {
       const result = await this.client.data.create(resource, data);
       this.emitMutation({ type: "create", resource, record: { ...result.record } });
-      this.notifyDroppedFields("create", resource, result, result.record?.id);
+      this.notifyDroppedFields(
+        "create",
+        resource,
+        result,
+        result.record?.id,
+        data
+      );
       return result.record;
     } catch (err) {
       throw normaliseClientError(err);
@@ -2155,7 +2197,7 @@ var ObjectStackAdapter = class {
         opts?.ifMatch ? { ifMatch: opts.ifMatch } : void 0
       );
       this.emitMutation({ type: "update", resource, id, record: { ...result.record } });
-      this.notifyDroppedFields("update", resource, result, id);
+      this.notifyDroppedFields("update", resource, result, id, data);
       return result.record;
     } catch (err) {
       throw normaliseClientError(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/data-objectstack",
-  "version": "17.2.0",
+  "version": "17.3.0",
   "description": "ObjectStack Data Adapter for Object UI",
   "license": "MIT",
   "type": "module",
@@ -22,10 +22,10 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@objectstack/client": "^17.0.0-rc.1",
-    "@objectstack/spec": "^17.0.0-rc.1",
-    "@object-ui/core": "17.2.0",
-    "@object-ui/types": "17.2.0"
+    "@objectstack/client": "^17.0.0-rc.2",
+    "@objectstack/spec": "^17.0.0-rc.2",
+    "@object-ui/core": "17.3.0",
+    "@object-ui/types": "17.3.0"
   },
   "devDependencies": {
     "tsup": "^8.5.1",

package/src/index.ts

@@ -771,9 +771,68 @@ function stableStringify(value: unknown): string {
   return `{${keys.map(k => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(',')}}`;
 }
 
+/**
+ * Whether two values are the SAME as far as the wire is concerned — used to
+ * tell a write-strip that lost something from one that lost nothing
+ * (objectui#3484).
+ *
+ * Deliberately strict: `1` and `'1'` are NOT the same here. A false "these are
+ * equal" silently swallows a warning about a value the user really did lose,
+ * which is the worse of the two errors; a false "these differ" only warns
+ * about a no-op. `null` and `undefined` both mean "empty" and do match.
+ */
+function sameWireValue(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  const aEmpty = a === null || a === undefined;
+  const bEmpty = b === null || b === undefined;
+  if (aEmpty || bEmpty) return aEmpty && bEmpty;
+  return stableStringify(a) === stableStringify(b);
+}
+
+/**
+ * Drop the fields whose strip changed nothing — the caller supplied exactly
+ * the value the record already holds (objectui#3484).
+ *
+ * The server is not wrong to report those: the client DID send the key and the
+ * engine DID refuse to write it, so `droppedFields` is an accurate account of
+ * the request. But "was not saved" is only news when something was actually
+ * lost, and the console's edit form used to round-trip the whole record —
+ * including fields it had itself rendered as read-only text — so every save of
+ * a state-locked record raised a warning listing fields the user never touched
+ * and whose values never changed.
+ *
+ * A field is kept (still warned about) whenever the no-op cannot be PROVEN:
+ * the response echoed no record, or that record does not carry the key.
+ *
+ * Returns entries with empty `fields` removed; an all-no-op event list comes
+ * back empty, which suppresses the warning entirely.
+ */
+function withoutNoOpDrops(
+  droppedFields: DroppedFieldsEvent[],
+  sent: Record<string, unknown> | undefined | null,
+  stored: Record<string, unknown> | undefined | null,
+): DroppedFieldsEvent[] {
+  if (!sent || !stored || typeof sent !== 'object' || typeof stored !== 'object') {
+    return droppedFields;
+  }
+  const out: DroppedFieldsEvent[] = [];
+  for (const e of droppedFields) {
+    const kept = e.fields.filter((f) => {
+      if (!Object.prototype.hasOwnProperty.call(sent, f)) return true;
+      if (!Object.prototype.hasOwnProperty.call(stored, f)) return true;
+      return !sameWireValue(
+        (sent as Record<string, unknown>)[f],
+        (stored as Record<string, unknown>)[f],
+      );
+    });
+    if (kept.length > 0) out.push({ ...e, fields: kept });
+  }
+  return out;
+}
+
 /**
  * ObjectStack Data Source Adapter
- * 
+ *
  * Bridges the ObjectStack Client SDK with the ObjectUI DataSource interface.
  * This allows Object UI applications to seamlessly integrate with ObjectStack
  * backends while maintaining the universal DataSource abstraction.
@@ -1309,13 +1368,17 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     resource: string,
     result: unknown,
     id?: string | number,
+    sent?: Record<string, unknown> | null,
   ): void {
     const dropped = (result as { droppedFields?: unknown } | null | undefined)?.droppedFields;
     if (!Array.isArray(dropped) || dropped.length === 0) return;
-    const droppedFields = dropped.filter(
+    const valid = dropped.filter(
       (e): e is DroppedFieldsEvent =>
         !!e && typeof e === 'object' && Array.isArray((e as DroppedFieldsEvent).fields) && (e as DroppedFieldsEvent).fields.length > 0,
     );
+    // A strip that changed nothing is not news — see withoutNoOpDrops (#3484).
+    const stored = (result as { record?: Record<string, unknown> } | null | undefined)?.record;
+    const droppedFields = withoutNoOpDrops(valid, sent, stored);
     if (droppedFields.length === 0) return;
     this.emitWriteWarning({ operation, resource, ...(id !== undefined ? { id } : {}), droppedFields });
   }
@@ -1338,11 +1401,25 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
   ): void {
     const dropped = (payload as { droppedFields?: unknown } | null | undefined)?.droppedFields;
     if (!Array.isArray(dropped) || dropped.length === 0) return;
+    const results = (payload as { results?: unknown[] } | null | undefined)?.results;
     for (const entry of dropped) {
       if (!entry || typeof entry !== 'object') continue;
       const e = entry as DroppedFieldsEvent & { index?: number };
       if (!Array.isArray(e.fields) || e.fields.length === 0) continue;
       const op = typeof e.index === 'number' ? operations[e.index] : undefined;
+      // Same no-op suppression as the single-record path (#3484). The echoed
+      // row for the originating op is the "stored" side; when the batch echoed
+      // nothing usable, `withoutNoOpDrops` keeps every field.
+      const stored =
+        typeof e.index === 'number' && Array.isArray(results)
+          ? (results[e.index] as Record<string, unknown> | undefined)
+          : undefined;
+      const [live] = withoutNoOpDrops(
+        [{ object: e.object, fields: e.fields, reason: e.reason }],
+        op?.data as Record<string, unknown> | undefined,
+        stored,
+      );
+      if (!live) continue;
       // `delete` never drops fields; anything unexpected reads as an update,
       // which is the truthful default for a batch that echoed a strip.
       const operation: 'create' | 'update' = (op?.action ?? 'create') === 'create' ? 'create' : 'update';
@@ -1350,7 +1427,7 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
         operation,
         resource: e.object ?? op?.object ?? '',
         ...(op?.id !== undefined && op?.id !== null ? { id: op.id } : {}),
-        droppedFields: [{ object: e.object, fields: e.fields, reason: e.reason }],
+        droppedFields: [live],
       });
     }
   }
@@ -1372,7 +1449,13 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     try {
       const result = await this.client.data.create<T>(resource, data);
       this.emitMutation({ type: 'create', resource, record: { ...result.record } });
-      this.notifyDroppedFields('create', resource, result, (result.record as { id?: string | number } | undefined)?.id);
+      this.notifyDroppedFields(
+        'create',
+        resource,
+        result,
+        (result.record as { id?: string | number } | undefined)?.id,
+        data as Record<string, unknown>,
+      );
       return result.record;
     } catch (err) {
       // `update` has always normalised; `create` did not, so a rejected insert
@@ -1409,7 +1492,7 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
         opts?.ifMatch ? { ifMatch: opts.ifMatch } : undefined,
       );
       this.emitMutation({ type: 'update', resource, id, record: { ...result.record } });
-      this.notifyDroppedFields('update', resource, result, id);
+      this.notifyDroppedFields('update', resource, result, id, data as Record<string, unknown>);
       return result.record;
     } catch (err) {
       throw normaliseClientError(err);

package/src/onWriteWarning.test.ts

@@ -157,6 +157,107 @@ describe('ObjectStackAdapter.onWriteWarning', () => {
     expect(events).toHaveLength(1);
   });
 
+  // ── no-op strips are not news (objectui#3484) ─────────────────────────────
+  //
+  // The server is right to report a strip — the client DID send the key. But
+  // "was not saved" is only worth a toast when something was LOST. The console
+  // edit form used to round-trip the whole record, so every save of a
+  // state-locked record warned about fields the user never touched whose values
+  // never changed. When the echoed record proves the stripped value equals what
+  // was sent, stay quiet.
+
+  it('suppresses the warning when every stripped value equals what the record already holds', async () => {
+    const update = vi.fn().mockResolvedValue({
+      record: { id: 'r1', type: 'quality_abnormal', source_method: 'qc_judgment', title: 'B' },
+      droppedFields: [
+        { object: 'andon', fields: ['type', 'source_method'], reason: 'readonly_when' },
+      ],
+    });
+    const ds = makeDS({ update });
+    const events: WriteWarningEvent[] = [];
+    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
+
+    await ds.update('andon', 'r1', {
+      title: 'B',
+      type: 'quality_abnormal',
+      source_method: 'qc_judgment',
+    });
+
+    expect(events).toEqual([]);
+  });
+
+  it('still warns about the fields that really did change, and only those', async () => {
+    const update = vi.fn().mockResolvedValue({
+      record: { id: 'r1', type: 'quality_abnormal', source_method: 'qc_judgment' },
+      droppedFields: [
+        { object: 'andon', fields: ['type', 'source_method'], reason: 'readonly_when' },
+      ],
+    });
+    const ds = makeDS({ update });
+    const events: WriteWarningEvent[] = [];
+    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
+
+    // The user really did try to change `type`; `source_method` round-tripped.
+    await ds.update('andon', 'r1', { type: 'equipment_fault', source_method: 'qc_judgment' });
+
+    expect(events).toEqual([
+      {
+        operation: 'update',
+        resource: 'andon',
+        id: 'r1',
+        droppedFields: [{ object: 'andon', fields: ['type'], reason: 'readonly_when' }],
+      },
+    ]);
+  });
+
+  it('keeps the warning when the no-op cannot be PROVEN (record echo lacks the key)', async () => {
+    const update = vi.fn().mockResolvedValue({
+      record: { id: 'r1' },
+      droppedFields: [{ object: 'andon', fields: ['type'], reason: 'readonly_when' }],
+    });
+    const ds = makeDS({ update });
+    const events: WriteWarningEvent[] = [];
+    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
+
+    await ds.update('andon', 'r1', { type: 'quality_abnormal' });
+
+    expect(events).toHaveLength(1);
+  });
+
+  it('does not treat a type change as a no-op (1 is not "1")', async () => {
+    const update = vi.fn().mockResolvedValue({
+      record: { id: 'r1', tax_rate: '9' },
+      droppedFields: [{ object: 'invoice', fields: ['tax_rate'], reason: 'readonly_when' }],
+    });
+    const ds = makeDS({ update });
+    const events: WriteWarningEvent[] = [];
+    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
+
+    await ds.update('invoice', 'r1', { tax_rate: 9 });
+
+    expect(events).toHaveLength(1);
+  });
+
+  it('suppresses a no-op strip on the cross-object batch path too', async () => {
+    const batchTransaction = vi.fn().mockResolvedValue({
+      results: [{ id: 'acc1' }, { id: 'inv1', tax_rate: 9 }],
+      droppedFields: [
+        { object: 'invoice', fields: ['tax_rate'], reason: 'readonly_when', index: 1 },
+      ],
+    });
+    const ds = makeDS({ batchTransaction });
+    ds.atomicBatchCapability = true;
+    const events: WriteWarningEvent[] = [];
+    ds.onWriteWarning((e: WriteWarningEvent) => events.push(e));
+
+    await ds.batchTransaction([
+      { object: 'account', action: 'create', data: { name: 'Acme' } },
+      { object: 'invoice', action: 'update', id: 'inv1', data: { status: 'paid', tax_rate: 9 } },
+    ]);
+
+    expect(events).toEqual([]);
+  });
+
   it('isolates a throwing listener so the write still resolves and other listeners fire', async () => {
     const update = vi.fn().mockResolvedValue({ record: { id: 'r1' }, droppedFields: ONE_DROP });
     const ds = makeDS({ update });

package/src/spec-symbol-batch6.test.ts

@@ -57,10 +57,13 @@ import type { DroppedFieldsEvent } from './index';
 import type { DroppedFieldsEvent as SpecDroppedFieldsEvent } from '@objectstack/spec/data';
 import type { CacheStats as SpecCacheStats } from '@objectstack/spec/contracts';
 import type {
-  MetadataSaveOptions as SpecMetadataSaveOptions,
   SecurityPolicy as SpecSecurityPolicy,
   ValidationError as SpecValidationError,
 } from '@objectstack/spec/kernel';
+// `MetadataSaveOptions` moved `./kernel` → `./system` in spec 17.0.0-rc.2.
+// The name still belongs to the spec and still means the FILE writer, so the
+// rename this batch recorded stands — only the entry point moved.
+import type { MetadataSaveOptions as SpecMetadataSaveOptions } from '@objectstack/spec/system';
 
 const PROBE_OPTIONS: ts.CompilerOptions = {
   noEmit: true,