@salesforce/platform-sdk 11.64.0 → 11.66.1

package/dist/core/extension-attach.d.ts

@@ -0,0 +1,56 @@
+import { ExtendedSDK, ExtensionsFor } from './extension-types';
+/**
+ * Run each extension's `setup` in array order and mount the returned namespace
+ * into the SDK's `ext` container under the entry's effective mount name — its
+ * `name`, or its `as` alias when the entry is `{ extension, as }`. `setup` may be
+ * sync or async; each is `await`ed before the next runs, so the ordering is
+ * deterministic.
+ *
+ * Compartmentalized under `ext`: every extension namespace mounts on `sdk.ext`
+ * (e.g. `sdk.ext.labels`), never as a sibling of the base surface's own members
+ * (`graphql`/`fetch`). This is the design decision that removes name
+ * reservation entirely — a extension key lives one level down from the SDK
+ * surface, so it can never shadow a current or future SDK member, and there is
+ * no set of names to declare off-limits. The only collision left is
+ * extension-vs-extension *within* `ext`, which still throws.
+ *
+ * Aliasing rebinds only the mount key: `setup` still runs on the underlying
+ * extension, so two extensions that both declare `name: "labels"` can attach under
+ * distinct keys (`{ extension: a, as: "x" }`, `{ extension: b, as: "y" }`). See
+ * {@link resolveEntry} for the bare-vs-aliased narrowing and the loud guard
+ * against a malformed entry from untyped JavaScript.
+ *
+ * Each `setup` receives the base SDK, and that is all the type promises it:
+ * `setup(sdk)` is typed as `Base`, never the accumulating shape. Because every
+ * namespace mounts onto one shared `ext` object (below) attached before the
+ * loop, a later extension *can* reach an earlier extension's namespace at runtime via
+ * `sdk.ext.<name>` — but that reachability is an untyped byproduct, not a WI-1
+ * contract to build on. Typed cross-extension access (a extension declaring the
+ * namespaces it needs and receiving them in `setup`) is WI-3, via the reserved
+ * `Deps` seam on {@link Extension}; until then, author setups as independent.
+ *
+ * Atomic and non-mutating: namespaces mount onto a fresh `ext` object hung off
+ * a fresh SDK view whose prototype is `base`, so the base's own and inherited
+ * members resolve through the prototype chain (and `instanceof` still holds)
+ * while `base` itself is never written to. If any `setup` throws, the
+ * half-built view is simply discarded and `base` is left pristine — there is
+ * nothing to roll back. This keeps attach safe against a memoized/shared
+ * instance (e.g. the chat/view singletons WI-4 introduces): each attach derives
+ * its own object, so a repeat attach can never collide with a prior one. The
+ * empty-extension case returns the base instance unchanged — no `ext` key — so
+ * `ExtendedSDK<Base, []>` stays structurally `Base`.
+ *
+ * SDK-agnostic: `Base` is inferred from the passed instance, and `extensions` is
+ * constrained to {@link ExtensionsFor}<Base> so only extensions compatible with this
+ * base type may attach. The returned type is {@link ExtendedSDK}<Base, Extensions>
+ * — the base plus an `ext` namespace carrying each extension's resolved API.
+ *
+ * Fail-loud: a base already declaring `ext` (the reserved container key), a
+ * malformed entry (no `setup`, or a non-string/empty mount name), a mount name
+ * already claimed by another extension in this call, or a `setup` that throws or
+ * rejects surfaces as an error (the extension cases name the extension and chain
+ * the cause). The `ext` slot is locked, so a `setup` reassigning the container
+ * wholesale throws rather than silently dropping every namespace.
+ */
+export declare function attachExtensions<Base extends object, const Extensions extends ExtensionsFor<Base>>(base: Base, extensions: Extensions): Promise<ExtendedSDK<Base, Extensions>>;
+//# sourceMappingURL=extension-attach.d.ts.map

package/dist/core/extension-attach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-attach.d.ts","sourceRoot":"","sources":["../../src/core/extension-attach.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAoB,WAAW,EAAa,aAAa,EAAE,MAAM,mBAAmB,CAAC;AA4CjG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAsB,gBAAgB,CACrC,IAAI,SAAS,MAAM,EACnB,KAAK,CAAC,UAAU,SAAS,aAAa,CAAC,IAAI,CAAC,EAC3C,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAoF5E"}

package/dist/core/{plugin-factory.d.ts → extension-factory.d.ts}

