@afora/core 0.0.6 → 0.0.8

package/dist/{index-3nd9bjnc.js → index-qxfkyd6k.js}

@@ -26,18 +26,18 @@ __export(exports_exceptions, {
   UnknownRecordPlugin: () => UnknownRecordPlugin2
 });
 
-// src/core/blueprint/exceptions.ts
+// src/core/property/exceptions.ts
 var exports_exceptions2 = {};
 __export(exports_exceptions2, {
-  ReservedBlueprintKey: () => ReservedBlueprintKey2,
-  UndeclaredBlueprintProperty: () => UndeclaredBlueprintProperty2
+  InvalidPropertyValue: () => InvalidPropertyValue2,
+  PropertyRequired: () => PropertyRequired2
 });
 
-// src/core/property/exceptions.ts
+// src/core/blueprint/exceptions.ts
 var exports_exceptions3 = {};
 __export(exports_exceptions3, {
-  InvalidPropertyValue: () => InvalidPropertyValue2,
-  PropertyRequired: () => PropertyRequired2
+  ReservedBlueprintKey: () => ReservedBlueprintKey2,
+  UndeclaredBlueprintProperty: () => UndeclaredBlueprintProperty2
 });
 
 // src/core/property/is-property.ts
@@ -989,293 +989,271 @@ class AbstractRecord2 {
   }
 }
 
