@entifix/core 0.1.0-0

package/dist/entity-definition/describe/describe-entity-columns.d.ts

@@ -0,0 +1,83 @@
+import { type ChildConstructor, type EntityLinkSerialization, MetaAccessorType } from '../meta-entities/meta-accessor/index.js';
+/**
+ * A displayable member of an entity, resolved from its accessor metadata. This
+ * is the contract generic UI builds itself from — a table's columns today, a
+ * form's fields later — so it stays framework-free and lives next to the
+ * metadata it derives from.
+ */
+export interface EntityFieldDescriptor {
+    /** Accessor name. The stable identity used by preferences and slots. */
+    name: string;
+    /** Wire/property key: `alias ?? name`. */
+    key: string;
+    label: string;
+    /**
+     * Catalog key for {@link label}, when the entity declared one. Resolution is
+     * the presentation layer's job — core has no locale and no catalogs, and the
+     * same descriptor feeds the server-side filter allowlist, where a translated
+     * label would be meaningless.
+     */
+    labelKey?: string;
+    type: MetaAccessorType;
+    sortable: boolean;
+    filterable: boolean;
+    order: number;
+    /** Cannot be written back. A form shows it but disables its input. */
+    readonly: boolean;
+    /** Must hold a value. A form rejects submit while it is empty. */
+    required: boolean;
+    enumValues?: readonly string[];
+    /** Catalog prefix for {@link enumValues}; a value reads as `${enumLabelKey}.${value}`. */
+    enumLabelKey?: string;
+    /** Property of a `link` target used as its display label. */
+    linkLabelProperty: string;
+    /** Property of a `link` target a picker searches on. Defaults to the label. */
+    linkSearchProperty: string;
+    /** Whether a `link` writes back its foreign key or the inlined target. */
+    linkSerialization: EntityLinkSerialization;
+    /**
+     * The class describing one row of a `composition` member, resolved from the
+     * accessor's thunk. Absent on every other type.
+     */
+    childType?: ChildConstructor;
+    /**
+     * The member is dropped when the record is copied — a unique code, an audit
+     * stamp. The identity member is always reset and is not flagged.
+     */
+    resetOnClone: boolean;
+}
+/** Types whose values are scalars a user can meaningfully sort/filter on. */
+export declare const SCALAR_TYPES: readonly MetaAccessorType[];
+/**
+ * Types whose value is a collection. None of them may ever be sorted or
+ * filtered: this descriptor is also the **server-side RSQL allowlist**, and an
+ * array compared as a scalar matches nothing — so the query would not fail, it
+ * would quietly return an empty page.
+ *
+ * Exported so `describe-entity-columns.spec.ts` can assert that this list,
+ * {@link SCALAR_TYPES} and the two reference types partition
+ * `MetaAccessorTypes` exactly. Nothing in the repo guards `MetaAccessorType`
+ * exhaustively — every switch over it has a `default` that treats the value as
+ * a string — so that partition spec is what makes an eleventh type impossible
+ * to add silently.
+ */
+export declare const COLLECTION_TYPES: readonly MetaAccessorType[];
+/**
+ * Resolves an entity's displayable members from its accessor metadata, sorted by
+ * `order` (declaration order when undeclared).
+ *
+ * Getter-kind and non-`hidden` mirror the filter {@link serializeEntity} walks,
+ * minus its `readonly` exclusion: a read-only member is still worth showing,
+ * it just cannot be written back.
+ *
+ * `sample` is an optional instance used only to infer the `type` of accessors
+ * that did not declare one.
+ *
+ * The target is a {@link ChildConstructor} rather than an `EntityConstructor`,
+ * which is wider than it looks: nothing here reads `id`, and a `composition`
+ * member's child is a **value** with accessors and no identity. So the same
+ * walk describes an entity and describes one row of the collection it owns,
+ * from one implementation.
+ */
+export declare function describeEntityColumns<TTarget extends object>(entityConstructor: ChildConstructor<TTarget>, sample?: TTarget): EntityFieldDescriptor[];
+//# sourceMappingURL=describe-entity-columns.d.ts.map

package/dist/entity-definition/describe/describe-entity-columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describe-entity-columns.d.ts","sourceRoot":"","sources":["../../../src/entity-definition/describe/describe-entity-columns.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAE5B,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,gBAAgB,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,QAAQ,EAAE,OAAO,CAAC;IAClB,kEAAkE;IAClE,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,0FAA0F;IAC1F,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6DAA6D;IAC7D,iBAAiB,EAAE,MAAM,CAAC;IAC1B,+EAA+E;IAC/E,kBAAkB,EAAE,MAAM,CAAC;IAC3B,0EAA0E;IAC1E,iBAAiB,EAAE,uBAAuB,CAAC;IAC3C;;;OAGG;IACH,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B;;;OAGG;IACH,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,6EAA6E;AAC7E,eAAO,MAAM,YAAY,EAAE,SAAS,gBAAgB,EAMnD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,gBAAgB,EAIvD,CAAC;AAkFF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,SAAS,MAAM,EAC1D,iBAAiB,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAC5C,MAAM,CAAC,EAAE,OAAO,GACf,qBAAqB,EAAE,CAazB"}

package/dist/entity-definition/describe/describe-entity-columns.js