@@ -1,36 +1,36 @@
-import { LiteralName, Plugin } from './plugin-types';
+import { LiteralName, Extension } from './extension-types';
 /**
- * Bind a plugin authoring helper to one SDK surface, so authors never annotate
- * `setup`'s parameter. `createPluginFactory<Sdk>()` captures the base SDK once
- * and returns a definer; each call to that definer infers only the plugin's
+ * Bind a extension authoring helper to one SDK surface, so authors never annotate
+ * `setup`'s parameter. `createExtensionFactory<Sdk>()` captures the base SDK once
+ * and returns a definer; each call to that definer infers only the extension's
  * literal `Name` and its `Api`, with `setup(sdk)` already typed as `Sdk`:
  *
  * ```ts
- * const defineDataPlugin = createPluginFactory<DataSDK>();
- * const labels = defineDataPlugin({ name: "labels", setup: (sdk) => ({ ... }) });
+ * const defineDataExtension = createExtensionFactory<DataSDK>();
+ * const labels = defineDataExtension({ name: "labels", setup: (sdk) => ({ ... }) });
  * ```
  *
- * `createDataSDK` exposes the DataSDK-bound definer as `defineDataPlugin`. This
+ * `createDataSDK` exposes the DataSDK-bound definer as `defineDataExtension`. This
  * factory is also the public escape hatch for a surface with no first-party
  * definer yet, or for an author's own SDK.
  *
- * ## Why a curried factory, and not a single `definePlugin<Sdk, Name, Api>`?
+ * ## Why a curried factory, and not a single `defineExtension<Sdk, Name, Api>`?
  *
  * The obvious alternative is one generic function whose caller fixes the SDK:
- * `definePlugin<DataSDK>({ name, setup })`. TypeScript does not allow it —
+ * `defineExtension<DataSDK>({ name, setup })`. TypeScript does not allow it —
  * type-argument lists are all-or-nothing per call, so supplying `Sdk` forces
  * you to also supply `Name` and `Api` (`Expected 3 type arguments, but got 1`),
  * which throws away the very inference that makes the helper worth using. That
  * leaves only one way to keep `Sdk` implicit at the value call: annotate the
- * parameter (`setup: (sdk: DataSDK) => ...`) on every plugin. And a *forgotten*
+ * parameter (`setup: (sdk: DataSDK) => ...`) on every extension. And a *forgotten*
  * annotation does not error — it silently infers `Sdk = unknown`, a
- * universally-attachable binding that slips a surface-specific plugin past the
- * per-surface {@link PluginsFor} guard.
+ * universally-attachable binding that slips a surface-specific extension past the
+ * per-surface {@link ExtensionsFor} guard.
  *
  * Currying dodges both problems. The outer call takes `Sdk` as its only type
  * argument and no value arguments, so nothing forces `Name`/`Api` to be spelled
- * out; the inner call infers those from the plugin object. `Sdk` is fixed before
- * any plugin is written, so it can be neither forgotten nor widened — the
+ * out; the inner call infers those from the extension object. `Sdk` is fixed before
+ * any extension is written, so it can be neither forgotten nor widened — the
  * footgun is designed out rather than documented around.
  *
  * The returned definer is identity at runtime. It carries the {@link LiteralName}
@@ -38,5 +38,5 @@ import { LiteralName, Plugin } from './plugin-types';
  * concrete literal there is no key to accumulate onto the extended SDK, so
  * failing loud here beats a silently dropped namespace downstream.
  */
-export declare function createPluginFactory<Sdk>(): <const Name extends string, Api>(plugin: Plugin<Sdk, LiteralName<Name>, Api>) => Plugin<Sdk, Name, Api>;
-//# sourceMappingURL=plugin-factory.d.ts.map
+export declare function createExtensionFactory<Sdk>(): <const Name extends string, Api>(extension: Extension<Sdk, LiteralName<Name>, Api>) => Extension<Sdk, Name, Api>;
+//# sourceMappingURL=extension-factory.d.ts.map

package/dist/core/extension-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-factory.d.ts","sourceRoot":"","sources":["../../src/core/extension-factory.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,MACT,KAAK,CAAC,IAAI,SAAS,MAAM,EAAE,GAAG,EAC7D,WAAW,SAAS,CAAC,GAAG,EAAE,WAAW,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,KAC/C,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,CAG5B"}

package/dist/core/extension-types.d.ts

