@ultimat3/entity 9.0.0 → 10.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultimat3/entity",
-  "version": "9.0.0",
+  "version": "10.0.0",
   "description": "A table + its domain type + invariants the database also enforces",
   "license": "MIT",
   "type": "module",
@@ -31,9 +31,9 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ultimat3/core": "9.0.0",
-    "@ultimat3/db": "9.0.0",
-    "@ultimat3/schema": "9.0.0",
-    "@ultimat3/time": "9.0.0"
+    "@ultimat3/core": "10.0.0",
+    "@ultimat3/db": "10.0.0",
+    "@ultimat3/schema": "10.0.0",
+    "@ultimat3/time": "10.0.0"
   }
 }

package/src/entity.ts

@@ -3,6 +3,7 @@
 // (the typed db handle, migrations, cache tags, the admin UI, the manifest) is projected from
 // this one call.
 
+import { renderThrowable } from '@ultimat3/core';
 import { describeValue, type StandardSchemaV1 } from '@ultimat3/schema';
 import { entityNow } from './clock';
 import { assertColumnName, bindColumn, columnName, moneyColumns } from './column';
@@ -284,9 +285,13 @@ export const entity = <const C extends ColumnMap>(
           try {
             return { value: parse(value) };
           } catch (error) {
-            return {
-              issues: [{ message: error instanceof Error ? error.message : String(error) }],
-            };
+            // `renderThrowable`, never `error instanceof Error ? error.message : String(error)`:
+            // both halves of that read the caught value directly. `instanceof` consults
+            // `getPrototypeOf` and `String()` runs the value's own coercion, so a `Proxy` or a
+            // null-prototype throwable raised a SECOND, uncatchable `TypeError` out of the
+            // validator — where a rejection belongs. A column parser is app-reachable and an
+            // app's `$parse` may throw anything at all.
+            return { issues: [{ message: renderThrowable(error) }] };
           }
         },
       },

package/src/errors.ts

@@ -61,6 +61,14 @@ registerErrorCodes(
   Object.fromEntries(Object.entries(ENTITY_ERROR_TITLES).map(([code, title]) => [code, { title }])),
 );
 
+/**
+ * Base for every error this package throws. No `docs:` — `UltimateError` fills it from
+ * `describeErrorCode(code).docs`, which is `@ultimat3/core`'s `ERROR_DOCS_URL`: one page for every
+ * code, never one per code, because `wiki/` is the framework's only public documentation surface
+ * and a code lives there in a TABLE ROW, which has no anchor. The
+ * `https://ultimate.dev/errors/<code>` links this class built until 9.x answered 404, host
+ * included, on every refusal it has ever raised.
+ */
 export class EntityError extends UltimateError {
   override readonly name = 'EntityError';
 
@@ -69,7 +77,6 @@ export class EntityError extends UltimateError {
       code: init.code,
       cause: init.cause,
       fix: init.fix,
-      docs: `https://ultimate.dev/errors/${init.code}`,
     });
   }
 }

package/src/view.ts

@@ -3,6 +3,7 @@
 // already describe. Values are validated by the entity's own column parsers; an unknown key is a
 // declaration-time failure, not a surprise on the first request.
 
+import { renderThrowable } from '@ultimat3/core';
 import { describeValue, type StandardSchemaV1 } from '@ultimat3/schema';
 import { invariantViolated } from './errors';
 import type { AnyColumn, ColumnMap } from './types';
@@ -83,9 +84,10 @@ export const viewFor = <Row, K extends keyof Row & string>(
         try {
           return { value: parse(value) };
         } catch (error) {
-          return {
-            issues: [{ message: error instanceof Error ? error.message : String(error) }],
-          };
+          // The entity's rule, for the same reason: `instanceof` and `String()` are both reads of
+          // a caught value, and a throwable that fights being read turned a rejected projection
+          // into an uncatchable `TypeError`. `renderThrowable` is total.
+          return { issues: [{ message: renderThrowable(error) }] };
         }
       },
     },