-// src/core/record/plugin.ts
-var RecordPlugins = Symbol("recordPlugins");
-var IdentifiedRecord = Symbol("identifiedRecord");
-var SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
-function isVersion(version) {
-  return typeof version === "string" && SEMVER.test(version);
+// src/core/blueprint/blueprint.ts
+import { Type as Type3 } from "typebox";
+
+// src/core/property/property.ts
+import { Type } from "typebox";
+
+// src/core/symbols/state.ts
+var State2 = Symbol("state");
+
+// src/core/property/abstract-property.ts
+var parsingDefinitions = new WeakMap;
+function parsingDefinitionOf(Class) {
+  let definition = parsingDefinitions.get(Class);
+  if (!definition) {
+    definition = Object.create(Class.prototype).createDefinition();
+    parsingDefinitions.set(Class, definition);
+  }
+  return definition;
 }
-function versionParts(version) {
-  const [, major, minor, patch] = SEMVER.exec(version);
-  return [Number(major), Number(minor), Number(patch)];
+
+class AbstractProperty2 {
+  get [State2]() {
+    return this.definition[State2];
+  }
+  definition;
+  value;
+  constructor(value) {
+    this.definition = this.createDefinition();
+    this.value = this.definition.make(value === Demo2 ? this.definition.type[Demo2] : value);
+  }
+  static demo() {
+    return new this(Demo2);
+  }
+  static safeParse(value) {
+    return parsingDefinitionOf(this).parse(value);
+  }
+  static with(options) {
+    return refinePropertyOf(this, options);
+  }
+  static get "~standard"() {
+    return standardOfClass(this);
+  }
 }
-var HOOKS = ["onSet", "onSetAll"];
-var internals = new WeakMap;
-function pluginsOf2(value) {
-  const Class = typeof value === "function" ? value : typeof value === "object" && value !== null ? value.constructor : undefined;
-  return Class?.[RecordPlugins] ?? [];
+
+// src/core/property/enums/property-states.ts
+var PropertyStates2;
+((PropertyStates) => {
+  PropertyStates[PropertyStates["Declared"] = 0] = "Declared";
+  PropertyStates[PropertyStates["PreHandling"] = 1] = "PreHandling";
+  PropertyStates[PropertyStates["Handling"] = 2] = "Handling";
+  PropertyStates[PropertyStates["AfterHandling"] = 3] = "AfterHandling";
+  PropertyStates[PropertyStates["Done"] = 4] = "Done";
+})(PropertyStates2 ||= {});
+
+// src/core/property/exceptions.ts
+var PropertyRequired2 = exceptionOf2({
+  layer: "property" /* Property */,
+  name: "PropertyRequired",
+  message: (_, source) => `Property "${source}" is required.`
+});
+var InvalidPropertyValue2 = exceptionOf2({
+  layer: "property" /* Property */,
+  name: "InvalidPropertyValue",
+  message: ({ errors }, source) => `Invalid value for property "${source}": ${errors.join("; ")}`
+});
+
+// src/core/property/define-property.ts
+var MISMATCH = Symbol("mismatch");
+function once(build) {
+  let result;
+  return () => {
+    result ??= build();
+    return result;
+  };
 }
-function isRecordPlugin2(value) {
-  return typeof value === "object" && value !== null && value[Kind2] === "record-plugin";
+function segmentsOf(pointer) {
+  if (pointer === "")
+    return [];
+  return pointer.slice(1).split("/").map((segment) => {
+    const key = segment.replaceAll("~1", "/").replaceAll("~0", "~");
+    return /^(0|[1-9]\d*)$/.test(key) ? Number(key) : key;
+  });
 }
-function hasPlugin2(value, plugin) {
-  const plugins = pluginsOf2(value);
-  if (typeof plugin === "string") {
-    return plugins.some((applied) => applied.name === plugin);
+
+class AbstractDefineProperty2 {
+  [State2] = 0 /* Declared */;
+  make(value) {
+    const attempt = this.attempt(value);
+    if ("failure" in attempt)
+      throw attempt.failure.exception();
+    return attempt.value;
   }
-  if (plugins.includes(plugin))
-    return true;
-  return typeof value === "function" ? value === plugin.record || value.prototype instanceof plugin.record : value instanceof plugin.record;
-}
-function membersOf(Record, name) {
-  const descriptors = {};
-  const hooks = {};
-  for (let prototype = Record.prototype;prototype !== null && !Object.hasOwn(prototype.constructor, "blueprint"); prototype = Object.getPrototypeOf(prototype)) {
-    for (const member of Object.getOwnPropertyNames(prototype)) {
-      if (member === "constructor")
-        continue;
-      const descriptor = Object.getOwnPropertyDescriptor(prototype, member);
-      if (HOOKS.includes(member)) {
-        hooks[member] ??= descriptor.value;
-        continue;
-      }
-      if (RESERVED_RECORD_KEYS2.includes(member)) {
-        throw new InvalidRecordPlugin2({
-          source: name,
-          details: {
-            reason: `"${member}" is a member of every record and cannot be replaced`
+  parse(value) {
+    const attempt = this.attemptWithoutThrowing(value);
+    if (!("failure" in attempt))
+      return { value: attempt.value };
+    const { exception, raised, issues } = attempt.failure;
+    return {
+      issues: issues.map((issue) => raised ? { ...issue, cause: exception() } : withLazyCause(issue, exception))
+    };
+  }
+  preHandle(value) {
+    return value;
+  }
+  afterHandle(value) {
+    return value;
+  }
+  handle(value) {
+    return this.type.schema.match(value) ? value : MISMATCH;
+  }
+  attemptWithoutThrowing(value) {
+    try {
+      return this.attempt(value);
+    } catch (error) {
+      return {
+        failure: this.raise(error instanceof Exception2 ? error : this.invalidValue(error))
+      };
+    }
+  }
+  attempt(value) {
+    const { name, optional } = this.type;
+    this[State2] = 0 /* Declared */;
+    if (value === undefined) {
+      if (!optional) {
+        return {
+          failure: {
+            exception: () => new PropertyRequired2({ source: name }),
+            raised: false,
+            issues: [
+              {
+                message: "is required",
+                path: [],
+                code: "required",
+                source: name
+              }
+            ]
           }
-        });
+        };
       }
-      descriptors[member] ??= descriptor;
+      this[State2] = 4 /* Done */;
+      return { value };
     }
+    if (!this.type.schema.matchShape(value)) {
+      return { failure: this.mismatch(value) };
+    }
+    try {
+      this[State2] = 1 /* PreHandling */;
+      value = this.runHandler(() => this.preHandle(value));
+      this[State2] = 2 /* Handling */;
+      const handled = this.handle(value);
+      if (handled === MISMATCH) {
+        return { failure: this.mismatch(value) };
+      }
+      value = handled;
+      this[State2] = 3 /* AfterHandling */;
+      value = this.runHandler(() => this.afterHandle(value));
+    } catch (error) {
+      if (error instanceof Exception2)
+        return { failure: this.raise(error) };
+      throw error;
+    }
+    this[State2] = 4 /* Done */;
+    return { value };
   }
-  return { descriptors: Object.freeze(descriptors), hooks };
-}
-function recordPluginOf2(name, Record, { version = "1.0.0", description } = {}) {
-  if (typeof name !== "string" || name.length === 0) {
-    throw new InvalidRecordPlugin2({
-      source: String(name),
-      details: { reason: "its name must be a non-empty string" }
-    });
-  }
-  if (!isRecordClass2(Record)) {
-    throw new InvalidRecordPlugin2({
-      source: name,
-      details: { reason: "it must be made from a class of `recordOf`" }
-    });
+  runHandler(handler) {
+    try {
+      return handler();
+    } catch (error) {
+      if (error instanceof Exception2)
+        throw error;
+      throw this.invalidValue(error);
+    }
   }
-  if (Record[IdentifiedRecord]) {
-    throw new InvalidRecordPlugin2({
-      source: name,
+  invalidValue(error) {
+    return new InvalidPropertyValue2({
+      source: this.type.name,
       details: {
-        reason: "it must be made from a record, not an entity: plugins have no identity"
-      }
-    });
-  }
-  if (!isVersion(version)) {
-    throw new InvalidRecordPlugin2({
-      source: name,
-      details: { reason: `"${version}" is not a semantic version` }
+        errors: [error instanceof Error ? error.message : String(error)]
+      },
+      cause: error
     });
   }
-  const requires = pluginsOf2(Record);
-  const inherited = new Set(requires.flatMap((required) => required.keys));
-  const declaration = Record;
-  const keys = Object.freeze(Object.keys(declaration.blueprint.properties).filter((key) => !inherited.has(key)));
-  const own = membersOf(Record, name);
-  const plugin = Object.freeze({
-    [Kind2]: "record-plugin",
-    name,
-    version,
-    ...description === undefined ? {} : { description },
-    record: Record,
-    keys,
-    members: Object.freeze(Object.keys(own.descriptors)),
-    options: declaration.options,
-    requires,
-    is: (value) => hasPlugin2(value, plugin),
-    toJSON: () => descriptorOf(plugin)
-  });
-  internals.set(plugin, own);
-  return plugin;
-}
-function descriptorOf(plugin) {
-  return Object.freeze({
-    kind: "record-plugin",
-    name: plugin.name,
-    version: plugin.version,
-    ...plugin.description === undefined ? {} : { description: plugin.description },
-    keys: plugin.keys,
-    sensitive: plugin.options.sensitive,
-    unique: plugin.options.unique,
-    change: plugin.options.change,
-    members: plugin.members,
-    requires: Object.freeze(plugin.requires.map(({ name, version }) => Object.freeze({ name, version })))
-  });
-}
-function applyPlugins(blueprint, plugins, name, reserved) {
-  const flat = [];
-  for (const plugin of plugins) {
-    if (!isRecordPlugin2(plugin)) {
-      throw new InvalidRecordPlugin2({
-        source: name,
-        details: {
-          reason: "`options.plugins` takes plugins made by `recordPluginOf`"
+  raise(exception) {
+    return {
+      exception: () => exception,
+      raised: true,
+      issues: [
+        {
+          message: exception.message,
+          path: [],
+          code: "invalid_value",
+          source: this.type.name
         }
-      });
-    }
-    for (const applied of [...plugin.requires, plugin]) {
-      if (flat.includes(applied))
-        continue;
-      if (flat.some((other) => other.name === applied.name)) {
-        throw new RecordPluginConflict2({
-          source: name,
-          details: {
-            plugin: applied.name,
-            key: applied.name,
-            owner: "another plugin"
-          }
-        });
-      }
-      flat.push(applied);
-    }
+      ]
+    };
   }
-  const owners = new Map(Object.keys(blueprint.properties).map((key) => [key, `record "${name}"`]));
-  for (const member of reserved)
-    owners.set(member, `record "${name}"`);
-  const claim = (plugin, key) => {
-    const owner = owners.get(key);
-    if (owner !== undefined) {
-      throw new RecordPluginConflict2({
+  mismatch(value) {
+    const { name, schema } = this.type;
+    const errors = schema.type.Errors(value);
+    const issues = errors.map((error) => ({
+      message: error.message,
+      path: segmentsOf(error.instancePath),
+      code: "invalid_value",
+      source: name
+    }));
+    return {
+      exception: once(() => new InvalidPropertyValue2({
         source: name,
-        details: { plugin: plugin.name, key, owner }
-      });
-    }
-    owners.set(key, `plugin "${plugin.name}"`);
-  };
-  const descriptors = {};
-  const hooks = [];
-  for (const plugin of flat) {
-    for (const key of plugin.keys)
-      claim(plugin, key);
-    const own = internals.get(plugin);
-    for (const member of plugin.members) {
-      claim(plugin, member);
-      descriptors[member] = own.descriptors[member];
-    }
-    if (own.hooks.onSet || own.hooks.onSetAll) {
-      hooks.push(Object.freeze({
-        plugin,
-        keys: Object.freeze(Object.keys(plugin.record.blueprint.properties)),
-        ...own.hooks
-      }));
-    }
+        details: { errors: errors.map(describeError) }
+      })),
+      raised: false,
+      issues: issues.length > 0 ? issues : [
+        {
+          message: "is invalid",
+          path: [],
+          code: "invalid_value",
+          source: name
+        }
+      ]
+    };
   }
-  return {
-    blueprint: flat.length === 0 ? blueprint : blueprint.join(...flat.map((plugin) => plugin.record.blueprint)),
-    plugins: Object.freeze(flat),
-    sensitive: flat.flatMap((plugin) => plugin.options.sensitive),
-    unique: flat.flatMap((plugin) => plugin.options.unique),
-    change: flat.flatMap((plugin) => plugin.options.change),
-    descriptors,
-    hooks: Object.freeze(hooks)
-  };
 }
 
-// src/core/record/record.ts
-function recordBuilderOf2(...catalogs) {
-  const context = pluginContextOf(catalogs);
-  return (blueprint, options = {}) => declareRecord(AbstractRecord2, blueprint, options, "record", [], context);
-}
-function pluginContextOf(catalogs) {
-  return Object.freeze(Object.assign({}, ...catalogs.map((catalog) => catalog.plugins)));
-}
-var recordOf3 = recordBuilderOf2();
-function declareRecord(Base, declared, { plugins = [], name: declaredName, ...declaredOptions }, fallback, reserved = [], context = {}) {
-  if (declaredName !== undefined && !isRecordName(declaredName)) {
-    throw new InvalidRecordDeclaration2({
-      source: fallback,
-      details: `"name" must be an identifier, got ${JSON.stringify(declaredName)}.`
-    });
-  }
-  const name = declaredName ?? fallback;
-  const applied = applyPlugins(declared, typeof plugins === "function" ? plugins(context) : plugins, name, reserved);
-  const blueprint = applied.blueprint;
-  const sensitive = [
-    ...declaredOptions.sensitive ?? [],
-    ...applied.sensitive
-  ];
-  const unique = [...declaredOptions.unique ?? [], ...applied.unique];
-  const declaredChange = declaredOptions.change ?? [];
-  const keys = Object.keys(blueprint.properties);
-  const change = keys.filter((key) => declaredChange.includes(key) || applied.change.includes(key));
-  for (const key of [...sensitive, ...unique, ...declaredChange]) {
-    if (!keys.includes(key)) {
-      throw new UndeclaredRecordProperty2({
-        source: name,
-        details: { key }
-      });
+// src/core/property/property.ts
+function propertyOf2({
+  name,
+  schema,
+  optional,
+  sensitive = false,
+  unique = false,
+  default: _default,
+  preHandle: onPreHandle,
+  afterHandle: onAfterHandle
+}) {
+  const valueSchema = optional ? Type.Optional(schema) : schema;
+  const SchemaConstructor = schemaOf2(name, valueSchema);
+  const type = {
+    [Demo2]: _default,
+    name,
+    schema: new SchemaConstructor,
+    optional: optional ?? false,
+    sensitive,
+    unique
+  };
+
+  class DefineProperty extends AbstractDefineProperty2 {
+    get type() {
+      return type;
     }
-  }
-  const methods = change.length > 0 ? [CHANGE_MEMBER] : [];
-  for (const member of Object.keys(applied.descriptors)) {
-    if (methods.includes(member)) {
-      const plugin = applied.plugins.find((plugin) => plugin.members.includes(member));
-      throw new RecordPluginConflict2({
-        source: name,
-        details: {
-          plugin: plugin.name,
-          key: member,
-          owner: `record "${name}" (the \`change\` namespace)`
-        }
-      });
+    preHandle(value) {
+      return onPreHandle ? onPreHandle(value) : value;
     }
-  }
-  for (const key of keys) {
-    if (RESERVED_RECORD_KEYS2.includes(key) || reserved.includes(key) || methods.includes(key)) {
-      throw new ReservedRecordKey2({ source: name, details: { key } });
+    afterHandle(value) {
+      return onAfterHandle ? onAfterHandle(value) : value;
     }
   }
-  const options = Object.freeze({
-    sensitive: Object.freeze(keys.filter((key) => sensitive.includes(key) || isMarked(blueprint.properties[key], "sensitive", { lists: true }))),
-    unique: Object.freeze(keys.filter((key) => unique.includes(key) || isMarked(blueprint.properties[key], "unique"))),
-    change: Object.freeze([...change])
-  });
 
-  class DeclaredRecord extends Base {
-    static [Kind2] = "record";
-    static blueprint = blueprint;
-    static options = options;
-    static plugins = applied.plugins;
-    static [RecordPlugins] = applied.plugins;
-    static [RecordPluginHooks] = applied.hooks;
-  }
-  if (declaredName !== undefined) {
-    declareRecordName(DeclaredRecord, declaredName);
-  }
-  Object.defineProperty(DeclaredRecord, "recordName", {
-    get() {
-      return declaredName ?? this.name;
-    },
-    configurable: true
-  });
-  exposeRecordKeys(DeclaredRecord.prototype, keys);
-  for (const [member, descriptor] of Object.entries(applied.descriptors)) {
-    Object.defineProperty(DeclaredRecord.prototype, member, descriptor);
-  }
-  if (change.length > 0) {
-    Object.defineProperty(DeclaredRecord.prototype, CHANGE_MEMBER, {
-      get() {
-        let namespace = changeNamespaces.get(this);
-        if (namespace === undefined) {
-          namespace = Object.freeze(Object.fromEntries(change.map((key) => [
-            key,
-            (value) => this.set(key, value)
-          ])));
-          changeNamespaces.set(this, namespace);
-        }
-        return namespace;
-      },
-      configurable: true
-    });
+  class Property extends AbstractProperty2 {
+    static type = type;
+    createDefinition() {
+      return new DefineProperty;
+    }
   }
-  Object.defineProperty(DeclaredRecord, "name", { value: name });
-  return DeclaredRecord;
+  return Property;
 }
-var CHANGE_MEMBER = "change";
-var changeNamespaces = new WeakMap;
 
 // src/core/blueprint/exceptions.ts
 var ReservedBlueprintKey2 = exceptionOf2({
@@ -1289,422 +1267,455 @@ var UndeclaredBlueprintProperty2 = exceptionOf2({
   message: ({ key }) => `Property "${key}" of the blueprint is not declared.`
 });
 
-// src/core/property/exceptions.ts
-var PropertyRequired2 = exceptionOf2({
-  layer: "property" /* Property */,
-  name: "PropertyRequired",
-  message: (_, source) => `Property "${source}" is required.`
-});
-var InvalidPropertyValue2 = exceptionOf2({
-  layer: "property" /* Property */,
-  name: "InvalidPropertyValue",
-  message: ({ errors }, source) => `Invalid value for property "${source}": ${errors.join("; ")}`
-});
+// src/core/blueprint/optional.ts
+import { Type as Type2 } from "typebox";
+var cache2 = new WeakMap;
+function optionalOf2(given) {
+  const field = fieldOf(given);
+  const cached = cache2.get(field);
+  if (cached)
+    return cached;
+  if (isOptionalRecord2(field))
+    return field;
+  if (isRecordClass2(field)) {
+    const optional = Object.freeze(withStandard({
+      [Kind2]: "record",
+      record: field,
+      optional: true
+    }, (value) => value === undefined ? { value } : field.safeParse(value)));
+    cache2.set(field, optional);
+    return optional;
+  }
+  if (isBlueprint2(field)) {
+    if (field.optional)
+      return field;
+    const optional = {
+      ...field,
+      optional: true,
+      safeParse: (value) => value === undefined ? { value } : field.safeParse(value)
+    };
+    Object.freeze(withStandard(optional, (value) => optional.safeParse(value)));
+    cache2.set(field, optional);
+    return optional;
+  }
+  if (isBlueprintList2(field)) {
+    if (field.optional)
+      return field;
+    const optional = standardListOf({ ...field, optional: true });
+    cache2.set(field, optional);
+    return optional;
+  }
+  const Property = field;
+  if (Property.type.optional)
+    return Property;
+  const base = Property.type;
+  const SchemaConstructor = schemaOf2(base.name, Type2.Optional(base.schema.type.Type()));
+  const type = {
+    ...base,
+    schema: new SchemaConstructor,
+    optional: true
+  };
+  const Optional = derivePropertyOf(Property, type);
+  recordPropertyLineage(Optional, { kind: "optional", base: Property });
+  cache2.set(Property, Optional);
+  return Optional;
+}
 
 // src/core/blueprint/blueprint.ts
-import { Type as Type3 } from "typebox";
-
-// src/core/property/property.ts
-import { Type } from "typebox";
-
-// src/core/symbols/state.ts
-var State2 = Symbol("state");
-
-// src/core/property/abstract-property.ts
-var parsingDefinitions = new WeakMap;
-function parsingDefinitionOf(Class) {
-  let definition = parsingDefinitions.get(Class);
-  if (!definition) {
-    definition = Object.create(Class.prototype).createDefinition();
-    parsingDefinitions.set(Class, definition);
+function blueprintBuilderOf2(...base) {
+  return (sourcesOrDefine, maybeDefine) => {
+    const [sources, define] = typeof sourcesOrDefine === "function" ? [[], sourcesOrDefine] : [
+      sourcesOrDefine,
+      maybeDefine
+    ];
+    const all = [...base, ...sources];
+    return create(all.flatMap((source) => isBlueprint2(source) ? source.plugins : [source]), { ...define(contextOf(all)) });
+  };
+}
+function blueprintFromProperties(plugins, properties) {
+  return create(plugins, { ...properties });
+}
+function create(plugins, properties) {
+  const shape = {};
+  for (const [key, field] of Object.entries(properties)) {
+    properties[key] = fieldOf(field);
+    shape[key] = schemaOfField(key, properties[key]);
   }
-  return definition;
+  const SchemaConstructor = schemaOf2("blueprint", Type3.Object(shape));
+  const blueprint = {
+    [Kind2]: "blueprint",
+    plugins: Object.freeze([...new Set(plugins)]),
+    properties: Object.freeze(properties),
+    schema: new SchemaConstructor,
+    optional: false,
+    safeParse: (value) => parseCollection(properties, value, [], "blueprint"),
+    join: (...others) => create([blueprint, ...others].flatMap((source) => source.plugins), Object.assign({}, ...[blueprint, ...others].map((source) => source.properties)))
+  };
+  return Object.freeze(withStandard(blueprint, (value) => blueprint.safeParse(value)));
 }
-
-class AbstractProperty2 {
-  get [State2]() {
-    return this.definition[State2];
+var HELPERS = { listOf: listOf2, optionalOf: optionalOf2, propertyOf: propertyOf2 };
+var RESERVED_KEYS = ["optional", "list", ...Object.keys(HELPERS)];
+function contextOf(sources) {
+  for (const key of RESERVED_KEYS) {
+    const reserving = sources.find((source) => Object.hasOwn(source.properties, key));
+    if (reserving) {
+      throw new ReservedBlueprintKey2({
+        source: isBlueprint2(reserving) ? "blueprint" : reserving.name,
+        details: { key }
+      });
+    }
   }
-  definition;
-  value;
-  constructor(value) {
-    this.definition = this.createDefinition();
-    this.value = this.definition.make(value === Demo2 ? this.definition.type[Demo2] : value);
+  const factories = Object.assign({}, ...sources.map((source) => isBlueprint2(source) ? {} : source.factories ?? {}));
+  for (const key of RESERVED_KEYS) {
+    if (Object.hasOwn(factories, key)) {
+      const reserving = sources.find((source) => !isBlueprint2(source) && Object.hasOwn(source.factories ?? {}, key));
+      throw new ReservedBlueprintKey2({
+        source: reserving.name,
+        details: { key }
+      });
+    }
   }
-  static demo() {
-    return new this(Demo2);
+  const available = Object.assign({}, ...sources.map((source) => source.properties));
+  for (const key of Object.keys(factories))
+    delete available[key];
+  const mirror = (fields, map) => Object.fromEntries(Object.entries(fields).map(([key, field]) => [key, map(field)]));
+  const list = mirror(available, (field) => listOf2(field));
+  const callable = (field) => isProperty2(field) ? callableOf(field) : field;
+  return Object.freeze({
+    ...mirror(available, callable),
+    ...factories,
+    ...HELPERS,
+    optional: Object.freeze(mirror(available, (field) => callable(optionalOf2(field)))),
+    list: Object.freeze({
+      ...list,
+      optional: Object.freeze(mirror(list, optionalOf2))
+    })
+  });
+}
+function schemaOfField(key, field) {
+  if (isBlueprintList2(field)) {
+    const { item, minItems, maxItems } = field;
+    const schema = Type3.Array(schemaOfField(key, item), {
+      ...minItems === undefined ? {} : { minItems },
+      ...maxItems === undefined ? {} : { maxItems }
+    });
+    return field.optional ? Type3.Optional(schema) : schema;
   }
-  static safeParse(value) {
-    return parsingDefinitionOf(this).parse(value);
+  if (isBlueprint2(field)) {
+    const schema = field.schema.type.Type();
+    return field.optional ? Type3.Optional(schema) : schema;
   }
-  static with(options) {
-    return refinePropertyOf(this, options);
+  const record = recordFieldOf2(field);
+  if (record) {
+    const schema = record.record.blueprint.schema.type.Type();
+    return record.optional ? Type3.Optional(schema) : schema;
   }
-  static get "~standard"() {
-    return standardOfClass(this);
+  if (isProperty2(field)) {
+    return field.type.schema.type.Type();
   }
+  throw new UndeclaredBlueprintProperty2({
+    source: "blueprint",
+    details: { key }
+  });
 }
 
-// src/core/property/enums/property-states.ts
-var PropertyStates2;
-((PropertyStates) => {
-  PropertyStates[PropertyStates["Declared"] = 0] = "Declared";
-  PropertyStates[PropertyStates["PreHandling"] = 1] = "PreHandling";
-  PropertyStates[PropertyStates["Handling"] = 2] = "Handling";
-  PropertyStates[PropertyStates["AfterHandling"] = 3] = "AfterHandling";
-  PropertyStates[PropertyStates["Done"] = 4] = "Done";
-})(PropertyStates2 ||= {});
-
-// src/core/property/define-property.ts
-var MISMATCH = Symbol("mismatch");
-function once(build) {
-  let result;
-  return () => {
-    result ??= build();
-    return result;
-  };
+// src/core/record/plugin.ts
+var RecordPlugins = Symbol("recordPlugins");
+var IdentifiedRecord = Symbol("identifiedRecord");
+var SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+function isVersion(version) {
+  return typeof version === "string" && SEMVER.test(version);
 }
-function segmentsOf(pointer) {
-  if (pointer === "")
-    return [];
-  return pointer.slice(1).split("/").map((segment) => {
-    const key = segment.replaceAll("~1", "/").replaceAll("~0", "~");
-    return /^(0|[1-9]\d*)$/.test(key) ? Number(key) : key;
-  });
+function versionParts(version) {
+  const [, major, minor, patch] = SEMVER.exec(version);
+  return [Number(major), Number(minor), Number(patch)];
 }
-
-class AbstractDefineProperty2 {
-  [State2] = 0 /* Declared */;
-  make(value) {
-    const attempt = this.attempt(value);
-    if ("failure" in attempt)
-      throw attempt.failure.exception();
-    return attempt.value;
-  }
-  parse(value) {
-    const attempt = this.attemptWithoutThrowing(value);
-    if (!("failure" in attempt))
-      return { value: attempt.value };
-    const { exception, raised, issues } = attempt.failure;
-    return {
-      issues: issues.map((issue) => raised ? { ...issue, cause: exception() } : withLazyCause(issue, exception))
-    };
-  }
-  preHandle(value) {
-    return value;
-  }
-  afterHandle(value) {
-    return value;
-  }
-  handle(value) {
-    return this.type.schema.match(value) ? value : MISMATCH;
-  }
-  attemptWithoutThrowing(value) {
-    try {
-      return this.attempt(value);
-    } catch (error) {
-      return {
-        failure: this.raise(error instanceof Exception2 ? error : this.invalidValue(error))
-      };
-    }
+function satisfies(available, requested) {
+  const [major, minor, patch] = versionParts(available);
+  const [wantedMajor, wantedMinor, wantedPatch] = versionParts(requested);
+  if (major !== wantedMajor)
+    return false;
+  if (major === 0 && minor !== wantedMinor)
+    return false;
+  if (minor !== wantedMinor)
+    return minor > wantedMinor;
+  return patch >= wantedPatch;
+}
+var HOOKS = ["onSet", "onSetAll"];
+var internals = new WeakMap;
+function pluginsOf2(value) {
+  const Class = typeof value === "function" ? value : typeof value === "object" && value !== null ? value.constructor : undefined;
+  return Class?.[RecordPlugins] ?? [];
+}
+function isRecordPlugin2(value) {
+  return typeof value === "object" && value !== null && value[Kind2] === "record-plugin";
+}
+function hasPlugin2(value, plugin) {
+  const plugins = pluginsOf2(value);
+  if (typeof plugin === "string") {
+    return plugins.some((applied) => applied.name === plugin);
   }
-  attempt(value) {
-    const { name, optional } = this.type;
-    this[State2] = 0 /* Declared */;
-    if (value === undefined) {
-      if (!optional) {
-        return {
-          failure: {
-            exception: () => new PropertyRequired2({ source: name }),
-            raised: false,
-            issues: [
-              {
-                message: "is required",
-                path: [],
-                code: "required",
-                source: name
-              }
-            ]
-          }
-        };
+  if (plugins.includes(plugin))
+    return true;
+  return typeof value === "function" ? value === plugin.record || value.prototype instanceof plugin.record : value instanceof plugin.record;
+}
+function membersOf(Record, name) {
+  const descriptors = {};
+  const hooks = {};
+  for (let prototype = Record.prototype;prototype !== null && !Object.hasOwn(prototype.constructor, "blueprint"); prototype = Object.getPrototypeOf(prototype)) {
+    for (const member of Object.getOwnPropertyNames(prototype)) {
+      if (member === "constructor")
+        continue;
+      const descriptor = Object.getOwnPropertyDescriptor(prototype, member);
+      if (HOOKS.includes(member)) {
+        hooks[member] ??= descriptor.value;
+        continue;
       }
-      this[State2] = 4 /* Done */;
-      return { value };
-    }
-    if (!this.type.schema.matchShape(value)) {
-      return { failure: this.mismatch(value) };
-    }
-    try {
-      this[State2] = 1 /* PreHandling */;
-      value = this.runHandler(() => this.preHandle(value));
-      this[State2] = 2 /* Handling */;
-      const handled = this.handle(value);
-      if (handled === MISMATCH) {
-        return { failure: this.mismatch(value) };
+      if (RESERVED_RECORD_KEYS2.includes(member)) {
+        throw new InvalidRecordPlugin2({
+          source: name,
+          details: {
+            reason: `"${member}" is a member of every record and cannot be replaced`
+          }
+        });
       }
-      value = handled;
-      this[State2] = 3 /* AfterHandling */;
-      value = this.runHandler(() => this.afterHandle(value));
-    } catch (error) {
-      if (error instanceof Exception2)
-        return { failure: this.raise(error) };
-      throw error;
+      descriptors[member] ??= descriptor;
     }
-    this[State2] = 4 /* Done */;
-    return { value };
   }
-  runHandler(handler) {
-    try {
-      return handler();
-    } catch (error) {
-      if (error instanceof Exception2)
-        throw error;
-      throw this.invalidValue(error);
-    }
+  return { descriptors: Object.freeze(descriptors), hooks };
+}
+function recordPluginOf2(name, Record, { version = "1.0.0", description } = {}) {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new InvalidRecordPlugin2({
+      source: String(name),
+      details: { reason: "its name must be a non-empty string" }
+    });
   }
-  invalidValue(error) {
-    return new InvalidPropertyValue2({
-      source: this.type.name,
+  if (!isRecordClass2(Record)) {
+    throw new InvalidRecordPlugin2({
+      source: name,
+      details: { reason: "it must be made from a class of `recordOf`" }
+    });
+  }
+  if (Record[IdentifiedRecord]) {
+    throw new InvalidRecordPlugin2({
+      source: name,
       details: {
-        errors: [error instanceof Error ? error.message : String(error)]
-      },
-      cause: error
+        reason: "it must be made from a record, not an entity: plugins have no identity"
+      }
     });
   }
-  raise(exception) {
-    return {
-      exception: () => exception,
-      raised: true,
-      issues: [
-        {
-          message: exception.message,
-          path: [],
-          code: "invalid_value",
-          source: this.type.name
-        }
-      ]
-    };
+  if (!isVersion(version)) {
+    throw new InvalidRecordPlugin2({
+      source: name,
+      details: { reason: `"${version}" is not a semantic version` }
+    });
   }
-  mismatch(value) {
-    const { name, schema } = this.type;
-    const errors = schema.type.Errors(value);
-    const issues = errors.map((error) => ({
-      message: error.message,
-      path: segmentsOf(error.instancePath),
-      code: "invalid_value",
-      source: name
-    }));
-    return {
-      exception: once(() => new InvalidPropertyValue2({
+  const requires = pluginsOf2(Record);
+  const inherited = new Set(requires.flatMap((required) => required.keys));
+  const declaration = Record;
+  const keys = Object.freeze(Object.keys(declaration.blueprint.properties).filter((key) => !inherited.has(key)));
+  const own = membersOf(Record, name);
+  const plugin = Object.freeze({
+    [Kind2]: "record-plugin",
+    name,
+    version,
+    ...description === undefined ? {} : { description },
+    record: Record,
+    keys,
+    members: Object.freeze(Object.keys(own.descriptors)),
+    options: declaration.options,
+    requires,
+    is: (value) => hasPlugin2(value, plugin),
+    toJSON: () => descriptorOf(plugin)
+  });
+  internals.set(plugin, own);
+  return plugin;
+}
+function descriptorOf(plugin) {
+  return Object.freeze({
+    kind: "record-plugin",
+    name: plugin.name,
+    version: plugin.version,
+    ...plugin.description === undefined ? {} : { description: plugin.description },
+    keys: plugin.keys,
+    sensitive: plugin.options.sensitive,
+    unique: plugin.options.unique,
+    change: plugin.options.change,
+    members: plugin.members,
+    requires: Object.freeze(plugin.requires.map(({ name, version }) => Object.freeze({ name, version })))
+  });
+}
+function applyPlugins(blueprint, plugins, name, reserved) {
+  const flat = [];
+  for (const plugin of plugins) {
+    if (!isRecordPlugin2(plugin)) {
+      throw new InvalidRecordPlugin2({
         source: name,
-        details: { errors: errors.map(describeError) }
-      })),
-      raised: false,
-      issues: issues.length > 0 ? issues : [
-        {
-          message: "is invalid",
-          path: [],
-          code: "invalid_value",
-          source: name
+        details: {
+          reason: "`options.plugins` takes plugins made by `recordPluginOf`"
         }
-      ]
-    };
-  }
-}
-
-// src/core/property/property.ts
-function propertyOf2({
-  name,
-  schema,
-  optional,
-  sensitive = false,
-  unique = false,
-  default: _default,
-  preHandle: onPreHandle,
-  afterHandle: onAfterHandle
-}) {
-  const valueSchema = optional ? Type.Optional(schema) : schema;
-  const SchemaConstructor = schemaOf2(name, valueSchema);
-  const type = {
-    [Demo2]: _default,
-    name,
-    schema: new SchemaConstructor,
-    optional: optional ?? false,
-    sensitive,
-    unique
-  };
-
-  class DefineProperty extends AbstractDefineProperty2 {
-    get type() {
-      return type;
+      });
     }
-    preHandle(value) {
-      return onPreHandle ? onPreHandle(value) : value;
+    for (const applied of [...plugin.requires, plugin]) {
+      if (flat.includes(applied))
+        continue;
+      if (flat.some((other) => other.name === applied.name)) {
+        throw new RecordPluginConflict2({
+          source: name,
+          details: {
+            plugin: applied.name,
+            key: applied.name,
+            owner: "another plugin"
+          }
+        });
+      }
+      flat.push(applied);
+    }
+  }
+  const owners = new Map(Object.keys(blueprint.properties).map((key) => [key, `record "${name}"`]));
+  for (const member of reserved)
+    owners.set(member, `record "${name}"`);
+  const claim = (plugin, key) => {
+    const owner = owners.get(key);
+    if (owner !== undefined) {
+      throw new RecordPluginConflict2({
+        source: name,
+        details: { plugin: plugin.name, key, owner }
+      });
     }
-    afterHandle(value) {
-      return onAfterHandle ? onAfterHandle(value) : value;
+    owners.set(key, `plugin "${plugin.name}"`);
+  };
+  const descriptors = {};
+  const hooks = [];
+  for (const plugin of flat) {
+    for (const key of plugin.keys)
+      claim(plugin, key);
+    const own = internals.get(plugin);
+    for (const member of plugin.members) {
+      claim(plugin, member);
+      descriptors[member] = own.descriptors[member];
     }
-  }
-
-  class Property extends AbstractProperty2 {
-    static type = type;
-    createDefinition() {
-      return new DefineProperty;
+    if (own.hooks.onSet || own.hooks.onSetAll) {
+      hooks.push(Object.freeze({
+        plugin,
+        keys: Object.freeze(Object.keys(plugin.record.blueprint.properties)),
+        ...own.hooks
+      }));
     }
   }
-  return Property;
-}
-
-// src/core/blueprint/optional.ts
-import { Type as Type2 } from "typebox";
-var cache2 = new WeakMap;
-function optionalOf2(given) {
-  const field = fieldOf(given);
-  const cached = cache2.get(field);
-  if (cached)
-    return cached;
-  if (isOptionalRecord2(field))
-    return field;
-  if (isRecordClass2(field)) {
-    const optional = Object.freeze(withStandard({
-      [Kind2]: "record",
-      record: field,
-      optional: true
-    }, (value) => value === undefined ? { value } : field.safeParse(value)));
-    cache2.set(field, optional);
-    return optional;
-  }
-  if (isBlueprint2(field)) {
-    if (field.optional)
-      return field;
-    const optional = {
-      ...field,
-      optional: true,
-      safeParse: (value) => value === undefined ? { value } : field.safeParse(value)
-    };
-    Object.freeze(withStandard(optional, (value) => optional.safeParse(value)));
-    cache2.set(field, optional);
-    return optional;
-  }
-  if (isBlueprintList2(field)) {
-    if (field.optional)
-      return field;
-    const optional = standardListOf({ ...field, optional: true });
-    cache2.set(field, optional);
-    return optional;
-  }
-  const Property = field;
-  if (Property.type.optional)
-    return Property;
-  const base = Property.type;
-  const SchemaConstructor = schemaOf2(base.name, Type2.Optional(base.schema.type.Type()));
-  const type = {
-    ...base,
-    schema: new SchemaConstructor,
-    optional: true
+  return {
+    blueprint: flat.length === 0 ? blueprint : blueprint.join(...flat.map((plugin) => plugin.record.blueprint)),
+    plugins: Object.freeze(flat),
+    sensitive: flat.flatMap((plugin) => plugin.options.sensitive),
+    unique: flat.flatMap((plugin) => plugin.options.unique),
+    change: flat.flatMap((plugin) => plugin.options.change),
+    descriptors,
+    hooks: Object.freeze(hooks)
   };
-  const Optional = derivePropertyOf(Property, type);
-  recordPropertyLineage(Optional, { kind: "optional", base: Property });
-  cache2.set(Property, Optional);
-  return Optional;
 }
 
-// src/core/blueprint/blueprint.ts
-function blueprintBuilderOf2(...base) {
-  return (sourcesOrDefine, maybeDefine) => {
-    const [sources, define] = typeof sourcesOrDefine === "function" ? [[], sourcesOrDefine] : [
-      sourcesOrDefine,
-      maybeDefine
-    ];
-    const all = [...base, ...sources];
-    return create(all.flatMap((source) => isBlueprint2(source) ? source.plugins : [source]), { ...define(contextOf(all)) });
-  };
+// src/core/record/record.ts
+function recordBuilderOf2(...catalogs) {
+  const context = pluginContextOf(catalogs);
+  return (blueprint, options = {}) => declareRecord(AbstractRecord2, blueprint, options, "record", [], context);
 }
-function blueprintFromProperties(plugins, properties) {
-  return create(plugins, { ...properties });
+function pluginContextOf(catalogs) {
+  return Object.freeze(Object.assign({}, ...catalogs.map((catalog) => catalog.plugins)));
 }
-function create(plugins, properties) {
-  const shape = {};
-  for (const [key, field] of Object.entries(properties)) {
-    properties[key] = fieldOf(field);
-    shape[key] = schemaOfField(key, properties[key]);
+var recordOf3 = recordBuilderOf2();
+function declareRecord(Base, declared, { plugins = [], name: declaredName, ...declaredOptions }, fallback, reserved = [], context = {}) {
+  if (declaredName !== undefined && !isRecordName(declaredName)) {
+    throw new InvalidRecordDeclaration2({
+      source: fallback,
+      details: `"name" must be an identifier, got ${JSON.stringify(declaredName)}.`
+    });
   }
-  const SchemaConstructor = schemaOf2("blueprint", Type3.Object(shape));
-  const blueprint = {
-    [Kind2]: "blueprint",
-    plugins: Object.freeze([...new Set(plugins)]),
-    properties: Object.freeze(properties),
-    schema: new SchemaConstructor,
-    optional: false,
-    safeParse: (value) => parseCollection(properties, value, [], "blueprint"),
-    join: (...others) => create([blueprint, ...others].flatMap((source) => source.plugins), Object.assign({}, ...[blueprint, ...others].map((source) => source.properties)))
-  };
-  return Object.freeze(withStandard(blueprint, (value) => blueprint.safeParse(value)));
-}
-var HELPERS = { listOf: listOf2, optionalOf: optionalOf2, propertyOf: propertyOf2 };
-var RESERVED_KEYS = ["optional", "list", ...Object.keys(HELPERS)];
-function contextOf(sources) {
-  for (const key of RESERVED_KEYS) {
-    const reserving = sources.find((source) => Object.hasOwn(source.properties, key));
-    if (reserving) {
-      throw new ReservedBlueprintKey2({
-        source: isBlueprint2(reserving) ? "blueprint" : reserving.name,
+  const name = declaredName ?? fallback;
+  const applied = applyPlugins(declared, typeof plugins === "function" ? plugins(context) : plugins, name, reserved);
+  const blueprint = applied.blueprint;
+  const sensitive = [
+    ...declaredOptions.sensitive ?? [],
+    ...applied.sensitive
+  ];
+  const unique = [...declaredOptions.unique ?? [], ...applied.unique];
+  const declaredChange = declaredOptions.change ?? [];
+  const keys = Object.keys(blueprint.properties);
+  const change = keys.filter((key) => declaredChange.includes(key) || applied.change.includes(key));
+  for (const key of [...sensitive, ...unique, ...declaredChange]) {
+    if (!keys.includes(key)) {
+      throw new UndeclaredRecordProperty2({
+        source: name,
         details: { key }
       });
     }
   }
-  const factories = Object.assign({}, ...sources.map((source) => isBlueprint2(source) ? {} : source.factories ?? {}));
-  for (const key of RESERVED_KEYS) {
-    if (Object.hasOwn(factories, key)) {
-      const reserving = sources.find((source) => !isBlueprint2(source) && Object.hasOwn(source.factories ?? {}, key));
-      throw new ReservedBlueprintKey2({
-        source: reserving.name,
-        details: { key }
+  const methods = change.length > 0 ? [CHANGE_MEMBER] : [];
+  for (const member of Object.keys(applied.descriptors)) {
+    if (methods.includes(member)) {
+      const plugin = applied.plugins.find((plugin) => plugin.members.includes(member));
+      throw new RecordPluginConflict2({
+        source: name,
+        details: {
+          plugin: plugin.name,
+          key: member,
+          owner: `record "${name}" (the \`change\` namespace)`
+        }
       });
     }
   }
-  const available = Object.assign({}, ...sources.map((source) => source.properties));
-  for (const key of Object.keys(factories))
-    delete available[key];
-  const mirror = (fields, map) => Object.fromEntries(Object.entries(fields).map(([key, field]) => [key, map(field)]));
-  const list = mirror(available, (field) => listOf2(field));
-  const callable = (field) => isProperty2(field) ? callableOf(field) : field;
-  return Object.freeze({
-    ...mirror(available, callable),
-    ...factories,
-    ...HELPERS,
-    optional: Object.freeze(mirror(available, (field) => callable(optionalOf2(field)))),
-    list: Object.freeze({
-      ...list,
-      optional: Object.freeze(mirror(list, optionalOf2))
-    })
+  for (const key of keys) {
+    if (RESERVED_RECORD_KEYS2.includes(key) || reserved.includes(key) || methods.includes(key)) {
+      throw new ReservedRecordKey2({ source: name, details: { key } });
+    }
+  }
+  const options = Object.freeze({
+    sensitive: Object.freeze(keys.filter((key) => sensitive.includes(key) || isMarked(blueprint.properties[key], "sensitive", { lists: true }))),
+    unique: Object.freeze(keys.filter((key) => unique.includes(key) || isMarked(blueprint.properties[key], "unique"))),
+    change: Object.freeze([...change])
   });
-}
-function schemaOfField(key, field) {
-  if (isBlueprintList2(field)) {
-    const { item, minItems, maxItems } = field;
-    const schema = Type3.Array(schemaOfField(key, item), {
-      ...minItems === undefined ? {} : { minItems },
-      ...maxItems === undefined ? {} : { maxItems }
-    });
-    return field.optional ? Type3.Optional(schema) : schema;
+
+  class DeclaredRecord extends Base {
+    static [Kind2] = "record";
+    static blueprint = blueprint;
+    static options = options;
+    static plugins = applied.plugins;
+    static [RecordPlugins] = applied.plugins;
+    static [RecordPluginHooks] = applied.hooks;
   }
-  if (isBlueprint2(field)) {
-    const schema = field.schema.type.Type();
-    return field.optional ? Type3.Optional(schema) : schema;
+  if (declaredName !== undefined) {
+    declareRecordName(DeclaredRecord, declaredName);
   }
-  const record = recordFieldOf2(field);
-  if (record) {
-    const schema = record.record.blueprint.schema.type.Type();
-    return record.optional ? Type3.Optional(schema) : schema;
+  Object.defineProperty(DeclaredRecord, "recordName", {
+    get() {
+      return declaredName ?? this.name;
+    },
+    configurable: true
+  });
+  exposeRecordKeys(DeclaredRecord.prototype, keys);
+  for (const [member, descriptor] of Object.entries(applied.descriptors)) {
+    Object.defineProperty(DeclaredRecord.prototype, member, descriptor);
   }
-  if (isProperty2(field)) {
-    return field.type.schema.type.Type();
+  if (change.length > 0) {
+    Object.defineProperty(DeclaredRecord.prototype, CHANGE_MEMBER, {
+      get() {
+        let namespace = changeNamespaces.get(this);
+        if (namespace === undefined) {
+          namespace = Object.freeze(Object.fromEntries(change.map((key) => [
+            key,
+            (value) => this.set(key, value)
+          ])));
+          changeNamespaces.set(this, namespace);
+        }
+        return namespace;
+      },
+      configurable: true
+    });
   }
-  throw new UndeclaredBlueprintProperty2({
-    source: "blueprint",
-    details: { key }
-  });
+  Object.defineProperty(DeclaredRecord, "name", { value: name });
+  return DeclaredRecord;
 }
+var CHANGE_MEMBER = "change";
+var changeNamespaces = new WeakMap;
 
-export { __export, isProperty2, schemaOf2, Demo2, recordPropertyLineage, propertyLineageOf2, fieldOf, Kind2, isBlueprint2, isRecordClass2, isOptionalRecord2, recordFieldOf2, recordNameOf2, declaredRecordNameOf, listOf2, isBlueprintList2, ExceptionLayers2, UNEXPECTED_ERROR2, Exception2, isDeclaredException, declaredMessageOf, exceptionOf2, Meta2, InvalidRecordValue2, InvalidRecordDeclaration2, UndeclaredRecordProperty2, ReservedRecordKey2, InvalidRecordPlugin2, RecordPluginConflict2, UnknownRecordPlugin2, IncompatibleRecordPlugin2, exports_exceptions, MASK2, RESERVED_RECORD_KEYS2, recordDataOf, recordFieldDataOf, storeRecordValue, runRecordEffects, AbstractRecord2, IdentifiedRecord, isVersion, versionParts, pluginsOf2, isRecordPlugin2, hasPlugin2, recordPluginOf2, recordBuilderOf2, pluginContextOf, recordOf3, declareRecord, ReservedBlueprintKey2, UndeclaredBlueprintProperty2, exports_exceptions2, PropertyRequired2, InvalidPropertyValue2, exports_exceptions3, State2, AbstractProperty2, PropertyStates2, AbstractDefineProperty2, propertyOf2, optionalOf2, blueprintBuilderOf2, blueprintFromProperties };
+export { __export, isProperty2, schemaOf2, Demo2, recordPropertyLineage, propertyLineageOf2, fieldOf, Kind2, isBlueprint2, isRecordClass2, isOptionalRecord2, recordFieldOf2, recordNameOf2, declaredRecordNameOf, fieldsOf, isPlainObject, listOf2, isBlueprintList2, ExceptionLayers2, UNEXPECTED_ERROR2, Exception2, isDeclaredException, declaredMessageOf, exceptionOf2, Meta2, InvalidRecordValue2, InvalidRecordDeclaration2, UndeclaredRecordProperty2, ReservedRecordKey2, InvalidRecordPlugin2, RecordPluginConflict2, UnknownRecordPlugin2, IncompatibleRecordPlugin2, exports_exceptions, MASK2, RESERVED_RECORD_KEYS2, recordDataOf, recordFieldDataOf, storeRecordValue, runRecordEffects, AbstractRecord2, State2, AbstractProperty2, PropertyStates2, PropertyRequired2, InvalidPropertyValue2, exports_exceptions2, AbstractDefineProperty2, propertyOf2, ReservedBlueprintKey2, UndeclaredBlueprintProperty2, exports_exceptions3, optionalOf2, blueprintBuilderOf2, blueprintFromProperties, IdentifiedRecord, isVersion, satisfies, pluginsOf2, isRecordPlugin2, hasPlugin2, recordPluginOf2, recordBuilderOf2, pluginContextOf, recordOf3, declareRecord };