@@ -0,0 +1,112 @@
+import { EntifixBuildError } from '../../base-entities/entifix-error/index.js';
+import { extractMetaAccessors } from '../helpers/index.js';
+import { EntityCollectionLink } from '../links/entity-collection-link/index.js';
+import { EntityLink } from '../links/entity-link/index.js';
+/** Types whose values are scalars a user can meaningfully sort/filter on. */ export const SCALAR_TYPES = [
+    'string',
+    'number',
+    'boolean',
+    'date',
+    'enum'
+];
+/**
+ * Types whose value is a collection. None of them may ever be sorted or
+ * filtered: this descriptor is also the **server-side RSQL allowlist**, and an
+ * array compared as a scalar matches nothing — so the query would not fail, it
+ * would quietly return an empty page.
+ *
+ * Exported so `describe-entity-columns.spec.ts` can assert that this list,
+ * {@link SCALAR_TYPES} and the two reference types partition
+ * `MetaAccessorTypes` exactly. Nothing in the repo guards `MetaAccessorType`
+ * exhaustively — every switch over it has a `default` that treats the value as
+ * a string — so that partition spec is what makes an eleventh type impossible
+ * to add silently.
+ */ export const COLLECTION_TYPES = [
+    'linkCollection',
+    'composition',
+    'scalarCollection'
+];
+/** `productCode` / `product-code` / `product_code` → `Product Code`. */ function humanize(name) {
+    return name.replace(/[-_]+/g, ' ').replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/\s+/g, ' ').trim().replace(/^./, (first)=>first.toUpperCase());
+}
+/**
+ * Best-effort type for accessors that did not declare one. Entities are not
+ * required to annotate every member, so a sample row keeps a bare `@accessor()`
+ * usable; a declared `type` always wins over this.
+ */ function inferType(name, value) {
+    if (value instanceof EntityLink) return 'link';
+    if (value instanceof EntityCollectionLink) return 'linkCollection';
+    if (value instanceof Date) return 'date';
+    if (typeof value === 'number') return 'number';
+    if (typeof value === 'boolean') return 'boolean';
+    if (name === 'id') return 'id';
+    return 'string';
+}
+/**
+ * A collection member declared queryable is always a mistake, so it breaks the
+ * developer rather than the query — the same posture as `applyEntityLinks`
+ * throwing on an `embedded` link it cannot build.
+ *
+ * Silently clamping to `false` was the alternative and is worse: the author
+ * keeps a declaration that reads as honoured, and the symptom is an empty
+ * result page rather than an error anyone can act on.
+ */ function assertNotQueryable(metaAccessor, type) {
+    if (!COLLECTION_TYPES.includes(type)) return;
+    if (metaAccessor.sortable !== true && metaAccessor.filterable !== true) return;
+    throw new EntifixBuildError(`"${String(metaAccessor.name)}" is a ${type} and cannot be sortable or filterable — member metadata is the server-side query allowlist, and a collection compared as a scalar matches nothing.`);
+}
+function toDescriptor(metaAccessor, index, sample) {
+    var _metaAccessor_type, _metaAccessor_linkLabelProperty, _metaAccessor_alias, _metaAccessor_label, _metaAccessor_sortable, _metaAccessor_filterable, _metaAccessor_order, _metaAccessor_readonly, _metaAccessor_required, _metaAccessor_linkSearchProperty, _metaAccessor_linkSerialization, _metaAccessor_resetOnClone;
+    const name = String(metaAccessor.name);
+    const type = (_metaAccessor_type = metaAccessor.type) != null ? _metaAccessor_type : inferType(name, sample == null ? void 0 : sample[name]);
+    assertNotQueryable(metaAccessor, type);
+    const isScalar = SCALAR_TYPES.includes(type);
+    const linkLabelProperty = (_metaAccessor_linkLabelProperty = metaAccessor.linkLabelProperty) != null ? _metaAccessor_linkLabelProperty : 'name';
+    return {
+        name,
+        key: String((_metaAccessor_alias = metaAccessor.alias) != null ? _metaAccessor_alias : metaAccessor.name),
+        label: (_metaAccessor_label = metaAccessor.label) != null ? _metaAccessor_label : humanize(name),
+        labelKey: metaAccessor.labelKey,
+        type,
+        sortable: (_metaAccessor_sortable = metaAccessor.sortable) != null ? _metaAccessor_sortable : isScalar,
+        filterable: (_metaAccessor_filterable = metaAccessor.filterable) != null ? _metaAccessor_filterable : isScalar,
+        order: (_metaAccessor_order = metaAccessor.order) != null ? _metaAccessor_order : index,
+        readonly: (_metaAccessor_readonly = metaAccessor.readonly) != null ? _metaAccessor_readonly : false,
+        required: (_metaAccessor_required = metaAccessor.required) != null ? _metaAccessor_required : false,
+        enumValues: metaAccessor.enumValues,
+        enumLabelKey: metaAccessor.enumLabelKey,
+        linkLabelProperty,
+        linkSearchProperty: (_metaAccessor_linkSearchProperty = metaAccessor.linkSearchProperty) != null ? _metaAccessor_linkSearchProperty : linkLabelProperty,
+        linkSerialization: (_metaAccessor_linkSerialization = metaAccessor.linkSerialization) != null ? _metaAccessor_linkSerialization : 'id',
+        childType: metaAccessor.childType == null ? void 0 : metaAccessor.childType.call(metaAccessor),
+        resetOnClone: (_metaAccessor_resetOnClone = metaAccessor.resetOnClone) != null ? _metaAccessor_resetOnClone : false
+    };
+}
+/**
+ * Resolves an entity's displayable members from its accessor metadata, sorted by
+ * `order` (declaration order when undeclared).
+ *
+ * Getter-kind and non-`hidden` mirror the filter {@link serializeEntity} walks,
+ * minus its `readonly` exclusion: a read-only member is still worth showing,
+ * it just cannot be written back.
+ *
+ * `sample` is an optional instance used only to infer the `type` of accessors
+ * that did not declare one.
+ *
+ * The target is a {@link ChildConstructor} rather than an `EntityConstructor`,
+ * which is wider than it looks: nothing here reads `id`, and a `composition`
+ * member's child is a **value** with accessors and no identity. So the same
+ * walk describes an entity and describes one row of the collection it owns,
+ * from one implementation.
+ */ export function describeEntityColumns(entityConstructor, sample) {
+    const seen = new Set();
+    return extractMetaAccessors(entityConstructor).filter((metaAccessor)=>{
+        if (metaAccessor.hidden || metaAccessor.kind !== 'getter') return false;
+        const name = String(metaAccessor.name);
+        if (seen.has(name)) return false;
+        seen.add(name);
+        return true;
+    }).map((metaAccessor, index)=>toDescriptor(metaAccessor, index, sample)).sort((left, right)=>left.order - right.order);
+}
+
+//# sourceMappingURL=describe-entity-columns.js.map

