@entifix/core 0.1.0-0

package/dist/entity-definition/links/entity-link-source/entity-link-source.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/links/entity-link-source/entity-link-source.ts"],"sourcesContent":["import { EntifixError } from '../../../base-entities/entifix-error/index.js';\nimport { Entity, EntityConstructor } from '../../../types/Entity.js';\nimport { FilterGroup } from '../../../types/EntityFiltering.js';\nimport { EntitySorting } from '../../../types/EntitySorting.js';\n\n/**\n * A paged, filterable list of link targets, expressed as state plus the commands\n * that change it.\n *\n * The member names match what a table already renders from, so a browse dialog\n * forwards this object through untouched. It carries no Effect and no React: the\n * hook that produces it lives in the integration layer, the components that\n * consume it in the controls layer, and those two may not import each other —\n * this contract in `core` is what lets them meet.\n */\nexport interface EntityLinkListView<TEntity extends Entity> {\n  items: ReadonlyArray<TEntity>;\n  totalItems: number;\n  currentPage: number;\n  pageSize: number;\n  isLoading: boolean;\n  error?: EntifixError;\n  filtering?: FilterGroup<TEntity>;\n  sorting?: EntitySorting<TEntity>;\n  onPageChange: (page: number) => void;\n  onPageSizeChange: (pageSize: number) => void;\n  onFilteringChange: (filtering: FilterGroup<TEntity>) => void;\n  onSortingChange: (sorting: EntitySorting<TEntity>) => void;\n}\n\n/** The quick half: a term, and the short list of matches it produces. */\nexport interface EntityLinkQuickSearch<TEntity extends Entity> {\n  term: string;\n  setTerm: (term: string) => void;\n  options: ReadonlyArray<TEntity>;\n  isLoading: boolean;\n  error?: EntifixError;\n}\n\n/** The browse half: the full list view, plus the dialog holding it. */\nexport interface EntityLinkBrowse<\n  TEntity extends Entity,\n> extends EntityLinkListView<TEntity> {\n  isOpen: boolean;\n  open: () => void;\n  close: () => void;\n}\n\n/**\n * Everything an editor needs in order to set one relation, and nothing about how\n * the targets are fetched.\n *\n * Two ways in, because they answer different questions: {@link quick} is\n * \"I know roughly what it is called\", {@link browse} is \"I need to look at the\n * catalog and filter it\". {@link selected} is the third, quieter one — a draft\n * restored from storage holds an id and no instance, and an id is not a name.\n */\nexport interface EntityLinkSource<TEntity extends Entity> {\n  entityConstructor: EntityConstructor<TEntity>;\n  /** Reads a target's display label, per the owner's `linkLabelProperty`. */\n  labelOf: (entity: TEntity) => string;\n  /**\n   * The currently held id, resolved into something a form can use.\n   *\n   * `entity` is the whole target, not just its name, and that matters: a draft\n   * restored from storage holds ids only, so the instance a `linkSerialization:\n   * 'embedded'` member needs at submit is gone. Resolving the id was already\n   * happening for the label — carrying the instance out is what lets the form\n   * rehydrate its selection instead of quietly writing the `id` shape onto an\n   * `embedded` member.\n   */\n  selected: { label?: string; entity?: TEntity; isLoading: boolean };\n  quick: EntityLinkQuickSearch<TEntity>;\n  browse: EntityLinkBrowse<TEntity>;\n}\n"],"names":[],"mappings":"AAgDA;;;;;;;;CAQC,GACD,WAiBC"}

package/dist/entity-definition/links/entity-link-source/index.d.ts

@@ -0,0 +1,2 @@
+export * from './entity-link-source.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/entity-definition/links/entity-link-source/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/links/entity-link-source/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC"}

package/dist/entity-definition/links/entity-link-source/index.js

@@ -0,0 +1,3 @@
+export * from './entity-link-source.js';
+
+//# sourceMappingURL=index.js.map

package/dist/entity-definition/links/entity-link-source/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/links/entity-link-source/index.ts"],"sourcesContent":["export * from './entity-link-source.js';\n"],"names":[],"mappings":"AAAA,cAAc,0BAA0B"}

package/dist/entity-definition/meta-entities/meta-accessor/index.d.ts

@@ -0,0 +1,2 @@
+export * from './meta-accessor.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/entity-definition/meta-entities/meta-accessor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/meta-entities/meta-accessor/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/entity-definition/meta-entities/meta-accessor/index.js

@@ -0,0 +1,3 @@
+export * from './meta-accessor.js';
+
+//# sourceMappingURL=index.js.map

package/dist/entity-definition/meta-entities/meta-accessor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/meta-entities/meta-accessor/index.ts"],"sourcesContent":["export * from './meta-accessor.js';\n"],"names":[],"mappings":"AAAA,cAAc,qBAAqB"}

package/dist/entity-definition/meta-entities/meta-accessor/meta-accessor.d.ts

