@formicoidea/labre-core 0.30.1 → 0.32.0

package/dist/_pkgs/affine-shared/services/toolbar-service/registry.js

@@ -2,7 +2,7 @@ import { createIdentifier } from '../../../global/di/index.js';
 import { StdIdentifier } from '../../../std/index.js';
 import { Extension } from '../../../store/index.js';
 import { signal } from '@preact/signals-core';
-import { Flags } from './flags';
+import { Flags } from './flags.js';
 export const ToolbarModuleIdentifier = createIdentifier('AffineToolbarModuleIdentifier');
 export const ToolbarRegistryIdentifier = createIdentifier('AffineToolbarRegistryIdentifier');
 export function ToolbarModuleExtension(module) {

package/dist/_pkgs/affine-shared/services/translation-service/index.d.ts

@@ -0,0 +1,68 @@
+import type { BlockStdScope } from '../../../std/index.js';
+import type { ExtensionType } from '../../../store/index.js';
+/**
+ * The library holds no prose: every human-readable string it produces —
+ * shortcut labels, role names, validation messages — is an i18n KEY
+ * (`com.labre.wardley.validation.change-arrow-against-evolution`). Historically those
+ * keys never had to be rendered here: `getShortcutManifest` hands them to the
+ * host, which owns the catalogue and the settings panel.
+ *
+ * PF7 is the first library UI that has to SHOW one — a violation bubble names
+ * the rule it reports. This is the seam for it, and nothing more: the host
+ * injects a catalogue, the library asks it for a key. There is no bundled
+ * catalogue, no locale negotiation and no pluralisation. Those belong to the
+ * host, which already runs an i18n stack.
+ *
+ * Mirrors `TelemetryExtension` / `KeymapOverrideExtension`: an optional
+ * host-injected service, absent by default, with a graceful fallback at every
+ * call site (see {@link translateKey}).
+ *
+ * A host builds its catalogue from `getTranslationKeyManifest()`
+ * (`@labre/affine/translations`) — every key the library can ask for, with its
+ * English fallback — rather than chasing call sites. See `./README.md`.
+ */
+export interface TranslationService {
+    /**
+     * Resolve an i18n key. Return `undefined` when the catalogue has no entry,
+     * so the caller can fall back rather than render an empty bubble.
+     */
+    t(key: string): string | undefined;
+    /**
+     * The language the catalogue is currently serving, as a BCP-47 tag
+     * (`'fr'`, `'en-GB'`). Optional, and NOT locale negotiation — the library
+     * still holds no catalogue and still chooses nothing.
+     *
+     * It exists for the one kind of statement the library cannot make without
+     * knowing the language: a suggestion ABOUT WORDS. A naming convention is a
+     * motif in one language (see `ReadingNamingConvention.lang`), and applying an
+     * English motif to a board named in French produces a confident wrong answer
+     * in both directions. The host that owns the catalogue is the only thing here
+     * that knows which language the user is working in; a host that does not say
+     * gets silence rather than a guess.
+     */
+    language?: string;
+}
+/**
+ * The primary subtag of the host's language, lower-cased — `'fr'` for
+ * `'fr-CA'` — or `undefined` when no host said.
+ *
+ * Primary subtag only: a naming motif is a property of a LANGUAGE, and no
+ * framework has a convention that holds in `en-GB` and not in `en-US`.
+ */
+export declare function hostLanguage(std: BlockStdScope): string | undefined;
+export declare const TranslationProvider: import("../../../global/di/types.js").ServiceIdentifier<TranslationService> & (<U extends TranslationService = TranslationService>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);
+export declare const TranslationExtension: (service: TranslationService) => ExtensionType;
+/**
+ * Resolve `key`, falling back to `fallback` — which defaults to the key itself.
+ *
+ * Two deliberate cases:
+ *
+ * - **Framework prose** (a rule message, a role name) passes NO fallback. With
+ *   no catalogue registered the raw key is shown. It is ugly, and that is the
+ *   point: the library must never invent the wording of somebody else's rule,
+ *   and a dangling key is a bug the host has to see rather than a sentence we
+ *   made up.
+ * - **Chrome** (the word "Warning" on a severity chip) passes an English
+ *   default, so a standalone playground reads correctly without a catalogue.
+ */
+export declare function translateKey(std: BlockStdScope, key: string, fallback?: string): string;

package/dist/_pkgs/affine-shared/services/translation-service/index.js

@@ -0,0 +1,39 @@
+import { createIdentifier } from '../../../global/di/index.js';
+/**
+ * The primary subtag of the host's language, lower-cased — `'fr'` for
+ * `'fr-CA'` — or `undefined` when no host said.
+ *
+ * Primary subtag only: a naming motif is a property of a LANGUAGE, and no
+ * framework has a convention that holds in `en-GB` and not in `en-US`.
+ */
+export function hostLanguage(std) {
+    const tag = std.getOptional(TranslationProvider)?.language;
+    if (typeof tag !== 'string' || tag.length === 0)
+        return undefined;
+    return tag.split('-')[0].toLowerCase();
+}
+export const TranslationProvider = createIdentifier('AffineTranslationService');
+export const TranslationExtension = (service) => {
+    return {
+        setup: di => {
+            di.override(TranslationProvider, () => service);
+        },
+    };
+};
+/**
+ * Resolve `key`, falling back to `fallback` — which defaults to the key itself.
+ *
+ * Two deliberate cases:
+ *
+ * - **Framework prose** (a rule message, a role name) passes NO fallback. With
+ *   no catalogue registered the raw key is shown. It is ugly, and that is the
+ *   point: the library must never invent the wording of somebody else's rule,
+ *   and a dangling key is a bug the host has to see rather than a sentence we
+ *   made up.
+ * - **Chrome** (the word "Warning" on a severity chip) passes an English
+ *   default, so a standalone playground reads correctly without a catalogue.
+ */
+export function translateKey(std, key, fallback = key) {
+    const resolved = std.getOptional(TranslationProvider)?.t(key);
+    return resolved !== undefined && resolved !== '' ? resolved : fallback;
+}

package/dist/_pkgs/affine-shared/services/universe-tag-defs-service.d.ts

@@ -0,0 +1,155 @@
+import type { BlockStdScope, FrameworkId } from '../../std/index.js';
+import type { RoleDefs, RoleId } from '../../std/gfx/index.js';
+import type { ExtensionType } from '../../store/index.js';
+/**
+ * `'<framework>:<local>'` — e.g. `'wardley:component'`, `'wardley:nature'`.
+ *
+ * A **seed-time** validation aid only. Persisted values are plain `string`s and
+ * are never narrowed to this, because a document may legitimately carry an id
+ * whose def was removed, renamed or never seeded in this deployment — and it
+ * must still open.
+ */
+export type QualifiedId = `${string}:${string}`;
+/** `'<tagId>/<local>'` — e.g. `'wardley:nature/data'`. */
+export type TagValueId = string;
+export type TagValueDef = {
+    /** `'<tagId>/<local>'`, e.g. `'wardley:nature/data'`. */
+    id: TagValueId;
+    /** Display label, already localized by the host. */
+    label: string;
+    description?: string;
+    /** Advisory colour token. The library may ignore it; it never affects layout. */
+    color?: string;
+    /** Hidden from pickers; still displayed when already present on an element. */
+    deprecated?: boolean;
+};
+export type TagDef = {
+    /** `'<framework>:<local>'`, e.g. `'wardley:nature'`. */
+    id: QualifiedId;
+    label: string;
+    description?: string;
+    /** How many values an element may carry for this tag. */
+    cardinality: 'single' | 'multi';
+    /** A closed list, or `'open'` for free-text values. */
+    values: TagValueDef[] | 'open';
+    /**
+     * Role ids this tag qualifies. `'*'` = every role of this framework.
+     * Specialisation applies: a tag on `'wardley:component'` also applies to
+     * every role whose `parent` chain reaches it — resolved with `roleIsA`
+     * against the framework's own `RoleDefs`, which the CALLER supplies.
+     */
+    appliesTo: RoleId[] | '*';
+    /**
+     * Advisory only. A missing "required" tag is reported by the rules engine; it
+     * NEVER blocks a gesture, a save, or a document load.
+     */
+    required?: boolean;
+    /** Ascending display order. Ties broken by seed order, then by id. */
+    order?: number;
+    deprecated?: boolean;
+};
+/**
+ * One pack of tag definitions. Plain data — no functions, no classes, no
+ * `Symbol` — so the TS type IS the JSON schema and a pack can ship as a `.json`
+ * asset.
+ *
+ * `roles` is deliberately absent: roles are lib-side data modules shipped by
+ * the framework that renders them (`WARDLEY_ROLES`), not app-seeded, and never
+ * pass through this registry (ADR 0007 § 2bis).
+ */
+export type UniverseTagDefs = {
+    /** Bumped only on a breaking change to THIS format. Currently 1. */
+    formatVersion: 1;
+    /**
+     * Unique id of this *pack*, not of the framework: several packs may extend
+     * the same framework (a base Wardley pack + a client's private extension).
+     * Doubles as the DI variant.
+     */
+    packId: string;
+    framework: FrameworkId;
+    label: string;
+    tags: TagDef[];
+};
+/** A seed-time problem, for a host diagnostics panel. Never thrown. */
+export type UniverseDefIssue = {
+    severity: 'warning' | 'error';
+    code: 'invalid-id' | 'cross-framework-id' | 'duplicate-conflict' | 'unsupported-format-version';
+    id?: string;
+    message: string;
+};
+/**
+ * Merged, validated, read-only view over the registered packs. **TAGS ONLY.**
+ */
+export interface UniverseRegistry {
+    frameworks(): FrameworkId[];
+    /**
+     * Tags applying to a role, ordered. Role specialisation is resolved with
+     * `roleIsA` against the framework's own `RoleDefs`, which the caller supplies
+     * — the registry holds no role vocabulary of its own.
+     */
+    tagsForRole(roleId: RoleId, defs: RoleDefs): TagDef[];
+    tag(id: string): TagDef | undefined;
+    /** Every merged tag, ordered. */
+    tags(): TagDef[];
+    /** Seed-time problems. Never thrown. */
+    issues(): UniverseDefIssue[];
+}
+/**
+ * Variant-parameterized: **one registration per pack, keyed by `packId`** —
+ * the same mechanism as `SpotlightHostExtension(elementType)` and
+ * `ExternalGroupByConfigProvider(config.name)`.
+ */
+export declare const UniverseTagDefsProvider: import("../../global/di/types.js").ServiceIdentifier<UniverseTagDefs> & (<U extends UniverseTagDefs = UniverseTagDefs>(variant: import("../../global/di/types.js").ServiceVariant) => import("../../global/di/types.js").ServiceIdentifier<U>);
+/**
+ * Seed one or more packs.
+ *
+ * `di.override`, **not** `di.addImpl`: `addImpl` throws
+ * `DuplicateServiceDefinitionError` when the same `[scope, identifier, variant]`
+ * is registered twice, while `override` works whether or not a prior
+ * registration exists. That is exactly the idempotency this needs — **distinct
+ * `packId`s accumulate, identical `packId`s replace** — so a host that
+ * re-registers on every render never throws and never grows the registry.
+ *
+ * Order stability is load-bearing and non-obvious: `getAll` returns a
+ * `Map<ServiceVariant, T>`, and `Map.set` on an EXISTING key keeps that key's
+ * original insertion position. Re-seeding a pack therefore updates it in place
+ * rather than moving it to the end, so a re-registration cannot silently flip
+ * which pack wins a cosmetic field.
+ *
+ * **All packs MUST be registered in the same DI scope.** `getAllRaw` falls back
+ * to the parent scope only when the current scope has no registration for the
+ * identifier AT ALL; it never merges across scopes. Seeding one pack from a
+ * `StoreExtension` and another from a `ViewExtension` would silently hide the
+ * first behind the second. The library cannot enforce this, so it is stated
+ * here and belongs in the host integration checklist.
+ */
+export declare function UniverseTagDefsExtension(defs: UniverseTagDefs | UniverseTagDefs[]): ExtensionType;
+/**
+ * Merge every registered pack into one read-only view.
+ *
+ * Pure, so it is testable with literals and no container. The merge rules, in
+ * full:
+ *
+ * - **Union by id.** Several packs may extend the same universe.
+ * - **Additive fields merge:** `values` are unioned by value id, `appliesTo`
+ *   arrays are unioned, and `'*'` absorbs any list.
+ * - **Cosmetic fields — last pack wins:** `label`, `description`, `color`,
+ *   `order`, `required`, `deprecated`.
+ * - **Structural fields — first pack wins, conflict recorded:** `cardinality`,
+ *   and `values: 'open'` vs a closed list. The conflict becomes a
+ *   `duplicate-conflict` error issue and does NOT throw. A host that needs a
+ *   deterministic winner should not define the same structural field twice; the
+ *   registry reports the collision rather than guessing.
+ * - **Idempotent by value.** Activating a universe twice yields the same
+ *   registry.
+ */
+export declare function buildUniverseRegistry(packs: readonly UniverseTagDefs[]): UniverseRegistry;
+/**
+ * Whether a tag qualifies a role, following specialisation: a tag declared on
+ * `'wardley:component'` also applies to `'wardley:market'`, which specialises
+ * it. `'*'` matches every role of the tag's own framework and nothing else —
+ * a wildcard that crossed framework boundaries would make two taxonomies
+ * qualify each other's elements.
+ */
+export declare function tagAppliesToRole(def: TagDef, roleId: RoleId | undefined, defs: RoleDefs): boolean;
+export declare function getUniverseRegistry(std: BlockStdScope): UniverseRegistry;

package/dist/_pkgs/affine-shared/services/universe-tag-defs-service.js

@@ -0,0 +1,254 @@
+/**
+ * Per-universe tag definitions — the format, the seeding mechanism and the
+ * merged read-only view over them (MF3 / ADR 0007 §§ 2 and 3).
+ *
+ * The **application seeds** the definitions per universe; the **library fixes
+ * their format**. That split is the whole point: a new business universe
+ * (cynefin, TOGAF, a client's private taxonomy) must be addable without
+ * shipping library code. The library ships exactly one pack of its own —
+ * Wardley's four natures — as a worked example, on the same mechanism a host
+ * would use.
+ *
+ * Three rules govern everything below, and they are not negotiable:
+ *
+ * - **Nothing throws, ever.** An invalid id, a cross-framework id, an
+ *   unrecognised `formatVersion` — each drops the offending def and records an
+ *   issue. A malformed seed must never prevent a document from opening. That is
+ *   the hard boundary between "the app misconfigured a pack" and "the user lost
+ *   their board".
+ * - **Defs are runtime configuration and are NEVER persisted.** The document
+ *   stores ids only. A value whose def has vanished still loads and is shown as
+ *   its raw id, marked unknown.
+ * - **Ids are forever.** A def is never removed, only `deprecated`.
+ */
+import { createIdentifier } from '../../global/di/index.js';
+import { FRAMEWORK_IDS } from '../../std/index.js';
+import { roleIsA } from '../../std/gfx/index.js';
+/**
+ * Lower-kebab, case-sensitive, no unicode, no dots. Hyphenated framework ids
+ * are legal, so `cynefin-estuarine:domain` is well formed.
+ */
+const ID_PATTERN = /^[a-z0-9][a-z0-9-]*:[a-z0-9][a-z0-9-]*(\/[a-z0-9][a-z0-9-]*)?$/;
+/**
+ * Variant-parameterized: **one registration per pack, keyed by `packId`** —
+ * the same mechanism as `SpotlightHostExtension(elementType)` and
+ * `ExternalGroupByConfigProvider(config.name)`.
+ */
+export const UniverseTagDefsProvider = createIdentifier('LabreUniverseTagDefs');
+/**
+ * Seed one or more packs.
+ *
+ * `di.override`, **not** `di.addImpl`: `addImpl` throws
+ * `DuplicateServiceDefinitionError` when the same `[scope, identifier, variant]`
+ * is registered twice, while `override` works whether or not a prior
+ * registration exists. That is exactly the idempotency this needs — **distinct
+ * `packId`s accumulate, identical `packId`s replace** — so a host that
+ * re-registers on every render never throws and never grows the registry.
+ *
+ * Order stability is load-bearing and non-obvious: `getAll` returns a
+ * `Map<ServiceVariant, T>`, and `Map.set` on an EXISTING key keeps that key's
+ * original insertion position. Re-seeding a pack therefore updates it in place
+ * rather than moving it to the end, so a re-registration cannot silently flip
+ * which pack wins a cosmetic field.
+ *
+ * **All packs MUST be registered in the same DI scope.** `getAllRaw` falls back
+ * to the parent scope only when the current scope has no registration for the
+ * identifier AT ALL; it never merges across scopes. Seeding one pack from a
+ * `StoreExtension` and another from a `ViewExtension` would silently hide the
+ * first behind the second. The library cannot enforce this, so it is stated
+ * here and belongs in the host integration checklist.
+ */
+export function UniverseTagDefsExtension(defs) {
+    return {
+        setup: di => {
+            for (const pack of Array.isArray(defs) ? defs : [defs]) {
+                di.override(UniverseTagDefsProvider(pack.packId), () => pack);
+            }
+        },
+    };
+}
+/** `'wardley:nature'` → `'wardley'`. */
+const namespaceOf = (id) => id.split(':')[0] ?? '';
+/** `'wardley:nature/data'` → `'wardley:nature'`. */
+const tagOfValue = (valueId) => valueId.split('/')[0] ?? '';
+/**
+ * Merge every registered pack into one read-only view.
+ *
+ * Pure, so it is testable with literals and no container. The merge rules, in
+ * full:
+ *
+ * - **Union by id.** Several packs may extend the same universe.
+ * - **Additive fields merge:** `values` are unioned by value id, `appliesTo`
+ *   arrays are unioned, and `'*'` absorbs any list.
+ * - **Cosmetic fields — last pack wins:** `label`, `description`, `color`,
+ *   `order`, `required`, `deprecated`.
+ * - **Structural fields — first pack wins, conflict recorded:** `cardinality`,
+ *   and `values: 'open'` vs a closed list. The conflict becomes a
+ *   `duplicate-conflict` error issue and does NOT throw. A host that needs a
+ *   deterministic winner should not define the same structural field twice; the
+ *   registry reports the collision rather than guessing.
+ * - **Idempotent by value.** Activating a universe twice yields the same
+ *   registry.
+ */
+export function buildUniverseRegistry(packs) {
+    const issues = [];
+    const drafts = new Map();
+    const frameworks = [];
+    let rank = 0;
+    const issue = (severity, code, message, id) => issues.push(id === undefined ? { severity, code, message } : { severity, code, id, message });
+    for (const pack of packs) {
+        if (pack?.formatVersion !== 1) {
+            // The WHOLE pack is dropped: a format we do not understand may mean
+            // anything. Documents still open; the tooling is simply unavailable.
+            issue('error', 'unsupported-format-version', `Pack "${pack?.packId ?? '<unnamed>'}" declares formatVersion ${String(pack?.formatVersion)}; this build understands 1. The pack is ignored.`, pack?.packId);
+            continue;
+        }
+        if (!FRAMEWORK_IDS.includes(pack.framework)) {
+            issue('warning', 'cross-framework-id', `Pack "${pack.packId}" declares the unknown framework "${pack.framework}".`, pack.packId);
+        }
+        if (!frameworks.includes(pack.framework))
+            frameworks.push(pack.framework);
+        for (const def of pack.tags ?? []) {
+            if (typeof def?.id !== 'string' || !ID_PATTERN.test(def.id)) {
+                issue('error', 'invalid-id', `Tag id "${String(def?.id)}" in pack "${pack.packId}" is not a well-formed '<framework>:<local>' id.`, typeof def?.id === 'string' ? def.id : undefined);
+                continue;
+            }
+            // The `<framework>` segment of every id in a pack MUST equal the pack's
+            // own framework. A cross-framework id is how one taxonomy would quietly
+            // start answering for another's roles.
+            if (namespaceOf(def.id) !== pack.framework) {
+                issue('error', 'cross-framework-id', `Tag "${def.id}" is namespaced "${namespaceOf(def.id)}" but pack "${pack.packId}" declares framework "${pack.framework}".`, def.id);
+                continue;
+            }
+            mergeTagDef(drafts, def, pack, issue, rank++);
+        }
+    }
+    const merged = [...drafts.values()]
+        .map(draft => finishDraft(draft))
+        .sort((a, b) => (a.order ?? 0) - (b.order ?? 0) ||
+        (drafts.get(a.id).rank - drafts.get(b.id).rank) ||
+        a.id.localeCompare(b.id));
+    // Keyed by plain `string`, not by `QualifiedId`: a lookup comes from a
+    // DOCUMENT, which may carry any id at all, and the template-literal type is a
+    // seed-time aid rather than a claim about what is persisted.
+    const byId = new Map(merged.map(def => [def.id, def]));
+    return {
+        frameworks: () => [...frameworks],
+        tags: () => [...merged],
+        tag: id => byId.get(id),
+        tagsForRole: (roleId, defs) => merged.filter(def => tagAppliesToRole(def, roleId, defs)),
+        issues: () => [...issues],
+    };
+}
+function mergeTagDef(drafts, def, pack, issue, rank) {
+    const existing = drafts.get(def.id);
+    if (!existing) {
+        drafts.set(def.id, {
+            def: { ...def },
+            values: valueMapOf(def, pack, issue),
+            appliesTo: appliesToOf(def),
+            rank,
+        });
+        return;
+    }
+    // Cosmetic: last pack wins. Absent stays absent rather than blanking what an
+    // earlier pack said.
+    const draft = existing.def;
+    if (def.label !== undefined)
+        draft.label = def.label;
+    if (def.description !== undefined)
+        draft.description = def.description;
+    if (def.order !== undefined)
+        draft.order = def.order;
+    if (def.required !== undefined)
+        draft.required = def.required;
+    if (def.deprecated !== undefined)
+        draft.deprecated = def.deprecated;
+    // Structural: first pack wins, and the collision is REPORTED rather than
+    // guessed at.
+    if (def.cardinality !== draft.cardinality) {
+        issue('error', 'duplicate-conflict', `Tag "${def.id}": pack "${pack.packId}" declares cardinality "${def.cardinality}" but "${draft.cardinality}" was declared first and stands.`, def.id);
+    }
+    const incomingOpen = def.values === 'open';
+    const existingOpen = existing.values === 'open';
+    if (incomingOpen !== existingOpen) {
+        issue('error', 'duplicate-conflict', `Tag "${def.id}": pack "${pack.packId}" declares ${incomingOpen ? "an open value list" : 'a closed value list'} but the opposite was declared first and stands.`, def.id);
+    }
+    else if (existing.values !== 'open') {
+        // Additive: values union by value id, last cosmetic wins.
+        for (const [valueId, value] of valueMapOf(def, pack, issue)) {
+            const current = existing.values.get(valueId);
+            existing.values.set(valueId, current ? { ...current, ...value } : value);
+        }
+    }
+    // Additive: `'*'` absorbs any list, in either direction.
+    const incomingRoles = appliesToOf(def);
+    if (existing.appliesTo !== '*') {
+        if (incomingRoles === '*')
+            existing.appliesTo = '*';
+        else
+            for (const role of incomingRoles)
+                existing.appliesTo.add(role);
+    }
+}
+function valueMapOf(def, pack, issue) {
+    if (def.values === 'open')
+        return 'open';
+    const values = new Map();
+    for (const value of def.values ?? []) {
+        if (typeof value?.id !== 'string' || !ID_PATTERN.test(value.id)) {
+            issue('error', 'invalid-id', `Value id "${String(value?.id)}" of tag "${def.id}" in pack "${pack.packId}" is not a well-formed '<tagId>/<local>' id.`, typeof value?.id === 'string' ? value.id : undefined);
+            continue;
+        }
+        // A value belongs to its tag, spelled out in the id itself. Anything else
+        // would let a pack file a value under a tag it does not own.
+        if (tagOfValue(value.id) !== def.id) {
+            issue('error', 'invalid-id', `Value "${value.id}" is not a value of tag "${def.id}".`, value.id);
+            continue;
+        }
+        values.set(value.id, { ...value });
+    }
+    return values;
+}
+const appliesToOf = (def) => def.appliesTo === '*' ? '*' : new Set(def.appliesTo ?? []);
+function finishDraft(draft) {
+    return {
+        ...draft.def,
+        values: draft.values === 'open' ? 'open' : [...draft.values.values()],
+        appliesTo: draft.appliesTo === '*' ? '*' : [...draft.appliesTo],
+    };
+}
+/**
+ * Whether a tag qualifies a role, following specialisation: a tag declared on
+ * `'wardley:component'` also applies to `'wardley:market'`, which specialises
+ * it. `'*'` matches every role of the tag's own framework and nothing else —
+ * a wildcard that crossed framework boundaries would make two taxonomies
+ * qualify each other's elements.
+ */
+export function tagAppliesToRole(def, roleId, defs) {
+    if (!roleId)
+        return false;
+    if (def.appliesTo === '*')
+        return namespaceOf(roleId) === namespaceOf(def.id);
+    return def.appliesTo.some(ancestor => roleIsA(roleId, ancestor, defs));
+}
+/**
+ * The merged registry for this editor assembly.
+ *
+ * Memoized per `BlockStdScope`: the merge is pure and the packs are fixed at
+ * assembly time, while callers (a toolbar section rebuilt on every selection
+ * change) ask for it often. A host that re-seeds a pack after the first read
+ * therefore needs a new scope — which is what re-creating the editor already
+ * does, and the only cost of not re-validating a static configuration on every
+ * keystroke.
+ */
+const REGISTRY_CACHE = new WeakMap();
+export function getUniverseRegistry(std) {
+    const cached = REGISTRY_CACHE.get(std);
+    if (cached)
+        return cached;
+    const packs = [...std.provider.getAll(UniverseTagDefsProvider).values()];
+    const registry = buildUniverseRegistry(packs);
+    REGISTRY_CACHE.set(std, registry);
+    return registry;
+}

package/dist/_pkgs/affine-shared/services/user-service/index.d.ts

@@ -1,4 +1,4 @@
-export * from './types';
-export * from './user-list-service';
-export * from './user-service';
-export * from './writer-info-service';
+export * from './types.js';
+export * from './user-list-service.js';
+export * from './user-service.js';
+export * from './writer-info-service.js';

package/dist/_pkgs/affine-shared/services/user-service/index.js

@@ -1,4 +1,4 @@
-export * from './types';
-export * from './user-list-service';
-export * from './user-service';
-export * from './writer-info-service';
+export * from './types.js';
+export * from './user-list-service.js';
+export * from './user-service.js';
+export * from './writer-info-service.js';

package/dist/_pkgs/affine-shared/services/user-service/user-list-service.d.ts

@@ -1,6 +1,6 @@
 import type { ExtensionType } from '../../../store/index.js';
 import type { ReadonlySignal } from '@preact/signals-core';
-import type { AffineUserInfo } from './types';
+import type { AffineUserInfo } from './types.js';
 export interface UserListService {
     users$: ReadonlySignal<AffineUserInfo[]>;
     isLoading$: ReadonlySignal<boolean>;

package/dist/_pkgs/affine-shared/services/user-service/user-service.d.ts

@@ -1,6 +1,6 @@
 import type { ExtensionType } from '../../../store/index.js';
 import type { Signal } from '@preact/signals-core';
-import type { AffineUserInfo } from './types';
+import type { AffineUserInfo } from './types.js';
 export interface UserService {
     userInfo$(id: string): Signal<AffineUserInfo | null>;
     isLoading$(id: string): Signal<boolean>;

package/dist/_pkgs/affine-shared/services/user-service/writer-info-service.d.ts

@@ -1,5 +1,5 @@
 import type { ExtensionType } from '../../../store/index.js';
-import type { AffineUserInfo } from './types';
+import type { AffineUserInfo } from './types.js';
 export interface WriterInfoService {
     getWriterInfo(): AffineUserInfo | null;
 }

package/dist/_pkgs/affine-shared/services/viewport-element-service.d.ts

@@ -1,5 +1,5 @@
 import type { ExtensionType } from '../../store/index.js';
-import type { Viewport } from '../types';
+import type { Viewport } from '../types/index.js';
 export interface ViewportElementService {
     get viewportElement(): HTMLElement;
     get viewport(): Viewport;

package/dist/_pkgs/affine-shared/styles/index.d.ts

@@ -1,4 +1,4 @@
-export { fontBaseStyle, fontSMStyle, fontXSStyle } from './font';
-export { panelBaseColorsStyle, panelBaseStyle } from './panel';
-export { scrollbarStyle } from './scrollbar-style';
-export { affineTextStyles } from './text';
+export { fontBaseStyle, fontSMStyle, fontXSStyle } from './font.js';
+export { panelBaseColorsStyle, panelBaseStyle } from './panel.js';
+export { scrollbarStyle } from './scrollbar-style.js';
+export { affineTextStyles } from './text.js';

package/dist/_pkgs/affine-shared/styles/index.js

@@ -1,4 +1,4 @@
-export { fontBaseStyle, fontSMStyle, fontXSStyle } from './font';
-export { panelBaseColorsStyle, panelBaseStyle } from './panel';
-export { scrollbarStyle } from './scrollbar-style';
-export { affineTextStyles } from './text';
+export { fontBaseStyle, fontSMStyle, fontXSStyle } from './font.js';
+export { panelBaseColorsStyle, panelBaseStyle } from './panel.js';
+export { scrollbarStyle } from './scrollbar-style.js';
+export { affineTextStyles } from './text.js';

package/dist/_pkgs/affine-shared/styles/panel.js

@@ -1,6 +1,6 @@
 import { css, unsafeCSS } from 'lit';
-import { unsafeCSSVarV2 } from '../theme/css-variables';
-import { fontSMStyle } from './font';
+import { unsafeCSSVarV2 } from '../theme/css-variables.js';
+import { fontSMStyle } from './font.js';
 export const panelBaseColorsStyle = (container) => css `
   ${unsafeCSS(container)} {
     color: var(--affine-icon-color);

package/dist/_pkgs/affine-shared/styles/text.d.ts

@@ -1,3 +1,3 @@
 import type { StyleInfo } from 'lit/directives/style-map.js';
-import type { AffineTextAttributes } from '../types';
+import type { AffineTextAttributes } from '../types/index.js';
 export declare function affineTextStyles(props: AffineTextAttributes, override?: Readonly<StyleInfo>): StyleInfo;

package/dist/_pkgs/affine-shared/test-utils/affine-template.js

@@ -3,7 +3,7 @@ import { Container } from '../../global/di/index.js';
 import { TextSelection } from '../../std/index.js';
 import { Text, } from '../../store/index.js';
 import { TestWorkspace } from '../../store/test/index.js';
-import { createTestHost } from './create-test-host';
+import { createTestHost } from './create-test-host.js';
 const DEFAULT_EXTENSIONS = [
     RootBlockSchemaExtension,
     NoteBlockSchemaExtension,

package/dist/_pkgs/affine-shared/test-utils/index.d.ts

@@ -1,3 +1,3 @@
-export * from './affine-template';
-export * from './affine-test-utils';
-export * from './create-test-host';
+export * from './affine-template.js';
+export * from './affine-test-utils.js';
+export * from './create-test-host.js';

package/dist/_pkgs/affine-shared/test-utils/index.js

@@ -1,3 +1,3 @@
-export * from './affine-template';
-export * from './affine-test-utils';
-export * from './create-test-host';
+export * from './affine-template.js';
+export * from './affine-test-utils.js';
+export * from './create-test-host.js';

package/dist/_pkgs/affine-shared/types/index.d.ts

@@ -1,7 +1,7 @@
 import type { FootNote, ReferenceInfo } from '../../affine-model/index.js';
 import type { InlineEditor } from '../../std/inline/index.js';
 import type { BlockModel } from '../../store/index.js';
-export * from './uni-component';
+export * from './uni-component.js';
 export type NoteChildrenFlavour = 'affine:paragraph' | 'affine:list' | 'affine:code' | 'affine:divider' | 'affine:database' | 'affine:data-view' | 'affine:image' | 'affine:bookmark' | 'affine:attachment' | 'affine:surface-ref';
 export interface Viewport {
     left: number;