Preserve default literals via the SQL family preserve-empty hook

The lint:framework-vocabulary ratchet (new on main) rightly rejects the
previous shape: a full storage path (entries.table.*.columns) in the
family-blind framework canonicalizer is SQL vocabulary in the wrong
layer. The default-omission walk already consults the family
shouldPreserveEmpty hook for exactly this kind of veto, so the
default.value pattern moves into sqlContractCanonicalizationHooks
preserveEmptyPatterns and the framework core reverts to main byte-for-
byte. Behavior and hashes are unchanged: the same paths are preserved,
now family-owned; the framework tests exercise the mechanism through
the mirrored SQL patterns and a new family-level test pins the hook.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Signed-off-by: Søren Bramer Schmidt <sorenbs@gmail.com>

Author: sorenbs

packages/1-framework/0-foundation/contract/src/canonicalization.ts

@@ -62,18 +62,6 @@ const STORAGE_NAMESPACE_ENTRIES_PATTERN = [
   '*',
   'entries',
 ] as const satisfies PathPattern;
-const STORAGE_COLUMN_DEFAULT_VALUE_PATTERN = [
-  'storage',
-  'namespaces',
-  '*',
-  'entries',
-  'table',
-  '*',
-  'columns',
-  '*',
-  'default',
-  'value',
-] as const satisfies PathPattern;
 
 const TOP_LEVEL_ORDER = [
   'schemaVersion',
@@ -159,14 +147,6 @@ function omitDefaults(
 
       const isNullableField = key === 'nullable';
 
-      // A column default's literal payload is data, not schema shape —
-      // `{ kind: 'literal', value: false }` (or `value: []`) must survive
-      // canonicalization or the emitted contract fails validation on read.
-      const isDefaultLiteralValue = matchesPathPattern(
-        currentPath,
-        STORAGE_COLUMN_DEFAULT_VALUE_PATTERN,
-      );
-
       const isFamilyPreserved = shouldPreserveEmpty?.(currentPath) ?? false;
 
       if (
@@ -184,7 +164,6 @@ function omitDefaults(
         !isModelRelations &&
         !isModelStorage &&
         !isNullableField &&
-        !isDefaultLiteralValue &&
         !isFamilyPreserved
       ) {
         continue;

packages/1-framework/0-foundation/contract/test/canonicalization.test.ts

@@ -46,6 +46,7 @@ const sqlPreserveEmptyPatterns = [
   ['storage', 'namespaces', '*', 'entries', 'table', '*'],
   ['storage', 'namespaces', '*', 'entries', 'table', '*', ['uniques', 'indexes', 'foreignKeys']],
   ['storage', 'namespaces', '*', 'entries', 'table', '*', 'foreignKeys', ['constraint', 'index']],
+  ['storage', 'namespaces', '*', 'entries', 'table', '*', 'columns', '*', 'default', 'value'],
 ] as const satisfies readonly PathPattern[];
 
 const sqlSortTargets = [
@@ -333,7 +334,7 @@ describe('default omission', () => {
     expect(idField).not.toHaveProperty('generated');
   });
 
-  it('preserves a literal false column default value', () => {
+  it('preserves a literal false column default value via the family hook', () => {
     const result = canonicalizeContractToObject(
       minimal({
         storage: unboundStorage({
@@ -349,12 +350,13 @@ describe('default omission', () => {
           },
         }),
       }),
+      { shouldPreserveEmpty: sqlPreserveEmpty },
     );
     const done = drill(unboundTables(result), 'task', 'columns', 'done');
     expect(done['default']).toEqual({ kind: 'literal', value: false });
   });
 
-  it('preserves a literal empty-array column default value', () => {
+  it('preserves a literal empty-array column default value via the family hook', () => {
     const result = canonicalizeContractToObject(
       minimal({
         storage: unboundStorage({
@@ -370,6 +372,7 @@ describe('default omission', () => {
           },
         }),
       }),
+      { shouldPreserveEmpty: sqlPreserveEmpty },
     );
     const labels = drill(unboundTables(result), 'task', 'columns', 'labels');
     expect(labels['default']).toEqual({ kind: 'literal', value: [] });

packages/2-sql/1-core/contract/src/canonicalization-hooks.ts

@@ -11,6 +11,11 @@ const preserveEmptyPatterns = [
   ['storage', 'namespaces', '*', 'entries', 'table', '*'],
   ['storage', 'namespaces', '*', 'entries', 'table', '*', ['uniques', 'indexes', 'foreignKeys']],
   ['storage', 'namespaces', '*', 'entries', 'table', '*', 'foreignKeys', ['constraint', 'index']],
+  // A column default's literal payload is data, not shape — `{ kind:
+  // 'literal', value: false }` (or `value: []`) must survive the
+  // default-omission walk or the emitted contract fails its own
+  // validation on the next read (PN-CLI-4003 on `Boolean @default(false)`).
+  ['storage', 'namespaces', '*', 'entries', 'table', '*', 'columns', '*', 'default', 'value'],
 ] as const satisfies readonly PathPattern[];
 
 const sortTargets = [

packages/2-sql/1-core/contract/test/canonicalization-hooks.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { sqlContractCanonicalizationHooks } from '../src/canonicalization-hooks';
+
+describe('sqlContractCanonicalizationHooks.shouldPreserveEmpty', () => {
+  it('preserves a column default literal payload (false / empty-array defaults)', () => {
+    // `{ kind: 'literal', value: false }` reaches the default-omission walk
+    // as a default value; without this veto the emitted contract fails its
+    // own validation on the next read (PN-CLI-4003 on Boolean @default(false)).
+    expect(
+      sqlContractCanonicalizationHooks.shouldPreserveEmpty([
+        'storage',
+        'namespaces',
+        'unbound',
+        'entries',
+        'table',
+        'task',
+        'columns',
+        'done',
+        'default',
+        'value',
+      ]),
+    ).toBe(true);
+  });
+
+  it('does not preserve arbitrary domain-side values', () => {
+    expect(
+      sqlContractCanonicalizationHooks.shouldPreserveEmpty([
+        'domain',
+        'namespaces',
+        'unbound',
+        'models',
+        'Task',
+        'fields',
+        'done',
+      ]),
+    ).toBe(false);
+  });
+});