package/dist/entity-definition/describe/describe-entity-columns.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/entity-definition/describe/describe-entity-columns.ts"],"sourcesContent":["import { EntifixBuildError } from '../../base-entities/entifix-error/index.js';\nimport { extractMetaAccessors } from '../helpers/index.js';\nimport { EntityCollectionLink } from '../links/entity-collection-link/index.js';\nimport { EntityLink } from '../links/entity-link/index.js';\nimport {\n  type ChildConstructor,\n  type EntityLinkSerialization,\n  MetaAccessor,\n  MetaAccessorType,\n} from '../meta-entities/meta-accessor/index.js';\n\n/**\n * A displayable member of an entity, resolved from its accessor metadata. This\n * is the contract generic UI builds itself from — a table's columns today, a\n * form's fields later — so it stays framework-free and lives next to the\n * metadata it derives from.\n */\nexport interface EntityFieldDescriptor {\n  /** Accessor name. The stable identity used by preferences and slots. */\n  name: string;\n  /** Wire/property key: `alias ?? name`. */\n  key: string;\n  label: string;\n  /**\n   * Catalog key for {@link label}, when the entity declared one. Resolution is\n   * the presentation layer's job — core has no locale and no catalogs, and the\n   * same descriptor feeds the server-side filter allowlist, where a translated\n   * label would be meaningless.\n   */\n  labelKey?: string;\n  type: MetaAccessorType;\n  sortable: boolean;\n  filterable: boolean;\n  order: number;\n  /** Cannot be written back. A form shows it but disables its input. */\n  readonly: boolean;\n  /** Must hold a value. A form rejects submit while it is empty. */\n  required: boolean;\n  enumValues?: readonly string[];\n  /** Catalog prefix for {@link enumValues}; a value reads as `${enumLabelKey}.${value}`. */\n  enumLabelKey?: string;\n  /** Property of a `link` target used as its display label. */\n  linkLabelProperty: string;\n  /** Property of a `link` target a picker searches on. Defaults to the label. */\n  linkSearchProperty: string;\n  /** Whether a `link` writes back its foreign key or the inlined target. */\n  linkSerialization: EntityLinkSerialization;\n  /**\n   * The class describing one row of a `composition` member, resolved from the\n   * accessor's thunk. Absent on every other type.\n   */\n  childType?: ChildConstructor;\n  /**\n   * The member is dropped when the record is copied — a unique code, an audit\n   * stamp. The identity member is always reset and is not flagged.\n   */\n  resetOnClone: boolean;\n}\n\n/** Types whose values are scalars a user can meaningfully sort/filter on. */\nexport const SCALAR_TYPES: readonly MetaAccessorType[] = [\n  'string',\n  'number',\n  'boolean',\n  'date',\n  'enum',\n];\n\n/**\n * Types whose value is a collection. None of them may ever be sorted or\n * filtered: this descriptor is also the **server-side RSQL allowlist**, and an\n * array compared as a scalar matches nothing — so the query would not fail, it\n * would quietly return an empty page.\n *\n * Exported so `describe-entity-columns.spec.ts` can assert that this list,\n * {@link SCALAR_TYPES} and the two reference types partition\n * `MetaAccessorTypes` exactly. Nothing in the repo guards `MetaAccessorType`\n * exhaustively — every switch over it has a `default` that treats the value as\n * a string — so that partition spec is what makes an eleventh type impossible\n * to add silently.\n */\nexport const COLLECTION_TYPES: readonly MetaAccessorType[] = [\n  'linkCollection',\n  'composition',\n  'scalarCollection',\n];\n\n/** `productCode` / `product-code` / `product_code` → `Product Code`. */\nfunction humanize(name: string): string {\n  return name\n    .replace(/[-_]+/g, ' ')\n    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')\n    .replace(/\\s+/g, ' ')\n    .trim()\n    .replace(/^./, first => first.toUpperCase());\n}\n\n/**\n * Best-effort type for accessors that did not declare one. Entities are not\n * required to annotate every member, so a sample row keeps a bare `@accessor()`\n * usable; a declared `type` always wins over this.\n */\nfunction inferType(name: string, value: unknown): MetaAccessorType {\n  if (value instanceof EntityLink) return 'link';\n  if (value instanceof EntityCollectionLink) return 'linkCollection';\n  if (value instanceof Date) return 'date';\n  if (typeof value === 'number') return 'number';\n  if (typeof value === 'boolean') return 'boolean';\n  if (name === 'id') return 'id';\n  return 'string';\n}\n\n/**\n * A collection member declared queryable is always a mistake, so it breaks the\n * developer rather than the query — the same posture as `applyEntityLinks`\n * throwing on an `embedded` link it cannot build.\n *\n * Silently clamping to `false` was the alternative and is worse: the author\n * keeps a declaration that reads as honoured, and the symptom is an empty\n * result page rather than an error anyone can act on.\n */\nfunction assertNotQueryable(\n  metaAccessor: MetaAccessor,\n  type: MetaAccessorType,\n) {\n  if (!COLLECTION_TYPES.includes(type)) return;\n  if (metaAccessor.sortable !== true && metaAccessor.filterable !== true)\n    return;\n  throw new EntifixBuildError(\n    `\"${String(metaAccessor.name)}\" is a ${type} and cannot be sortable or filterable — member metadata is the server-side query allowlist, and a collection compared as a scalar matches nothing.`,\n  );\n}\n\nfunction toDescriptor(\n  metaAccessor: MetaAccessor,\n  index: number,\n  sample: unknown,\n): EntityFieldDescriptor {\n  const name = String(metaAccessor.name);\n  const type =\n    metaAccessor.type ??\n    inferType(name, (sample as Record<string, unknown> | undefined)?.[name]);\n  assertNotQueryable(metaAccessor, type);\n  const isScalar = SCALAR_TYPES.includes(type);\n  const linkLabelProperty = metaAccessor.linkLabelProperty ?? 'name';\n\n  return {\n    name,\n    key: String(metaAccessor.alias ?? metaAccessor.name),\n    label: metaAccessor.label ?? humanize(name),\n    labelKey: metaAccessor.labelKey,\n    type,\n    sortable: metaAccessor.sortable ?? isScalar,\n    filterable: metaAccessor.filterable ?? isScalar,\n    order: metaAccessor.order ?? index,\n    readonly: metaAccessor.readonly ?? false,\n    required: metaAccessor.required ?? false,\n    enumValues: metaAccessor.enumValues,\n    enumLabelKey: metaAccessor.enumLabelKey,\n    linkLabelProperty,\n    linkSearchProperty: metaAccessor.linkSearchProperty ?? linkLabelProperty,\n    linkSerialization: metaAccessor.linkSerialization ?? 'id',\n    childType: metaAccessor.childType?.(),\n    resetOnClone: metaAccessor.resetOnClone ?? false,\n  };\n}\n\n/**\n * Resolves an entity's displayable members from its accessor metadata, sorted by\n * `order` (declaration order when undeclared).\n *\n * Getter-kind and non-`hidden` mirror the filter {@link serializeEntity} walks,\n * minus its `readonly` exclusion: a read-only member is still worth showing,\n * it just cannot be written back.\n *\n * `sample` is an optional instance used only to infer the `type` of accessors\n * that did not declare one.\n *\n * The target is a {@link ChildConstructor} rather than an `EntityConstructor`,\n * which is wider than it looks: nothing here reads `id`, and a `composition`\n * member's child is a **value** with accessors and no identity. So the same\n * walk describes an entity and describes one row of the collection it owns,\n * from one implementation.\n */\nexport function describeEntityColumns<TTarget extends object>(\n  entityConstructor: ChildConstructor<TTarget>,\n  sample?: TTarget,\n): EntityFieldDescriptor[] {\n  const seen = new Set<string>();\n\n  return extractMetaAccessors(entityConstructor)\n    .filter(metaAccessor => {\n      if (metaAccessor.hidden || metaAccessor.kind !== 'getter') return false;\n      const name = String(metaAccessor.name);\n      if (seen.has(name)) return false;\n      seen.add(name);\n      return true;\n    })\n    .map((metaAccessor, index) => toDescriptor(metaAccessor, index, sample))\n    .sort((left, right) => left.order - right.order);\n}\n"],"names":["EntifixBuildError","extractMetaAccessors","EntityCollectionLink","EntityLink","SCALAR_TYPES","COLLECTION_TYPES","humanize","name","replace","trim","first","toUpperCase","inferType","value","Date","assertNotQueryable","metaAccessor","type","includes","sortable","filterable","String","toDescriptor","index","sample","isScalar","linkLabelProperty","key","alias","label","labelKey","order","readonly","required","enumValues","enumLabelKey","linkSearchProperty","linkSerialization","childType","resetOnClone","describeEntityColumns","entityConstructor","seen","Set","filter","hidden","kind","has","add","map","sort","left","right"],"mappings":"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"}

package/dist/entity-definition/describe/describe-entity-use-cases.d.ts

@@ -0,0 +1,34 @@
+import { Entity, EntityConstructor } from '../../types/Entity.js';
+import type { UseCaseBinding, UseCaseCell, UseCaseConfirm, UseCasePlacement } from '../meta-entities/meta-use-case/index.js';
+/**
+ * An action a caller may take on an entity, resolved from its use-case
+ * metadata. The counterpart to {@link EntityFieldDescriptor}, and like it,
+ * framework-free and copy-free — every human-readable member is a catalog key.
+ *
+ * It carries no `entity`: this is the shape that goes over the wire from
+ * `GET /api/<entity>/$metadata`, where the entity is already the address.
+ */
+export interface UseCaseDescriptor {
+    /** The verb. Also the third segment of the permission guarding it. */
+    key: string;
+    binding: UseCaseBinding;
+    placement: UseCasePlacement;
+    /** Further cells this same verb appears in — see `MetaUseCaseOptions`. */
+    alsoAt?: readonly UseCaseCell[];
+    labelKey: string;
+    keywordsKey?: string;
+    confirm?: UseCaseConfirm;
+    form?: string;
+}
+/**
+ * Resolves the use cases declared against an entity, in declaration order.
+ *
+ * Unlike {@link describeEntityColumns}, this is only trustworthy where the
+ * use-case modules have been loaded: a `@useCase()` class registers itself when
+ * its module evaluates. On a service that is the composition root's job, and
+ * `@r10c/slices` fails the build on a class its package barrel does not export.
+ * A browser never calls this — it fetches the descriptors instead, so no
+ * use-case implementation reaches a client bundle.
+ */
+export declare function describeEntityUseCases<TEntity extends Entity>(entityConstructor: EntityConstructor<TEntity>): UseCaseDescriptor[];
+//# sourceMappingURL=describe-entity-use-cases.d.ts.map

package/dist/entity-definition/describe/describe-entity-use-cases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describe-entity-use-cases.d.ts","sourceRoot":"","sources":["../../../src/entity-definition/describe/describe-entity-use-cases.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAElE,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EACX,cAAc,EACd,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAEjD;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAiB;IAChC,sEAAsE;IACtE,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,cAAc,CAAC;IACxB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,0EAA0E;IAC1E,MAAM,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,SAAS,MAAM,EAC3D,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,CAAC,GAC5C,iBAAiB,EAAE,CAWrB"}

package/dist/entity-definition/describe/describe-entity-use-cases.js

@@ -0,0 +1,24 @@
+import { extractMetaUseCases } from '../helpers/index.js';
+/**
+ * Resolves the use cases declared against an entity, in declaration order.
+ *
+ * Unlike {@link describeEntityColumns}, this is only trustworthy where the
+ * use-case modules have been loaded: a `@useCase()` class registers itself when
+ * its module evaluates. On a service that is the composition root's job, and
+ * `@r10c/slices` fails the build on a class its package barrel does not export.
+ * A browser never calls this — it fetches the descriptors instead, so no
+ * use-case implementation reaches a client bundle.
+ */ export function describeEntityUseCases(entityConstructor) {
+    return extractMetaUseCases(entityConstructor).map((metaUseCase)=>({
+            key: metaUseCase.key,
+            binding: metaUseCase.binding,
+            placement: metaUseCase.placement,
+            alsoAt: metaUseCase.alsoAt,
+            labelKey: metaUseCase.labelKey,
+            keywordsKey: metaUseCase.keywordsKey,
+            confirm: metaUseCase.confirm,
+            form: metaUseCase.form
+        }));
+}
+
+//# sourceMappingURL=describe-entity-use-cases.js.map

package/dist/entity-definition/describe/describe-entity-use-cases.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/entity-definition/describe/describe-entity-use-cases.ts"],"sourcesContent":["import { Entity, EntityConstructor } from '../../types/Entity.js';\nimport { extractMetaUseCases } from '../helpers/index.js';\nimport type {\n  UseCaseBinding,\n  UseCaseCell,\n  UseCaseConfirm,\n  UseCasePlacement,\n} from '../meta-entities/meta-use-case/index.js';\n\n/**\n * An action a caller may take on an entity, resolved from its use-case\n * metadata. The counterpart to {@link EntityFieldDescriptor}, and like it,\n * framework-free and copy-free — every human-readable member is a catalog key.\n *\n * It carries no `entity`: this is the shape that goes over the wire from\n * `GET /api/<entity>/$metadata`, where the entity is already the address.\n */\nexport interface UseCaseDescriptor {\n  /** The verb. Also the third segment of the permission guarding it. */\n  key: string;\n  binding: UseCaseBinding;\n  placement: UseCasePlacement;\n  /** Further cells this same verb appears in — see `MetaUseCaseOptions`. */\n  alsoAt?: readonly UseCaseCell[];\n  labelKey: string;\n  keywordsKey?: string;\n  confirm?: UseCaseConfirm;\n  form?: string;\n}\n\n/**\n * Resolves the use cases declared against an entity, in declaration order.\n *\n * Unlike {@link describeEntityColumns}, this is only trustworthy where the\n * use-case modules have been loaded: a `@useCase()` class registers itself when\n * its module evaluates. On a service that is the composition root's job, and\n * `@r10c/slices` fails the build on a class its package barrel does not export.\n * A browser never calls this — it fetches the descriptors instead, so no\n * use-case implementation reaches a client bundle.\n */\nexport function describeEntityUseCases<TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n): UseCaseDescriptor[] {\n  return extractMetaUseCases(entityConstructor).map(metaUseCase => ({\n    key: metaUseCase.key,\n    binding: metaUseCase.binding,\n    placement: metaUseCase.placement,\n    alsoAt: metaUseCase.alsoAt,\n    labelKey: metaUseCase.labelKey,\n    keywordsKey: metaUseCase.keywordsKey,\n    confirm: metaUseCase.confirm,\n    form: metaUseCase.form,\n  }));\n}\n"],"names":["extractMetaUseCases","describeEntityUseCases","entityConstructor","map","metaUseCase","key","binding","placement","alsoAt","labelKey","keywordsKey","confirm","form"],"mappings":"AACA,SAASA,mBAAmB,QAAQ,sBAAsB;AA6B1D;;;;;;;;;CASC,GACD,OAAO,SAASC,uBACdC,iBAA6C;IAE7C,OAAOF,oBAAoBE,mBAAmBC,GAAG,CAACC,CAAAA,cAAgB,CAAA;YAChEC,KAAKD,YAAYC,GAAG;YACpBC,SAASF,YAAYE,OAAO;YAC5BC,WAAWH,YAAYG,SAAS;YAChCC,QAAQJ,YAAYI,MAAM;YAC1BC,UAAUL,YAAYK,QAAQ;YAC9BC,aAAaN,YAAYM,WAAW;YACpCC,SAASP,YAAYO,OAAO;YAC5BC,MAAMR,YAAYQ,IAAI;QACxB,CAAA;AACF"}