@@ -0,0 +1,231 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+/**
+ * A extension: a named namespace factory bound to a base SDK instance at attach
+ * time. SDK-agnostic — `Sdk` is the base type this extension's `setup` requires.
+ *
+ * The contract does not depend on any concrete SDK. Enforcement of a specific
+ * SDK happens at attach time via {@link ExtensionsFor}: a extension is attachable to
+ * a base `B` only where `B` is assignable to `Sdk`. So authoring
+ * `setup(sdk: DataSDK)` type-checks the extension against DataSDK when it is
+ * attached through `createDataSDK`, even though `Extension` itself never imports
+ * DataSDK.
+ *
+ * Reserved — `Deps` (inert in WI-1): the trailing type parameter is the seam
+ * for WI-3 extension dependencies. It defaults to `[]` and is referenced only
+ * through `setup`'s parameter, as `Sdk & Accumulate<Deps>`. With the default
+ * empty tuple `Accumulate<[]>` is `unknown`, and `Sdk & unknown` reduces to
+ * `Sdk`, so `setup` sees exactly the base SDK — a three-argument
+ * `Extension<Sdk, Name, Api>` (see {@link AnyExtension}, {@link ExtensionsFor}) is
+ * unchanged and no WI-1 extension's type shifts. There is no `deps` field yet, so
+ * `attach` has no dependency to honor or silently drop.
+ *
+ * Threading it through `setup` (rather than leaving it dangling) is deliberate:
+ * an unreferenced reserved type parameter is not free — it trips
+ * `noUnusedLocals`. This makes the slot load-bearing while behaviorally a
+ * no-op. WI-3's add-back is then a pure superset: add a `deps?: Deps` field and
+ * populate the tuple, and the already-wired `setup` view lights up. The spike
+ * notes the superset holds with or without this slot, so it is kept as an
+ * explicit intent marker, not a forward-compat necessity.
+ */
+export interface Extension<Sdk, Name extends string, Api, Deps extends readonly AnyExtension[] = []> {
+    /** The single namespace key this extension mounts under (e.g. "labels"). */
+    name: Name;
+    /**
+     * Build the extension API. Runs at attach time with the fully-resolved,
+     * instance-bound base SDK. May be synchronous or async — return the API
+     * directly, or a promise of it (e.g. to `await` a dynamic import or a
+     * capability handshake). The resolved `Api` is what mounts under `name`.
+     *
+     * `sdk` is `Sdk & Accumulate<Deps>`; with the reserved `Deps = []` this is
+     * just `Sdk` today (see the `Deps` note above). WI-3 populates `Deps` so a
+     * extension's declared dependencies' namespaces appear here.
+     */
+    setup: (sdk: Sdk & Accumulate<Deps>) => Api | PromiseLike<Api>;
+}
+/** True iff `T` is a union of two or more members. */
+type IsUnion<T, U = T> = T extends unknown ? ([U] extends [T] ? false : true) : never;
+/**
+ * Reject a `name` that is not a single string literal. A concrete literal
+ * (`"labels"`) passes through unchanged; anything else collapses to `never`, so
+ * the authoring helpers error at definition time rather than silently losing key
+ * accumulation. See {@link createExtensionFactory}.
+ *
+ * Two shapes are rejected, both of which would otherwise mount phantom keys:
+ *   - a widened `string` (`string extends Name`) — no literal key to accumulate;
+ *   - a union literal (`"a" | "b"`, e.g. from `name: cond ? "a" : "b"`) — this
+ *     survives the `string extends Name` check, but {@link Accumulate}
+ *     distributes over the union and types *both* `a` and `b` as present,
+ *     non-optional members while `attach` mounts only one, leaving the other
+ *     typed-present yet `undefined` at runtime. Requiring a single literal is
+ *     what keeps the accumulated key set sound.
+ */
+export type LiteralName<Name extends string> = string extends Name ? never : IsUnion<Name> extends true ? never : Name;
+/**
+ * Any extension, for use in constraints. `never` in the (contravariant) `Sdk`
+ * slot makes every concrete `Extension<...>` assignable to this — it is the top
+ * type over the SDK parameter.
+ */
+export type AnyExtension = Extension<never, string, unknown>;
+/**
+ * Rebind a extension's mount point: attach `extension` under `as` instead of its own
+ * `name`. This is the consumer's recourse for a collision they didn't cause —
+ * two uneditable third-party extensions that both mount `sdk.ext.labels` can each be
+ * aliased to a distinct key. Aliasing rebinds the mount *key* only, never the
+ * extension's identity, which is what keeps identity-based dependency resolution
+ * (a later WI) robust to it.
+ *
+ * `As` is intentionally the raw alias literal, NOT `LiteralName<As>`: pinning
+ * `LiteralName` here would collapse the constraint form `AliasedExtension<_,
+ * string>` (used in {@link ExtensionsFor}) to `as: never` and reject every alias.
+ * The widened/union-`as` guard is instead applied at the call boundary by
+ * {@link ValidAliasNames}, exactly as {@link UniqueExtensionNames} guards mount
+ * uniqueness there — the entry type stays permissive; the boundary validates.
+ *
+ * `name?: never; setup?: never` reject the mixed shape structurally, mirroring
+ * the runtime discriminator. An object carrying a bare extension's defining
+ * members *and* `{ extension, as }` satisfies both arms of {@link ExtensionEntry};
+ * without these guards {@link MountName} (which tests the aliased arm first)
+ * would key it under `as`, while `attach` — discriminating on `"setup" in
+ * entry` — mounts the bare extension under `name`. The `never` fields fail the
+ * aliased arm for such an object, so it matches only {@link Extension} and both
+ * sides agree on `name`. Unlike the `LiteralName` case above, these are fixed
+ * optional-never fields independent of `P`/`As`, so a real `{ extension, as }`
+ * entry (which omits them) leaves the `ExtensionsFor` constraint form intact.
+ */
+export interface AliasedExtension<P extends AnyExtension, As extends string> {
+    extension: P;
+    as: As;
+    name?: never;
+    setup?: never;
+}
+/** Any aliased entry, for use in unions/constraints (cf. {@link AnyExtension}). */
+type AnyAliasedExtension = AliasedExtension<AnyExtension, string>;
+/**
+ * The `extensions: []` array constraint that enforces a concrete base SDK. A bare
+ * `Extension<Sdk, Name, Api>` — or an {@link AliasedExtension} wrapping one — is a
+ * member iff a `Base` value is assignable to the (inner) extension's `setup`
+ * parameter, i.e. the extension asks for no more than `Base` provides (a extension
+ * that ignores the SDK, `Sdk = unknown`, is universally attachable).
+ * `createDataSDK` binds `Base = DataSDK`; that is where DataSDK-specific
+ * enforcement occurs.
+ */
+export type ExtensionsFor<Base> = readonly (Extension<Base, string, unknown> | AliasedExtension<Extension<Base, string, unknown>, string>)[];
+/**
+ * What may appear in the `extensions: []` array: a bare extension, or a bare extension
+ * wrapped with an `{ as }` alias. Everything downstream ({@link Accumulate},
+ * {@link DuplicateMountName}, {@link ExtendedSDK}) is written against
+ * `ExtensionEntry` and routes through {@link ExtensionOf}/{@link MountName}, so the
+ * bare-vs-aliased distinction is resolved in exactly those two helpers and
+ * nowhere else.
+ */
+export type ExtensionEntry = AnyExtension | AnyAliasedExtension;
+/** The underlying extension of an entry, whether it was passed bare or aliased. */
+type ExtensionOf<E extends ExtensionEntry> = E extends AnyAliasedExtension ? E["extension"] : E;
+/**
+ * The literal key an entry mounts under: its alias `as` when aliased, else the
+ * extension's own `name`. This is the single place the effective mount key is
+ * computed — all mount-name-keyed logic ({@link Accumulate},
+ * {@link DuplicateMountName}) routes through it, so aliasing is transparent to
+ * them: `[a, a]` (both mount `"labels"`) collides, but `[{ extension: a, as: "x"
+ * }, { extension: a, as: "y" }]` resolves to distinct keys and does not.
+ */
+type MountName<E extends ExtensionEntry> = E extends AnyAliasedExtension ? E["as"] : ExtensionOf<E>["name"];
+/**
+ * The resolved API an entry's extension `setup` returns. `Awaited` unwraps the
+ * async case so the mounted namespace is the settled value, never a promise.
+ */
+type ApiOf<E extends ExtensionEntry> = Awaited<ReturnType<ExtensionOf<E>["setup"]>>;
+/**
+ * Walk the extension tuple left→right, intersecting `{ [name]: namespace }` per
+ * entry. Namespaces are non-optional: presence is a static attach fact.
+ *
+ * This intersects unconditionally: a duplicate mount name would collapse to
+ * `{ labels: A } & { labels: B }` here rather than erroring. Uniqueness is not
+ * this type's job — it is enforced up front by {@link UniqueExtensionNames} at the
+ * authoring boundary, with `attach`'s runtime guard as the backstop for tuples
+ * built dynamically past the static check.
+ */
+type Accumulate<Extensions extends readonly ExtensionEntry[]> = Extensions extends readonly [
+    infer Head extends ExtensionEntry,
+    ...infer Tail extends readonly ExtensionEntry[]
+] ? {
+    [K in MountName<Head>]: ApiOf<Head>;
+} & Accumulate<Tail> : unknown;
+/**
+ * The first mount name that repeats in the tuple, or `never` if all are
+ * distinct. Walks left→right accumulating seen names in `Seen`; the first
+ * {@link MountName} already in `Seen` is the duplicate. Keyed on
+ * {@link MountName}, so aliasing a clash apart is a valid recourse (see there).
+ */
+type DuplicateMountName<Extensions extends readonly ExtensionEntry[], Seen = never> = Extensions extends readonly [
+    infer Head extends ExtensionEntry,
+    ...infer Tail extends readonly ExtensionEntry[]
+] ? [MountName<Head>] extends [Seen] ? MountName<Head> : DuplicateMountName<Tail, Seen | MountName<Head>> : never;
+/**
+ * A constraint intersected into the `extensions` option to reject a tuple whose
+ * mount names are not unique. Resolves to `unknown` (a no-op intersection) when
+ * every mount name is distinct; otherwise to an object whose `extensions` field is
+ * a human-readable error string, which makes the supplied array inassignable
+ * and surfaces the message in the diagnostic.
+ *
+ * This moves the collision from a runtime throw (`attach` fail-loud) to a
+ * compile error at the call site. The two are complementary, not redundant:
+ * this catches statically-known tuples early with a clear message, while
+ * `attach` still guards tuples assembled dynamically (e.g. `[...a, ...b]`)
+ * whose duplicates a static check cannot see.
+ */
+export type UniqueExtensionNames<Extensions extends readonly ExtensionEntry[]> = [
+    DuplicateMountName<Extensions>
+] extends [never] ? unknown : {
+    extensions: `Two extensions mount under "${DuplicateMountName<Extensions> & string}"; mount names must be unique.`;
+};
+/**
+ * A constraint intersected into the `extensions` option to reject an aliased entry
+ * whose `as` is not a single string literal — the same soundness bar
+ * {@link LiteralName} applies to a extension's `name` (see there for why a widened
+ * or union `as` would mount a phantom namespace). Applied at the boundary rather
+ * than on {@link AliasedExtension} for the reason that type documents. Resolves to
+ * `unknown` or an inassignable `{ extensions }` error exactly as
+ * {@link UniqueExtensionNames} does.
+ */
+export type ValidAliasNames<Extensions extends readonly ExtensionEntry[]> = Extensions extends readonly [
+    infer Head extends ExtensionEntry,
+    ...infer Tail extends readonly ExtensionEntry[]
+] ? Head extends AnyAliasedExtension ? [LiteralName<Head["as"]>] extends [never] ? {
+    extensions: `An alias "as" must be a single string literal, not a widened or union type.`;
+} : ValidAliasNames<Tail> : ValidAliasNames<Tail> : unknown;
+/** Collapse an intersection into a single flat object type for readable hovers. */
+type Flatten<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * The base SDK plus an `ext` namespace carrying every attached extension's API.
+ *
+ * Extensions are compartmentalized under `ext` (e.g. `sdk.ext.labels`) rather than
+ * spliced onto the SDK root, mirroring where {@link attachExtensions} mounts them.
+ * This is what lets the SDK add members over time without a name-reservation
+ * registry: a extension *key* can never collide with a current or future root
+ * member because it lives one level down. The single exception is `ext` itself —
+ * that one root key is now SDK-owned as the extension container, exactly as
+ * `graphql`/`fetch` are SDK-owned. A base SDK surface must therefore not declare
+ * its own `ext` member. Extension-vs-extension uniqueness within `ext` is still
+ * enforced — statically by {@link UniqueExtensionNames}, at runtime by `attach`.
+ *
+ * Only a tuple *known* to be non-empty introduces `ext`, whose value is the
+ * left→right {@link Accumulate}d namespace map. Both other cases resolve to
+ * exactly `Base` (no `ext` key): the empty tuple `[]`, and — deliberately — a
+ * widened, non-tuple extension array (e.g. `DataSDKExtension[]`) whose length TypeScript
+ * cannot see. The runtime returns the base untouched whenever the array is empty,
+ * so keying presence off "provably non-empty" (rather than "provably empty")
+ * keeps the type from promising an `ext` the runtime may not create for a widened
+ * array that happens to be empty.
+ */
+export type ExtendedSDK<Base, Extensions extends readonly ExtensionEntry[]> = Extensions extends readonly [ExtensionEntry, ...ExtensionEntry[]] ? Flatten<Base & {
+    ext: Flatten<Accumulate<Extensions>>;
+}> : Base;
+export {};
+//# sourceMappingURL=extension-types.d.ts.map