@@ -0,0 +1,137 @@
+export type MetaAccessorKind = 'getter' | 'setter';
+/**
+ * The kinds of value an accessor can hold, as far as generic UI and adapters
+ * care. It is deliberately a presentation/behaviour taxonomy rather than a
+ * TypeScript mirror: `id` and `enum` are strings at runtime but are rendered,
+ * sorted and filtered differently.
+ */
+export declare const MetaAccessorTypes: readonly ["string", "number", "boolean", "date", "enum", "id", "link", "linkCollection", "composition", "scalarCollection"];
+export type MetaAccessorType = (typeof MetaAccessorTypes)[number];
+/**
+ * The class whose accessors describe one row of a `composition` member.
+ *
+ * Deliberately not `EntityConstructor`: a child of a composition is a **value**,
+ * not an entity. It has no identity of its own, is never addressed apart from
+ * the master that holds it, and therefore has no `id` for `Entity` to require.
+ * What it does have is `@accessor()` metadata, which is written to its own
+ * class's `Symbol.metadata` bag independently of `@entity()` — so a child is
+ * described by its accessors and by nothing else.
+ *
+ * ⚠️ It is a **shape declaration, not a runtime constructor contract.** Children
+ * arrive off the wire as plain objects — the serializer walks `instanceof
+ * EntityLink`, not the declared type, so an embedded array passes straight
+ * through — and ADR 0032 forbids a class instance inside an autosaved draft
+ * anyway. Nothing may branch on `instanceof` against this constructor.
+ */
+export type ChildConstructor<TChild extends object = object> = new (...args: any[]) => TChild;
+/**
+ * The wire shape a relation takes: the target's foreign key, or the whole
+ * target inlined. Declared here rather than next to `EntityLink` because it is
+ * metadata about a member, not state of a link instance.
+ */
+export declare const EntityLinkSerializations: readonly ["id", "embedded"];
+export type EntityLinkSerialization = (typeof EntityLinkSerializations)[number];
+export interface MetaAccessorOptions {
+    alias?: string;
+    type?: MetaAccessorType;
+    readonly?: boolean;
+    hidden?: boolean;
+    /** Member must hold a value. Drives form validation; defaults to optional. */
+    required?: boolean;
+    /** Human label for UI. Falls back to a humanized `name`. */
+    label?: string;
+    /**
+     * Translation key for the label, resolved by the presentation layer. Takes
+     * precedence over `label`, which stays as the untranslated fallback for a
+     * member that has no catalog entry yet.
+     *
+     * Keys mirror the entity's own `@entity({ key })`, so they are derivable
+     * rather than invented: `entity:product-specification.fields.code`.
+     */
+    labelKey?: string;
+    /** Opt in/out of sorting controls. Defaults per `type`. */
+    sortable?: boolean;
+    /** Opt in/out of filtering controls. Defaults per `type`. */
+    filterable?: boolean;
+    /** Default position among the entity's members; ties keep declaration order. */
+    order?: number;
+    /** Allowed values when `type` is `enum` — drives the filter value control. */
+    enumValues?: readonly string[];
+    /**
+     * Catalog prefix for those values; a value's label is `${enumLabelKey}.${value}`.
+     * Explicit rather than derived from `labelKey`, so a member whose values are
+     * shared with another member can point both at one vocabulary.
+     */
+    enumLabelKey?: string;
+    /** Property of a `link` target used as its display label. Default `name`. */
+    linkLabelProperty?: string;
+    /**
+     * Property of a `link` target a picker searches on. Defaults to
+     * {@link linkLabelProperty} — you search for what you read. It must be
+     * `filterable` on the target entity, since member metadata is also the
+     * server-side filter allowlist.
+     */
+    linkSearchProperty?: string;
+    /**
+     * How a `link` travels when its owner is serialized: as the target's scalar
+     * foreign key (`id`, the default) or with the whole target inlined
+     * (`embedded`). The serializer decides per *link instance* — it inlines
+     * whatever `isLoaded` — so without this the shape a write takes would depend
+     * on whether the form happened to hold the target. Declaring it on the entity
+     * makes the wire shape a property of the relation instead of an accident of
+     * the UI.
+     */
+    linkSerialization?: EntityLinkSerialization;
+    /**
+     * The class describing one row of a `composition` member — the child's own
+     * `@accessor()` metadata is what a detail grid renders its columns from.
+     *
+     * A **thunk**, because a child module and the entity that owns it are usually
+     * declared in the same package and a direct reference makes the decorator's
+     * evaluation order load-bearing. Deferring the read to first use removes the
+     * ordering question entirely, which is the same reason a to-one relation's
+     * target is reached through a resolver rather than an import.
+     *
+     * Meaningless on any other type. There is no inference fallback: an empty
+     * array cannot be told apart from an empty `string[]` at runtime, so a
+     * collection must be declared.
+     */
+    childType?: () => ChildConstructor;
+    /**
+     * Reset this member when the record is copied.
+     *
+     * It lives on the **accessor**, not on a use case's descriptor, and that is a
+     * decision already on file: ADR 0026 closed `UseCaseDescriptor` against
+     * per-verb payloads and named this exact case, because a descriptor that
+     * grows a field per verb ends up a union of every verb's arguments. Which
+     * members a copy must not carry is a property of the *member* — a unique
+     * code, an audit stamp, a sequence number — and it is the same answer however
+     * the copy is triggered.
+     *
+     * The identity member is always reset and needs no flag.
+     */
+    resetOnClone?: boolean;
+}
+export declare class MetaAccessor {
+    readonly name: string | symbol;
+    readonly kind: MetaAccessorKind;
+    readonly alias?: string;
+    readonly type?: MetaAccessorType;
+    readonly readonly?: boolean;
+    readonly hidden?: boolean;
+    readonly required?: boolean;
+    readonly label?: string;
+    readonly labelKey?: string;
+    readonly sortable?: boolean;
+    readonly filterable?: boolean;
+    readonly order?: number;
+    readonly enumValues?: readonly string[];
+    readonly enumLabelKey?: string;
+    readonly linkLabelProperty?: string;
+    readonly linkSearchProperty?: string;
+    readonly linkSerialization?: EntityLinkSerialization;
+    readonly childType?: () => ChildConstructor;
+    readonly resetOnClone?: boolean;
+    constructor(name: string | symbol, kind: MetaAccessorKind, options?: MetaAccessorOptions);
+}
+//# sourceMappingURL=meta-accessor.d.ts.map

package/dist/entity-definition/meta-entities/meta-accessor/meta-accessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta-accessor.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/meta-entities/meta-accessor/meta-accessor.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,6HAWpB,CAAC;AACX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,gBAAgB,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,IAAI,KAI7D,GAAG,IAAI,EAAE,GAAG,EAAE,KACX,MAAM,CAAC;AAEZ;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,6BAA8B,CAAC;AACpE,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhF,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,gBAAgB,CAAC;IACxB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,4DAA4D;IAC5D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,gFAAgF;IAChF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;IAC5C;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,EAAE,MAAM,gBAAgB,CAAC;IACnC;;;;;;;;;;;;OAYG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,qBAAa,YAAY;IAGvB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;IACrD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,gBAAgB,CAAC;IAC5C,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;gBAM9B,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,IAAI,EAAE,gBAAgB,EACtB,OAAO,CAAC,EAAE,mBAAmB;CA6BhC"}

package/dist/entity-definition/meta-entities/meta-accessor/meta-accessor.js