package/dist/entity-definition/describe/index.d.ts

@@ -0,0 +1,4 @@
+export * from './describe-child-columns.js';
+export * from './describe-entity-columns.js';
+export * from './describe-entity-use-cases.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/entity-definition/describe/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/entity-definition/describe/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC"}

package/dist/entity-definition/describe/index.js

@@ -0,0 +1,5 @@
+export * from './describe-child-columns.js';
+export * from './describe-entity-columns.js';
+export * from './describe-entity-use-cases.js';
+
+//# sourceMappingURL=index.js.map

package/dist/entity-definition/describe/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/entity-definition/describe/index.ts"],"sourcesContent":["export * from './describe-child-columns.js';\nexport * from './describe-entity-columns.js';\nexport * from './describe-entity-use-cases.js';\n"],"names":[],"mappings":"AAAA,cAAc,8BAA8B;AAC5C,cAAc,+BAA+B;AAC7C,cAAc,iCAAiC"}

package/dist/entity-definition/field-path.d.ts

@@ -0,0 +1,49 @@
+/**
+ * How an error names a member of one row of an owned collection.
+ *
+ * Every error map in the stack is `Record<string, string>` keyed by accessor
+ * name, which has no way to say "the quantity of the third line". This is that
+ * key: `items[2].quantity`.
+ *
+ * ## Why the index and not the row's key
+ *
+ * A row carries a minted `ROW_KEY` that is stable across re-renders, and it is
+ * tempting to address errors by it. It cannot be done: a Standard Schema issue
+ * carries a **positional** path (`['items', 2, 'quantity']`) and nothing else,
+ * so an index is the only thing a schema-authored rule can produce. Building the
+ * map on keys would mean the metadata rules and the schema rules addressed the
+ * same cell two different ways, and `composeEntityFormErrors` merges them by key.
+ *
+ * The index being stale after a removal is harmless here, and only here: the
+ * form re-runs its whole validator on every edit (`revalidateLogic`), so no
+ * index outlives the keystroke that invalidated it. React keys cannot be
+ * recomputed that way, which is exactly why rows are keyed by `ROW_KEY` and
+ * errors are keyed by index — two identities, two jobs, neither substitutable
+ * for the other.
+ */
+/** The error-map key for `member[index].child`. */
+export declare function rowFieldPath(member: string, index: number, child: string): string;
+/** A parsed {@link rowFieldPath}. */
+export interface RowFieldPath {
+    member: string;
+    index: number;
+    child: string;
+}
+/**
+ * Reads a {@link rowFieldPath} back, or `undefined` for a plain member name.
+ *
+ * The `undefined` is what keeps every existing caller working: a top-level
+ * field's key is just its accessor name, which is not this shape, so a consumer
+ * that only understands plain names is unaffected by the ones it cannot parse.
+ */
+export declare function parseRowFieldPath(path: string): RowFieldPath | undefined;
+/**
+ * Joins a Standard Schema issue path into an error-map key.
+ *
+ * Numeric segments become `[n]` and everything else a dotted member, so
+ * `['items', 2, 'quantity']` reads as `items[2].quantity` and a lone
+ * `['name']` reads as `name` — which is what `issueFieldName` returned before
+ * nested paths existed, so no existing rule changes meaning.
+ */
+export declare function joinFieldPath(segments: readonly (string | number)[]): string;
+//# sourceMappingURL=field-path.d.ts.map