package/dist/core/extension-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-types.d.ts","sourceRoot":"","sources":["../../src/core/extension-types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,SAAS,CACzB,GAAG,EACH,IAAI,SAAS,MAAM,EACnB,GAAG,EACH,IAAI,SAAS,SAAS,YAAY,EAAE,GAAG,EAAE;IAEzC,4EAA4E;IAC5E,IAAI,EAAE,IAAI,CAAC;IACX;;;;;;;;;OASG;IACH,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,KAAK,GAAG,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;CAC/D;AAED,sDAAsD;AACtD,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,GAAG,KAAK,CAAC;AAEtF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,WAAW,CAAC,IAAI,SAAS,MAAM,IAAI,MAAM,SAAS,IAAI,GAC/D,KAAK,GACL,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,GACzB,KAAK,GACL,IAAI,CAAC;AAET;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,YAAY,EAAE,EAAE,SAAS,MAAM;IAC1E,SAAS,EAAE,CAAC,CAAC;IACb,EAAE,EAAE,EAAE,CAAC;IACP,IAAI,CAAC,EAAE,KAAK,CAAC;IACb,KAAK,CAAC,EAAE,KAAK,CAAC;CACd;AAED,mFAAmF;AACnF,KAAK,mBAAmB,GAAG,gBAAgB,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;AAElE;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,CAAC,IAAI,IAAI,SAAS,CACxC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,GAChC,gBAAgB,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,CAC5D,EAAE,CAAC;AAEJ;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,mBAAmB,CAAC;AAEhE,mFAAmF;AACnF,KAAK,WAAW,CAAC,CAAC,SAAS,cAAc,IAAI,CAAC,SAAS,mBAAmB,GAAG,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;AAEhG;;;;;;;GAOG;AACH,KAAK,SAAS,CAAC,CAAC,SAAS,cAAc,IAAI,CAAC,SAAS,mBAAmB,GACrE,CAAC,CAAC,IAAI,CAAC,GACP,WAAW,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1B;;;GAGG;AACH,KAAK,KAAK,CAAC,CAAC,SAAS,cAAc,IAAI,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AAEpF;;;;;;;;;GASG;AACH,KAAK,UAAU,CAAC,UAAU,SAAS,SAAS,cAAc,EAAE,IAAI,UAAU,SAAS,SAAS;IAC3F,MAAM,IAAI,SAAS,cAAc;IACjC,GAAG,MAAM,IAAI,SAAS,SAAS,cAAc,EAAE;CAC/C,GACE;KAAG,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC;CAAE,GAAG,UAAU,CAAC,IAAI,CAAC,GAC1D,OAAO,CAAC;AAEX;;;;;GAKG;AACH,KAAK,kBAAkB,CACtB,UAAU,SAAS,SAAS,cAAc,EAAE,EAC5C,IAAI,GAAG,KAAK,IACT,UAAU,SAAS,SAAS;IAC/B,MAAM,IAAI,SAAS,cAAc;IACjC,GAAG,MAAM,IAAI,SAAS,SAAS,cAAc,EAAE;CAC/C,GACE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAC/B,SAAS,CAAC,IAAI,CAAC,GACf,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,GACjD,KAAK,CAAC;AAET;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,oBAAoB,CAAC,UAAU,SAAS,SAAS,cAAc,EAAE,IAAI;IAChF,kBAAkB,CAAC,UAAU,CAAC;CAC9B,SAAS,CAAC,KAAK,CAAC,GACd,OAAO,GACP;IACA,UAAU,EAAE,+BAA+B,kBAAkB,CAAC,UAAU,CAAC,GACxE,MAAM,gCAAgC,CAAC;CACxC,CAAC;AAEJ;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,CAAC,UAAU,SAAS,SAAS,cAAc,EAAE,IACvE,UAAU,SAAS,SAAS;IAC3B,MAAM,IAAI,SAAS,cAAc;IACjC,GAAG,MAAM,IAAI,SAAS,SAAS,cAAc,EAAE;CAC/C,GACE,IAAI,SAAS,mBAAmB,GAC/B,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GACxC;IACA,UAAU,EAAE,6EAA6E,CAAC;CAC1F,GACA,eAAe,CAAC,IAAI,CAAC,GACtB,eAAe,CAAC,IAAI,CAAC,GACtB,OAAO,CAAC;AAEZ,mFAAmF;AACnF,KAAK,OAAO,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,GAAG,EAAE,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,WAAW,CACtB,IAAI,EACJ,UAAU,SAAS,SAAS,cAAc,EAAE,IACzC,UAAU,SAAS,SAAS,CAAC,cAAc,EAAE,GAAG,cAAc,EAAE,CAAC,GAClE,OAAO,CAAC,IAAI,GAAG;IAAE,GAAG,EAAE,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAA;CAAE,CAAC,GACxD,IAAI,CAAC"}

