@ultimat3/action 19.1.2 → 19.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultimat3/action",
-  "version": "19.1.2",
+  "version": "19.2.0",
   "description": "The action primitive: one declaration projected to route, OpenAPI, client, MCP tool, job handle, tests",
   "license": "MIT",
   "type": "module",
@@ -34,10 +34,10 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ultimat3/cache": "19.1.2",
-    "@ultimat3/core": "19.1.2",
-    "@ultimat3/http": "19.1.2",
-    "@ultimat3/policy": "19.1.2",
-    "@ultimat3/schema": "19.1.2"
+    "@ultimat3/cache": "19.2.0",
+    "@ultimat3/core": "19.2.0",
+    "@ultimat3/http": "19.2.0",
+    "@ultimat3/policy": "19.2.0",
+    "@ultimat3/schema": "19.2.0"
   }
 }

package/src/client.ts

@@ -10,7 +10,7 @@
  * and the way that is guaranteed is that `keyFor` is never called here.
  */
 import type { ClientFlight, ClientRetry, UltimateError, WireAnswer } from '@ultimat3/core';
-import { FRAMEWORK_CODE, problemOf, traceHeaders } from '@ultimat3/core';
+import { FRAMEWORK_CODE, isJsonObject, problemOf, traceHeaders } from '@ultimat3/core';
 import type { InferInput, InferOutput, StandardSchemaV1 } from '@ultimat3/schema';
 import type { Action } from './action';
 import { ContractDriftError, RemoteActionError, RpcFailedError } from './errors';
@@ -216,6 +216,7 @@ function toUltimateError(text: string, status: number, name: string): UltimateEr
     // Parsed, never taken: `body` is whatever answered the request. A list this build cannot read
     // is dropped rather than repaired, and `cause` below still carries every rejection in it.
     issues: issuesFromWire(body['issues']),
+    meta: metaFromWire(body['meta']),
     cause: stringOr(body['cause'] ?? body['detail'], `${name} failed with ${status}`),
     fix: stringOr(body['fix'], `x actions describe ${name} --json`),
     // RFC-9457's `type` IS a documentation URI, so a server that sends no `docs` extension has
@@ -226,6 +227,31 @@ function toUltimateError(text: string, status: number, name: string): UltimateEr
   });
 }
 
+/**
+ * The document's `meta` member, or nothing. Parsed JSON is JSON-safe by construction, so the only
+ * work is shape: an object, copied own key by own key onto a fresh record. `issues` is skipped
+ * because it has its own reader and its own bound one line up, and `__proto__` because
+ * `JSON.parse` mints it as a real own key — copied by assignment it would replace the prototype
+ * of the error's `meta`, which the reporter and the overlay walk. EMPTY is `undefined`: an
+ * `{}` under `meta` would say the server declared keys and sent none.
+ */
+function metaFromWire(value: unknown): Readonly<Record<string, unknown>> | undefined {
+  if (!isJsonObject(value)) return undefined;
+  const out: Record<string, unknown> = {};
+  let carried = 0;
+  for (const [key, member] of Object.entries(value)) {
+    if (key === 'issues' || key === '__proto__') continue;
+    Object.defineProperty(out, key, {
+      value: member,
+      writable: true,
+      enumerable: true,
+      configurable: true,
+    });
+    carried += 1;
+  }
+  return carried === 0 ? undefined : out;
+}
+
 function nonEmpty(value: unknown): string | undefined {
   return typeof value === 'string' && value.length > 0 ? value : undefined;
 }

package/src/errors.ts

@@ -260,6 +260,12 @@ export interface RemoteFailure {
    * refuses to read, and in both cases `cause` still holds every rejection.
    */
   readonly issues?: readonly ValidationIssue[] | undefined;
+  /**
+   * The document's `meta` member — the keys the server's `registerProblemMeta` declared for the
+   * code, already read as a plain JSON object by `client.ts`. Carried onto the error's own `meta`
+   * so an island reads `error.meta.sessionId` where it used to run a regex over `cause`.
+   */
+  readonly meta?: Readonly<Record<string, unknown>> | undefined;
 }
 
 /** A link, not a string the server happened to put in a field the overlay renders as an href. */
@@ -314,6 +320,10 @@ export class RemoteActionError extends UltimateError {
       // `terminal` on the one field the framework promises a client never has to infer.
       retry: retryForStatus(failure.code, failure.status),
       meta: {
+        // The server's declared keys FIRST, so the four this class owns win a collision: a server
+        // meta naming `status` would otherwise overwrite the one a report reads the HTTP status
+        // from, and `origin: 'remote'` is what marks the code as one this bundle never declared.
+        ...failure.meta,
         origin: 'remote',
         action: failure.action,
         status: failure.status,