package/dist/entity-definition/field-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-path.d.ts","sourceRoot":"","sources":["../../src/entity-definition/field-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,mDAAmD;AACnD,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,MAAM,CAER;AAED,qCAAqC;AACrC,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAID;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CASxE;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,MAAM,CAO5E"}

package/dist/entity-definition/field-path.js

@@ -0,0 +1,58 @@
+/**
+ * How an error names a member of one row of an owned collection.
+ *
+ * Every error map in the stack is `Record<string, string>` keyed by accessor
+ * name, which has no way to say "the quantity of the third line". This is that
+ * key: `items[2].quantity`.
+ *
+ * ## Why the index and not the row's key
+ *
+ * A row carries a minted `ROW_KEY` that is stable across re-renders, and it is
+ * tempting to address errors by it. It cannot be done: a Standard Schema issue
+ * carries a **positional** path (`['items', 2, 'quantity']`) and nothing else,
+ * so an index is the only thing a schema-authored rule can produce. Building the
+ * map on keys would mean the metadata rules and the schema rules addressed the
+ * same cell two different ways, and `composeEntityFormErrors` merges them by key.
+ *
+ * The index being stale after a removal is harmless here, and only here: the
+ * form re-runs its whole validator on every edit (`revalidateLogic`), so no
+ * index outlives the keystroke that invalidated it. React keys cannot be
+ * recomputed that way, which is exactly why rows are keyed by `ROW_KEY` and
+ * errors are keyed by index — two identities, two jobs, neither substitutable
+ * for the other.
+ */ /** The error-map key for `member[index].child`. */ export function rowFieldPath(member, index, child) {
+    return `${member}[${index}].${child}`;
+}
+const ROW_FIELD_PATH = /^([^[\]]+)\[(\d+)]\.([^[\]]+)$/;
+/**
+ * Reads a {@link rowFieldPath} back, or `undefined` for a plain member name.
+ *
+ * The `undefined` is what keeps every existing caller working: a top-level
+ * field's key is just its accessor name, which is not this shape, so a consumer
+ * that only understands plain names is unaffected by the ones it cannot parse.
+ */ export function parseRowFieldPath(path) {
+    const match = ROW_FIELD_PATH.exec(path);
+    if (match === null) return undefined;
+    return {
+        member: match[1],
+        index: Number(match[2]),
+        child: match[3]
+    };
+}
+/**
+ * Joins a Standard Schema issue path into an error-map key.
+ *
+ * Numeric segments become `[n]` and everything else a dotted member, so
+ * `['items', 2, 'quantity']` reads as `items[2].quantity` and a lone
+ * `['name']` reads as `name` — which is what `issueFieldName` returned before
+ * nested paths existed, so no existing rule changes meaning.
+ */ export function joinFieldPath(segments) {
+    return segments.reduce((path, segment)=>{
+        if (typeof segment === 'number' || /^\d+$/.test(segment)) {
+            return `${path}[${segment}]`;
+        }
+        return path === '' ? segment : `${path}.${segment}`;
+    }, '');
+}
+
+//# sourceMappingURL=field-path.js.map