@@ -0,0 +1,52 @@
+/**
+ * The kinds of value an accessor can hold, as far as generic UI and adapters
+ * care. It is deliberately a presentation/behaviour taxonomy rather than a
+ * TypeScript mirror: `id` and `enum` are strings at runtime but are rendered,
+ * sorted and filtered differently.
+ */ export const MetaAccessorTypes = [
+    'string',
+    'number',
+    'boolean',
+    'date',
+    'enum',
+    'id',
+    'link',
+    'linkCollection',
+    'composition',
+    'scalarCollection'
+];
+/**
+ * The wire shape a relation takes: the target's foreign key, or the whole
+ * target inlined. Declared here rather than next to `EntityLink` because it is
+ * metadata about a member, not state of a link instance.
+ */ export const EntityLinkSerializations = [
+    'id',
+    'embedded'
+];
+export class MetaAccessor {
+    //#endregion
+    //#region Constructors
+    constructor(name, kind, options){
+        this.name = name;
+        this.kind = kind;
+        this.alias = options == null ? void 0 : options.alias;
+        this.type = options == null ? void 0 : options.type;
+        this.readonly = options == null ? void 0 : options.readonly;
+        this.hidden = options == null ? void 0 : options.hidden;
+        this.required = options == null ? void 0 : options.required;
+        this.label = options == null ? void 0 : options.label;
+        this.labelKey = options == null ? void 0 : options.labelKey;
+        this.sortable = options == null ? void 0 : options.sortable;
+        this.filterable = options == null ? void 0 : options.filterable;
+        this.order = options == null ? void 0 : options.order;
+        this.enumValues = options == null ? void 0 : options.enumValues;
+        this.enumLabelKey = options == null ? void 0 : options.enumLabelKey;
+        this.linkLabelProperty = options == null ? void 0 : options.linkLabelProperty;
+        this.linkSearchProperty = options == null ? void 0 : options.linkSearchProperty;
+        this.linkSerialization = options == null ? void 0 : options.linkSerialization;
+        this.childType = options == null ? void 0 : options.childType;
+        this.resetOnClone = options == null ? void 0 : options.resetOnClone;
+    }
+}
+
+//# sourceMappingURL=meta-accessor.js.map