package/dist/core/index.d.ts

@@ -17,6 +17,6 @@ export type { McpAppsHostContext, McpAppsSessionOptions } from './mcpapps-sessio
 export { getSurfaceCapabilities } from './capabilities';
 export type { SurfaceCapabilities } from './capabilities';
 export { wrapSDKPromise } from './sdk-promise';
-export { createPluginFactory } from './plugin-factory';
-export type { Plugin, AnyPlugin, AliasedPlugin, PluginsFor, PluginEntry, ExtendedSDK, LiteralName, UniquePluginNames, ValidAliasNames, } from './plugin-types';
+export { createExtensionFactory } from './extension-factory';
+export type { Extension, AnyExtension, AliasedExtension, ExtensionsFor, ExtensionEntry, ExtendedSDK, LiteralName, UniqueExtensionNames, ValidAliasNames, } from './extension-types';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACN,OAAO,EACP,kBAAkB,EAClB,UAAU,EACV,mBAAmB,EACnB,YAAY,GACZ,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAGnD,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG5C,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAGrD,YAAY,EACX,WAAW,EACX,UAAU,EACV,WAAW,EACX,OAAO,EACP,YAAY,EACZ,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,cAAc,EACd,qBAAqB,EACrB,QAAQ,EACR,SAAS,GACT,MAAM,QAAQ,CAAC;AAGhB,YAAY,EACX,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,KAAK,EACL,SAAS,EACT,OAAO,EACP,QAAQ,EACR,OAAO,GACP,MAAM,QAAQ,CAAC;AAGhB,YAAY,EACX,YAAY,EACZ,OAAO,EACP,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,qBAAqB,EACrB,eAAe,EACf,aAAa,EACb,cAAc,EACd,YAAY,EACZ,WAAW,EACX,eAAe,EACf,WAAW,GACX,MAAM,QAAQ,CAAC;AAGhB,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAG7F,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,OAAO,EAAE,wBAAwB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC7E,YAAY,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAGnF,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACxD,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAG1D,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAQ/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,YAAY,EACX,MAAM,EACN,SAAS,EACT,aAAa,EACb,UAAU,EACV,WAAW,EACX,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,eAAe,GACf,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACN,OAAO,EACP,kBAAkB,EAClB,UAAU,EACV,mBAAmB,EACnB,YAAY,GACZ,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAGnD,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG5C,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAGrD,YAAY,EACX,WAAW,EACX,UAAU,EACV,WAAW,EACX,OAAO,EACP,YAAY,EACZ,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,cAAc,EACd,qBAAqB,EACrB,QAAQ,EACR,SAAS,GACT,MAAM,QAAQ,CAAC;AAGhB,YAAY,EACX,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,KAAK,EACL,SAAS,EACT,OAAO,EACP,QAAQ,EACR,OAAO,GACP,MAAM,QAAQ,CAAC;AAGhB,YAAY,EACX,YAAY,EACZ,OAAO,EACP,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,qBAAqB,EACrB,eAAe,EACf,aAAa,EACb,cAAc,EACd,YAAY,EACZ,WAAW,EACX,eAAe,EACf,WAAW,GACX,MAAM,QAAQ,CAAC;AAGhB,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAG7F,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,OAAO,EAAE,wBAAwB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC7E,YAAY,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAGnF,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACxD,YAAY,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAG1D,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAQ/C,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,YAAY,EACX,SAAS,EACT,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,WAAW,EACX,WAAW,EACX,oBAAoB,EACpB,eAAe,GACf,MAAM,mBAAmB,CAAC"}