package/dist/entity-definition/field-path.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/entity-definition/field-path.ts"],"sourcesContent":["/**\n * How an error names a member of one row of an owned collection.\n *\n * Every error map in the stack is `Record<string, string>` keyed by accessor\n * name, which has no way to say \"the quantity of the third line\". This is that\n * key: `items[2].quantity`.\n *\n * ## Why the index and not the row's key\n *\n * A row carries a minted `ROW_KEY` that is stable across re-renders, and it is\n * tempting to address errors by it. It cannot be done: a Standard Schema issue\n * carries a **positional** path (`['items', 2, 'quantity']`) and nothing else,\n * so an index is the only thing a schema-authored rule can produce. Building the\n * map on keys would mean the metadata rules and the schema rules addressed the\n * same cell two different ways, and `composeEntityFormErrors` merges them by key.\n *\n * The index being stale after a removal is harmless here, and only here: the\n * form re-runs its whole validator on every edit (`revalidateLogic`), so no\n * index outlives the keystroke that invalidated it. React keys cannot be\n * recomputed that way, which is exactly why rows are keyed by `ROW_KEY` and\n * errors are keyed by index — two identities, two jobs, neither substitutable\n * for the other.\n */\n\n/** The error-map key for `member[index].child`. */\nexport function rowFieldPath(\n  member: string,\n  index: number,\n  child: string,\n): string {\n  return `${member}[${index}].${child}`;\n}\n\n/** A parsed {@link rowFieldPath}. */\nexport interface RowFieldPath {\n  member: string;\n  index: number;\n  child: string;\n}\n\nconst ROW_FIELD_PATH = /^([^[\\]]+)\\[(\\d+)]\\.([^[\\]]+)$/;\n\n/**\n * Reads a {@link rowFieldPath} back, or `undefined` for a plain member name.\n *\n * The `undefined` is what keeps every existing caller working: a top-level\n * field's key is just its accessor name, which is not this shape, so a consumer\n * that only understands plain names is unaffected by the ones it cannot parse.\n */\nexport function parseRowFieldPath(path: string): RowFieldPath | undefined {\n  const match = ROW_FIELD_PATH.exec(path);\n  if (match === null) return undefined;\n\n  return {\n    member: match[1] as string,\n    index: Number(match[2]),\n    child: match[3] as string,\n  };\n}\n\n/**\n * Joins a Standard Schema issue path into an error-map key.\n *\n * Numeric segments become `[n]` and everything else a dotted member, so\n * `['items', 2, 'quantity']` reads as `items[2].quantity` and a lone\n * `['name']` reads as `name` — which is what `issueFieldName` returned before\n * nested paths existed, so no existing rule changes meaning.\n */\nexport function joinFieldPath(segments: readonly (string | number)[]): string {\n  return segments.reduce<string>((path, segment) => {\n    if (typeof segment === 'number' || /^\\d+$/.test(segment)) {\n      return `${path}[${segment}]`;\n    }\n    return path === '' ? segment : `${path}.${segment}`;\n  }, '');\n}\n"],"names":["rowFieldPath","member","index","child","ROW_FIELD_PATH","parseRowFieldPath","path","match","exec","undefined","Number","joinFieldPath","segments","reduce","segment","test"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;CAsBC,GAED,iDAAiD,GACjD,OAAO,SAASA,aACdC,MAAc,EACdC,KAAa,EACbC,KAAa;IAEb,OAAO,GAAGF,OAAO,CAAC,EAAEC,MAAM,EAAE,EAAEC,OAAO;AACvC;AASA,MAAMC,iBAAiB;AAEvB;;;;;;CAMC,GACD,OAAO,SAASC,kBAAkBC,IAAY;IAC5C,MAAMC,QAAQH,eAAeI,IAAI,CAACF;IAClC,IAAIC,UAAU,MAAM,OAAOE;IAE3B,OAAO;QACLR,QAAQM,KAAK,CAAC,EAAE;QAChBL,OAAOQ,OAAOH,KAAK,CAAC,EAAE;QACtBJ,OAAOI,KAAK,CAAC,EAAE;IACjB;AACF;AAEA;;;;;;;CAOC,GACD,OAAO,SAASI,cAAcC,QAAsC;IAClE,OAAOA,SAASC,MAAM,CAAS,CAACP,MAAMQ;QACpC,IAAI,OAAOA,YAAY,YAAY,QAAQC,IAAI,CAACD,UAAU;YACxD,OAAO,GAAGR,KAAK,CAAC,EAAEQ,QAAQ,CAAC,CAAC;QAC9B;QACA,OAAOR,SAAS,KAAKQ,UAAU,GAAGR,KAAK,CAAC,EAAEQ,SAAS;IACrD,GAAG;AACL"}