package/dist/entity-definition/meta-entities/meta-accessor/meta-accessor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/meta-entities/meta-accessor/meta-accessor.ts"],"sourcesContent":["export type MetaAccessorKind = 'getter' | 'setter';\n\n/**\n * The kinds of value an accessor can hold, as far as generic UI and adapters\n * care. It is deliberately a presentation/behaviour taxonomy rather than a\n * TypeScript mirror: `id` and `enum` are strings at runtime but are rendered,\n * sorted and filtered differently.\n */\nexport const MetaAccessorTypes = [\n  'string',\n  'number',\n  'boolean',\n  'date',\n  'enum',\n  'id',\n  'link',\n  'linkCollection',\n  'composition',\n  'scalarCollection',\n] as const;\nexport type MetaAccessorType = (typeof MetaAccessorTypes)[number];\n\n/**\n * The class whose accessors describe one row of a `composition` member.\n *\n * Deliberately not `EntityConstructor`: a child of a composition is a **value**,\n * not an entity. It has no identity of its own, is never addressed apart from\n * the master that holds it, and therefore has no `id` for `Entity` to require.\n * What it does have is `@accessor()` metadata, which is written to its own\n * class's `Symbol.metadata` bag independently of `@entity()` — so a child is\n * described by its accessors and by nothing else.\n *\n * ⚠️ It is a **shape declaration, not a runtime constructor contract.** Children\n * arrive off the wire as plain objects — the serializer walks `instanceof\n * EntityLink`, not the declared type, so an embedded array passes straight\n * through — and ADR 0032 forbids a class instance inside an autosaved draft\n * anyway. Nothing may branch on `instanceof` against this constructor.\n */\nexport type ChildConstructor<TChild extends object = object> = new (\n  // Mirrors `EntityConstructor`: the arguments are the child's business, only\n  // the class identity matters here.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ...args: any[]\n) => TChild;\n\n/**\n * The wire shape a relation takes: the target's foreign key, or the whole\n * target inlined. Declared here rather than next to `EntityLink` because it is\n * metadata about a member, not state of a link instance.\n */\nexport const EntityLinkSerializations = ['id', 'embedded'] as const;\nexport type EntityLinkSerialization = (typeof EntityLinkSerializations)[number];\n\nexport interface MetaAccessorOptions {\n  alias?: string;\n  type?: MetaAccessorType;\n  readonly?: boolean;\n  hidden?: boolean;\n  /** Member must hold a value. Drives form validation; defaults to optional. */\n  required?: boolean;\n  /** Human label for UI. Falls back to a humanized `name`. */\n  label?: string;\n  /**\n   * Translation key for the label, resolved by the presentation layer. Takes\n   * precedence over `label`, which stays as the untranslated fallback for a\n   * member that has no catalog entry yet.\n   *\n   * Keys mirror the entity's own `@entity({ key })`, so they are derivable\n   * rather than invented: `entity:product-specification.fields.code`.\n   */\n  labelKey?: string;\n  /** Opt in/out of sorting controls. Defaults per `type`. */\n  sortable?: boolean;\n  /** Opt in/out of filtering controls. Defaults per `type`. */\n  filterable?: boolean;\n  /** Default position among the entity's members; ties keep declaration order. */\n  order?: number;\n  /** Allowed values when `type` is `enum` — drives the filter value control. */\n  enumValues?: readonly string[];\n  /**\n   * Catalog prefix for those values; a value's label is `${enumLabelKey}.${value}`.\n   * Explicit rather than derived from `labelKey`, so a member whose values are\n   * shared with another member can point both at one vocabulary.\n   */\n  enumLabelKey?: string;\n  /** Property of a `link` target used as its display label. Default `name`. */\n  linkLabelProperty?: string;\n  /**\n   * Property of a `link` target a picker searches on. Defaults to\n   * {@link linkLabelProperty} — you search for what you read. It must be\n   * `filterable` on the target entity, since member metadata is also the\n   * server-side filter allowlist.\n   */\n  linkSearchProperty?: string;\n  /**\n   * How a `link` travels when its owner is serialized: as the target's scalar\n   * foreign key (`id`, the default) or with the whole target inlined\n   * (`embedded`). The serializer decides per *link instance* — it inlines\n   * whatever `isLoaded` — so without this the shape a write takes would depend\n   * on whether the form happened to hold the target. Declaring it on the entity\n   * makes the wire shape a property of the relation instead of an accident of\n   * the UI.\n   */\n  linkSerialization?: EntityLinkSerialization;\n  /**\n   * The class describing one row of a `composition` member — the child's own\n   * `@accessor()` metadata is what a detail grid renders its columns from.\n   *\n   * A **thunk**, because a child module and the entity that owns it are usually\n   * declared in the same package and a direct reference makes the decorator's\n   * evaluation order load-bearing. Deferring the read to first use removes the\n   * ordering question entirely, which is the same reason a to-one relation's\n   * target is reached through a resolver rather than an import.\n   *\n   * Meaningless on any other type. There is no inference fallback: an empty\n   * array cannot be told apart from an empty `string[]` at runtime, so a\n   * collection must be declared.\n   */\n  childType?: () => ChildConstructor;\n  /**\n   * Reset this member when the record is copied.\n   *\n   * It lives on the **accessor**, not on a use case's descriptor, and that is a\n   * decision already on file: ADR 0026 closed `UseCaseDescriptor` against\n   * per-verb payloads and named this exact case, because a descriptor that\n   * grows a field per verb ends up a union of every verb's arguments. Which\n   * members a copy must not carry is a property of the *member* — a unique\n   * code, an audit stamp, a sequence number — and it is the same answer however\n   * the copy is triggered.\n   *\n   * The identity member is always reset and needs no flag.\n   */\n  resetOnClone?: boolean;\n}\n\nexport class MetaAccessor {\n  //#region Properties\n\n  readonly name: string | symbol;\n  readonly kind: MetaAccessorKind;\n  readonly alias?: string;\n  readonly type?: MetaAccessorType;\n  readonly readonly?: boolean;\n  readonly hidden?: boolean;\n  readonly required?: boolean;\n  readonly label?: string;\n  readonly labelKey?: string;\n  readonly sortable?: boolean;\n  readonly filterable?: boolean;\n  readonly order?: number;\n  readonly enumValues?: readonly string[];\n  readonly enumLabelKey?: string;\n  readonly linkLabelProperty?: string;\n  readonly linkSearchProperty?: string;\n  readonly linkSerialization?: EntityLinkSerialization;\n  readonly childType?: () => ChildConstructor;\n  readonly resetOnClone?: boolean;\n\n  //#endregion\n\n  //#region Constructors\n  constructor(\n    name: string | symbol,\n    kind: MetaAccessorKind,\n    options?: MetaAccessorOptions,\n  ) {\n    this.name = name;\n    this.kind = kind;\n    this.alias = options?.alias;\n    this.type = options?.type;\n    this.readonly = options?.readonly;\n    this.hidden = options?.hidden;\n    this.required = options?.required;\n    this.label = options?.label;\n    this.labelKey = options?.labelKey;\n    this.sortable = options?.sortable;\n    this.filterable = options?.filterable;\n    this.order = options?.order;\n    this.enumValues = options?.enumValues;\n    this.enumLabelKey = options?.enumLabelKey;\n    this.linkLabelProperty = options?.linkLabelProperty;\n    this.linkSearchProperty = options?.linkSearchProperty;\n    this.linkSerialization = options?.linkSerialization;\n    this.childType = options?.childType;\n    this.resetOnClone = options?.resetOnClone;\n  }\n  //#endregion\n\n  //#region Methods\n  //#endregion\n\n  //#region Accessors\n  //#endregion\n}\n"],"names":["MetaAccessorTypes","EntityLinkSerializations","MetaAccessor","name","kind","options","alias","type","readonly","hidden","required","label","labelKey","sortable","filterable","order","enumValues","enumLabelKey","linkLabelProperty","linkSearchProperty","linkSerialization","childType","resetOnClone"],"mappings":"AAEA;;;;;CAKC,GACD,OAAO,MAAMA,oBAAoB;IAC/B;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD,CAAU;AA0BX;;;;CAIC,GACD,OAAO,MAAMC,2BAA2B;IAAC;IAAM;CAAW,CAAU;AAqFpE,OAAO,MAAMC;IAuBX,YAAY;IAEZ,sBAAsB;IACtB,YACEC,IAAqB,EACrBC,IAAsB,EACtBC,OAA6B,CAC7B;QACA,IAAI,CAACF,IAAI,GAAGA;QACZ,IAAI,CAACC,IAAI,GAAGA;QACZ,IAAI,CAACE,KAAK,GAAGD,2BAAAA,QAASC,KAAK;QAC3B,IAAI,CAACC,IAAI,GAAGF,2BAAAA,QAASE,IAAI;QACzB,IAAI,CAACC,QAAQ,GAAGH,2BAAAA,QAASG,QAAQ;QACjC,IAAI,CAACC,MAAM,GAAGJ,2BAAAA,QAASI,MAAM;QAC7B,IAAI,CAACC,QAAQ,GAAGL,2BAAAA,QAASK,QAAQ;QACjC,IAAI,CAACC,KAAK,GAAGN,2BAAAA,QAASM,KAAK;QAC3B,IAAI,CAACC,QAAQ,GAAGP,2BAAAA,QAASO,QAAQ;QACjC,IAAI,CAACC,QAAQ,GAAGR,2BAAAA,QAASQ,QAAQ;QACjC,IAAI,CAACC,UAAU,GAAGT,2BAAAA,QAASS,UAAU;QACrC,IAAI,CAACC,KAAK,GAAGV,2BAAAA,QAASU,KAAK;QAC3B,IAAI,CAACC,UAAU,GAAGX,2BAAAA,QAASW,UAAU;QACrC,IAAI,CAACC,YAAY,GAAGZ,2BAAAA,QAASY,YAAY;QACzC,IAAI,CAACC,iBAAiB,GAAGb,2BAAAA,QAASa,iBAAiB;QACnD,IAAI,CAACC,kBAAkB,GAAGd,2BAAAA,QAASc,kBAAkB;QACrD,IAAI,CAACC,iBAAiB,GAAGf,2BAAAA,QAASe,iBAAiB;QACnD,IAAI,CAACC,SAAS,GAAGhB,2BAAAA,QAASgB,SAAS;QACnC,IAAI,CAACC,YAAY,GAAGjB,2BAAAA,QAASiB,YAAY;IAC3C;AAQF"}

package/dist/entity-definition/meta-entities/meta-entity/index.d.ts

@@ -0,0 +1,2 @@
+export * from './meta-entity.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/entity-definition/meta-entities/meta-entity/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/meta-entities/meta-entity/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/dist/entity-definition/meta-entities/meta-entity/index.js

@@ -0,0 +1,3 @@
+export * from './meta-entity.js';
+
+//# sourceMappingURL=index.js.map

package/dist/entity-definition/meta-entities/meta-entity/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/meta-entities/meta-entity/index.ts"],"sourcesContent":["export * from './meta-entity.js';\n"],"names":[],"mappings":"AAAA,cAAc,mBAAmB"}

package/dist/entity-definition/meta-entities/meta-entity/meta-entity.d.ts

@@ -0,0 +1,17 @@
+export interface MetaEntityOptions {
+    key?: string;
+    domain?: string;
+    /** Translation key for the entity's singular name, e.g. `entity:product-specification.label`. */
+    labelKey?: string;
+    /** Translation key for its plural, e.g. `entity:product-specification.plural`. */
+    pluralKey?: string;
+}
+export declare class MetaEntity {
+    readonly name: string;
+    readonly key?: string;
+    readonly domain?: string;
+    readonly labelKey?: string;
+    readonly pluralKey?: string;
+    constructor(name: string, options?: MetaEntityOptions);
+}
+//# sourceMappingURL=meta-entity.d.ts.map

package/dist/entity-definition/meta-entities/meta-entity/meta-entity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta-entity.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/meta-entities/meta-entity/meta-entity.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iGAAiG;IACjG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,UAAU;IAErB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;gBAIhB,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB;CActD"}

package/dist/entity-definition/meta-entities/meta-entity/meta-entity.js

@@ -0,0 +1,13 @@
+export class MetaEntity {
+    //#endregion
+    //#region Constructors
+    constructor(name, options){
+        this.name = name;
+        this.key = options == null ? void 0 : options.key;
+        this.domain = options == null ? void 0 : options.domain;
+        this.labelKey = options == null ? void 0 : options.labelKey;
+        this.pluralKey = options == null ? void 0 : options.pluralKey;
+    }
+}
+
+//# sourceMappingURL=meta-entity.js.map

package/dist/entity-definition/meta-entities/meta-entity/meta-entity.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/meta-entities/meta-entity/meta-entity.ts"],"sourcesContent":["export interface MetaEntityOptions {\n  key?: string;\n  domain?: string;\n  /** Translation key for the entity's singular name, e.g. `entity:product-specification.label`. */\n  labelKey?: string;\n  /** Translation key for its plural, e.g. `entity:product-specification.plural`. */\n  pluralKey?: string;\n}\n\nexport class MetaEntity {\n  //#region Properties\n  readonly name: string;\n  readonly key?: string;\n  readonly domain?: string;\n  readonly labelKey?: string;\n  readonly pluralKey?: string;\n  //#endregion\n\n  //#region Constructors\n  constructor(name: string, options?: MetaEntityOptions) {\n    this.name = name;\n    this.key = options?.key;\n    this.domain = options?.domain;\n    this.labelKey = options?.labelKey;\n    this.pluralKey = options?.pluralKey;\n  }\n  //#endregion\n\n  //#region Methods\n  //#endregion\n\n  //#region Accessors\n  //#endregion\n}\n"],"names":["MetaEntity","name","options","key","domain","labelKey","pluralKey"],"mappings":"AASA,OAAO,MAAMA;IAOX,YAAY;IAEZ,sBAAsB;IACtB,YAAYC,IAAY,EAAEC,OAA2B,CAAE;QACrD,IAAI,CAACD,IAAI,GAAGA;QACZ,IAAI,CAACE,GAAG,GAAGD,2BAAAA,QAASC,GAAG;QACvB,IAAI,CAACC,MAAM,GAAGF,2BAAAA,QAASE,MAAM;QAC7B,IAAI,CAACC,QAAQ,GAAGH,2BAAAA,QAASG,QAAQ;QACjC,IAAI,CAACC,SAAS,GAAGJ,2BAAAA,QAASI,SAAS;IACrC;AAQF"}

package/dist/entity-definition/meta-entities/meta-method/index.d.ts

@@ -0,0 +1,2 @@
+export * from './meta-method.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/entity-definition/meta-entities/meta-method/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/meta-entities/meta-method/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/dist/entity-definition/meta-entities/meta-method/index.js

@@ -0,0 +1,3 @@
+export * from './meta-method.js';
+
+//# sourceMappingURL=index.js.map

package/dist/entity-definition/meta-entities/meta-method/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/meta-entities/meta-method/index.ts"],"sourcesContent":["export * from './meta-method.js';\n"],"names":[],"mappings":"AAAA,cAAc,mBAAmB"}

package/dist/entity-definition/meta-entities/meta-method/meta-method.d.ts

@@ -0,0 +1,16 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export interface MetaMethodHttp {
+    method: HttpMethod;
+    path: string;
+}
+export interface MetaMethodOptions {
+    http?: MetaMethodHttp;
+    returnType?: string;
+}
+export declare class MetaMethod {
+    readonly name: string | symbol;
+    readonly http?: MetaMethodHttp;
+    readonly returnType?: string;
+    constructor(name: string | symbol, options?: MetaMethodOptions);
+}
+//# sourceMappingURL=meta-method.d.ts.map

package/dist/entity-definition/meta-entities/meta-method/meta-method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta-method.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/meta-entities/meta-method/meta-method.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;AAErE,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,UAAU;IAGrB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,QAAQ,CAAC,IAAI,CAAC,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;gBAKjB,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB;CAY/D"}

package/dist/entity-definition/meta-entities/meta-method/meta-method.js

@@ -0,0 +1,11 @@
+export class MetaMethod {
+    //#endregion
+    //#region Constructors
+    constructor(name, options){
+        this.name = name;
+        this.http = options == null ? void 0 : options.http;
+        this.returnType = options == null ? void 0 : options.returnType;
+    }
+}
+
+//# sourceMappingURL=meta-method.js.map

package/dist/entity-definition/meta-entities/meta-method/meta-method.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/meta-entities/meta-method/meta-method.ts"],"sourcesContent":["export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';\n\nexport interface MetaMethodHttp {\n  method: HttpMethod;\n  path: string;\n}\n\nexport interface MetaMethodOptions {\n  http?: MetaMethodHttp;\n  returnType?: string;\n}\n\nexport class MetaMethod {\n  //#region Properties\n\n  readonly name: string | symbol;\n  readonly http?: MetaMethodHttp;\n  readonly returnType?: string;\n\n  //#endregion\n\n  //#region Constructors\n  constructor(name: string | symbol, options?: MetaMethodOptions) {\n    this.name = name;\n    this.http = options?.http;\n    this.returnType = options?.returnType;\n  }\n  //#endregion\n\n  //#region Methods\n  //#endregion\n\n  //#region Accessors\n  //#endregion\n}\n"],"names":["MetaMethod","name","options","http","returnType"],"mappings":"AAYA,OAAO,MAAMA;IAOX,YAAY;IAEZ,sBAAsB;IACtB,YAAYC,IAAqB,EAAEC,OAA2B,CAAE;QAC9D,IAAI,CAACD,IAAI,GAAGA;QACZ,IAAI,CAACE,IAAI,GAAGD,2BAAAA,QAASC,IAAI;QACzB,IAAI,CAACC,UAAU,GAAGF,2BAAAA,QAASE,UAAU;IACvC;AAQF"}

package/dist/entity-definition/meta-entities/meta-use-case/index.d.ts

@@ -0,0 +1,2 @@
+export * from './meta-use-case.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/entity-definition/meta-entities/meta-use-case/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/meta-entities/meta-use-case/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/entity-definition/meta-entities/meta-use-case/index.js

@@ -0,0 +1,3 @@
+export * from './meta-use-case.js';
+
+//# sourceMappingURL=index.js.map

package/dist/entity-definition/meta-entities/meta-use-case/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/meta-entities/meta-use-case/index.ts"],"sourcesContent":["export * from './meta-use-case.js';\n"],"names":[],"mappings":"AAAA,cAAc,qBAAqB"}

package/dist/entity-definition/meta-entities/meta-use-case/meta-use-case.d.ts

@@ -0,0 +1,94 @@
+import type { Entity, EntityConstructor } from '../../../types/Entity.js';
+/** What a use case acts on: one record, a selection, or nothing. */
+export type UseCaseBinding = 'entity' | 'collection' | 'unbound';
+/**
+ * Where a surface puts the action. Deliberately **not** derivable from
+ * {@link UseCaseBinding}: an entity-bound action can be determining (a footer
+ * "Publish" that finalizes the page) or context-independent (a toolbar action
+ * available whenever a record is open). Collapsing the two would force every
+ * surface to re-derive a placement the author already knew.
+ */
+export type UseCasePlacement = 'context-dependent' | 'context-independent' | 'determining';
+/**
+ * One place a verb can appear: a binding and a placement together.
+ *
+ * The pair is the unit rather than either half, because the two answer
+ * different questions — placement decides the *surface* and binding decides the
+ * *payload* — and a verb reachable from a row and from a selection differs in
+ * both at once.
+ */
+export interface UseCaseCell {
+    binding: UseCaseBinding;
+    placement: UseCasePlacement;
+}
+/** Confirmation a surface must obtain before running the use case. */
+export interface UseCaseConfirm {
+    tone: 'destructive' | 'neutral';
+    /** Catalog key. Copy never lives in a descriptor. */
+    messageKey: string;
+}
+/**
+ * What `@useCase()` declares.
+ *
+ * `entity` is the target the verb is registered against — it is what the
+ * decorator appends to, and it is not part of the served descriptor.
+ *
+ * `labelKey` is mandatory and namespace-qualified, the `GuardedNavItem`
+ * convention: i18n is mandatory and `react/jsx-no-literals` fails the build on a
+ * string written into JSX, so a descriptor carrying copy could not be rendered.
+ *
+ * `keywordsKey` is a catalog key rather than a `string[]` so the command palette
+ * matches across locales — a user typing an English term reaches a Spanish
+ * command.
+ */
+export interface MetaUseCaseOptions<TKey extends string, TEntity extends Entity> {
+    entity: EntityConstructor<TEntity>;
+    key: TKey;
+    binding: UseCaseBinding;
+    placement: UseCasePlacement;
+    /**
+     * Further places the same verb appears, beyond the {@link binding} and
+     * {@link placement} above.
+     *
+     * ⚠️ **One verb, one permission, several surfaces.** Publishing an offering
+     * from its form, from a row menu and over a selection is one act reached three
+     * ways, and the alternative was three `@useCase()` classes — which `slices`
+     * refuses anyway, since a verb key is the third segment of one permission and
+     * two classes cannot share a key. Three classes would have meant three
+     * permissions for one act, and a grant that let somebody publish one offering
+     * but not twenty (#216).
+     *
+     * The primary cell stays where it is so that nothing already declared
+     * changes, and so a descriptor still reads as "this verb lives here" with the
+     * rest as additions.
+     */
+    alsoAt?: readonly UseCaseCell[];
+    labelKey: string;
+    keywordsKey?: string;
+    confirm?: UseCaseConfirm;
+    /** Names a form a surface should open instead of acting immediately. */
+    form?: string;
+}
+/**
+ * What the use-case class's **own** metadata carries, as opposed to what is
+ * appended to the entity. Two fields are enough to derive the permission, which
+ * is what lets `permissionForUseCase(SomeUC)` take a single argument and keeps
+ * the verb string written exactly once.
+ */
+export interface MetaUseCaseBinding {
+    entity: EntityConstructor<Entity>;
+    key: string;
+}
+export declare class MetaUseCase {
+    readonly entity: EntityConstructor<Entity>;
+    readonly key: string;
+    readonly binding: UseCaseBinding;
+    readonly placement: UseCasePlacement;
+    readonly alsoAt?: readonly UseCaseCell[];
+    readonly labelKey: string;
+    readonly keywordsKey?: string;
+    readonly confirm?: UseCaseConfirm;
+    readonly form?: string;
+    constructor(options: MetaUseCaseOptions<string, Entity>);
+}
+//# sourceMappingURL=meta-use-case.d.ts.map

package/dist/entity-definition/meta-entities/meta-use-case/meta-use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta-use-case.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/meta-entities/meta-use-case/meta-use-case.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE1E,oEAAoE;AACpE,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,CAAC;AAEjE;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAC1B,mBAAmB,GAAG,qBAAqB,GAAG,aAAa,CAAC;AAE9D;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,cAAc,CAAC;IACxB,SAAS,EAAE,gBAAgB,CAAC;CAC7B;AAED,sEAAsE;AACtE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,aAAa,GAAG,SAAS,CAAC;IAChC,qDAAqD;IACrD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,kBAAkB,CACjC,IAAI,SAAS,MAAM,EACnB,OAAO,SAAS,MAAM;IAEtB,MAAM,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;IACnC,GAAG,EAAE,IAAI,CAAC;IACV,OAAO,EAAE,cAAc,CAAC;IACxB,SAAS,EAAE,gBAAgB,CAAC;IAC5B;;;;;;;;;;;;;;;OAeG;IACH,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,wEAAwE;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAClC,GAAG,EAAE,MAAM,CAAC;CACb;AAED,qBAAa,WAAW;IAEtB,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAC3C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;gBAIX,OAAO,EAAE,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC;CAkBxD"}

package/dist/entity-definition/meta-entities/meta-use-case/meta-use-case.js

@@ -0,0 +1,17 @@
+export class MetaUseCase {
+    //#endregion
+    //#region Constructors
+    constructor(options){
+        this.entity = options.entity;
+        this.key = options.key;
+        this.binding = options.binding;
+        this.placement = options.placement;
+        this.alsoAt = options.alsoAt;
+        this.labelKey = options.labelKey;
+        this.keywordsKey = options.keywordsKey;
+        this.confirm = options.confirm;
+        this.form = options.form;
+    }
+}
+
+//# sourceMappingURL=meta-use-case.js.map

package/dist/entity-definition/meta-entities/meta-use-case/meta-use-case.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/meta-entities/meta-use-case/meta-use-case.ts"],"sourcesContent":["import type { Entity, EntityConstructor } from '../../../types/Entity.js';\n\n/** What a use case acts on: one record, a selection, or nothing. */\nexport type UseCaseBinding = 'entity' | 'collection' | 'unbound';\n\n/**\n * Where a surface puts the action. Deliberately **not** derivable from\n * {@link UseCaseBinding}: an entity-bound action can be determining (a footer\n * \"Publish\" that finalizes the page) or context-independent (a toolbar action\n * available whenever a record is open). Collapsing the two would force every\n * surface to re-derive a placement the author already knew.\n */\nexport type UseCasePlacement =\n  'context-dependent' | 'context-independent' | 'determining';\n\n/**\n * One place a verb can appear: a binding and a placement together.\n *\n * The pair is the unit rather than either half, because the two answer\n * different questions — placement decides the *surface* and binding decides the\n * *payload* — and a verb reachable from a row and from a selection differs in\n * both at once.\n */\nexport interface UseCaseCell {\n  binding: UseCaseBinding;\n  placement: UseCasePlacement;\n}\n\n/** Confirmation a surface must obtain before running the use case. */\nexport interface UseCaseConfirm {\n  tone: 'destructive' | 'neutral';\n  /** Catalog key. Copy never lives in a descriptor. */\n  messageKey: string;\n}\n\n/**\n * What `@useCase()` declares.\n *\n * `entity` is the target the verb is registered against — it is what the\n * decorator appends to, and it is not part of the served descriptor.\n *\n * `labelKey` is mandatory and namespace-qualified, the `GuardedNavItem`\n * convention: i18n is mandatory and `react/jsx-no-literals` fails the build on a\n * string written into JSX, so a descriptor carrying copy could not be rendered.\n *\n * `keywordsKey` is a catalog key rather than a `string[]` so the command palette\n * matches across locales — a user typing an English term reaches a Spanish\n * command.\n */\nexport interface MetaUseCaseOptions<\n  TKey extends string,\n  TEntity extends Entity,\n> {\n  entity: EntityConstructor<TEntity>;\n  key: TKey;\n  binding: UseCaseBinding;\n  placement: UseCasePlacement;\n  /**\n   * Further places the same verb appears, beyond the {@link binding} and\n   * {@link placement} above.\n   *\n   * ⚠️ **One verb, one permission, several surfaces.** Publishing an offering\n   * from its form, from a row menu and over a selection is one act reached three\n   * ways, and the alternative was three `@useCase()` classes — which `slices`\n   * refuses anyway, since a verb key is the third segment of one permission and\n   * two classes cannot share a key. Three classes would have meant three\n   * permissions for one act, and a grant that let somebody publish one offering\n   * but not twenty (#216).\n   *\n   * The primary cell stays where it is so that nothing already declared\n   * changes, and so a descriptor still reads as \"this verb lives here\" with the\n   * rest as additions.\n   */\n  alsoAt?: readonly UseCaseCell[];\n  labelKey: string;\n  keywordsKey?: string;\n  confirm?: UseCaseConfirm;\n  /** Names a form a surface should open instead of acting immediately. */\n  form?: string;\n}\n\n/**\n * What the use-case class's **own** metadata carries, as opposed to what is\n * appended to the entity. Two fields are enough to derive the permission, which\n * is what lets `permissionForUseCase(SomeUC)` take a single argument and keeps\n * the verb string written exactly once.\n */\nexport interface MetaUseCaseBinding {\n  entity: EntityConstructor<Entity>;\n  key: string;\n}\n\nexport class MetaUseCase {\n  //#region Properties\n  readonly entity: EntityConstructor<Entity>;\n  readonly key: string;\n  readonly binding: UseCaseBinding;\n  readonly placement: UseCasePlacement;\n  readonly alsoAt?: readonly UseCaseCell[];\n  readonly labelKey: string;\n  readonly keywordsKey?: string;\n  readonly confirm?: UseCaseConfirm;\n  readonly form?: string;\n  //#endregion\n\n  //#region Constructors\n  constructor(options: MetaUseCaseOptions<string, Entity>) {\n    this.entity = options.entity;\n    this.key = options.key;\n    this.binding = options.binding;\n    this.placement = options.placement;\n    this.alsoAt = options.alsoAt;\n    this.labelKey = options.labelKey;\n    this.keywordsKey = options.keywordsKey;\n    this.confirm = options.confirm;\n    this.form = options.form;\n  }\n  //#endregion\n\n  //#region Methods\n  //#endregion\n\n  //#region Accessors\n  //#endregion\n}\n"],"names":["MetaUseCase","options","entity","key","binding","placement","alsoAt","labelKey","keywordsKey","confirm","form"],"mappings":"AA4FA,OAAO,MAAMA;IAWX,YAAY;IAEZ,sBAAsB;IACtB,YAAYC,OAA2C,CAAE;QACvD,IAAI,CAACC,MAAM,GAAGD,QAAQC,MAAM;QAC5B,IAAI,CAACC,GAAG,GAAGF,QAAQE,GAAG;QACtB,IAAI,CAACC,OAAO,GAAGH,QAAQG,OAAO;QAC9B,IAAI,CAACC,SAAS,GAAGJ,QAAQI,SAAS;QAClC,IAAI,CAACC,MAAM,GAAGL,QAAQK,MAAM;QAC5B,IAAI,CAACC,QAAQ,GAAGN,QAAQM,QAAQ;QAChC,IAAI,CAACC,WAAW,GAAGP,QAAQO,WAAW;QACtC,IAAI,CAACC,OAAO,GAAGR,QAAQQ,OAAO;QAC9B,IAAI,CAACC,IAAI,GAAGT,QAAQS,IAAI;IAC1B;AAQF"}

package/dist/entity-definition/metadata/entity-metadata-document.d.ts

@@ -0,0 +1,23 @@
+import type { EntityAction } from '../../types/EntityAction.js';
+import type { UseCaseDescriptor } from '../describe/describe-entity-use-cases.js';
+/**
+ * What a caller may do with one entity, as answered by
+ * `GET /api/<entity>/$metadata`.
+ *
+ * Both members are **already filtered against the verified principal** — the
+ * service computes them through `PolicyDecisionTag`, so this is not a catalogue
+ * of everything the model declares but of what this caller is permitted. A UI
+ * renders it directly; it never re-checks, and it has nothing to re-check with.
+ *
+ * `actions` is here beside `useCases` because Save and Delete are the three most
+ * common affordances on any screen and they have no descriptor — without them a
+ * form would keep rendering its buttons unconditionally and the document would
+ * describe only the rare half of the surface.
+ */
+export interface EntityMetadataDocument {
+    /** The CRUD subset this caller holds, in {@link ENTITY_ACTIONS} order. */
+    actions: EntityAction[];
+    /** The declared use cases this caller may invoke, in declaration order. */
+    useCases: UseCaseDescriptor[];
+}
+//# sourceMappingURL=entity-metadata-document.d.ts.map

package/dist/entity-definition/metadata/entity-metadata-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-metadata-document.d.ts","sourceRoot":"","sources":["../../../src/entity-definition/metadata/entity-metadata-document.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAC;AAElF;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,sBAAsB;IACrC,0EAA0E;IAC1E,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,2EAA2E;IAC3E,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B"}

package/dist/entity-definition/metadata/entity-metadata-document.js

@@ -0,0 +1,16 @@
+/**
+ * What a caller may do with one entity, as answered by
+ * `GET /api/<entity>/$metadata`.
+ *
+ * Both members are **already filtered against the verified principal** — the
+ * service computes them through `PolicyDecisionTag`, so this is not a catalogue
+ * of everything the model declares but of what this caller is permitted. A UI
+ * renders it directly; it never re-checks, and it has nothing to re-check with.
+ *
+ * `actions` is here beside `useCases` because Save and Delete are the three most
+ * common affordances on any screen and they have no descriptor — without them a
+ * form would keep rendering its buttons unconditionally and the document would
+ * describe only the rare half of the surface.
+ */ export { };
+
+//# sourceMappingURL=entity-metadata-document.js.map

package/dist/entity-definition/metadata/entity-metadata-document.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/entity-definition/metadata/entity-metadata-document.ts"],"sourcesContent":["import type { EntityAction } from '../../types/EntityAction.js';\nimport type { UseCaseDescriptor } from '../describe/describe-entity-use-cases.js';\n\n/**\n * What a caller may do with one entity, as answered by\n * `GET /api/<entity>/$metadata`.\n *\n * Both members are **already filtered against the verified principal** — the\n * service computes them through `PolicyDecisionTag`, so this is not a catalogue\n * of everything the model declares but of what this caller is permitted. A UI\n * renders it directly; it never re-checks, and it has nothing to re-check with.\n *\n * `actions` is here beside `useCases` because Save and Delete are the three most\n * common affordances on any screen and they have no descriptor — without them a\n * form would keep rendering its buttons unconditionally and the document would\n * describe only the rare half of the surface.\n */\nexport interface EntityMetadataDocument {\n  /** The CRUD subset this caller holds, in {@link ENTITY_ACTIONS} order. */\n  actions: EntityAction[];\n  /** The declared use cases this caller may invoke, in declaration order. */\n  useCases: UseCaseDescriptor[];\n}\n"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;CAaC,GACD,WAKC"}

package/dist/entity-definition/metadata/entity-metadata-source.d.ts

@@ -0,0 +1,19 @@
+import type { Entity, EntityConstructor } from '../../types/Entity.js';
+import type { EntityMetadataDocument } from './entity-metadata-document.js';
+/**
+ * Where a UI gets an entity's {@link EntityMetadataDocument} from.
+ *
+ * A port, for the same reason `EntityLinkSource` is one: the implementation that
+ * fetches lives in the client layer, the components that render live in the
+ * controls layer, and those two may not import each other — this contract in
+ * `core` is what lets them meet. It carries no Effect and no React deliberately.
+ *
+ * The indirection is also what keeps use-case *implementations* out of a client
+ * bundle. A browser must never import a `@useCase()` class: that would drag its
+ * `Effect` body, its repository tags and its whole import closure across the
+ * wire. It fetches descriptors instead.
+ */
+export interface EntityMetadataSource {
+    fetchMetadata<TEntity extends Entity>(entityConstructor: EntityConstructor<TEntity>): Promise<EntityMetadataDocument>;
+}
+//# sourceMappingURL=entity-metadata-source.d.ts.map

package/dist/entity-definition/metadata/entity-metadata-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-metadata-source.d.ts","sourceRoot":"","sources":["../../../src/entity-definition/metadata/entity-metadata-source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAE5E;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,oBAAoB;IACnC,aAAa,CAAC,OAAO,SAAS,MAAM,EAClC,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,CAAC,GAC5C,OAAO,CAAC,sBAAsB,CAAC,CAAC;CACpC"}