@dxos/echo 0.9.1-main.c7dcc2e112 → 0.9.1-staging.ee54ba693a

package/src/internal/Format/string.ts

@@ -32,18 +32,6 @@ export const Formula = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Formul
 // TODO(burdon): Implement.
 export const Hostname = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Hostname));
 
-/**
- *
- */
-// TODO(burdon): Implement.
-export const JSON = Schema.String.pipe(FormatAnnotation.set(TypeFormat.JSON));
-
-/**
- *
- */
-// TODO(burdon): Implement.
-export const Markdown = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Markdown));
-
 /**
  * Regex
  * https://json-schema.org/understanding-json-schema/reference/regular_expressions

package/src/internal/Format/types.ts

@@ -7,7 +7,7 @@ import type * as JSONSchema from 'effect/JSONSchema';
 import * as Option from 'effect/Option';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { createAnnotationHelper } from '../Annotation/util';
+import { createAnnotationHelper } from '../Annotation';
 import { type JsonSchemaType } from '../JsonSchema';
 
 // TODO(burdon): Rename PropertyType.
@@ -79,10 +79,11 @@ export enum TypeFormat {
   DID = 'did', // Users, etc.
   DXN = 'dxn',
   Email = 'email',
-  Formula = 'formula', // Spreadsheet formula.
+  Formula = 'formula', // Spreadsheet (Excel, Google Sheets, etc.) formula.
   Hostname = 'hostname',
   JSON = 'json',
   Markdown = 'markdown',
+  Password = 'password',
   Regex = 'regex',
   SingleSelect = 'single-select',
   Text = 'text',
@@ -149,6 +150,7 @@ export const formatToType: Record<TypeFormat, TypeEnum> = {
   [TypeFormat.Hostname]: TypeEnum.String,
   [TypeFormat.JSON]: TypeEnum.String,
   [TypeFormat.Markdown]: TypeEnum.String,
+  [TypeFormat.Password]: TypeEnum.String,
   [TypeFormat.Regex]: TypeEnum.String,
   [TypeFormat.URL]: TypeEnum.String,
   [TypeFormat.UUID]: TypeEnum.String,

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

@@ -33,9 +33,7 @@ const EXAMPLE_NAMESPACE = '@example';
 
 describe('effect-to-json', () => {
   test('type annotation', () => {
-    const Test = Schema.Struct({ name: Schema.String }).pipe(
-      Type.makeObject(DXN.make('com.example.type.test', '0.1.0')),
-    );
+    const Test = Type.makeObject(DXN.make('com.example.type.test', '0.1.0'))(Schema.Struct({ name: Schema.String }));
     const jsonSchema = toJsonSchema(Test);
     expect(jsonSchema.$id).toEqual('dxn:com.example.type.test:0.1.0');
     expect(jsonSchema.version).toEqual('0.1.0');
@@ -43,20 +41,26 @@ describe('effect-to-json', () => {
 
   test('property meta annotation', () => {
     const meta = { maxLength: 0 };
-    const Test = Schema.Struct({
-      name: Schema.String.pipe(PropertyMeta(EXAMPLE_NAMESPACE, meta)),
-    }).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
+    const Test = Type.makeObject(DXN.make('com.example.type.test', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.String.pipe(PropertyMeta(EXAMPLE_NAMESPACE, meta)),
+      }),
+    );
     const jsonSchema = toJsonSchema(Test);
     expect(getNormalizedEchoAnnotations(jsonSchema.properties!.name!)!.meta![EXAMPLE_NAMESPACE]).to.deep.eq(meta);
   });
 
   test('reference annotation', () => {
-    const Nested = Schema.Struct({
-      name: Schema.String,
-    }).pipe(Type.makeObject(DXN.make('com.example.type.testNested', '0.1.0')));
-    const Test = Schema.Struct({
-      name: Ref(Nested),
-    }).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
+    const Nested = Type.makeObject(DXN.make('com.example.type.testNested', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.String,
+      }),
+    );
+    const Test = Type.makeObject(DXN.make('com.example.type.test', '0.1.0'))(
+      Schema.Struct({
+        name: Ref(Nested),
+      }),
+    );
     const jsonSchema = toJsonSchema(Test);
     // log.info('schema', { jsonSchema });
     const nested = jsonSchema.properties!.name;
@@ -66,12 +70,16 @@ describe('effect-to-json', () => {
   // TODO(ZaymonFC): @dmaretskyi we still need to fix this.
   // TODO(dmaretskyi): Remove FieldLookupAnnotationId.
   test.skip('reference annotation with lookup property', () => {
-    const Nested = Schema.Struct({
-      name: Schema.String,
-    }).pipe(Type.makeObject(DXN.make('com.example.type.testNested', '0.1.0')));
-    const Test = Schema.Struct({
-      name: Ref(Nested).annotations({ [FieldLookupAnnotationId]: 'name' }),
-    }).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
+    const Nested = Type.makeObject(DXN.make('com.example.type.testNested', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.String,
+      }),
+    );
+    const Test = Type.makeObject(DXN.make('com.example.type.test', '0.1.0'))(
+      Schema.Struct({
+        name: Ref(Nested).annotations({ [FieldLookupAnnotationId]: 'name' }),
+      }),
+    );
     const jsonSchema = toJsonSchema(Test);
     const effectSchema = toEffectSchema(jsonSchema);
 
@@ -80,24 +88,32 @@ describe('effect-to-json', () => {
   });
 
   test('array of references', () => {
-    const Nested = Schema.Struct({
-      name: Schema.String,
-    }).pipe(Type.makeObject(DXN.make('com.example.type.testNested', '0.1.0')));
-    const Test = Schema.Struct({
-      name: Schema.Array(Ref(Nested)),
-    }).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
+    const Nested = Type.makeObject(DXN.make('com.example.type.testNested', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.String,
+      }),
+    );
+    const Test = Type.makeObject(DXN.make('com.example.type.test', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.Array(Ref(Nested)),
+      }),
+    );
 
     const jsonSchema = toJsonSchema(Test);
     expectReferenceAnnotation((jsonSchema.properties!.name as any).items);
   });
 
   test('optional references', () => {
-    const Nested = Schema.Struct({
-      name: Schema.String,
-    }).pipe(Type.makeObject(DXN.make('com.example.type.testNested', '0.1.0')));
-    const Test = Schema.Struct({
-      name: Schema.optional(Ref(Nested)),
-    }).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
+    const Nested = Type.makeObject(DXN.make('com.example.type.testNested', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.String,
+      }),
+    );
+    const Test = Type.makeObject(DXN.make('com.example.type.test', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.optional(Ref(Nested)),
+      }),
+    );
     const jsonSchema = toJsonSchema(Test);
     expectReferenceAnnotation(jsonSchema.properties!.name);
   });
@@ -110,12 +126,14 @@ describe('effect-to-json', () => {
   });
 
   test('annotations', () => {
-    const TempSchema = Schema.Struct({
-      name: Schema.String.annotations({ description: 'Person name', title: 'Name' }),
-      email: Schema.String.pipe(FormatAnnotation.set(TypeFormat.Email)).annotations({
-        description: 'Email address',
+    const TempSchema = Type.makeObject(DXN.make('com.example.type.person', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.String.annotations({ description: 'Person name', title: 'Name' }),
+        email: Schema.String.pipe(FormatAnnotation.set(TypeFormat.Email)).annotations({
+          description: 'Email address',
+        }),
       }),
-    }).pipe(Type.makeObject(DXN.make('com.example.type.person', '0.1.0')));
+    );
 
     const jsonSchema = toJsonSchema(TempSchema);
     expect(jsonSchema).to.deep.eq({
@@ -159,14 +177,18 @@ describe('effect-to-json', () => {
   });
 
   test('reference property by ref', () => {
-    const Organization = Schema.Struct({
-      field: Schema.String,
-    }).pipe(Type.makeObject(DXN.make('com.example.type.organization', '0.1.0')));
+    const Organization = Type.makeObject(DXN.make('com.example.type.organization', '0.1.0'))(
+      Schema.Struct({
+        field: Schema.String,
+      }),
+    );
 
-    const Contact = Schema.Struct({
-      name: Schema.String,
-      organization: Ref(Organization).annotations({ description: 'Contact organization' }),
-    }).pipe(Type.makeObject(DXN.make('com.example.type.person', '0.1.0')));
+    const Contact = Type.makeObject(DXN.make('com.example.type.person', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.String,
+        organization: Ref(Organization).annotations({ description: 'Contact organization' }),
+      }),
+    );
 
     // log.info('Contact', { ast: Contact.ast });
 
@@ -211,14 +233,18 @@ describe('effect-to-json', () => {
   });
 
   test('add reference property', () => {
-    const Organization = Schema.Struct({
-      field: Schema.String,
-    }).pipe(Type.makeObject(DXN.make('com.example.type.organization', '0.1.0')));
+    const Organization = Type.makeObject(DXN.make('com.example.type.organization', '0.1.0'))(
+      Schema.Struct({
+        field: Schema.String,
+      }),
+    );
 
-    const Contact = Schema.Struct({
-      name: Schema.String,
-      organization: Ref(Organization).annotations({ description: 'Contact organization' }),
-    }).pipe(Type.makeObject(DXN.make('com.example.type.person', '0.1.0')));
+    const Contact = Type.makeObject(DXN.make('com.example.type.person', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.String,
+        organization: Ref(Organization).annotations({ description: 'Contact organization' }),
+      }),
+    );
 
     const jsonSchema = toJsonSchema(Contact);
     setSchemaProperty(
@@ -418,9 +444,11 @@ describe('json-to-effect', () => {
 
   for (const partial of [false, true]) {
     test(`deserialized equals original ${partial ? 'with partial' : ''}`, () => {
-      const Organization = Schema.Struct({
-        field: Schema.String,
-      }).pipe(Type.makeObject(DXN.make('com.example.type.organization', '0.1.0')));
+      const Organization = Type.makeObject(DXN.make('com.example.type.organization', '0.1.0'))(
+        Schema.Struct({
+          field: Schema.String,
+        }),
+      );
 
       const fields = {
         string: Schema.String,
@@ -436,8 +464,8 @@ describe('json-to-effect', () => {
         null: Schema.Null,
       } as const;
 
-      const Test = (partial ? Schema.partial(Schema.Struct(fields)) : Schema.Struct(fields)).pipe(
-        Type.makeObject(DXN.make('com.example.type.test', '0.1.0')),
+      const Test = Type.makeObject(DXN.make('com.example.type.test', '0.1.0'))(
+        partial ? Schema.partial(Schema.Struct(fields)) : Schema.Struct(fields),
       );
 
       const jsonSchema = toJsonSchema(Test);

package/src/internal/Obj/atoms.ts

@@ -15,10 +15,12 @@ import type * as Obj from '../../Obj';
 import type * as Ref from '../../Ref';
 import type * as Relation from '../../Relation';
 import { getLabel } from '../Annotation';
+import { snapshotForComparison } from '../common/atom-snapshot';
 import { subscribe } from '../common/proxy/reactive';
-import { isEntity, getDatabase } from '../Entity';
+import { getDatabase, isEntity } from '../Entity';
 import { RefTypeId } from '../Ref/ref';
 import { loadRefTarget } from '../Ref/utils';
+import { isDeleted } from './deleted';
 import { getSnapshot } from './snapshot';
 
 const isRef = (obj: unknown): obj is Ref.Ref<any> =>
@@ -63,8 +65,9 @@ const refFamily = Atom.family(<T extends Obj.Unknown>(ref: Ref.Ref<T>): Atom.Ato
     const setupTargetSubscription = (target: T): Obj.Snapshot<T> => {
       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(getSnapshot(target) as unknown as Obj.Snapshot<T>);
+        get.setSelf(isDeleted(target) ? undefined : (getSnapshot(target) as unknown as Obj.Snapshot<T>));
       });
       return getSnapshot(target) as unknown as Obj.Snapshot<T>;
     };
@@ -77,19 +80,6 @@ const refFamily = Atom.family(<T extends Obj.Unknown>(ref: Ref.Ref<T>): Atom.Ato
   }).pipe(Atom.keepAlive);
 });
 
-/**
- * Snapshot a value to create a new reference for comparison and React dependency tracking.
- */
-const snapshotForComparison = <V>(value: V): V => {
-  if (Array.isArray(value)) {
-    return [...value] as V;
-  }
-  if (value !== null && typeof value === 'object') {
-    return { ...value } as V;
-  }
-  return value;
-};
-
 /**
  * Atom family for ECHO object properties.
  * Uses nested families: outer keyed by object, inner keyed by property key.
@@ -150,6 +140,20 @@ const refWithReactiveFamily = Atom.family(<T extends Obj.Unknown>(ref: Ref.Ref<T
   );
 });
 
+/**
+ * Atom family for a property of a ref's target object.
+ * Resolves the ref (reactively) then projects the property atom, so it fires when the ref resolves or when
+ * that property changes. Yields `undefined` while the target is unresolved.
+ */
+const refPropertyFamily = Atom.family(<T extends Obj.Unknown>(ref: Ref.Ref<T>) =>
+  Atom.family(<K extends keyof T>(key: K): Atom.Atom<T[K] | undefined> => {
+    return Atom.make<T[K] | undefined>((get) => {
+      const target = get(refWithReactiveFamily(ref));
+      return target ? get(propertyFamily(target)(key)) : undefined;
+    }).pipe(Atom.keepAlive);
+  }),
+);
+
 /**
  * Atom family for any ECHO entity (obj or relation) — returns a snapshot.
  */