package/dist/core/index.js

@@ -1,16 +1,16 @@
-import { M as r, a as s, S as i, g as o, i as p, b as t, r as f } from "../surface-Dd2tqrPi.js";
+import { M as r, a as s, S as i, g as o, i as t, b as p, r as f } from "../surface-Dd2tqrPi.js";
 import { g as S } from "../capabilities-5BWkCbcP.js";
 import { w as g } from "../sdk-promise-D0sy7OW1.js";
-import { c as u } from "../plugin-factory-BC3b3BOy.js";
+import { c as x } from "../extension-factory-CJkfM4km.js";
 export {
   r as McpAppsNotAvailableError,
   s as McpAppsSession,
   i as Surface,
-  u as createPluginFactory,
+  x as createExtensionFactory,
   S as getSurfaceCapabilities,
   o as getVerifiedSurface,
-  p as initialize,
-  t as isSfEmbeddingIframe,
+  t as initialize,
+  p as isSfEmbeddingIframe,
   f as resetSurface,
   g as wrapSDKPromise
 };

package/dist/data/extensions/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+/**
+ * First-party DataSDK extension catalog. Import extensions from this subpath and
+ * attach them via `createDataSDK({ extensions: [...] })`:
+ *
+ * ```typescript
+ * import { createDataSDK } from "@salesforce/platform-sdk/data";
+ * import { labels } from "@salesforce/platform-sdk/data/extensions";
+ *
+ * const sdk = await createDataSDK({ extensions: [labels({ namespace: "MyApp" })] });
+ * ```
+ */
+export { labels } from './labels';
+export type { LabelsApi, LabelsOptions, LabelFallback } from './labels';
+//# sourceMappingURL=index.d.ts.map