package/dist/entity-definition/helpers/entity-definition-helpers.d.ts

@@ -0,0 +1,59 @@
+import { Entity, EntityConstructor } from '../../types/Entity.js';
+import { UseCaseConstructor } from '../../types/UseCase.js';
+import { type ChildConstructor, MetaAccessor } from '../meta-entities/meta-accessor/index.js';
+import { MetaEntity } from '../meta-entities/meta-entity/index.js';
+import { MetaMethod } from '../meta-entities/meta-method/index.js';
+import { MetaUseCase, MetaUseCaseBinding } from '../meta-entities/meta-use-case/index.js';
+declare global {
+    interface SymbolConstructor {
+        readonly metadata: unique symbol;
+    }
+}
+export declare const META_ENTITY_KEY: unique symbol;
+export declare const META_ACCESSOR_KEY: unique symbol;
+export declare const META_METHOD_KEY: unique symbol;
+export declare const META_USE_CASE_KEY: unique symbol;
+export declare const META_USE_CASE_BINDING_KEY: unique symbol;
+export declare function setMetaEntity(metadata: DecoratorMetadataObject | undefined, metaEntity: MetaEntity): void;
+export declare function appendMetaAccessor(metadata: DecoratorMetadataObject | undefined, metaAccessor: MetaAccessor): void;
+export declare function appendMetaMethod(metadata: DecoratorMetadataObject | undefined, metaMethod: MetaMethod): void;
+/**
+ * Append a use case to the metadata of the entity it acts on.
+ *
+ * This is the one decorator that writes a bag other than its own: a use case is
+ * declared on its own class, but the entity is what a surface holds, so the
+ * descriptor has to end up there. The consequence is that a use-case module
+ * which is never imported leaves the entity looking as if it had no actions,
+ * which is why `@r10c/slices` asserts every `@useCase()` class is re-exported
+ * from its package barrel.
+ *
+ * It reads the target's **own** metadata rather than going through
+ * {@link readMetadata}. `Symbol.metadata` resolves along the prototype chain, so
+ * an inherited read would append the verb to a base class's bag and leak it to
+ * every subclass. A target with no own metadata is an entity missing
+ * `@entity()`, or a circular import that evaluated the use case first.
+ */
+export declare function appendMetaUseCase<TEntity extends Entity>(target: EntityConstructor<TEntity>, metaUseCase: MetaUseCase): void;
+/**
+ * Record on the use-case class itself which entity and verb it implements, so
+ * the permission can be derived from the class alone. That is what keeps the
+ * verb string written once, at the declaration, instead of being retyped at
+ * every guard.
+ */
+export declare function setMetaUseCaseBinding(metadata: DecoratorMetadataObject | undefined, binding: MetaUseCaseBinding): void;
+export declare function extractMetaEntity<TEntity extends Entity>(target: EntityConstructor<TEntity>): MetaEntity;
+/**
+ * Every accessor declared on a class.
+ *
+ * The target is a {@link ChildConstructor}, not an `EntityConstructor`: an
+ * `@accessor()` writes to its own class's metadata bag with no help from
+ * `@entity()`, so a `composition` member's child — a value with no `id` — is
+ * described by exactly this walk.
+ */
+export declare function extractMetaAccessors(target: ChildConstructor): MetaAccessor[];
+export declare function extractMetaMethods<TEntity extends Entity>(target: EntityConstructor<TEntity>): MetaMethod[];
+/** Every use case declared against an entity. Empty until one is imported. */
+export declare function extractMetaUseCases<TEntity extends Entity>(target: EntityConstructor<TEntity>): MetaUseCase[];
+/** The entity and verb a `@useCase()` class implements. */
+export declare function extractMetaUseCaseBinding(target: UseCaseConstructor): MetaUseCaseBinding;
+//# sourceMappingURL=entity-definition-helpers.d.ts.map

package/dist/entity-definition/helpers/entity-definition-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-definition-helpers.d.ts","sourceRoot":"","sources":["../../../src/entity-definition/helpers/entity-definition-helpers.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EACL,KAAK,gBAAgB,EACrB,YAAY,EACb,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EACL,WAAW,EACX,kBAAkB,EACnB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,iBAAiB;QACzB,QAAQ,CAAC,QAAQ,EAAE,OAAO,MAAM,CAAC;KAClC;CACF;AAED,eAAO,MAAM,eAAe,eAAuB,CAAC;AACpD,eAAO,MAAM,iBAAiB,eAAyB,CAAC;AACxD,eAAO,MAAM,eAAe,eAAuB,CAAC;AACpD,eAAO,MAAM,iBAAiB,eAAwB,CAAC;AACvD,eAAO,MAAM,yBAAyB,eAA+B,CAAC;AAatE,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,uBAAuB,GAAG,SAAS,EAC7C,UAAU,EAAE,UAAU,QAGvB;AAED,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,uBAAuB,GAAG,SAAS,EAC7C,YAAY,EAAE,YAAY,QAM3B;AAED,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,uBAAuB,GAAG,SAAS,EAC7C,UAAU,EAAE,UAAU,QAKvB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,SAAS,MAAM,EACtD,MAAM,EAAE,iBAAiB,CAAC,OAAO,CAAC,EAClC,WAAW,EAAE,WAAW,QAWzB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,uBAAuB,GAAG,SAAS,EAC7C,OAAO,EAAE,kBAAkB,QAG5B;AAQD,wBAAgB,iBAAiB,CAAC,OAAO,SAAS,MAAM,EACtD,MAAM,EAAE,iBAAiB,CAAC,OAAO,CAAC,GACjC,UAAU,CAOZ;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,GAAG,YAAY,EAAE,CAG7E;AAED,wBAAgB,kBAAkB,CAAC,OAAO,SAAS,MAAM,EACvD,MAAM,EAAE,iBAAiB,CAAC,OAAO,CAAC,GACjC,UAAU,EAAE,CAGd;AAED,8EAA8E;AAC9E,wBAAgB,mBAAmB,CAAC,OAAO,SAAS,MAAM,EACxD,MAAM,EAAE,iBAAiB,CAAC,OAAO,CAAC,GACjC,WAAW,EAAE,CAGf;AAED,2DAA2D;AAC3D,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,kBAAkB,GACzB,kBAAkB,CAYpB"}

