@dxos/echo 0.10.0 → 0.11.0

package/src/internal/JsonSchema/json-schema.test.ts

@@ -266,6 +266,33 @@ describe('effect-to-json', () => {
     log('schema', { jsonSchema });
   });
 
+  test('serialize a pair of mutually-recursive schemas (A embeds B, B embeds A)', () => {
+    // Unlike a schema that's self-referential (caught by suspendCache within one expansion), a
+    // *mutual* cycle across two distinct schemas isn't: each side starts a fresh suspendCache with
+    // no memory of the other already being in flight, so without the `inProgress` guard this
+    // recurses forever (A -> B -> A -> B -> ...).
+    interface A {
+      readonly kind: 'a';
+      readonly b?: B;
+    }
+    interface B {
+      readonly kind: 'b';
+      readonly a?: A;
+    }
+    const A: Schema.Schema<A> = Schema.Struct({
+      kind: Schema.Literal('a'),
+      b: Schema.optional(Schema.suspend((): Schema.Schema<B> => B)),
+    });
+    const B: Schema.Schema<B> = Schema.Struct({
+      kind: Schema.Literal('b'),
+      a: Schema.optional(Schema.suspend((): Schema.Schema<A> => A)),
+    });
+
+    const jsonSchema = toJsonSchema(A);
+    expect(jsonSchema.properties?.kind).toEqual({ type: 'string', enum: ['a'] });
+    expect(jsonSchema.properties?.b).toBeDefined();
+  });
+
   test('tuple schema with description', () => {
     const schema = Schema.Struct({
       args: Schema.Tuple(
@@ -526,7 +553,7 @@ describe('json-to-effect', () => {
       typename: 'com.example.type.project',
       version: '0.1.0',
     });
-    expect(getTypeIdentifierAnnotation(schema)).to.deep.eq('echo:/01JERV1HQCQZDQ4NVCJ42QB38F');
+    expect(getTypeIdentifierAnnotation(schema)).to.deep.eq('echo:///01JERV1HQCQZDQ4NVCJ42QB38F');
   });
 
   test('symbol annotations get compared', () => {

package/src/internal/JsonSchema/json-schema.ts

@@ -120,8 +120,11 @@ export const toJsonSchema = (
   return jsonSchema;
 };
 
-const _toJsonSchemaAST = (ast: SchemaAST.AST): Types.DeepMutable<JsonSchemaType> => {
-  const withRefinements = withEchoRefinements(ast, '#');
+const _toJsonSchemaAST = (
+  ast: SchemaAST.AST,
+  inProgress: Set<SchemaAST.AST> = new Set(),
+): Types.DeepMutable<JsonSchemaType> => {
+  const withRefinements = withEchoRefinements(ast, '#', new Map(), inProgress);
   const jsonSchema = JSONSchema.fromAST(withRefinements, {
     definitions: {},
   }) as Types.DeepMutable<JsonSchemaType>;
@@ -133,6 +136,9 @@ const withEchoRefinements = (
   ast: SchemaAST.AST,
   path: string | undefined,
   suspendCache = new Map<SchemaAST.AST, string>(),
+  // Suspended ASTs whose expansion is currently in flight — unlike `suspendCache`, this is shared
+  // across the fresh caches each new expansion starts with, so it also catches mutual cycles.
+  inProgress: Set<SchemaAST.AST> = new Set(),
 ): SchemaAST.AST => {
   if (path) {
     suspendCache.set(ast, path);
@@ -144,21 +150,41 @@ const withEchoRefinements = (
     const suspendedAst = ast.f();
     const cachedPath = suspendCache.get(suspendedAst);
     if (cachedPath) {
-      recursiveResult = new SchemaAST.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache), {
+      recursiveResult = new SchemaAST.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache, inProgress), {
         [SchemaAST.JSONSchemaAnnotationId]: {
           $ref: cachedPath,
         },
       });
+    } else if (inProgress.has(suspendedAst)) {
+      // Reached via a *different* suspended type already being expanded (e.g. two mutually-recursive
+      // schemas, A embedding B and B embedding A) — `suspendCache` alone won't catch this, since each
+      // fresh expansion below starts from an empty one. Stop with a permissive "any" placeholder
+      // instead of expanding again. The `type` key is required: effect's JSONSchema.fromAST only
+      // treats this annotation as a full override (vs. merging it onto a recomputed, and for a bare
+      // Suspend unsupported, structural schema) when it sees type/oneOf/anyOf/$ref.
+      recursiveResult = new SchemaAST.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache, inProgress), {
+        [SchemaAST.JSONSchemaAnnotationId]: {
+          $id: '/schemas/any',
+          type: ['string', 'number', 'boolean', 'object', 'array', 'null'],
+        },
+      });
     } else {
-      const jsonSchema = _toJsonSchemaAST(suspendedAst);
-      recursiveResult = new SchemaAST.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache), {
+      inProgress.add(suspendedAst);
+      const jsonSchema = _toJsonSchemaAST(suspendedAst, inProgress);
+      inProgress.delete(suspendedAst);
+      recursiveResult = new SchemaAST.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache, inProgress), {
         [SchemaAST.JSONSchemaAnnotationId]: jsonSchema,
       });
     }
   } else if (SchemaAST.isTypeLiteral(ast)) {
     // Add property order annotations
     recursiveResult = SchemaEx.mapAst(ast, (ast, key) =>
-      withEchoRefinements(ast, path && typeof key === 'string' ? `${path}/${key}` : undefined, suspendCache),
+      withEchoRefinements(
+        ast,
+        path && typeof key === 'string' ? `${path}/${key}` : undefined,
+        suspendCache,
+        inProgress,
+      ),
     );
     recursiveResult = addJsonSchemaFields(recursiveResult, {
       propertyOrder: [...ast.propertySignatures.map((p) => p.name)] as string[],
@@ -172,6 +198,7 @@ const withEchoRefinements = (
         ast,
         path && (typeof key === 'string' || typeof key === 'number') ? `${path}/${key}` : undefined,
         suspendCache,
+        inProgress,
       ),
     );
   }

package/src/internal/Obj/atoms.ts

@@ -62,14 +62,16 @@ const refFamily = Atom.family(<T extends Obj.Unknown>(ref: Ref.Ref<T>): Atom.Ato
   return Atom.make<Obj.Snapshot<T> | undefined>((get) => {
     let unsubscribeTarget: (() => void) | undefined;
 
-    const setupTargetSubscription = (target: T): Obj.Snapshot<T> => {
+    const setupTargetSubscription = (target: T): Obj.Snapshot<T> | undefined => {
       unsubscribeTarget?.();
       unsubscribeTarget = subscribe(target, () => {
         // Deleted objects resolve to undefined so callers don't need to inspect isDeleted.
         // getSnapshot adds SnapshotKindId brand at runtime; cast bridges static types.
         get.setSelf(isDeleted(target) ? undefined : (getSnapshot(target) as unknown as Obj.Snapshot<T>));
       });
-      return getSnapshot(target) as unknown as Obj.Snapshot<T>;
+      // Guard the initial value too: an already-deleted target must resolve to undefined, not leak a
+      // snapshot until the next update.
+      return isDeleted(target) ? undefined : (getSnapshot(target) as unknown as Obj.Snapshot<T>);
     };
 
     get.addFinalizer(() => {

package/src/internal/Obj/json-serializer.test.ts

@@ -8,18 +8,27 @@ import { describe, expect, test } from 'vitest';
 import { DXN, EID } from '@dxos/keys';
 
 import * as Obj from '../../Obj';
+import * as Relation from '../../Relation';
 import { TestSchema } from '../../testing';
 import * as Type from '../../Type';
 import { getTypename, getTypeURI } from '../Annotation';
 import { getMetaChecked } from '../common/api';
-import { ATTR_TYPE, EntityKind, KindId, TypeId, getSchema } from '../common/types';
+import { makeDecodedEntityLive } from '../common/proxy';
+import { type AnyEntity, ATTR_TYPE, EntityKind, KindId, TypeId, getSchema } from '../common/types';
 import { MetaId } from '../common/types/model-symbols';
 import { RelationSourceId, RelationTargetId, getObjectEchoUri } from '../Entity';
 import * as JsonSchema from '../JsonSchema';
-import { Ref, StaticRefResolver } from '../Ref';
+import { Ref, type RefResolver, StaticRefResolver } from '../Ref';
 import { createObject } from './create-object';
 import { objectFromJSON, objectToJSON } from './json-serializer';
 
+/**
+ * Decode JSON and rewrap as a live reactive proxy — mirrors the feed hydration path
+ * (`objectFromJSON` then {@link makeDecodedEntityLive}).
+ */
+const decodeLive = async (json: unknown, options?: { refResolver?: RefResolver }): Promise<AnyEntity> =>
+  makeDecodedEntityLive(await objectFromJSON(json, options));
+
 describe('Object JSON serializer', () => {
   test('should serialize and deserialize object', async () => {
     const contact = Obj.make(TestSchema.Person, { name: 'Alice' });
@@ -159,6 +168,157 @@ describe('Object JSON serializer', () => {
     });
   });
 
+  describe('live decode', () => {
+    test('decodes as a live proxy, not a plain snapshot', async () => {
+      const contact = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const contactJson = objectToJSON(contact);
+      const refResolver = new StaticRefResolver().addSchema(TestSchema.Person);
+
+      const live = (await decodeLive(contactJson, { refResolver })) as TestSchema.Person;
+
+      expect(Obj.instanceOf(TestSchema.Person)(live)).toBe(true);
+      expect(live.name).toBe('Alice');
+    });
+
+    test('Obj.update mutates synchronously and notifies subscribers', async () => {
+      const contact = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const contactJson = objectToJSON(contact);
+      const refResolver = new StaticRefResolver().addSchema(TestSchema.Person);
+      const live = (await decodeLive(contactJson, { refResolver })) as TestSchema.Person;
+
+      let notified = 0;
+      const unsubscribe = Obj.subscribe(live, () => {
+        notified++;
+      });
+
+      Obj.update(live, (live) => {
+        live.name = 'Bob';
+      });
+
+      expect(live.name).toBe('Bob');
+      expect(notified).toBe(1);
+      unsubscribe();
+    });
+
+    test('direct assignment outside Obj.update throws', async () => {
+      const contact = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const contactJson = objectToJSON(contact);
+      const refResolver = new StaticRefResolver().addSchema(TestSchema.Person);
+      const live = (await decodeLive(contactJson, { refResolver })) as TestSchema.Person;
+
+      expect(() => {
+        Reflect.set(live, 'name', 'Bob');
+      }).toThrow();
+    });
+
+    test('Obj.getSnapshot returns a non-live snapshot unaffected by later updates', async () => {
+      const contact = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const contactJson = objectToJSON(contact);
+      const refResolver = new StaticRefResolver().addSchema(TestSchema.Person);
+      const live = (await decodeLive(contactJson, { refResolver })) as TestSchema.Person;
+
+      const snapshot = Obj.getSnapshot(live);
+      Obj.update(live, (live) => {
+        live.name = 'Bob';
+      });
+
+      expect(snapshot.name).toBe('Alice');
+      expect(live.name).toBe('Bob');
+    });
+
+    test('meta is mutable within a change context', async () => {
+      const contact = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const contactJson = objectToJSON(contact);
+      const refResolver = new StaticRefResolver().addSchema(TestSchema.Person);
+      const live = (await decodeLive(contactJson, { refResolver })) as TestSchema.Person;
+
+      Obj.update(live, (live) => {
+        Obj.getMeta(live).keys.push({ id: 'abc', source: 'example.com' });
+      });
+
+      expect(Obj.getMeta(live).keys).toEqual([{ id: 'abc', source: 'example.com' }]);
+    });
+
+    test('live decode of a relation', async () => {
+      const alice = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const org = Obj.make(TestSchema.Organization, { name: 'Acme' });
+      const relation = Relation.make(TestSchema.EmployedBy, {
+        [Relation.Source]: alice,
+        [Relation.Target]: org,
+        role: 'Engineer',
+      });
+      const relationJson = objectToJSON(relation as any);
+      const refResolver = new StaticRefResolver()
+        .addSchema(TestSchema.EmployedBy)
+        .addSchema(TestSchema.Person)
+        .addSchema(TestSchema.Organization)
+        .addObject(alice)
+        .addObject(org);
+
+      const live = (await decodeLive(relationJson, { refResolver })) as any;
+
+      let notified = 0;
+      const unsubscribe = Obj.subscribe(live, () => {
+        notified++;
+      });
+      Relation.update(live, (live) => {
+        live.role = 'Senior Engineer';
+      });
+      expect(live.role).toBe('Senior Engineer');
+      expect(notified).toBe(1);
+      unsubscribe();
+    });
+
+    test('schemaless (unresolvable type) items stay plain, non-proxy snapshots', async () => {
+      const contact = createObject(TestSchema.Person, { name: 'Alice' });
+      const contactJson = objectToJSON(contact);
+
+      const live: any = await decodeLive(contactJson);
+
+      expect(getSchema(live)).toBeUndefined();
+      expect(live.name).toBe('Alice');
+      // No schema means `Obj.update` cannot validate mutations — direct assignment remains a
+      // silent no-op-safe plain-object write, not a throw.
+      live.name = 'Bob';
+      expect(live.name).toBe('Bob');
+    });
+
+    test('a malformed decoded shape surfaces a clear error rather than a silent bad proxy', async () => {
+      const contact = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const contactJson: any = objectToJSON(contact);
+      // Corrupt a field so it violates the schema; live decode must not swallow this.
+      contactJson.age = 'not-a-number';
+      const refResolver = new StaticRefResolver().addSchema(TestSchema.Person);
+
+      await expect(decodeLive(contactJson, { refResolver })).rejects.toThrow();
+    });
+
+    test('nested array fields become reactive on live decode', async () => {
+      const task1 = Obj.make(TestSchema.Task, { title: 'Task 1' });
+      const contact = Obj.make(TestSchema.Person, { name: 'Alice', tasks: [Ref.make(task1)] });
+      const contactJson = objectToJSON(contact);
+      const refResolver = new StaticRefResolver()
+        .addSchema(TestSchema.Person)
+        .addSchema(TestSchema.Task)
+        .addObject(task1);
+
+      const live = (await decodeLive(contactJson, { refResolver })) as TestSchema.Person;
+
+      let notified = 0;
+      const unsubscribe = Obj.subscribe(live, () => {
+        notified++;
+      });
+      const task2 = Obj.make(TestSchema.Task, { title: 'Task 2' });
+      Obj.update(live, (live) => {
+        live.tasks!.push(Ref.make(task2));
+      });
+
+      expect(live.tasks).toHaveLength(2);
+      expect(notified).toBe(1);
+      unsubscribe();
+    });
+  });
+
   describe('Uint8Array', () => {
     const Blob = Type.makeObject(DXN.make('com.example.type.blob', '0.1.0'))(
       Schema.Struct({

package/src/internal/Obj/json-serializer.ts

@@ -33,6 +33,7 @@ import {
   ATTR_SELF_URI,
   ATTR_SELF_URI_LEGACY,
   ObjectDatabaseId,
+  ObjectDeletedId,
   type ObjectJSON,
   RelationSourceDXNId,
   RelationSourceId,
@@ -175,6 +176,10 @@ export const objectFromJSON = async (
     defineHiddenProperty(obj, ObjectDatabaseId, database);
   }
 
+  // Carry the deletion marker so a tombstone snapshot (e.g. a feed item removed via `Feed.remove`)
+  // hydrates with `Obj.isDeleted === true` rather than as a live object.
+  defineHiddenProperty(obj, ObjectDeletedId, jsonData[ATTR_DELETED] === true);
+
   assertObjectModel(obj);
   invariant((obj as any)[ATTR_TYPE] === undefined, 'Invalid object model');
   invariant((obj as any)[ATTR_META] === undefined, 'Invalid object model');
@@ -183,6 +188,7 @@ export const objectFromJSON = async (
   invariant((obj as any)[ATTR_SELF_URI_LEGACY] === undefined, 'Invalid object model');
   invariant((obj as any)[ATTR_RELATION_SOURCE] === undefined, 'Invalid object model');
   invariant((obj as any)[ATTR_RELATION_TARGET] === undefined, 'Invalid object model');
+
   return obj;
 };
 

package/src/internal/Query/pretty.ts

@@ -50,6 +50,8 @@ export const prettyFilter = (filter: QueryAST.Filter): string => {
       return `Filter.${filter.operator}(${JSON.stringify(filter.value)})`;
     case 'in':
       return `Filter.in([${filter.values.map((v) => JSON.stringify(v)).join(', ')}])`;
+    case 'in-query':
+      return `Filter.in(${prettyQuery(filter.subquery)}.project(${JSON.stringify(filter.property)}))`;
     case 'contains':
       return `Filter.contains(${JSON.stringify(filter.value)})`;
     case 'tag':
@@ -113,7 +115,7 @@ export const prettyQuery = (query: QueryAST.Query): string => {
     case 'order': {
       const orders = query.order.map((o) => {
         if (o.kind === 'natural') {
-          return 'Order.natural()';
+          return `Order.natural(${JSON.stringify(o.direction)})`;
         } else if (o.kind === 'rank') {
           return `Order.rank(${JSON.stringify(o.direction)})`;
         } else if (o.kind === 'timestamp') {
@@ -158,5 +160,21 @@ export const prettyQuery = (query: QueryAST.Query): string => {
     }
     case 'limit':
       return `${prettyQuery(query.query)}.limit(${query.limit})`;
+    case 'skip':
+      return `${prettyQuery(query.query)}.skip(${query.skip})`;
+    case 'aggregate': {
+      const aggregates = query.aggregates.map((aggregate) => {
+        const arg =
+          aggregate.kind === 'items'
+            ? aggregate.limit !== undefined
+              ? `{ limit: ${aggregate.limit} }`
+              : ''
+            : aggregate.kind === 'count'
+              ? ''
+              : JSON.stringify(aggregate.property);
+        return `${JSON.stringify(aggregate.name)}: Aggregate.${aggregate.kind}(${arg})`;
+      });
+      return `${prettyQuery(query.query)}.aggregate({ ${aggregates.join(', ')} })`;
+    }
   }
 };

package/src/internal/Query/query-result-effect.ts

@@ -6,8 +6,6 @@ import * as Effect from 'effect/Effect';
 import * as Effectable from 'effect/Effectable';
 import * as Option from 'effect/Option';
 
-import { EffectEx } from '@dxos/effect';
-
 import type * as QueryResult from '../../QueryResult';
 
 /**
@@ -19,9 +17,9 @@ export const makeQueryResultEffect = <T, E, R>(
   eff: Effect.Effect<QueryResult.QueryResult<T>, E, R>,
 ): QueryResult.QueryResultEffect<T, E, R> => {
   return {
-    run: Effect.flatMap(eff, (result) => EffectEx.promiseWithCauseCapture(() => result.run())),
+    run: Effect.flatMap(eff, (result) => Effect.promise(() => result.run())),
     first: Effect.flatMap(eff, (result) =>
-      EffectEx.promiseWithCauseCapture(async () => Option.fromNullable(await result.firstOrUndefined())),
+      Effect.promise(async () => Option.fromNullable(await result.firstOrUndefined())),
     ),
 
     // Effect internals: the result is itself an Effect, so it carries the commit prototype.

package/src/internal/Ref/atoms.ts

@@ -36,5 +36,5 @@ export const refSimpleFamily = Atom.family(<T>(ref: Ref<T>): Atom.Atom<T | undef
     });
 
     return loadRefTarget(ref, get, setupSubscription);
-  });
+  }).pipe(Atom.keepAlive);
 });

package/src/internal/common/proxy/change-context.ts

@@ -124,7 +124,7 @@ export const executeChange = (
     batchEvents(() => callback(proxy));
   } finally {
     exitContext();
-    // Fire primary notification.
+    // Fire the primary notification (a real change).
     if (hasPendingNotifications(contextKey)) {
       clearPendingNotifications(contextKey);
       (eventTarget as any)[EventId]?.emit();

package/src/internal/common/proxy/make-object.ts

@@ -7,13 +7,19 @@ import type * as Schema from 'effect/Schema';
 import { EntityId } from '@dxos/keys';
 
 import { getTypeAnnotation } from '../../Annotation/annotations';
-import { type AnyProperties, KindId, ParentId, SchemaKindId, StaticTypeSchemaSlot } from '../types';
+import { type AnyProperties, KindId, ParentId, SchemaId, SchemaKindId, StaticTypeSchemaSlot } from '../types';
 import { type EntityMeta, EntityMetaSchema } from '../types/meta';
 import { MetaId } from '../types/model-symbols';
 import { defineHiddenProperty } from './define-hidden-property';
 import { attachTypedJsonSerializer } from './json-serializer';
-import { createProxy, getProxyTarget, isValidProxyTarget } from './proxy-utils';
-import { TypedReactiveHandler, TypeSource, prepareTypedTarget, setMetaOwner } from './typed-handler';
+import { createProxy, getProxyTarget, isProxy, isValidProxyTarget } from './proxy-utils';
+import {
+  TypedReactiveHandler,
+  TypeSource,
+  prepareDecodedTypedTarget,
+  prepareTypedTarget,
+  setMetaOwner,
+} from './typed-handler';
 
 /**
  *
@@ -96,6 +102,39 @@ const createReactiveObject = <T extends AnyProperties>(
   return proxy;
 };
 
+/**
+ * Rewrap an object decoded from JSON (via `objectFromJSON`) into a live reactive proxy, so that
+ * `Obj.update` synchronously mutates it and `Obj.subscribe`/atoms fire — the same contract as
+ * automerge-backed objects. Unlike {@link makeObject}, the target already carries `SchemaId`/
+ * `TypeId` stamped by `setSchema`/`setTypename` (both `configurable: false`), so this does not
+ * re-derive or re-stamp them — it only validates against the schema, reactifies nested arrays,
+ * rewraps `[MetaId]` as a live nested proxy, and wraps the whole object in a proxy.
+ *
+ * Objects whose type could not be resolved at decode time (no `SchemaId`) are returned unchanged —
+ * they remain plain snapshots and `Obj.update` on them stays a no-op, since there is no schema to
+ * validate mutations against.
+ */
+export const makeDecodedEntityLive = <T extends AnyProperties>(obj: T): T => {
+  const schema = (obj as any)[SchemaId] as Schema.Schema<T, any> | undefined;
+  if (!schema) {
+    return obj;
+  }
+
+  prepareDecodedTypedTarget(obj, schema);
+
+  const meta = (obj as any)[MetaId];
+  if (meta != null && typeof meta === 'object' && !isProxy(meta)) {
+    prepareTypedTarget(meta, EntityMetaSchema);
+    const metaProxy = createProxy(meta, TypedReactiveHandler.instance);
+    defineHiddenProperty(obj, MetaId, metaProxy);
+    const metaTarget = getProxyTarget(metaProxy);
+    setMetaOwner(metaTarget, obj);
+  }
+
+  attachTypedJsonSerializer(obj);
+  return createProxy(obj, TypedReactiveHandler.instance);
+};
+
 /**
  * Set ID on ECHO object targets during creation.
  * Used for objects with schema and the ones explicitly marked as Expando.

package/src/internal/common/proxy/reactive.ts

@@ -68,6 +68,11 @@ export type ChangeCallback<T> = (mutableObj: Mutable<T>) => void;
 export const change = <T>(obj: T, callback: ChangeCallback<T>): void => {
   // Check proxy first (allows handler to intercept), then fall back to target.
   // This order is important for EchoReactiveHandler which handles ChangeId in the proxy trap.
+  //
+  // The direct-callback fallback (no `[ChangeId]`) now only applies to true snapshots and
+  // schemaless feed items (unresolvable type at decode time, see `makeDecodedEntityLive`) — live
+  // feed-backed objects carry a `[ChangeId]` (via `TypedReactiveHandler`) same as any other typed
+  // reactive object, so they take the `changeFn` branch above like automerge-backed objects do.
   const changeFn = (obj as any)[ChangeId];
   if (changeFn) {
     changeFn(callback);

package/src/internal/common/proxy/symbols.ts

@@ -4,4 +4,5 @@
 
 // TODO(dmaretskyi): Rename all symbols that are props to end with *Key.
 export const EventId = Symbol.for('@dxos/live-object/EventId');
+
 export const ChangeId = Symbol.for('@dxos/live-object/ChangeId');

package/src/internal/common/proxy/typed-handler.ts

@@ -264,10 +264,17 @@ const compactMetadataToInstanceState = (target: ProxyTarget): void => {
   }
   const state = Object.create(TypedObjectPrototype);
   for (const symbol of Object.getOwnPropertySymbols(target)) {
-    Object.defineProperty(state, symbol, Object.getOwnPropertyDescriptor(target, symbol)!);
-    // Dynamic delete over arbitrary symbol keys: `ProxyTarget` declares these as required, so the
-    // statically-typed view cannot express deleting them; the symbol set is only known at runtime.
-    delete (target as any)[symbol];
+    const descriptor = Object.getOwnPropertyDescriptor(target, symbol)!;
+    Object.defineProperty(state, symbol, descriptor);
+    // Non-configurable symbols (e.g. `SchemaId`/`TypeId`, locked by `setSchema`/`setTypename` on
+    // objects decoded from JSON) cannot be deleted — leave them as an own property on the target,
+    // shadowing the copy on `state`; reads still resolve correctly since own properties take
+    // precedence over the prototype chain.
+    if (descriptor.configurable) {
+      // Dynamic delete over arbitrary symbol keys: `ProxyTarget` declares these as required, so the
+      // statically-typed view cannot express deleting them; the symbol set is only known at runtime.
+      delete (target as any)[symbol];
+    }
   }
   Object.setPrototypeOf(target, state);
 };
@@ -295,7 +302,11 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
       defineHiddenProperty(target, EventId, new Event());
     }
 
-    defineHiddenProperty(target, ObjectDeletedId, false);
+    // Default to not-deleted, but preserve a deletion marker already stamped on the target (e.g. by
+    // `objectFromJSON` when hydrating a tombstone snapshot).
+    if (!(ObjectDeletedId in target)) {
+      defineHiddenProperty(target, ObjectDeletedId, false);
+    }
 
     // Only set owners if this is a root object (no existing owner).
     // Nested objects already have owners set by their root's initialization.
@@ -606,31 +617,43 @@ export type TypeSource = { readonly [StaticTypeSchemaSlot]?: Schema.Schema.AnyNo
 
 /**
  * Recursively set AST on all potential proxy targets.
+ *
+ * @param skipOwnStamp Skip stamping `TypeId`/`SchemaId` on `obj` itself (still recurses into
+ *   children, which always get stamped). Used for objects decoded from JSON, whose own `TypeId`/
+ *   `SchemaId` are already set by `setTypename`/`setSchema` as `configurable: false` — redefining
+ *   them here (with `configurable: true`) would throw.
  */
-const setSchemaProperties = (obj: any, schema: Schema.Schema.AnyNoContext, typeSource?: TypeSource) => {
-  const schemaType = getSchemaURI(schema);
-  if (schemaType != null) {
-    defineHiddenProperty(obj, TypeId, schemaType);
-  }
+const setSchemaProperties = (
+  obj: any,
+  schema: Schema.Schema.AnyNoContext,
+  typeSource?: TypeSource,
+  skipOwnStamp = false,
+) => {
+  if (!skipOwnStamp) {
+    const schemaType = getSchemaURI(schema);
+    if (schemaType != null) {
+      defineHiddenProperty(obj, TypeId, schemaType);
+    }
 
-  if (typeSource != null) {
-    // Keep a back-reference to the type entity so `Obj.getType` /
-    // `Relation.getType` / `Entity.getType` can return it.
-    defineHiddenProperty(obj, TypeEntityId, typeSource);
-
-    // Install `SchemaId` as a getter that reads through the entity's static
-    // schema slot. The three entity shapes (static / persisted / in-memory
-    // pre-persist) each populate the slot via their own get-trap path, so
-    // `Type.update` / `Type.addFields` mutations propagate into validation
-    // for objects created via `Obj.make(typeEntity, ...)` without this file
-    // having to rebuild from `jsonSchema` itself.
-    Object.defineProperty(obj, SchemaId, {
-      get: () => typeSource[StaticTypeSchemaSlot] ?? schema,
-      enumerable: false,
-      configurable: true,
-    });
-  } else {
-    defineHiddenProperty(obj, SchemaId, schema);
+    if (typeSource != null) {
+      // Keep a back-reference to the type entity so `Obj.getType` /
+      // `Relation.getType` / `Entity.getType` can return it.
+      defineHiddenProperty(obj, TypeEntityId, typeSource);
+
+      // Install `SchemaId` as a getter that reads through the entity's static
+      // schema slot. The three entity shapes (static / persisted / in-memory
+      // pre-persist) each populate the slot via their own get-trap path, so
+      // `Type.update` / `Type.addFields` mutations propagate into validation
+      // for objects created via `Obj.make(typeEntity, ...)` without this file
+      // having to rebuild from `jsonSchema` itself.
+      Object.defineProperty(obj, SchemaId, {
+        get: () => typeSource[StaticTypeSchemaSlot] ?? schema,
+        enumerable: false,
+        configurable: true,
+      });
+    } else {
+      defineHiddenProperty(obj, SchemaId, schema);
+    }
   }
 
   if (Array.isArray(obj)) {
@@ -661,6 +684,15 @@ const setSchemaProperties = (obj: any, schema: Schema.Schema.AnyNoContext, typeS
 // whose encoded form differs (e.g. refs encode as `{ '/': uri }`) are valid here.
 export const prepareTypedTarget = <T>(target: T, schema: Schema.Schema<T, any>, typeSource?: TypeSource) => {
   // log.info('prepareTypedTarget', { target, schema });
+  validateAndReactifyTarget(target, schema);
+  setSchemaProperties(target, schema, typeSource);
+};
+
+/**
+ * Validate a target against its schema and convert nested arrays to `ReactiveArray`. Shared by
+ * {@link prepareTypedTarget} and {@link prepareDecodedTypedTarget}.
+ */
+export const validateAndReactifyTarget = <T>(target: T, schema: Schema.Schema<T, any>) => {
   if (!SchemaAST.isTypeLiteral(schema.ast)) {
     throw new Error('schema has to describe an object type');
   }
@@ -669,7 +701,17 @@ export const prepareTypedTarget = <T>(target: T, schema: Schema.Schema<T, any>,
   const _ = Schema.asserts(schema)(target);
   SchemaValidator.assertExactProperties(schema, target, (path) => getDeep(target, path));
   makeArraysReactive(target);
-  setSchemaProperties(target, schema, typeSource);
+};
+
+/**
+ * Like {@link prepareTypedTarget}, for a target whose own `SchemaId`/`TypeId` are already stamped
+ * and locked `configurable: false` — e.g. an object decoded from JSON via `setSchema`/`setTypename`
+ * (see `objectFromJSON`). Validates and reactifies as usual, then stamps `SchemaId`/`TypeId` on
+ * nested records/arrays only, leaving the target's own (locked) stamps untouched.
+ */
+export const prepareDecodedTypedTarget = <T>(target: T, schema: Schema.Schema<T, any>) => {
+  validateAndReactifyTarget(target, schema);
+  setSchemaProperties(target, schema, undefined, true);
 };
 
 const makeArraysReactive = (target: any) => {