package/dist/data/extensions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/data/extensions/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;GAUG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC"}

package/dist/data/{plugins → extensions}/index.js

@@ -1,4 +1,4 @@
-import { defineDataPlugin as b } from "../index.js";
+import { defineDataExtension as b } from "../index.js";
 const m = "BASE_VALUE", p = `
 	query Labels($namespace: String, $names: [String!]!, $locale: String, $fallback: LabelFallback) {
 		uiapi {
@@ -10,23 +10,23 @@ const m = "BASE_VALUE", p = `
 			}
 		}
 	}
-`, L = /* @__PURE__ */ new Set(["TRANSLATION_NOT_FOUND", "LABEL_NOT_FOUND"]), f = ["uiapi", "platform", "labels"];
-function E(n) {
+`, E = /* @__PURE__ */ new Set(["TRANSLATION_NOT_FOUND", "LABEL_NOT_FOUND"]), f = ["uiapi", "platform", "labels"];
+function L(n) {
   const e = n.path;
   return e?.length !== f.length + 1 ? !1 : f.every((s, l) => e[l] === s) && typeof e[f.length] == "number";
 }
 function d(n) {
   const e = n.extensions?.code;
-  return e != null && L.has(e) && E(n);
+  return e != null && E.has(e) && L(n);
 }
 const h = 100;
