@@ -48,7 +48,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { FieldSchema, ObjectSchema } from '@objectstack/spec/data';
+import { FieldSchema, ObjectSchema, referenceTargetOf } from '@objectstack/spec/data';
 import { ObjectQL } from './engine.js';
 
 type Row = Record<string, unknown>;
@@ -494,6 +494,17 @@ describe('[#23065] a tree field that names no reference is a reference to its ow
     expect(driver.rolledBack).toHaveLength(0);
   });
 
+  it('an empty-string reference is not written over: it reaches the registry as written, and names nothing', async () => {
+    // The parse refuses `reference: ''` on a tree (`refuseForeignTreeReference`),
+    // so the registry, which never parses, must not repair it into a valid
+    // self-reference: the two doors give the shape one reading. The carrier
+    // reader then reads it as naming nothing, as it did before.
+    const { engine } = await makeEngine([treeObject('zr_empty', { type: 'tree', reference: '' })]);
+    const parent = (engine.registry.getObject('zr_empty') as any)?.fields?.parent;
+    expect(parent?.reference).toBe('');
+    expect(referenceTargetOf(parent)).toBeUndefined();
+  });
+
   it('CONTROL: a tree that wrote its own name registers exactly as written', async () => {
     const { engine } = await makeEngine([treeObject('zr_written', { type: 'tree', reference: 'zr_written' })]);
     expect((engine.registry.getObject('zr_written') as any)?.fields?.parent?.reference).toBe('zr_written');
 
@@ -1670,11 +1670,20 @@ function refuseForeignTreeReference(ownName: unknown, fields: unknown, ctx: z.Re
  *    save stores the authored body verbatim and a raw registration is never
  *    parsed, and both reach the registry without the parse's output.
  *
- * Absence is what `referenceCarrierOf` reads as absence — `undefined`, `null`
- * or `''` — so the carrier reader and this materialization agree on which
- * fields name nothing. A present value is returned untouched: a foreign one is
- * `refuseForeignTreeReference`'s to refuse, and a non-string one is the carrier
- * reader's to refuse loudly. The key lands at its `FieldSchema` shape position,
+ * Absence is the two spellings a contract admits for "names no target":
+ * `undefined` (what `FieldSchema`'s `.optional()` admits) and `null` (what the
+ * blueprint's `StrictField` admits). Every other value is returned untouched,
+ * so the two doors cannot disagree about it:
+ *
+ *  - `''` is NOT absence here. The parse refuses it on a `tree` as a foreign
+ *    target (`refuseForeignTreeReference` passes only an absent key or the own
+ *    name), so the registry leaves it as written rather than repairing,
+ *    unparsed, a value the contract refuses; the carrier reader then reads it
+ *    as naming nothing, exactly as before this helper existed;
+ *  - a foreign name is `refuseForeignTreeReference`'s to refuse, and a
+ *    non-string value is the carrier reader's to refuse loudly.
+ *
+ * The key lands at its `FieldSchema` shape position,
  * so a parsed referenceless `tree` is byte-identical to one that wrote its own
  * name, and a re-parse is a no-op.
  *
@@ -1691,7 +1700,7 @@ export function materializeTreeSelfReferences<F>(ownName: unknown, fields: F): F
   for (const [fieldName, def] of Object.entries(fields as Record<string, unknown>)) {
     if (def === null || typeof def !== 'object') continue;
     const { type, reference } = def as { type?: unknown; reference?: unknown };
-    if (type !== 'tree' || !(reference === undefined || reference === null || reference === '')) continue;
+    if (type !== 'tree' || !(reference === undefined || reference === null)) continue;
     stamped ??= { ...(fields as Record<string, unknown>) };
     stamped[fieldName] = withReferenceAtShapePosition(def as Record<string, unknown>, ownName);
   }
 
@@ -221,31 +221,44 @@ describe('a referenceless `tree` is written as a self-reference by the doors tha
     expect(parsed.fields.f_text).not.toHaveProperty('reference');
   });
 
-  it('the helper: absence is the carrier reader\'s absence, a present value is untouched, nothing to write allocates nothing', () => {
+  it('the helper: absence is `undefined` or `null`, every other value is untouched, nothing to write allocates nothing', () => {
     const untouched = { name: { type: 'text' }, parent: { type: 'tree', reference: 'node' } };
     expect(materializeTreeSelfReferences('node', untouched)).toBe(untouched);
 
-    const absent = {
+    const fields = {
       a: { type: 'tree' },
       b: { type: 'tree', reference: null },
       c: { type: 'tree', reference: '' },
       d: { type: 'tree', reference: { object: 'node' } },
       e: { type: 'lookup' },
     };
-    const out = materializeTreeSelfReferences('node', absent) as Record<string, { reference?: unknown }>;
-    expect(out).not.toBe(absent);
-    expect([out.a.reference, out.b.reference, out.c.reference]).toEqual(['node', 'node', 'node']);
+    const out = materializeTreeSelfReferences('node', fields) as Record<string, { reference?: unknown }>;
+    expect(out).not.toBe(fields);
+    expect([out.a.reference, out.b.reference]).toEqual(['node', 'node']);
+    // `''` is not absence here: the parse refuses it on a tree (the pin below),
+    // so the helper leaves it as written instead of repairing it unparsed.
+    expect(out.c).toBe(fields.c);
     // A non-string carrier is the carrier reader's to refuse, loudly — never
     // overwritten here, where it would read as a valid self-reference.
-    expect(out.d.reference).toEqual({ object: 'node' });
-    expect(out.e).toBe(absent.e);
+    expect(out.d).toBe(fields.d);
+    expect(out.e).toBe(fields.e);
     // The input is not mutated.
-    expect(absent.a).toEqual({ type: 'tree' });
+    expect(fields.a).toEqual({ type: 'tree' });
+    // Only an empty string to look at: nothing is written, nothing allocated.
+    const onlyEmpty = { parent: { type: 'tree', reference: '' } };
+    expect(materializeTreeSelfReferences('node', onlyEmpty)).toBe(onlyEmpty);
 
     // No name, or no field map, is nothing to write against.
-    expect(materializeTreeSelfReferences(undefined, absent)).toBe(absent);
-    expect(materializeTreeSelfReferences('', absent)).toBe(absent);
+    expect(materializeTreeSelfReferences(undefined, fields)).toBe(fields);
+    expect(materializeTreeSelfReferences('', fields)).toBe(fields);
     const list = [{ name: 'parent', type: 'tree' }];
     expect(materializeTreeSelfReferences('node', list)).toBe(list);
   });
+
+  it('`reference: \'\'` on a tree has one reading: the parse refuses it, and nothing writes over it', () => {
+    const parsed = ObjectSchema.safeParse(zoo(''));
+    expect(parsed.success).toBe(false);
+    if (parsed.success) return;
+    expect(parsed.error.issues.map((i) => i.path)).toEqual([['fields', 'f_tree', 'reference']]);
+  });
 });
@@ -27,6 +27,17 @@
 //     through both of its doors, instead of excluding it as "names no target";
 //   - CONTROLS: a tree that writes its own name, a `lookup` and a
 //     `master_detail` answer exactly as they always did.
+//
+// And the other readers of the same target, at the record doors (measured on
+// `origin/main` `275ad4229a` before, on this stack after):
+//   - the write-time reference check: a parent id that names no record is
+//     refused `400` with `reference_not_found` (it was `201`, accepted) — the
+//     one refusal this change adds at a data door; CONTROL: an existing parent
+//     is accepted;
+//   - `expand=parent` resolves the parent record (it was `404`, "declares no
+//     target object");
+//   - a nested relation condition `{ parent: { title } }` filters through the
+//     parent (it was `400`, "declares no related object").
 
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 
@@ -176,6 +187,37 @@ describe('[#23065] a referenceless tree field — delete behaviour at the public
     }
   });
 
+  it('the write check: a parent id that names no record is refused 400 reference_not_found; an existing parent is accepted', async () => {
+    const refused = await stack.apiAs(token, 'POST', '/data/rtl_default', { title: 'orphan', parent: 'no_such_parent_id' });
+    const body = JSON.parse(await refused.text()) as { code?: string; fields?: Array<{ field?: string; code?: string }> };
+    expect(refused.status).toBe(400);
+    expect(body.code).toBe('VALIDATION_FAILED');
+    expect(body.fields).toEqual(
+      expect.arrayContaining([expect.objectContaining({ field: 'parent', code: 'reference_not_found' })]),
+    );
+
+    // CONTROL: a parent that exists is accepted, and stored as written.
+    const p = await create('rtl_default', { title: 'p' });
+    const c = await create('rtl_default', { title: 'c', parent: p });
+    expect((await read('rtl_default', c)).record?.parent).toBe(p);
+  });
+
+  it('expand=parent resolves the parent record, and a nested relation condition filters through it', async () => {
+    const p = await create('rtl_default', { title: 'expand-parent' });
+    const c = await create('rtl_default', { title: 'expand-child', parent: p });
+
+    const expanded = await stack.apiAs(token, 'GET', `/data/rtl_default/${c}?expand=parent`);
+    const record = (JSON.parse(await expanded.text()) as { record?: { parent?: { id?: unknown; title?: unknown } } }).record;
+    expect(expanded.status).toBe(200);
+    expect(record?.parent).toMatchObject({ id: p, title: 'expand-parent' });
+
+    const filter = encodeURIComponent(JSON.stringify({ parent: { title: 'expand-parent' } }));
+    const listed = await stack.apiAs(token, 'GET', `/data/rtl_default?filter=${filter}`);
+    const rows = (JSON.parse(await listed.text()) as { records?: Array<{ id?: unknown }> }).records;
+    expect(listed.status).toBe(200);
+    expect(rows?.map((r) => r.id)).toEqual([c]);
+  });
+
   it('CONTROLS: a tree that writes its own name, a lookup and a master_detail answer as before', async () => {
     const p = await create('rtl_written', { title: 'p' });
     const c = await create('rtl_written', { title: 'c', parent: p });