@@ -201,10 +205,19 @@ export const makeAtom: {
 };
 
 /**
- * Create a read-only atom for a specific property of a reactive object.
- * Only fires updates when the property value actually changes.
+ * Create a read-only atom for a specific property of a reactive object, or of a ref's target.
+ * Only fires updates when the property value actually changes. Given a ref, the atom resolves the target
+ * first and yields `undefined` until it loads.
  */
-export const makeProperty = <T extends Obj.Unknown, K extends keyof T>(obj: T, key: K): Atom.Atom<T[K]> => {
+export const makeProperty: {
+  <T extends Obj.Unknown, K extends keyof T>(obj: T, key: K): Atom.Atom<T[K]>;
+  <T extends Obj.Unknown, K extends keyof T>(ref: Ref.Ref<T>, key: K): Atom.Atom<T[K] | undefined>;
+} = (objOrRef: Obj.Unknown | Ref.Ref<any>, key: any): Atom.Atom<any> => {
+  if (isRef(objOrRef)) {
+    return refPropertyFamily(objOrRef as Ref.Ref<any>)(key);
+  }
+
+  const obj = objOrRef as Obj.Unknown;
   assertArgument(isEntity(obj), 'obj', 'Object must be a reactive object');
   return propertyFamily(obj)(key);
 };

package/src/internal/Obj/clone.ts

@@ -3,20 +3,42 @@
 //
 
 import { invariant } from '@dxos/invariant';
-import { deepMapValues } from '@dxos/util';
+import { assumeType, deepMapValues } from '@dxos/util';
 
 import type * as Obj from '../../Obj';
 import { makeObject } from '../common/proxy';
-import { getSchema, getStaticTypeSchema, getType } from '../common/types';
+import { ParentId, getSchema, getStaticTypeSchema, getType } from '../common/types';
 import { getMeta } from '../common/types/meta';
+import { type InternalObjectProps } from '../Entity/model';
 import { Ref } from '../Ref';
 
 /**
  * Clones an object or relation.
- * This does not clone referenced objects, only the properties in the object.
+ * By default this does not clone referenced objects, only the properties in the object; pass `opts.deep`
+ * to recurse into refs (see {@link Obj.CloneOptions}).
  * @returns A new object with the same schema and properties.
  */
-export const clone = <T extends Obj.Any>(obj: T, opts?: Obj.CloneOptions): T => {
+export const clone = <T extends Obj.Any>(obj: T, opts?: Obj.CloneOptions): T =>
+  cloneInner(obj, opts, obj, new Map(), new Set());
+
+/**
+ * Recursive clone worker threaded with two cycle-guard structures:
+ * - `cache`: id → already-finished clone; reused when the same object appears more than once in a DAG.
+ * - `inProgress`: ids of objects whose clone is currently being computed; a ref back into this set means
+ *   a true cycle — the original ref is kept rather than recursing forever.
+ */
+const cloneInner = <T extends Obj.Any>(
+  obj: T,
+  opts: Obj.CloneOptions | undefined,
+  root: Obj.Any,
+  cache: Map<string, Obj.Any>,
+  inProgress: Set<string>,
+): T => {
+  if (cache.has(obj.id)) {
+    return cache.get(obj.id) as T;
+  }
+  inProgress.add(obj.id);
+
   const { id, ...data } = obj;
   // Prefer cloning through the type entity so the cloned instance preserves
   // `Obj.getType` identity. Falls back to the raw schema for older instances
@@ -24,30 +46,49 @@ export const clone = <T extends Obj.Any>(obj: T, opts?: Obj.CloneOptions): T =>
   const typeEntity = getType(obj);
   const schema = typeEntity != null ? getStaticTypeSchema(typeEntity) : getSchema(obj);
   invariant(schema != null, 'Object should have a type or schema');
-  const props: any = deepMapValues(data, (value, recurse) => {
+
+  const mapRef = (value: unknown, recurse: (value: unknown) => unknown): unknown => {
     if (Ref.isRef(value)) {
-      if (opts?.deep) {
-        // TODO(dmaretskyi): Will break on circular references.
-        return Ref.make(clone(value.target!, opts));
+      const target = value.target;
+      // A ref back to an in-progress object means a cycle — keep the original ref to break it.
+      if (
+        target != null &&
+        !inProgress.has(target.id) &&
+        (opts?.deep === 'all' || (opts?.deep === 'parent' && isChildOf(target, root)))
+      ) {
+        return Ref.make(cloneInner(target, opts, root, cache, inProgress));
       }
       return value;
     }
     return recurse(value);
-  });
+  };
 
+  const props: any = deepMapValues(data, mapRef);
   if (opts?.retainId) {
     props.id = id;
   }
-  const meta = deepMapValues(getMeta(obj), (value, recurse) => {
-    if (Ref.isRef(value)) {
-      if (opts?.deep) {
-        // TODO(dmaretskyi): Will break on circular references.
-        return Ref.make(clone(value.target!, opts));
-      }
-      return value;
-    }
-    return recurse(value);
-  });
+  const meta = deepMapValues(getMeta(obj), mapRef);
+  const result = makeObject(schema, props, meta, typeEntity as object | undefined);
+
+  inProgress.delete(obj.id);
+  cache.set(obj.id, result);
+  return result;
+};
 
-  return makeObject(schema, props, meta, typeEntity as object | undefined);
+/**
+ * Whether `entity`'s parent chain reaches `root` — i.e. it is an owned descendant that cascade-deletes with
+ * the root. Walks the `ParentId` back-links (a finite tree); guarded against cycles defensively.
+ */
+const isChildOf = (entity: unknown, root: Obj.Any): boolean => {
+  const seen = new Set<InternalObjectProps>();
+  assumeType<InternalObjectProps>(entity);
+  let parent = entity[ParentId];
+  while (parent != null && !seen.has(parent)) {
+    if (parent.id === root.id) {
+      return true;
+    }
+    seen.add(parent);
+    parent = parent[ParentId];
+  }
+  return false;
 };

package/src/internal/Obj/create-object.test.ts

@@ -54,13 +54,13 @@ describe('create (static version)', () => {
 
     const json = JSON.parse(JSON.stringify(contact));
     expect(json).toEqual({
-      id: contact.id,
+      'id': contact.id,
       '@type': DXN.make(Type.getTypename(TestSchema.Person), Type.getVersion(TestSchema.Person)),
       '@meta': {
         keys: [],
       },
-      name: 'Bot',
-      email: 'bot@example.com',
+      'name': 'Bot',
+      'email': 'bot@example.com',
     });
     expect(objectToJSON(contact)).toStrictEqual(json);
   });

package/src/internal/Obj/create-object.ts

@@ -55,10 +55,9 @@ export type CreateObjectProps<T> = (T extends { id: string }
  *
  * @example
  * ```ts
- * const Contact = Schema.Struct({
- *   name: Schema.String,
- *   email: Schema.String,
- * }).pipe(Type.makeObject(DXN.make('com.example.type.person', '0.1.0')))
+ * class Contact extends Type.makeObject<Contact>(DXN.make('com.example.type.person', '0.1.0'))(
+ *   Schema.Struct({ name: Schema.String, email: Schema.String }),
+ * ) {}
  *
  * const contact = createObject(Contact, {
  *   name: "John",

package/src/internal/Obj/inspect.ts

@@ -7,7 +7,7 @@ import type { InspectOptionsStylized, inspect as inspectFn } from 'node:util';
 import { type CustomInspectFunction, inspectCustom } from '@dxos/debug';
 
 import { getTypeURI } from '../Annotation';
-import { ATTR_TYPE, type AnyEntity } from '../common/types';
+import { type AnyEntity, ATTR_TYPE } from '../common/types';
 import { ATTR_META } from '../common/types/meta';
 import { MetaId } from '../common/types/model-symbols';
 

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

@@ -10,7 +10,7 @@ import { DXN, EID } from '@dxos/keys';
 import * as Obj from '../../Obj';
 import { TestSchema } from '../../testing';
 import * as Type from '../../Type';
-import { getTypeURI, getTypename } from '../Annotation';
+import { getTypename, getTypeURI } from '../Annotation';
 import { getMetaChecked } from '../common/api';
 import { ATTR_TYPE, EntityKind, KindId, TypeId, getSchema } from '../common/types';
 import { MetaId } from '../common/types/model-symbols';
@@ -160,10 +160,12 @@ describe('Object JSON serializer', () => {
   });
 
   describe('Uint8Array', () => {
-    const Blob = Schema.Struct({
-      name: Schema.String,
-      bytes: Schema.Uint8ArrayFromSelf,
-    }).pipe(Type.makeObject(DXN.make('com.example.type.blob', '0.1.0')));
+    const Blob = Type.makeObject(DXN.make('com.example.type.blob', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.String,
+        bytes: Schema.Uint8ArrayFromSelf,
+      }),
+    );
     type Blob = Type.InstanceType<typeof Blob>;
 
     test('round-trips Uint8Array field through JSON with schema', async ({ expect }) => {

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

@@ -15,9 +15,9 @@ import type * as Obj from '../../Obj';
 import { getTypeAnnotation, getTypeURI, setTypename } from '../Annotation';
 import { attachTypedJsonSerializer, defineHiddenProperty, typedJsonSerializer } from '../common/proxy';
 import {
+  type AnyEntity,
   ATTR_PARENT,
   ATTR_TYPE,
-  type AnyEntity,
   EntityKind,
   KindId,
   ParentId,

package/src/internal/Obj/schema-validator.test.ts

@@ -129,6 +129,19 @@ describe('schema-validator', () => {
         valueToAssign: { any: 'value' },
       });
     });
+
+    test('walking into an Unknown-typed value does not throw', ({ expect }) => {
+      // Mirrors the annotation Dictionary (Record<string, Unknown>): nested keys/indices under an
+      // Unknown slot are all valid, so the validator must not reject while walking them.
+      const schema = Schema.Struct({ dict: Schema.Record({ key: Schema.String, value: Schema.Unknown }) });
+      for (const path of [
+        ['dict', 'someType'],
+        ['dict', 'someType', 'nested'],
+        ['dict', 'someType', '0'],
+      ]) {
+        SchemaValidator.getPropertySchema(schema, path);
+      }
+    });
     test('index signatures', () => {
       for (const value of [42, '42']) {
         validateValueToAssign({
@@ -179,4 +192,44 @@ describe('schema-validator', () => {
       }
     });
   });
+
+  describe('assertExactProperties', () => {
+    test('rejects extra properties on a closed struct', () => {
+      const Person = Schema.Struct({ name: Schema.String });
+      expect(() => SchemaValidator.assertExactProperties(Person, { name: 'Alice', extra: true })).to.throw(
+        /Unknown property: extra/,
+      );
+    });
+
+    test('allows extra properties when the schema has an index signature', () => {
+      const Expando = Schema.Struct({}, { key: Schema.String, value: Schema.Any });
+      expect(() => SchemaValidator.assertExactProperties(Expando, { custom: 'value' })).not.to.throw();
+    });
+
+    test('rejects extra nested properties', () => {
+      const schema = Schema.Struct({
+        nested: Schema.Struct({ field: Schema.Number }),
+      });
+      expect(() => SchemaValidator.assertExactProperties(schema, { nested: { field: 1, extra: true } })).to.throw(
+        /Unknown property: nested.extra/,
+      );
+    });
+
+    test('resolves nested discriminated union using target property values', () => {
+      const spec = Schema.Union(
+        Schema.Struct({ kind: Schema.Literal('feed'), feed: Schema.optional(Schema.String) }),
+        Schema.Struct({ kind: Schema.Literal('timer'), cron: Schema.String }),
+      );
+      const schema = Schema.Struct({ spec });
+      const target = { spec: { kind: 'feed' as const, feed: 'echo:/feed', extra: true } };
+      expect(() => SchemaValidator.assertExactProperties(schema, target, (path) => getDeep(target, path))).to.throw(
+        /Unknown property: spec.extra/,
+      );
+      expect(() =>
+        SchemaValidator.assertExactProperties(schema, { spec: { kind: 'feed' as const } }, (path) =>
+          getDeep({ spec: { kind: 'feed' as const } }, path),
+        ),
+      ).not.to.throw();
+    });
+  });
 });