-function g(n, e) {
+function y(n, e) {
   const s = [...new Set(n)], l = [];
   for (let r = 0; r < s.length; r += e)
     l.push(s.slice(r, r + e));
   return l;
 }
-async function y(n, e, s, l, r) {
+async function A(n, e, s, l, r) {
   const t = { names: s, fallback: r };
   e != null && (t.namespace = e), l != null && (t.locale = l);
   const a = await n.query({
@@ -43,9 +43,9 @@ async function y(n, e, s, l, r) {
     );
   return c;
 }
-async function A(n, e, s, l, r) {
-  const t = g(s, h), a = await Promise.all(
-    t.map((c) => y(n, e, c, l, r))
+async function S(n, e, s, l, r) {
+  const t = y(s, h), a = await Promise.all(
+    t.map((c) => A(n, e, c, l, r))
   ), o = {};
   for (const c of a)
     for (const i of c)
@@ -56,7 +56,7 @@ function u(n) {
   const e = n?.trim();
   return e || void 0;
 }
-function _(n = {}) {
+function g(n = {}) {
   const e = { ...n };
   return b({
     name: "labels",
@@ -66,7 +66,7 @@ function _(n = {}) {
         return {};
       const r = async (t, a) => {
         const o = u(a?.namespace) ?? u(e.namespace), c = u(a?.locale) ?? u(e.locale), i = a?.fallback ?? e.fallback ?? m;
-        return A(l, o, t, c, i);
+        return S(l, o, t, c, i);
       };
       return {
         async get(t, a) {
@@ -80,5 +80,5 @@ function _(n = {}) {
   });
 }
 export {
-  _ as labelsPlugin
+  g as labels
 };

package/dist/data/{plugins → extensions}/labels/index.d.ts

@@ -1,9 +1,9 @@
 import { LabelFallback } from './query';
-import { DataSDKPlugin } from '../../index';
+import { DataSDKExtension } from '../../index';
 export type { LabelFallback };
 /**
  * Where labels are read from and how they resolve. Supplied once when the
- * plugin is configured (`labelsPlugin({ namespace: "MyApp" })`) to set defaults,
+ * extension is configured (`labels({ namespace: "MyApp" })`) to set defaults,
  * and again per call ({@link LabelsApi.get}/{@link LabelsApi.getAll}) to override
  * them for that call. Each field resolves independently as `call ?? config ??
  * built-in default`.
@@ -31,15 +31,15 @@ export interface LabelsOptions {
     fallback?: LabelFallback;
 }
 /**
- * The `labels` namespace mounted on the DataSDK. Both methods resolve labels in
- * a namespace (configured or per-call) and report an unresolved label as a miss
- * — `undefined` from {@link get}, an absent key from {@link getAll}. The caller
- * decides what a miss means; fall back to the name with
- * `await sdk.labels.get?.(name) ?? name`.
+ * The `labels` namespace mounted in the DataSDK's `ext` container — `sdk.ext.labels`.
+ * Both methods resolve labels in a namespace (configured or per-call) and report
+ * an unresolved label as a miss — `undefined` from {@link get}, an absent key
+ * from {@link getAll}. The caller decides what a miss means; fall back to the
+ * name with `await sdk.ext.labels.get?.(name) ?? name`.
  *
  * The methods are optional, mirroring the {@link DataSDK.graphql} namespace they
  * depend on: a surface whose DataSDK has no `graphql` cannot fetch labels, so
- * `get`/`getAll` are absent there. Feature-detect (`sdk.labels.get?.(name)`) or
+ * `get`/`getAll` are absent there. Feature-detect (`sdk.ext.labels.get?.(name)`) or
  * narrow once, exactly as you would `sdk.graphql`.
  */
 export interface LabelsApi {
@@ -71,13 +71,13 @@ export interface LabelsApi {
     getAll?(names: readonly string[], options?: LabelsOptions): Promise<Record<string, string>>;
 }
 /**
- * A first-party DataSDK plugin that mounts a `labels` namespace for reading
- * custom labels. Attach it via `createDataSDK({ plugins: [labelsPlugin()] })`,
- * then call `sdk.labels.get?.(name)` / `sdk.labels.getAll?.(names)` — the
+ * A first-party DataSDK extension that mounts a `labels` namespace for reading
+ * custom labels. Attach it via `createDataSDK({ extensions: [labels()] })`,
+ * then call `sdk.ext.labels.get?.(name)` / `sdk.ext.labels.getAll?.(names)` — the
  * methods are optional, absent on a surface whose DataSDK has no `graphql`.
  *
  * Requires org API v264 or later (the release that introduced the
- * `uiapi.platform.labels` GraphQL shape this plugin queries).
+ * `uiapi.platform.labels` GraphQL shape this extension queries).
  *
  * @param config - Default {@link LabelsOptions} for every call; each field is
  *   overridable per call. Omit `namespace` (here and per call) to read from the
@@ -86,13 +86,13 @@ export interface LabelsApi {
  * @example
  * ```typescript
  * import { createDataSDK } from "@salesforce/platform-sdk/data";
- * import { labelsPlugin } from "@salesforce/platform-sdk/data/plugins";
+ * import { labels } from "@salesforce/platform-sdk/data/extensions";
  *
- * const sdk = await createDataSDK({ plugins: [labelsPlugin({ namespace: "MyApp" })] });
- * const greeting = (await sdk.labels.get?.("greeting")) ?? "greeting"; // uses "MyApp"; ?? name if you want the key
- * const french = await sdk.labels.get?.("greeting", { locale: "fr" }); // string | undefined
- * const many = await sdk.labels.getAll?.(["greeting", "farewell"]);    // only resolved names
+ * const sdk = await createDataSDK({ extensions: [labels({ namespace: "MyApp" })] });
+ * const greeting = (await sdk.ext.labels.get?.("greeting")) ?? "greeting"; // uses "MyApp"; ?? name if you want the key
+ * const french = await sdk.ext.labels.get?.("greeting", { locale: "fr" }); // string | undefined
+ * const many = await sdk.ext.labels.getAll?.(["greeting", "farewell"]);    // only resolved names
  * ```
  */
-export declare function labelsPlugin(config?: LabelsOptions): DataSDKPlugin<"labels", LabelsApi>;
+export declare function labels(config?: LabelsOptions): DataSDKExtension<"labels", LabelsApi>;
 //# sourceMappingURL=index.d.ts.map

package/dist/data/extensions/labels/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/data/extensions/labels/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAA0B,KAAK,aAAa,EAAiB,MAAM,SAAS,CAAC;AACpF,OAAO,EAAuB,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEzE,YAAY,EAAE,aAAa,EAAE,CAAC;AAE9B;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC7B;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC;CACzB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,SAAS;IACzB;;;;;;OAMG;IACH,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACzE;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC5F;AAgBD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,MAAM,CAAC,MAAM,GAAE,aAAkB,GAAG,gBAAgB,CAAC,QAAQ,EAAE,SAAS,CAAC,CAsDxF"}

package/dist/data/{plugins → extensions}/labels/query.d.ts

@@ -11,7 +11,7 @@ export type LabelFallback = "BASE_VALUE" | "USER_DEFAULT" | "NONE";
 /**
  * Return the org-default (base) value when a label has no translation for the
  * requested locale, instead of the logged-in user's language (the server's
- * `USER_DEFAULT` behavior). The plugin resolves an explicit target locale, so it
+ * `USER_DEFAULT` behavior). The extension resolves an explicit target locale, so it
  * opts into `BASE_VALUE`.
  */
 export declare const DEFAULT_LABEL_FALLBACK: LabelFallback;

package/dist/data/extensions/labels/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../src/data/extensions/labels/query.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,OAAO,EAAgB,MAAM,eAAe,CAAC;AAE3D;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,cAAc,GAAG,MAAM,CAAC;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,EAAE,aAA4B,CAAC;AAiIlE,oEAAoE;AACpE,KAAK,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;AA6D/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,aAAa,CAClC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,QAAQ,EAAE,aAAa,GACrB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAuBjC"}