@afora/core 0.0.7 → 0.0.9

package/dist/index-r78dsvtc.js

@@ -1,1721 +0,0 @@
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-
-// src/core/record/exceptions.ts
-var exports_exceptions = {};
-__export(exports_exceptions, {
-  IncompatibleRecordPlugin: () => IncompatibleRecordPlugin2,
-  InvalidRecordDeclaration: () => InvalidRecordDeclaration2,
-  InvalidRecordPlugin: () => InvalidRecordPlugin2,
-  InvalidRecordValue: () => InvalidRecordValue2,
-  RecordPluginConflict: () => RecordPluginConflict2,
-  ReservedRecordKey: () => ReservedRecordKey2,
-  UndeclaredRecordProperty: () => UndeclaredRecordProperty2,
-  UnknownRecordPlugin: () => UnknownRecordPlugin2
-});
-
-// src/core/blueprint/exceptions.ts
-var exports_exceptions2 = {};
-__export(exports_exceptions2, {
-  ReservedBlueprintKey: () => ReservedBlueprintKey2,
-  UndeclaredBlueprintProperty: () => UndeclaredBlueprintProperty2
-});
-
-// src/core/property/exceptions.ts
-var exports_exceptions3 = {};
-__export(exports_exceptions3, {
-  InvalidPropertyValue: () => InvalidPropertyValue2,
-  PropertyRequired: () => PropertyRequired2
-});
-
-// src/core/property/is-property.ts
-function isProperty2(value) {
-  return typeof value === "function" && typeof value.type === "object";
-}
-
-// src/core/schema/schema.ts
-import Compile from "typebox/compile";
-var KEPT_KEYWORDS = new Set([
-  "type",
-  "required",
-  "$ref",
-  "$id",
-  "$anchor",
-  "$dynamicRef",
-  "$dynamicAnchor"
-]);
-var SCHEMA_KEYWORDS = new Set([
-  "additionalProperties",
-  "items",
-  "additionalItems",
-  "prefixItems",
-  "anyOf",
-  "oneOf",
-  "allOf",
-  "contains",
-  "propertyNames"
-]);
-var SCHEMA_MAP_KEYWORDS = new Set([
-  "properties",
-  "patternProperties",
-  "dependentSchemas",
-  "$defs",
-  "definitions"
-]);
-var JSON_TYPES = new Set([
-  "null",
-  "array",
-  "string",
-  "number",
-  "boolean",
-  "object"
-]);
-function typeOfValue(value) {
-  const type = value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
-  return JSON_TYPES.has(type) ? type : undefined;
-}
-function shapeOf(schema) {
-  if (Array.isArray(schema))
-    return schema.map(shapeOf);
-  if (typeof schema !== "object" || schema === null)
-    return schema;
-  const shape = {};
-  for (const [key, value] of Object.entries(schema)) {
-    if (KEPT_KEYWORDS.has(key))
-      shape[key] = value;
-    else if (SCHEMA_KEYWORDS.has(key))
-      shape[key] = shapeOf(value);
-    else if (SCHEMA_MAP_KEYWORDS.has(key)) {
-      shape[key] = Object.fromEntries(Object.entries(value).map(([name, item]) => [
-        name,
-        shapeOf(item)
-      ]));
-    }
-  }
-  if (!("type" in shape)) {
-    const values = "const" in schema ? [schema.const] : schema.enum;
-    if (Array.isArray(values)) {
-      const types = values.map(typeOfValue);
-      if (types.every((type) => type !== undefined)) {
-        shape.type = [...new Set(types)];
-      }
-    }
-  }
-  return shape;
-}
-function describeError(error) {
-  return `${error.instancePath || "/"}: ${error.message}`;
-}
-
-class AbstractSchema {
-  _type;
-  validator;
-  shapeValidator;
-  constructor(_type) {
-    this._type = _type;
-  }
-  match(value) {
-    return this.type.Check(value);
-  }
-  matchShape(value) {
-    this.shapeValidator ??= Compile(shapeOf(this._type));
-    return this.shapeValidator.Check(value);
-  }
-  errors(value) {
-    return this.type.Errors(value).map(describeError);
-  }
-  toString() {
-    return JSON.stringify(this._type);
-  }
-  get type() {
-    this.validator ??= Compile(this._type);
-    return this.validator;
-  }
-}
-function schemaOf2(name, schema) {
-
-  class Schema extends AbstractSchema {
-    constructor(type = schema) {
-      super(type);
-    }
-    static fromString(value) {
-      return new Schema(JSON.parse(value));
-    }
-  }
-  Object.defineProperty(Schema, "name", { value: name });
-  Object.defineProperty(Schema, Symbol.for("nodejs.util.inspect.custom"), {
-    value: () => `@afora::schema:${name}`
-  });
-  return Schema;
-}
-
-// src/core/symbols/demo.ts
-var Demo2 = Symbol("demo");
-
-// src/core/property/lineage.ts
-var lineages = new WeakMap;
-function recordPropertyLineage(Property, lineage) {
-  if (!lineages.has(Property))
-    lineages.set(Property, lineage);
-}
-function propertyLineageOf2(Property) {
-  return typeof Property === "function" ? lineages.get(Property) : undefined;
-}
-
-// src/core/property/refine.ts
-var METADATA_KEYS = [
-  "title",
-  "description",
-  "examples",
-  "deprecated",
-  "readOnly",
-  "writeOnly"
-];
-var LOWER_BOUNDS = {
-  min: ["minimum", "minLength"],
-  exclusiveMin: ["exclusiveMinimum"]
-};
-var UPPER_BOUNDS = {
-  max: ["maximum", "maxLength"],
-  exclusiveMax: ["exclusiveMaximum"]
-};
-function derivePropertyOf(Property, type) {
-  const Base = Property;
-
-  class Derived extends Base {
-    static type = type;
-    createDefinition() {
-      const definition = super.createDefinition();
-      Object.defineProperty(definition, "type", {
-        value: type,
-        configurable: true
-      });
-      return definition;
-    }
-  }
-  Object.defineProperty(Derived, "name", { value: Property.name });
-  return Derived;
-}
-function copyOf(schema) {
-  return Object.defineProperties({}, Object.getOwnPropertyDescriptors(schema));
-}
-function addAllOf(schema, constraint) {
-  schema.allOf = [...schema.allOf ?? [], constraint];
-}
-function refinedSchemaOf(base, options) {
-  const schema = copyOf(base);
-  const keyword = (keys) => keys.length === 1 || schema.type !== "string" ? keys[0] : keys[1];
-  for (const key of METADATA_KEYS) {
-    if (options[key] !== undefined)
-      schema[key] = options[key];
-  }
-  for (const [option, keys] of Object.entries(LOWER_BOUNDS)) {
-    const value = options[option];
-    if (value === undefined)
-      continue;
-    const name = keyword(keys);
-    const current = schema[name];
-    schema[name] = current === undefined ? value : Math.max(current, value);
-  }
-  for (const [option, keys] of Object.entries(UPPER_BOUNDS)) {
-    const value = options[option];
-    if (value === undefined)
-      continue;
-    const name = keyword(keys);
-    const current = schema[name];
-    schema[name] = current === undefined ? value : Math.min(current, value);
-  }
-  if (options.multipleOf !== undefined) {
-    if (schema.multipleOf === undefined)
-      schema.multipleOf = options.multipleOf;
-    else
-      addAllOf(schema, { multipleOf: options.multipleOf });
-  }
-  if (options.pattern !== undefined) {
-    const pattern = options.pattern instanceof RegExp ? options.pattern.source : options.pattern;
-    if (schema.pattern === undefined)
-      schema.pattern = pattern;
-    else
-      addAllOf(schema, { pattern });
-  }
-  return schema;
-}
-function refinePropertyOf(Property, options) {
-  const base = Property.type;
-  const settings = options;
-  const schema = refinedSchemaOf(base.schema.type.Type(), settings);
-  const SchemaConstructor = schemaOf2(base.name, schema);
-  const examples = settings.examples;
-  const type = {
-    ...base,
-    [Demo2]: settings.default ?? examples?.[0] ?? base[Demo2],
-    schema: new SchemaConstructor
-  };
-  const Refined = derivePropertyOf(Property, type);
-  recordPropertyLineage(Refined, {
-    kind: "refined",
-    base: Property,
-    options: Object.freeze({ ...settings })
-  });
-  return Refined;
-}
-
-// src/core/blueprint/callable.ts
-var targets = new WeakMap;
-function callableOf(Property) {
-  const callable = new Proxy(Property, {
-    apply: (target, _this, [options]) => refinePropertyOf(target, options ?? {})
-  });
-  targets.set(callable, Property);
-  return callable;
-}
-function fieldOf(field) {
-  return (isProperty2(field) ? targets.get(field) : undefined) ?? field;
-}
-
-// src/core/symbols/kind.ts
-var Kind2 = Symbol("kind");
-
-// src/core/blueprint/is-blueprint.ts
-function isBlueprint2(value) {
-  return typeof value === "object" && value !== null && value[Kind2] === "blueprint";
-}
-
-// src/core/blueprint/record-field.ts
-function isRecordClass2(value) {
-  return typeof value === "function" && value[Kind2] === "record";
-}
-function isOptionalRecord2(value) {
-  return typeof value === "object" && value !== null && value[Kind2] === "record";
-}
-function recordFieldOf2(field) {
-  if (isRecordClass2(field))
-    return { record: field, optional: false };
-  if (isOptionalRecord2(field))
-    return field;
-  return;
-}
-
-// src/core/record/name.ts
-var RECORD_NAME = /^[A-Za-z_$][\w$]*$/;
-function isRecordName(name) {
-  return typeof name === "string" && RECORD_NAME.test(name);
-}
-function recordNameOf2(Class) {
-  const { recordName, name } = Class;
-  return typeof recordName === "string" ? recordName : String(name);
-}
-var declaredNames = new WeakMap;
-function declareRecordName(Class, name) {
-  declaredNames.set(Class, name);
-}
-function declaredRecordNameOf(Class) {
-  for (let current = Class;typeof current === "function"; current = Object.getPrototypeOf(current)) {
-    const own = Object.getOwnPropertyDescriptor(current, "recordName")?.value;
-    if (typeof own === "string")
-      return own;
-    const declared = declaredNames.get(current);
-    if (declared !== undefined)
-      return declared;
-  }
-  return;
-}
-
-// src/core/parse/issue.ts
-function withLazyCause(issue, build) {
-  let cause;
-  return Object.defineProperty(issue, "cause", {
-    get: () => {
-      cause ??= build();
-      return cause;
-    },
-    enumerable: false,
-    configurable: true
-  });
-}
-function movedIssue(issue, path) {
-  const moved = { ...issue, path };
-  const cause = Object.getOwnPropertyDescriptor(issue, "cause");
-  if (cause && !cause.enumerable)
-    Object.defineProperty(moved, "cause", cause);
-  return moved;
-}
-
-// src/core/parse/parse.ts
-var NO_KEY = Symbol("no key");
-function pathAt(parent, key) {
-  return key === NO_KEY ? parent : [...parent, key];
-}
-function rejection(code, message, path, source) {
-  return { issues: [{ code, message, path, source }] };
-}
-function underPath(result, path) {
-  if (!result.issues)
-    return result;
-  return {
-    issues: result.issues.map((issue) => movedIssue(issue, [...path, ...issue.path]))
-  };
-}
-function ownIssuesUnderPath(result, path) {
-  if (!result.issues)
-    return result;
-  if (result.issues.some((issue) => Object.isFrozen(issue))) {
-    return underPath(result, path);
-  }
-  for (const issue of result.issues) {
-    issue.path = [...path, ...issue.path];
-  }
-  return result;
-}
-var entriesOf = new WeakMap;
-function fieldsOf(properties) {
-  let entries = entriesOf.get(properties);
-  if (!entries) {
-    entries = Object.entries(properties);
-    entriesOf.set(properties, entries);
-  }
-  return entries;
-}
-function isPlainObject(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function parseCollection(properties, value, path, source) {
-  return collectionAt(properties, value, path, NO_KEY, source);
-}
-function collectionAt(properties, value, parent, key, source) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return rejection("invalid_type", "must be an object", pathAt(parent, key), source);
-  }
-  let issues;
-  const path = pathAt(parent, key);
-  for (const name of Object.keys(value)) {
-    if (Object.hasOwn(properties, name))
-      continue;
-    issues ??= [];
-    issues.push({
-      code: "undeclared_key",
-      message: "is not declared",
-      path: [...path, name],
-      source
-    });
-  }
-  const handled = {};
-  for (const [name, field] of fieldsOf(properties)) {
-    const result = fieldAt(field, value[name], path, name, source);
-    if (result.issues) {
-      issues ??= [];
-      issues.push(...result.issues);
-    } else if (result.value !== undefined)
-      handled[name] = result.value;
-  }
-  return issues ? { issues } : { value: Object.freeze(handled) };
-}
-function parseField(field, value, path, source) {
-  return fieldAt(field, value, path, NO_KEY, source);
-}
-function fieldAt(field, value, parent, key, source) {
-  const required = () => rejection("required", "is required", pathAt(parent, key), source);
-  if (isBlueprintList2(field)) {
-    if (value === undefined)
-      return field.optional ? { value } : required();
-    if (!Array.isArray(value)) {
-      return rejection("invalid_type", "must be an array", pathAt(parent, key), source);
-    }
-    const { minItems, maxItems } = field;
-    const path = pathAt(parent, key);
-    let issues;
-    if (minItems !== undefined && value.length < minItems) {
-      issues ??= [];
-      issues.push({
-        code: "too_few_items",
-        message: `must have at least ${minItems} items`,
-        path,
-        source
-      });
-    }
-    if (maxItems !== undefined && value.length > maxItems) {
-      issues ??= [];
-      issues.push({
-        code: "too_many_items",
-        message: `must have at most ${maxItems} items`,
-        path,
-        source
-      });
-    }
-    const items = [];
-    for (const [index, item] of value.entries()) {
-      const result = fieldAt(field.item, item, path, index, source);
-      if (result.issues) {
-        issues ??= [];
-        issues.push(...result.issues);
-      } else
-        items.push(result.value);
-    }
-    return issues ? { issues } : { value: Object.freeze(items) };
-  }
-  if (isBlueprint2(field)) {
-    if (value === undefined)
-      return field.optional ? { value } : required();
-    return collectionAt(field.properties, value, parent, key, source);
-  }
-  const record = recordFieldOf2(field);
-  if (record) {
-    if (value === undefined)
-      return record.optional ? { value } : required();
-    if (value instanceof record.record)
-      return { value };
-    if (!isPlainObject(value)) {
-      return rejection("not_record", `must be an instance of record "${recordNameOf2(record.record)}"`, pathAt(parent, key), source);
-    }
-    const result = record.record.safeParse(value);
-    return result.issues ? underPath(result, pathAt(parent, key)) : result;
-  }
-  if (isProperty2(field)) {
-    const result = field.safeParse(value);
-    return result.issues ? ownIssuesUnderPath(result, pathAt(parent, key)) : result;
-  }
-  return rejection("undeclared_key", "is not declared", pathAt(parent, key), source);
-}
-
-// src/core/standard/standard-schema.ts
-var STANDARD_VENDOR = "afora";
-
-// src/core/standard/standard.ts
-function standardOf(parse) {
-  return Object.freeze({
-    version: 1,
-    vendor: STANDARD_VENDOR,
-    validate: (value) => parse(value)
-  });
-}
-function withStandard(target, parse) {
-  return Object.defineProperty(target, "~standard", {
-    value: standardOf(parse),
-    enumerable: false
-  });
-}
-var cache = new WeakMap;
-function standardOfClass(Class) {
-  let standard = cache.get(Class);
-  if (!standard) {
-    standard = standardOf((value) => Class.safeParse(value));
-    cache.set(Class, standard);
-  }
-  return standard;
-}
-
-// src/core/blueprint/list.ts
-function listOf2(item, { minItems, maxItems } = {}) {
-  return standardListOf({
-    [Kind2]: "list",
-    item: fieldOf(item),
-    optional: false,
-    minItems,
-    maxItems
-  });
-}
-function standardListOf(list) {
-  return Object.freeze(withStandard(list, (value) => parseField(list, value, [], "list")));
-}
-function isBlueprintList2(value) {
-  return typeof value === "object" && value !== null && value[Kind2] === "list";
-}
-
-// src/core/exception/enums/exception-layers.ts
-var ExceptionLayers2;
-((ExceptionLayers) => {
-  ExceptionLayers["Schema"] = "schema";
-  ExceptionLayers["Property"] = "property";
-  ExceptionLayers["Blueprint"] = "blueprint";
-  ExceptionLayers["Record"] = "record";
-  ExceptionLayers["Entity"] = "entity";
-  ExceptionLayers["UseCase"] = "use-case";
-  ExceptionLayers["Repository"] = "repository";
-  ExceptionLayers["Environment"] = "environment";
-  ExceptionLayers["Event"] = "event";
-  ExceptionLayers["Command"] = "command";
-  ExceptionLayers["Application"] = "application";
-  ExceptionLayers["Output"] = "output";
-})(ExceptionLayers2 ||= {});
-
-// src/core/exception/exception.ts
-var UNEXPECTED_ERROR2 = "UnexpectedError";
-
-class Exception2 extends Error {
-  name;
-  layer;
-  source;
-  details;
-  cause;
-  constructor({
-    layer,
-    name,
-    source,
-    message,
-    details,
-    cause
-  }) {
-    super(message, cause === undefined ? undefined : { cause });
-    this.name = name;
-    this.layer = layer;
-    this.source = source;
-    this.details = details;
-    this.cause = cause;
-  }
-  static from(error, scope) {
-    if (error instanceof Exception2)
-      return error;
-    return new Exception2({
-      ...scope,
-      name: UNEXPECTED_ERROR2,
-      message: error instanceof Error ? error.message : String(error),
-      cause: error
-    });
-  }
-  get frame() {
-    const { layer, name, source, message, details } = this;
-    return { layer, name, source, message, details };
-  }
-  get trace() {
-    return this.chain().map((exception) => exception.frame).reverse();
-  }
-  get origin() {
-    return this.chain().at(-1);
-  }
-  find(target) {
-    return this.chain().find((exception) => typeof target === "string" ? exception.name === target : exception instanceof target);
-  }
-  is(target) {
-    return this.find(target) !== undefined;
-  }
-  passedThrough(layer) {
-    return this.chain().some((exception) => exception.layer === layer);
-  }
-  propagate({
-    layer,
-    source,
-    name = this.name,
-    message = this.message,
-    details
-  }) {
-    const keepsClass = name === this.name && details === undefined && isDeclaredInstance(this);
-    const init = {
-      layer,
-      source,
-      name,
-      message,
-      details: keepsClass ? this.details : details,
-      cause: this
-    };
-    return keepsClass ? Reflect.construct(Exception2, [init], this.constructor) : new Exception2(init);
-  }
-  toJSON() {
-    return { ...this.frame, trace: this.trace };
-  }
-  toString() {
-    return this.chain().map((exception, index) => `${index === 0 ? "" : "  <- "}${exception.name} [${exception.layer} @ ${exception.source}]: ${exception.message}`).join(`
-`);
-  }
-  chain() {
-    const chain = [];
-    for (let current = this;current instanceof Exception2; current = current.cause) {
-      chain.push(current);
-    }
-    return chain;
-  }
-}
-var declarations = new WeakMap;
-function isDeclaredInstance(exception) {
-  for (let current = exception.constructor;typeof current === "function"; current = Object.getPrototypeOf(current)) {
-    if (declarations.has(current))
-      return true;
-  }
-  return false;
-}
-function isDeclaredException(value) {
-  return typeof value === "function" && declarations.has(value);
-}
-function declaredMessageOf(Declared) {
-  const { message } = declarations.get(Declared) ?? {};
-  return typeof message === "string" ? message : undefined;
-}
-function exceptionOf2({
-  layer,
-  name,
-  message
-}) {
-
-  class DeclaredException extends Exception2 {
-    static layer = layer;
-    constructor({
-      source,
-      details,
-      cause,
-      message: custom
-    }) {
-      super({
-        layer,
-        name,
-        source,
-        details,
-        cause,
-        message: custom ?? (typeof message === "function" ? message(details, source) : message)
-      });
-    }
-  }
-  Object.defineProperty(DeclaredException, "name", { value: name });
-  declarations.set(DeclaredException, { message });
-  return DeclaredException;
-}
-
-// src/core/symbols/meta.ts
-var Meta2 = Symbol("meta");
-
-// src/core/record/exceptions.ts
-var InvalidRecordValue2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "InvalidRecordValue",
-  message: ({
-    key,
-    errors
-  }, source) => `Invalid value for ${key ? `"${key}" of ` : ""}record "${source}": ${errors.join("; ")}`
-});
-var InvalidRecordDeclaration2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "InvalidRecordDeclaration",
-  message: (reason, source) => `Invalid declaration of record "${source}": ${reason}`
-});
-var UndeclaredRecordProperty2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "UndeclaredRecordProperty",
-  message: ({ key }, source) => `Property "${key}" is not declared in record "${source}".`
-});
-var ReservedRecordKey2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "ReservedRecordKey",
-  message: ({ key }, source) => `"${key}" is a member of record "${source}" and cannot be a key of its blueprint.`
-});
-var InvalidRecordPlugin2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "InvalidRecordPlugin",
-  message: ({ reason }, source) => `Invalid record plugin "${source}": ${reason}.`
-});
-var RecordPluginConflict2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "RecordPluginConflict",
-  message: ({
-    plugin,
-    key,
-    owner
-  }, source) => `Plugin "${plugin}" of record "${source}" adds "${key}", which ${owner} already has.`
-});
-var UnknownRecordPlugin2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "UnknownRecordPlugin",
-  message: ({ name }) => `No record plugin named "${name}" in the catalog.`
-});
-var IncompatibleRecordPlugin2 = exceptionOf2({
-  layer: "record" /* Record */,
-  name: "IncompatibleRecordPlugin",
-  message: ({ reason }, source) => `Record plugin "${source}" does not satisfy the reference: ${reason}.`
-});
-
-// src/core/record/marks.ts
-function isMarked(field, mark, { lists = false } = {}) {
-  if (lists && isBlueprintList2(field))
-    return isMarked(field.item, mark, { lists });
-  return isProperty2(field) && field.type[mark] === true;
-}
-
-// src/core/record/mask.ts
-var MASK2 = "********";
-function maskAll(value) {
-  if (value === undefined || value === null)
-    return value;
-  if (Array.isArray(value))
-    return Object.freeze(value.map(maskAll));
-  if (typeof value === "object" && isRecordClass2(value.constructor)) {
-    return maskAll(value.toJSON());
-  }
-  if (typeof value === "object") {
-    return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, maskAll(item)])));
-  }
-  return MASK2;
-}
-function maskField(field, value, sensitive) {
-  if (value === undefined)
-    return value;
-  if (recordFieldOf2(field)) {
-    const json = value.toJSON();
-    return sensitive ? maskAll(json) : json;
-  }
-  if (sensitive || isMarked(field, "sensitive"))
-    return maskAll(value);
-  if (isBlueprintList2(field) && Array.isArray(value)) {
-    return Object.freeze(value.map((item) => maskField(field.item, item, false)));
-  }
-  if (isBlueprint2(field) && typeof value === "object" && value !== null) {
-    return maskCollection(field.properties, value);
-  }
-  return value;
-}
-function maskCollection(properties, value, sensitive = []) {
-  return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [
-    key,
-    maskField(properties[key], item, sensitive.includes(key))
-  ])));
-}
-
-// src/core/record/abstract-record.ts
-var values = new WeakMap;
-var metadata = new WeakMap;
-var RESERVED_RECORD_KEYS2 = Object.freeze([
-  "onSet",
-  "onSetAll",
-  "set",
-  "toJSON",
-  "toString",
-  "toLocaleString",
-  "valueOf",
-  "hasOwnProperty",
-  "propertyIsEnumerable",
-  "isPrototypeOf",
-  "__defineGetter__",
-  "__defineSetter__",
-  "__lookupGetter__",
-  "__lookupSetter__",
-  "__proto__",
-  "constructor"
-]);
-function exposeRecordKeys(prototype, keys) {
-  for (const key of keys) {
-    Object.defineProperty(prototype, key, {
-      get() {
-        return values.get(this)?.[key];
-      },
-      enumerable: true,
-      configurable: true
-    });
-  }
-}
-var checked = new WeakSet;
-function checkMembers(record, keys) {
-  const Class = record.constructor;
-  if (checked.has(Class))
-    return;
-  for (let prototype = Object.getPrototypeOf(record);prototype !== null && !Object.hasOwn(prototype.constructor, "blueprint"); prototype = Object.getPrototypeOf(prototype)) {
-    const key = Object.getOwnPropertyNames(prototype).find((name) => keys.includes(name));
-    if (key !== undefined) {
-      throw new ReservedRecordKey2({
-        source: recordNameOf2(Class),
-        details: { key }
-      });
-    }
-  }
-  checked.add(Class);
-}
-function withIssues(details, issues) {
-  return Object.defineProperty(details, "issues", {
-    value: Object.freeze([...issues]),
-    enumerable: false
-  });
-}
-function exceptionOfIssues(issues, source) {
-  const [first] = issues;
-  const key = first.path.join(".");
-  if (first.cause) {
-    return first.cause.propagate({
-      layer: "record" /* Record */,
-      source,
-      details: withIssues({ key }, issues)
-    });
-  }
-  if (first.code === "undeclared_key") {
-    return new UndeclaredRecordProperty2({
-      source,
-      details: withIssues({ key }, issues)
-    });
-  }
-  return new InvalidRecordValue2({
-    source,
-    details: withIssues({ key, errors: [first.message] }, issues)
-  });
-}
-function issuesOfError(error, source) {
-  const issues = error?.details?.issues;
-  if (error instanceof Exception2 && issues)
-    return issues;
-  const cause = Exception2.from(error, {
-    layer: "record" /* Record */,
-    source
-  });
-  return [
-    {
-      code: "invalid_value",
-      message: cause.message,
-      path: [],
-      source,
-      cause
-    }
-  ];
-}
-function parseRecord(Class, value) {
-  if (value instanceof Class)
-    return { value };
-  try {
-    return { value: new Class(value) };
-  } catch (error) {
-    return { issues: issuesOfError(error, recordNameOf2(Class)) };
-  }
-}
-function recordValue(record) {
-  return values.get(record);
-}
-function recordDataOf(record, options) {
-  const { properties } = record[Meta2].blueprint;
-  return dataOfCollection(properties, values.get(record), options);
-}
-function dataOfCollection(properties, value, options) {
-  return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [
-    key,
-    recordFieldDataOf(properties[key], item, options)
-  ])));
-}
-function recordFieldDataOf(field, value, options) {
-  if (value === undefined || value === null)
-    return value;
-  if (value instanceof AbstractRecord2) {
-    return options?.reference?.(value) ?? recordDataOf(value, options);
-  }
-  if (isBlueprintList2(field) && Array.isArray(value)) {
-    return Object.freeze(value.map((item) => recordFieldDataOf(field.item, item, options)));
-  }
-  if (isBlueprint2(field) && typeof value === "object") {
-    return dataOfCollection(field.properties, value, options);
-  }
-  return value;
-}
-function storeRecordValue(record, key, value) {
-  const source = recordNameOf2(record.constructor);
-  const { properties } = record[Meta2].blueprint;
-  if (!Object.hasOwn(properties, key)) {
-    throw exceptionOfIssues([
-      {
-        code: "undeclared_key",
-        message: "is not declared",
-        path: [key],
-        source
-      }
-    ], source);
-  }
-  const current = values.get(record);
-  const previous = current[key];
-  const result = parseField(properties[key], value, [key], source);
-  if (result.issues)
-    throw exceptionOfIssues(result.issues, source);
-  const next = result.value;
-  const { [key]: _, ...rest } = current;
-  values.set(record, Object.freeze(next === undefined ? rest : { ...rest, [key]: next }));
-  return { next, previous };
-}
-var RecordPluginHooks = Symbol("recordPluginHooks");
-function runRecordEffects(record, key, next, previous) {
-  const pluginHooks = record.constructor[RecordPluginHooks];
-  if (pluginHooks !== undefined && pluginHooks.length > 0) {
-    const name = String(key);
-    for (const hook of pluginHooks) {
-      if (!hook.keys.includes(name))
-        continue;
-      hook.onSetAll?.call(record, { key, value: next, previous });
-      hook.onSet?.call(record)[name]?.call(record, next, previous);
-    }
-  }
-  const hooks = record;
-  hooks.onSetAll({ key, value: next, previous });
-  hooks.onSet()[key]?.(next, previous);
-  return record;
-}
-
-class AbstractRecord2 {
-  get [Meta2]() {
-    const Class = this.constructor;
-    let declaration = metadata.get(Class);
-    if (!declaration) {
-      const { blueprint, options } = Class;
-      declaration = Object.freeze({ blueprint, options });
-      metadata.set(Class, declaration);
-    }
-    return declaration;
-  }
-  constructor(value) {
-    checkMembers(this, Object.keys(this[Meta2].blueprint.properties));
-    const source = recordNameOf2(this.constructor);
-    const result = parseCollection(this[Meta2].blueprint.properties, value, [], source);
-    if (result.issues)
-      throw exceptionOfIssues(result.issues, source);
-    values.set(this, result.value);
-  }
-  static safeParse(value) {
-    return parseRecord(this, value);
-  }
-  static get "~standard"() {
-    return standardOfClass(this);
-  }
-  toJSON() {
-    return maskCollection(this[Meta2].blueprint.properties, recordValue(this), this[Meta2].options.sensitive);
-  }
-  set(key, value) {
-    const { next, previous } = storeRecordValue(this, String(key), value);
-    return runRecordEffects(this, key, next, previous);
-  }
-  onSetAll(_change) {}
-  onSet() {
-    return {};
-  }
-}
-
-// 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 versionParts(version) {
-  const [, major, minor, patch] = SEMVER.exec(version);
-  return [Number(major), Number(minor), Number(patch)];
-}
-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);
-  }
-  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`
-          }
-        });
-      }
-      descriptors[member] ??= descriptor;
-    }
-  }
-  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`" }
-    });
-  }
-  if (Record[IdentifiedRecord]) {
-    throw new InvalidRecordPlugin2({
-      source: 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` }
-    });
-  }
-  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`"
-        }
-      });
-    }
-    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 }
-      });
-    }
-    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
-      }));
-    }
-  }
-  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 }
-      });
-    }
-  }
-  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)`
-        }
-      });
-    }
-  }
-  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])
-  });
-
-  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
-    });
-  }
-  Object.defineProperty(DeclaredRecord, "name", { value: name });
-  return DeclaredRecord;
-}
-var CHANGE_MEMBER = "change";
-var changeNamespaces = new WeakMap;
-
-// src/core/blueprint/optional.ts
-import { Type } 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, Type.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/exceptions.ts
-var ReservedBlueprintKey2 = exceptionOf2({
-  layer: "blueprint" /* Blueprint */,
-  name: "ReservedBlueprintKey",
-  message: ({ key }) => `"${key}" is reserved and cannot be a plugin property.`
-});
-var UndeclaredBlueprintProperty2 = exceptionOf2({
-  layer: "blueprint" /* Blueprint */,
-  name: "UndeclaredBlueprintProperty",
-  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/blueprint.ts
-import { Type as Type3 } from "typebox";
-
-// src/core/property/property.ts
-import { Type as Type2 } 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;
-}
-
-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);
-  }
-}
-
-// 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;
-  };
-}
-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;
-  });
-}
-
-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))
-      };
-    }
-  }
-  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
-              }
-            ]
-          }
-        };
-      }
-      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 };
-  }
-  runHandler(handler) {
-    try {
-      return handler();
-    } catch (error) {
-      if (error instanceof Exception2)
-        throw error;
-      throw this.invalidValue(error);
-    }
-  }
-  invalidValue(error) {
-    return new InvalidPropertyValue2({
-      source: this.type.name,
-      details: {
-        errors: [error instanceof Error ? error.message : String(error)]
-      },
-      cause: error
-    });
-  }
-  raise(exception) {
-    return {
-      exception: () => exception,
-      raised: true,
-      issues: [
-        {
-          message: exception.message,
-          path: [],
-          code: "invalid_value",
-          source: this.type.name
-        }
-      ]
-    };
-  }
-  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: { errors: errors.map(describeError) }
-      })),
-      raised: false,
-      issues: issues.length > 0 ? issues : [
-        {
-          message: "is invalid",
-          path: [],
-          code: "invalid_value",
-          source: name
-        }
-      ]
-    };
-  }
-}
-
-// src/core/property/property.ts
-function propertyOf2({
-  name,
-  schema,
-  optional,
-  sensitive = false,
-  unique = false,
-  default: _default,
-  preHandle: onPreHandle,
-  afterHandle: onAfterHandle
-}) {
-  const valueSchema = optional ? Type2.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;
-    }
-    afterHandle(value) {
-      return onAfterHandle ? onAfterHandle(value) : value;
-    }
-  }
-
-  class Property extends AbstractProperty2 {
-    static type = type;
-    createDefinition() {
-      return new DefineProperty;
-    }
-  }
-  return Property;
-}
-
-// 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)) });
-  };
-}
-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]);
-  }
-  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,
-        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 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;
-  }
-  if (isBlueprint2(field)) {
-    const schema = field.schema.type.Type();
-    return field.optional ? Type3.Optional(schema) : schema;
-  }
-  const record = recordFieldOf2(field);
-  if (record) {
-    const schema = record.record.blueprint.schema.type.Type();
-    return record.optional ? Type3.Optional(schema) : schema;
-  }
-  if (isProperty2(field)) {
-    return field.type.schema.type.Type();
-  }
-  throw new UndeclaredBlueprintProperty2({
-    source: "blueprint",
-    details: { key }
-  });
-}
-
-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, satisfies, pluginsOf2, isRecordPlugin2, hasPlugin2, recordPluginOf2, recordBuilderOf2, pluginContextOf, recordOf3, declareRecord, optionalOf2, ReservedBlueprintKey2, UndeclaredBlueprintProperty2, exports_exceptions2, PropertyRequired2, InvalidPropertyValue2, exports_exceptions3, State2, AbstractProperty2, PropertyStates2, AbstractDefineProperty2, propertyOf2, blueprintBuilderOf2, blueprintFromProperties };