@aethervtt/shard-core 0.0.1

package/dist/schema/field.js

@@ -0,0 +1,591 @@
+import { ShardError } from "../error.js";
+import { cloneData, isPlainObject, pointer } from "../json.js";
+import { HEX_COLOR, hexToLinear, linearToHex } from "./color.js";
+function describeValue(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return `array(${value.length})`;
+  return typeof value;
+}
+function mismatch(path, expected, got) {
+  return new ShardError(
+    "schema/type-mismatch",
+    `Expected ${expected} at ${path || "/"}, got ${describeValue(got)}`,
+    { path, hint: `Use ${expected}.` }
+  );
+}
+function outOfRange(path, value, min, max) {
+  return new ShardError(
+    "schema/out-of-range",
+    `Value ${value} at ${path || "/"} is outside [${min}, ${max}]`,
+    { path, hint: `Use a value between ${min} and ${max}.` }
+  );
+}
+function editDistance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    let prev = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const tmp = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+      prev = tmp;
+    }
+  }
+  return row[b.length];
+}
+function unknownField(path, key, known) {
+  const close = known.find((k) => editDistance(k.toLowerCase(), key.toLowerCase()) <= 2);
+  const hint = close ? `Did you mean "${close}"?` : known.length > 0 ? `Known fields: ${known.join(", ")}.` : "This type has no fields; use {}.";
+  return new ShardError("schema/unknown-field", `Unknown field "${key}" at ${path || "/"}`, {
+    path: pointer(path, key),
+    hint
+  });
+}
+function baseSchema(options, defaultJson) {
+  const schema = {};
+  if (options.description) schema.description = options.description;
+  if (options.readonly) schema.readOnly = true;
+  if (options.unit) schema["x-unit"] = options.unit;
+  if (options.hidden) schema["x-hidden"] = true;
+  schema.default = defaultJson;
+  return schema;
+}
+function makeField(spec) {
+  const field = {
+    ...spec,
+    jsonSchema: () => ({
+      ...baseSchema(spec.options, spec.toJson(spec.defaultValue())),
+      ...spec.schema()
+    })
+  };
+  delete field.schema;
+  return field;
+}
+function callable(create) {
+  return Object.assign((options = {}) => create(options), create({}));
+}
+function f32ToJson(v) {
+  if (!Number.isFinite(v) || Number.isInteger(v)) return v;
+  const target = Math.fround(v);
+  let best = Number(v.toPrecision(7));
+  if (Math.fround(best) !== target) {
+    for (let p = 8; p <= 9; p++) {
+      const candidate = Number(v.toPrecision(p));
+      if (Math.fround(candidate) === target) return candidate;
+    }
+    return v;
+  }
+  for (let p = 6; p >= 1; p--) {
+    const candidate = Number(v.toPrecision(p));
+    if (Math.fround(candidate) !== target) break;
+    best = candidate;
+  }
+  return best;
+}
+const INT_RANGE = {
+  i8: [-128, 127],
+  i16: [-32768, 32767],
+  i32: [-2147483648, 2147483647],
+  u8: [0, 255],
+  u16: [0, 65535],
+  u32: [0, 4294967295]
+};
+function numberField(storage) {
+  return callable((options) => {
+    const range = INT_RANGE[storage];
+    const isInt = range !== void 0;
+    const min = Math.max(range?.[0] ?? -Infinity, options.min ?? -Infinity);
+    const max = Math.min(range?.[1] ?? Infinity, options.max ?? Infinity);
+    return makeField({
+      kind: storage,
+      storage,
+      stride: 1,
+      options,
+      defaultValue: () => options.default ?? 0,
+      read: (c, r) => c[r],
+      write: (c, r, v) => {
+        ;
+        c[r] = v;
+      },
+      validate(json2, path, errors) {
+        if (typeof json2 === "string" && options.presets) {
+          if (!Object.hasOwn(options.presets, json2)) {
+            errors.push(
+              new ShardError(
+                "schema/unknown-preset",
+                `Unknown preset "${json2}" at ${path || "/"}`,
+                {
+                  path,
+                  hint: `Use a number or one of: ${Object.keys(options.presets).join(", ")}.`
+                }
+              )
+            );
+          }
+        } else if (typeof json2 !== "number" || !Number.isFinite(json2)) {
+          errors.push(mismatch(path, isInt ? "an integer" : "a number", json2));
+        } else if (isInt && !Number.isInteger(json2)) {
+          errors.push(mismatch(path, "an integer", json2));
+        } else if (json2 < min || json2 > max) {
+          errors.push(outOfRange(path, json2, min, max));
+        }
+      },
+      toJson: storage === "f32" ? f32ToJson : (v) => v,
+      fromJson: (json2) => typeof json2 === "string" ? options.presets[json2] : json2,
+      schema: () => {
+        const s = { type: isInt ? "integer" : "number" };
+        if (Number.isFinite(min)) s.minimum = min;
+        if (Number.isFinite(max)) s.maximum = max;
+        if (!options.presets) return s;
+        return {
+          anyOf: [s, { type: "string", enum: Object.keys(options.presets) }],
+          "x-presets": options.presets
+        };
+      }
+    });
+  });
+}
+const bool = callable(
+  (options) => makeField({
+    kind: "bool",
+    storage: "u8",
+    stride: 1,
+    options,
+    defaultValue: () => options.default ?? false,
+    read: (c, r) => c[r] === 1,
+    write: (c, r, v) => {
+      ;
+      c[r] = v ? 1 : 0;
+    },
+    validate(json2, path, errors) {
+      if (typeof json2 !== "boolean") errors.push(mismatch(path, "a boolean", json2));
+    },
+    toJson: (v) => v,
+    fromJson: (json2) => json2,
+    schema: () => ({ type: "boolean" })
+  })
+);
+function readStrided(c, r, n) {
+  const out = new Array(n);
+  const base = r * n;
+  for (let i = 0; i < n; i++) out[i] = c[base + i];
+  return out;
+}
+function writeStrided(c, r, n, v) {
+  const base = r * n;
+  for (let i = 0; i < n; i++) c[base + i] = v[i];
+}
+function validateNumberArray(json2, n, path, errors, min = -Infinity, max = Infinity) {
+  const expected = `an array of ${n} numbers`;
+  if (!Array.isArray(json2) || json2.length !== n) {
+    errors.push(mismatch(path, expected, json2));
+    return;
+  }
+  for (let i = 0; i < n; i++) {
+    const v = json2[i];
+    if (typeof v !== "number" || !Number.isFinite(v)) {
+      errors.push(mismatch(pointer(path, i), "a number", v));
+    } else if (v < min || v > max) {
+      errors.push(outOfRange(pointer(path, i), v, min, max));
+    }
+  }
+}
+function numberArraySchema(n, options) {
+  const items = { type: "number" };
+  if (options.min !== void 0) items.minimum = options.min;
+  if (options.max !== void 0) items.maximum = options.max;
+  return { type: "array", items, minItems: n, maxItems: n };
+}
+function vectorField(kind, zero) {
+  const n = zero.length;
+  return callable(
+    (options) => makeField({
+      kind,
+      storage: "f32",
+      stride: n,
+      options,
+      defaultValue: () => [...options.default ?? zero],
+      read: (c, r) => readStrided(c, r, n),
+      write: (c, r, v) => writeStrided(c, r, n, v),
+      validate: (json2, path, errors) => validateNumberArray(json2, n, path, errors, options.min, options.max),
+      toJson: (v) => v.map(f32ToJson),
+      fromJson: (json2) => [...json2],
+      schema: () => numberArraySchema(n, options)
+    })
+  );
+}
+const I32_MIN = -2147483648;
+const I32_MAX = 2147483647;
+const ivec3 = callable((options) => {
+  const min = Math.max(I32_MIN, options.min ?? I32_MIN);
+  const max = Math.min(I32_MAX, options.max ?? I32_MAX);
+  return makeField({
+    kind: "ivec3",
+    storage: "i32",
+    stride: 3,
+    options,
+    defaultValue: () => [...options.default ?? [0, 0, 0]],
+    read: (c, r) => readStrided(c, r, 3),
+    write: (c, r, v) => writeStrided(c, r, 3, v),
+    validate(json2, path, errors) {
+      validateNumberArray(json2, 3, path, errors, min, max);
+      if (!Array.isArray(json2) || json2.length !== 3) return;
+      for (let i = 0; i < 3; i++) {
+        const v = json2[i];
+        if (typeof v === "number" && Number.isFinite(v) && !Number.isInteger(v)) {
+          errors.push(mismatch(pointer(path, i), "an integer", v));
+        }
+      }
+    },
+    toJson: (v) => [...v],
+    fromJson: (json2) => [...json2],
+    schema: () => ({
+      type: "array",
+      items: { type: "integer", minimum: min, maximum: max },
+      minItems: 3,
+      maxItems: 3
+    })
+  });
+});
+const color = callable(
+  (options) => makeField({
+    kind: "color",
+    storage: "f32",
+    stride: 4,
+    options,
+    defaultValue: () => [...options.default ?? [1, 1, 1, 1]],
+    read: (c, r) => readStrided(c, r, 4),
+    write: (c, r, v) => writeStrided(c, r, 4, v),
+    validate(json2, path, errors) {
+      if (typeof json2 === "string") {
+        if (!HEX_COLOR.test(json2)) {
+          errors.push(
+            new ShardError("schema/type-mismatch", `Invalid color "${json2}" at ${path || "/"}`, {
+              path,
+              hint: 'Use "#rrggbb", "#rrggbbaa", or a linear [r, g, b, a] array.'
+            })
+          );
+        }
+        return;
+      }
+      validateNumberArray(json2, 4, path, errors, 0);
+    },
+    toJson: (v) => linearToHex(v) ?? v.map(f32ToJson),
+    fromJson: (json2) => typeof json2 === "string" ? hexToLinear(json2) : [...json2],
+    schema: () => ({
+      anyOf: [
+        { type: "string", pattern: HEX_COLOR.source },
+        { type: "array", items: { type: "number", minimum: 0 }, minItems: 4, maxItems: 4 }
+      ]
+    })
+  })
+);
+function enumField(values, options = {}) {
+  if (values.length === 0 || values.length > 256) {
+    throw new ShardError("schema/invalid-field", "Enums need between 1 and 256 values");
+  }
+  const index = new Map(values.map((v, i) => [v, i]));
+  return makeField({
+    kind: "enum",
+    storage: "u8",
+    stride: 1,
+    options,
+    defaultValue: () => options.default ?? values[0],
+    read: (c, r) => values[c[r]],
+    write: (c, r, v) => {
+      const i = index.get(v);
+      if (i === void 0) {
+        throw new ShardError("schema/invalid-enum", `"${v}" is not one of ${values.join(", ")}`);
+      }
+      ;
+      c[r] = i;
+    },
+    validate(json2, path, errors) {
+      if (typeof json2 !== "string" || !index.has(json2)) {
+        errors.push(
+          new ShardError(
+            "schema/type-mismatch",
+            `Expected one of ${values.map((v) => `"${v}"`).join(", ")} at ${path || "/"}, got ${JSON.stringify(json2)}`,
+            { path }
+          )
+        );
+      }
+    },
+    toJson: (v) => v,
+    fromJson: (json2) => json2,
+    schema: () => ({ type: "string", enum: [...values] })
+  });
+}
+const entity = callable(
+  (options) => makeField({
+    kind: "entity",
+    storage: "f64",
+    stride: 1,
+    options,
+    defaultValue: () => null,
+    read: (c, r) => {
+      const v = c[r];
+      return v < 0 ? null : v;
+    },
+    write: (c, r, v) => {
+      ;
+      c[r] = v ?? -1;
+    },
+    validate(json2, path, errors) {
+      const ok = json2 === null || typeof json2 === "number" && Number.isInteger(json2) && json2 >= 0 || typeof json2 === "string" && json2.length > 0;
+      if (!ok) errors.push(mismatch(path, "an entity id, an entity path, or null", json2));
+    },
+    toJson: (v) => v,
+    fromJson(json2, ctx) {
+      if (typeof json2 !== "string") return json2;
+      const resolved = ctx?.resolveEntity?.(json2);
+      if (resolved === void 0) {
+        throw new ShardError("schema/unresolved-entity", `Entity path "${json2}" did not resolve`, {
+          hint: "Entity paths are resolved by the scene loader; check the path exists."
+        });
+      }
+      return resolved;
+    },
+    schema: () => ({
+      anyOf: [{ type: "null" }, { type: "integer", minimum: 0 }, { type: "string", minLength: 1 }]
+    })
+  })
+);
+function objectField(spec) {
+  return makeField({
+    ...spec,
+    storage: "object",
+    stride: 1,
+    read: (c, r) => cloneData(c[r]),
+    write: (c, r, v) => {
+      ;
+      c[r] = cloneData(v);
+    }
+  });
+}
+const string = callable(
+  (options) => objectField({
+    kind: "string",
+    options,
+    defaultValue: () => options.default ?? "",
+    validate(json2, path, errors) {
+      if (typeof json2 !== "string") errors.push(mismatch(path, "a string", json2));
+    },
+    toJson: (v) => v,
+    fromJson: (json2) => json2,
+    schema: () => ({ type: "string" })
+  })
+);
+function handle(type, options = {}) {
+  return objectField({
+    kind: "handle",
+    options,
+    assetType: type,
+    defaultValue: () => cloneData(options.default ?? null),
+    validate(json2, path, errors, ctx) {
+      if (json2 === null) return;
+      if (!isPlainObject(json2)) {
+        errors.push(mismatch(path, `a ${type} reference { guid, path } or null`, json2));
+        return;
+      }
+      for (const key of Object.keys(json2)) {
+        if (key !== "guid" && key !== "path") errors.push(unknownField(path, key, ["guid", "path"]));
+      }
+      const { guid, path: assetPath } = json2;
+      if (guid !== void 0 && (typeof guid !== "string" || guid === "")) {
+        errors.push(mismatch(pointer(path, "guid"), "a non-empty string", guid));
+      }
+      if (assetPath !== void 0 && (typeof assetPath !== "string" || assetPath === "")) {
+        errors.push(mismatch(pointer(path, "path"), "a non-empty string", assetPath));
+      }
+      if (guid === void 0 && assetPath === void 0) {
+        errors.push(
+          new ShardError("schema/missing-field", `Asset reference at ${path || "/"} is empty`, {
+            path,
+            hint: 'Give a "guid", a "path", or both.'
+          })
+        );
+        return;
+      }
+      if (!ctx?.resolveAsset) return;
+      const resolved = ctx.resolveAsset(json2);
+      if (!resolved) {
+        errors.push(
+          new ShardError(
+            "schema/asset-not-found",
+            `No asset matches ${JSON.stringify(json2)} at ${path || "/"}`,
+            { path, hint: "Check the path, or that the asset has been imported." }
+          )
+        );
+      } else if (resolved.type !== type) {
+        errors.push(
+          new ShardError(
+            "schema/asset-type-mismatch",
+            `Expected a ${type} at ${path || "/"}, but ${resolved.path} is a ${resolved.type}`,
+            { path }
+          )
+        );
+      }
+    },
+    toJson(v) {
+      if (v === null) return null;
+      const out = {};
+      if (v.guid !== void 0) out.guid = v.guid;
+      if (v.path !== void 0) out.path = v.path;
+      return out;
+    },
+    fromJson(json2, ctx) {
+      if (json2 === null) return null;
+      const ref = json2;
+      const resolved = ctx?.resolveAsset?.(ref);
+      return { type, guid: resolved?.guid ?? ref.guid, path: resolved?.path ?? ref.path };
+    },
+    schema: () => ({
+      anyOf: [
+        { type: "null" },
+        {
+          type: "object",
+          properties: {
+            guid: { type: "string", minLength: 1 },
+            path: { type: "string", minLength: 1 }
+          },
+          additionalProperties: false,
+          minProperties: 1,
+          "x-asset-type": type
+        }
+      ]
+    })
+  });
+}
+function list(inner, options = {}) {
+  return objectField({
+    kind: "list",
+    options,
+    item: inner,
+    defaultValue: () => cloneData(options.default ?? []),
+    validate(json2, path, errors, ctx) {
+      if (!Array.isArray(json2)) {
+        errors.push(mismatch(path, "an array", json2));
+        return;
+      }
+      for (let i = 0; i < json2.length; i++) inner.validate(json2[i], pointer(path, i), errors, ctx);
+    },
+    toJson: (v) => v.map((item) => inner.toJson(item)),
+    fromJson: (json2, ctx) => json2.map((item) => inner.fromJson(item, ctx)),
+    schema: () => ({ type: "array", items: inner.jsonSchema() })
+  });
+}
+function struct(fields, options = {}) {
+  return objectField({
+    kind: "struct",
+    options,
+    fields,
+    defaultValue: () => cloneData(options.default ?? defaultsOf(fields)),
+    validate: (json2, path, errors, ctx) => validateObject(fields, json2, path, errors, ctx),
+    toJson: (v) => objectToJson(fields, v),
+    fromJson: (json2, ctx) => objectFromJson(fields, json2, ctx),
+    schema: () => objectSchema(fields)
+  });
+}
+const json = callable(
+  (options) => objectField({
+    kind: "json",
+    options,
+    defaultValue: () => cloneData(options.default ?? null),
+    validate() {
+    },
+    toJson: (v) => cloneData(v),
+    fromJson: (json2) => cloneData(json2),
+    schema: () => ({})
+  })
+);
+function defaultsOf(fields) {
+  const out = {};
+  for (const name in fields) out[name] = fields[name].defaultValue();
+  return out;
+}
+function validateObject(fields, json2, path, errors, ctx) {
+  if (!isPlainObject(json2)) {
+    errors.push(mismatch(path, "an object", json2));
+    return;
+  }
+  const known = Object.keys(fields);
+  for (const key of Object.keys(json2)) {
+    if (!Object.hasOwn(fields, key)) errors.push(unknownField(path, key, known));
+  }
+  for (const name of known) {
+    const field = fields[name];
+    const value = json2[name];
+    if (value === void 0) {
+      if (field.options.required) {
+        errors.push(
+          new ShardError("schema/missing-field", `Missing required field "${name}"`, {
+            path: pointer(path, name),
+            hint: field.options.description
+          })
+        );
+      }
+      continue;
+    }
+    field.validate(value, pointer(path, name), errors, ctx);
+  }
+}
+function objectToJson(fields, value) {
+  const out = {};
+  for (const name in fields) out[name] = fields[name].toJson(value[name]);
+  return out;
+}
+function objectFromJson(fields, json2, ctx) {
+  const out = {};
+  for (const name in fields) {
+    const field = fields[name];
+    out[name] = json2[name] === void 0 ? field.defaultValue() : field.fromJson(json2[name], ctx);
+  }
+  return out;
+}
+function objectSchema(fields) {
+  const properties = {};
+  const required = [];
+  for (const name in fields) {
+    properties[name] = fields[name].jsonSchema();
+    if (fields[name].options.required) required.push(name);
+  }
+  const schema = { type: "object", properties, additionalProperties: false };
+  if (required.length > 0) schema.required = required;
+  return schema;
+}
+const t = {
+  f32: numberField("f32"),
+  f64: numberField("f64"),
+  i8: numberField("i8"),
+  i16: numberField("i16"),
+  i32: numberField("i32"),
+  u8: numberField("u8"),
+  u16: numberField("u16"),
+  u32: numberField("u32"),
+  bool,
+  vec2: vectorField("vec2", [0, 0]),
+  vec3: vectorField("vec3", [0, 0, 0]),
+  vec4: vectorField("vec4", [0, 0, 0, 0]),
+  ivec3,
+  quat: vectorField("quat", [0, 0, 0, 1]),
+  mat3: vectorField("mat3", [1, 0, 0, 0, 1, 0, 0, 0, 1]),
+  mat4: vectorField("mat4", [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
+  affine3x4: vectorField("affine3x4", [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0]),
+  color,
+  enum: enumField,
+  entity,
+  string,
+  handle,
+  list,
+  struct,
+  json
+};
+export {
+  defaultsOf,
+  f32ToJson,
+  objectFromJson,
+  objectSchema,
+  objectToJson,
+  t,
+  validateObject
+};

package/dist/schema/index.d.ts

@@ -0,0 +1,6 @@
+export { allComponents, type ColumnLayout, type ComponentDef, type ComponentOptions, defineComponent, defineSchema, defineTag, findComponent, type Infer, type TagDef, } from './component.js';
+export type { Affine3x4, AnyField, AssetRef, Color, Column, FieldInput, FieldKind, FieldOptions, Fields, FieldType, FieldValue, InferFields, InitFields, IVec3, Mat3, Mat4, NumericStorage, Quat, ResolvedAsset, SchemaContext, Storage, TypedArray, TypedArrayFor, Vec2, Vec3, Vec4, } from './field.js';
+export { t } from './field.js';
+export { beginRedefinition, endRedefinition, isRedefinable, type Redefinition, } from './names.js';
+export { Registry, type RegistryDescription } from './registry.js';
+export { allEvents, allResources, defineEvent, defineResource, type EventDef, findEvent, findResource, type ResourceDef, type ResourceOptions, } from './resource.js';

package/dist/schema/index.js

@@ -0,0 +1,40 @@
+import {
+  allComponents,
+  defineComponent,
+  defineSchema,
+  defineTag,
+  findComponent
+} from "./component.js";
+import { t } from "./field.js";
+import {
+  beginRedefinition,
+  endRedefinition,
+  isRedefinable
+} from "./names.js";
+import { Registry } from "./registry.js";
+import {
+  allEvents,
+  allResources,
+  defineEvent,
+  defineResource,
+  findEvent,
+  findResource
+} from "./resource.js";
+export {
+  Registry,
+  allComponents,
+  allEvents,
+  allResources,
+  beginRedefinition,
+  defineComponent,
+  defineEvent,
+  defineResource,
+  defineSchema,
+  defineTag,
+  endRedefinition,
+  findComponent,
+  findEvent,
+  findResource,
+  isRedefinable,
+  t
+};

package/dist/schema/names.d.ts

@@ -0,0 +1,27 @@
+export declare function assertName(kind: string, name: string): void;
+/** Process-wide ids, dense from 0, shared by components, resources, and events. */
+export declare function allocateId(): number;
+export interface Redefinition {
+    readonly kind: 'component' | 'resource' | 'event';
+    readonly name: string;
+    /** The definition being replaced; the new one reuses its id. */
+    readonly previous: {
+        readonly id: number;
+    };
+    readonly next: {
+        readonly id: number;
+    };
+    /** Puts the previous definition back in the global catalog (a failed reload). */
+    undo(): void;
+}
+/**
+ * Starts a redefinition scope: until `endRedefinition`, defining a component, resource, or event
+ * whose name is in `namespace` and already exists replaces it, keeping its id, instead of creating
+ * a second definition. Hot reload evaluates the new project bundle inside one.
+ */
+export declare function beginRedefinition(namespace: string): void;
+/** Ends the scope and returns what was redefined. */
+export declare function endRedefinition(): Redefinition[];
+/** True when `name` may replace an existing definition right now. */
+export declare function isRedefinable(name: string): boolean;
+export declare function recordRedefinition(change: Redefinition): void;

package/dist/schema/names.js

@@ -0,0 +1,39 @@
+import { ShardError } from "../error.js";
+const NAME = /^[a-z][a-z0-9-]*\/[A-Z][A-Za-z0-9]*$/;
+function assertName(kind, name) {
+  if (!NAME.test(name)) {
+    throw new ShardError("schema/invalid-name", `Invalid ${kind} name "${name}"`, {
+      hint: 'Use "namespace/PascalName", e.g. "game/Health".'
+    });
+  }
+}
+let nextId = 0;
+function allocateId() {
+  return nextId++;
+}
+let scope;
+function beginRedefinition(namespace) {
+  if (scope) {
+    throw new ShardError("schema/redefinition-active", "A redefinition scope is already open");
+  }
+  scope = { namespace, changes: [] };
+}
+function endRedefinition() {
+  const changes = scope?.changes ?? [];
+  scope = void 0;
+  return changes;
+}
+function isRedefinable(name) {
+  return scope !== void 0 && name.startsWith(`${scope.namespace}/`);
+}
+function recordRedefinition(change) {
+  scope?.changes.push(change);
+}
+export {
+  allocateId,
+  assertName,
+  beginRedefinition,
+  endRedefinition,
+  isRedefinable,
+  recordRedefinition
+};