package/dist/entity-definition/helpers/entity-definition-helpers.js

@@ -0,0 +1,115 @@
+var _Symbol, _metadata;
+(_metadata = (_Symbol = Symbol).metadata) != null ? _metadata : _Symbol.metadata = Symbol.for('Symbol.metadata');
+import { EntifixBuildError } from '../../base-entities/entifix-error/index.js';
+export const META_ENTITY_KEY = Symbol('MetaEntity');
+export const META_ACCESSOR_KEY = Symbol('MetaAccessor');
+export const META_METHOD_KEY = Symbol('MetaMethod');
+export const META_USE_CASE_KEY = Symbol('MetaUseCase');
+export const META_USE_CASE_BINDING_KEY = Symbol('MetaUseCaseBinding');
+function requireMetadata(metadata) {
+    if (!metadata) {
+        throw new EntifixBuildError('Decorator metadata unavailable — Symbol.metadata polyfill missing or stage-3 decorator emit not enabled.');
+    }
+    return metadata;
+}
+export function setMetaEntity(metadata, metaEntity) {
+    requireMetadata(metadata)[META_ENTITY_KEY] = metaEntity;
+}
+export function appendMetaAccessor(metadata, metaAccessor) {
+    var _meta_META_ACCESSOR_KEY;
+    const meta = requireMetadata(metadata);
+    const existing = (_meta_META_ACCESSOR_KEY = meta[META_ACCESSOR_KEY]) != null ? _meta_META_ACCESSOR_KEY : [];
+    meta[META_ACCESSOR_KEY] = [
+        ...existing,
+        metaAccessor
+    ];
+}
+export function appendMetaMethod(metadata, metaMethod) {
+    var _meta_META_METHOD_KEY;
+    const meta = requireMetadata(metadata);
+    const existing = (_meta_META_METHOD_KEY = meta[META_METHOD_KEY]) != null ? _meta_META_METHOD_KEY : [];
+    meta[META_METHOD_KEY] = [
+        ...existing,
+        metaMethod
+    ];
+}
+/**
+ * Append a use case to the metadata of the entity it acts on.
+ *
+ * This is the one decorator that writes a bag other than its own: a use case is
+ * declared on its own class, but the entity is what a surface holds, so the
+ * descriptor has to end up there. The consequence is that a use-case module
+ * which is never imported leaves the entity looking as if it had no actions,
+ * which is why `@r10c/slices` asserts every `@useCase()` class is re-exported
+ * from its package barrel.
+ *
+ * It reads the target's **own** metadata rather than going through
+ * {@link readMetadata}. `Symbol.metadata` resolves along the prototype chain, so
+ * an inherited read would append the verb to a base class's bag and leak it to
+ * every subclass. A target with no own metadata is an entity missing
+ * `@entity()`, or a circular import that evaluated the use case first.
+ */ export function appendMetaUseCase(target, metaUseCase) {
+    var _own_META_USE_CASE_KEY;
+    var _Object_getOwnPropertyDescriptor;
+    const own = (_Object_getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(target, Symbol.metadata)) == null ? void 0 : _Object_getOwnPropertyDescriptor.value;
+    if (!own) {
+        throw new EntifixBuildError(`Use case "${metaUseCase.key}" targets ${target.name}, which has no metadata of its own — it is missing @entity(), or a circular import evaluated the use case first.`);
+    }
+    const existing = (_own_META_USE_CASE_KEY = own[META_USE_CASE_KEY]) != null ? _own_META_USE_CASE_KEY : [];
+    own[META_USE_CASE_KEY] = [
+        ...existing,
+        metaUseCase
+    ];
+}
+/**
+ * Record on the use-case class itself which entity and verb it implements, so
+ * the permission can be derived from the class alone. That is what keeps the
+ * verb string written once, at the declaration, instead of being retyped at
+ * every guard.
+ */ export function setMetaUseCaseBinding(metadata, binding) {
+    requireMetadata(metadata)[META_USE_CASE_BINDING_KEY] = binding;
+}
+function readMetadata(target) {
+    var _target_Symbol_metadata;
+    return (_target_Symbol_metadata = target[Symbol.metadata]) != null ? _target_Symbol_metadata : undefined;
+}
+export function extractMetaEntity(target) {
+    const metadata = readMetadata(target);
+    const metaEntity = metadata == null ? void 0 : metadata[META_ENTITY_KEY];
+    if (!metaEntity) {
+        throw new EntifixBuildError(`MetaEntity not found for ${target.name}`);
+    }
+    return metaEntity;
+}
+/**
+ * Every accessor declared on a class.
+ *
+ * The target is a {@link ChildConstructor}, not an `EntityConstructor`: an
+ * `@accessor()` writes to its own class's metadata bag with no help from
+ * `@entity()`, so a `composition` member's child — a value with no `id` — is
+ * described by exactly this walk.
+ */ export function extractMetaAccessors(target) {
+    var _ref;
+    const metadata = readMetadata(target);
+    return (_ref = metadata == null ? void 0 : metadata[META_ACCESSOR_KEY]) != null ? _ref : [];
+}
+export function extractMetaMethods(target) {
+    var _ref;
+    const metadata = readMetadata(target);
+    return (_ref = metadata == null ? void 0 : metadata[META_METHOD_KEY]) != null ? _ref : [];
+}
+/** Every use case declared against an entity. Empty until one is imported. */ export function extractMetaUseCases(target) {
+    var _ref;
+    const metadata = readMetadata(target);
+    return (_ref = metadata == null ? void 0 : metadata[META_USE_CASE_KEY]) != null ? _ref : [];
+}
+/** The entity and verb a `@useCase()` class implements. */ export function extractMetaUseCaseBinding(target) {
+    const metadata = target[Symbol.metadata];
+    const binding = metadata == null ? void 0 : metadata[META_USE_CASE_BINDING_KEY];
+    if (!binding) {
+        throw new EntifixBuildError(`MetaUseCase not found for ${target.name} — is it missing @useCase()?`);
+    }
+    return binding;
+}
+
+//# sourceMappingURL=entity-definition-helpers.js.map