@lwrjs/gate-module-provider 0.22.9

package/LICENSE

@@ -0,0 +1,10 @@
+MIT LICENSE
+
+Copyright (c) 2020, Salesforce.com, Inc.
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,180 @@
+# @lwrjs/gate-module-provider
+
+A module provider for LWR that exposes `@salesforce/gate` for feature gating. Use it to control feature rollouts, experiment toggles, and gradual releases within your LWC modules.
+
+## Overview
+
+The gate module provider resolves imports like `@salesforce/gate/<gateName>` into virtual modules that expose a standard API: `isOpen(map)` and `hasError()`. Each gate is resolved at build/runtime from a configurable source—by default, a `gates.json` file in your project.
+
+## Installation
+
+The provider is included in the default LWR config. To customize it, add it to `moduleProviders` in your `lwr.config.json`:
+
+```json
+{
+    "moduleProviders": [
+        [
+            "@lwrjs/gate-module-provider",
+            {
+                "gateConfigPath": "$rootDir/src/gates.json"
+            }
+        ]
+    ]
+}
+```
+
+### Options
+
+| Option           | Type           | Default                   | Description                                                                                                                       |
+| ---------------- | -------------- | ------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| `gateConfigPath` | `string`       | `$rootDir/src/gates.json` | Path to your gates config file. Supports `$rootDir` placeholder.                                                                  |
+| `resolver`       | `GateResolver` | —                         | Custom resolver function. Overrides `gateConfigPath` when provided. Use for container-specific resolution (e.g., Core, metadata). |
+
+## gates.json Format
+
+Create a `gates.json` file (typically in `src/`) with an array of gate entries:
+
+```json
+[
+    {
+        "name": "myFeatureGate",
+        "enabled": true,
+        "description": "Controls access to the new feature"
+    },
+    {
+        "name": "experimentPreview",
+        "enabled": false,
+        "description": "Preview mode for A/B test"
+    }
+]
+```
+
+### Gate Entry Fields
+
+| Field         | Type      | Required | Description                                                                                          |
+| ------------- | --------- | -------- | ---------------------------------------------------------------------------------------------------- |
+| `name`        | `string`  | Yes      | Gate identifier. Must match the specifier (e.g. `myFeatureGate` → `@salesforce/gate/myFeatureGate`). |
+| `enabled`     | `boolean` | Yes      | Open/closed state.                                                                                   |
+| `description` | `string`  | No       | Human-readable description.                                                                          |
+
+Gate names may use alphanumeric characters, dots, underscores, and hyphens (e.g. `myFeatureGate`, `namespace.gateName`).
+
+### Unknown Gates
+
+If a gate name is not found in `gates.json`, the resolver returns `{ isOpen: false, hasError: false }`. Unknown gates are indistinguishable from known closed gates—both resolve as closed with no error. Ensure gate names in your imports match the `name` field in `gates.json` exactly.
+
+## Client API
+
+Each gate module exports two functions:
+
+### `isOpen(map)`
+
+Returns whether the gate is open.
+
+-   **Resolved**: Returns `true` or `false` based on the gate config.
+-   **Error**: Returns `map.fallback` when `hasError()` is true. If `map` is undefined or lacks `fallback`, returns `false`.
+-   **Defensive**: Safe to call `isOpen()` with no args; returns `false` when resolution failed and no fallback was provided.
+
+```ts
+isOpen({ fallback: false }); // Use false when resolution fails
+isOpen({ fallback: true }); // Use true when resolution fails (opt-in to feature on error)
+isOpen(); // Safe: returns false when hasError() and no fallback provided
+```
+
+### `hasError()`
+
+Returns `true` when gate resolution failed (e.g. config missing, network error). Use this to handle error states explicitly.
+
+## Usage in LWC Modules
+
+### Basic Gating
+
+```ts
+// myComponent.ts
+import { LightningElement } from 'lwc';
+import { isOpen, hasError } from '@salesforce/gate/myFeatureGate';
+
+export default class MyComponent extends LightningElement {
+    get featureEnabled(): boolean {
+        return isOpen({ fallback: false });
+    }
+
+    get showError(): boolean {
+        return hasError();
+    }
+}
+```
+
+```html
+<!-- myComponent.html -->
+<template>
+    <template lwc:if="{showError}">
+        <p class="error">Unable to check feature availability.</p>
+    </template>
+    <template lwc:elseif="{featureEnabled}">
+        <p>New feature content</p>
+    </template>
+    <template lwc:else>
+        <p>Feature not available</p>
+    </template>
+</template>
+```
+
+### Conditional Rendering
+
+```ts
+import { isOpen } from '@salesforce/gate/experimentPreview';
+
+export default class Dashboard extends LightningElement {
+    get showNewDashboard(): boolean {
+        return isOpen({ fallback: false });
+    }
+}
+```
+
+### Safe Defaults
+
+When resolution fails, `isOpen` returns your `fallback` value. Choose based on your use case:
+
+-   `fallback: false` — Feature off when resolution fails (safer for new features).
+-   `fallback: true` — Feature on when resolution fails (use when the gate protects removal of legacy behavior).
+
+## TypeScript Support
+
+Add a declaration file (e.g. `src/types/scoped-modules.d.ts`) so TypeScript recognizes the gate imports:
+
+```ts
+declare module '@salesforce/gate/*' {
+    export function isOpen(map: { fallback?: boolean }): boolean;
+    export function hasError(): boolean;
+    const gate: { isOpen: (map: { fallback?: boolean }) => boolean; hasError: () => boolean };
+    export default gate;
+}
+```
+
+## Custom Resolver
+
+For container-specific resolution (e.g. Core Gater, metadata), provide a custom `resolver`:
+
+```ts
+import type { GateResolver } from '@lwrjs/gate-module-provider';
+
+const myResolver: GateResolver = async (gateName, runtimeParams) => {
+    // Resolve from Core, metadata API, etc.
+    const enabled = await fetchGateState(gateName);
+    return { isOpen: enabled, hasError: false };
+};
+
+// In lwr.config.json moduleProviders:
+// ["@lwrjs/gate-module-provider", { resolver: myResolver }]
+```
+
+The resolver receives `(gateName: string, runtimeParams: RuntimeParams)` and returns `{ isOpen: boolean, hasError?: boolean }` (or a Promise of that).
+
+## Static Builds (MRT)
+
+Gate modules are compiled into static bundles at build time. The gate provider and `gates.json` are not required in the SSR lambda runtime; resolution happens during the build.
+
+## gates.json Caching (Dev Mode)
+
+The JSON resolver caches the parsed `gates.json` for the lifetime of the process. When editing `gates.json` during development, **restart the dev server** for changes to take effect. Resolution is effectively build-time for both dev and production.

package/build/cjs/index.cjs

@@ -0,0 +1,87 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/gate-module-provider/src/index.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => src_default
+});
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_utils = __toModule(require("./utils.cjs"));
+var GateModuleProvider = class {
+  constructor(options = {}, {config, runtimeEnvironment: {lwrVersion}}) {
+    this.name = "gate-module-provider";
+    this.version = lwrVersion;
+    const gateConfigPath = options.gateConfigPath ?? "$rootDir/src/gates.json";
+    if (options.resolver) {
+      this.resolver = options.resolver;
+    } else {
+      this.resolver = (0, import_utils.createJsonGateResolver)({
+        gateConfigPath,
+        rootDir: config.rootDir
+      });
+    }
+  }
+  async getModuleEntry({specifier}, _runtimeParams = {}) {
+    const gateInfo = (0, import_utils.parseSpecifier)(specifier);
+    if (!gateInfo) {
+      return void 0;
+    }
+    return {
+      id: `${specifier}|gate`,
+      virtual: true,
+      entry: `<virtual>/${gateInfo.package}/${gateInfo.gateName}.js`,
+      specifier,
+      version: this.version
+    };
+  }
+  async getModule({specifier, namespace, name = specifier}, runtimeParams = {}) {
+    const gateInfo = (0, import_utils.parseSpecifier)(specifier);
+    if (!gateInfo) {
+      return void 0;
+    }
+    let compiledSource;
+    try {
+      const resolution = await Promise.resolve(this.resolver(gateInfo.gateName, runtimeParams));
+      compiledSource = (0, import_utils.generateModule)(resolution);
+    } catch {
+      compiledSource = (0, import_utils.generateModule)({isOpen: false, hasError: true});
+    }
+    const moduleEntry = await this.getModuleEntry({specifier}, runtimeParams);
+    if (!moduleEntry) {
+      return void 0;
+    }
+    return {
+      id: moduleEntry.id,
+      specifier,
+      namespace,
+      name,
+      version: this.version,
+      originalSource: compiledSource,
+      moduleEntry,
+      ownHash: (0, import_shared_utils.hashContent)(compiledSource),
+      compiledSource
+    };
+  }
+};
+var src_default = GateModuleProvider;

package/build/cjs/utils.cjs

@@ -0,0 +1,96 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/gate-module-provider/src/utils.ts
+__markAsModule(exports);
+__export(exports, {
+  GATE_PACKAGE: () => GATE_PACKAGE,
+  createJsonGateResolver: () => createJsonGateResolver,
+  generateModule: () => generateModule,
+  parseSpecifier: () => parseSpecifier,
+  stubGateResolver: () => stubGateResolver
+});
+var import_fs = __toModule(require("fs"));
+var import_path = __toModule(require("path"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var GATE_NAME_PATTERN = /^[a-zA-Z0-9._-]+$/;
+var GATE_PACKAGE = "@salesforce/gate";
+var stubGateResolver = async () => ({
+  isOpen: false,
+  hasError: false
+});
+function createJsonGateResolver(options) {
+  const {gateConfigPath, rootDir} = options;
+  const resolvedPath = (0, import_path.resolve)((0, import_shared_utils.normalizeDirectory)(gateConfigPath, rootDir));
+  let cache = null;
+  const loadGates = () => {
+    if (cache)
+      return cache;
+    if (!(0, import_fs.existsSync)(resolvedPath)) {
+      cache = [];
+      return cache;
+    }
+    try {
+      const content = (0, import_shared_utils.readFile)(resolvedPath);
+      const parsed = JSON.parse(content);
+      cache = Array.isArray(parsed) ? parsed : [];
+      return cache;
+    } catch {
+      cache = [];
+      return cache;
+    }
+  };
+  return (gateName) => {
+    const gates = loadGates();
+    const entry = gates.find((g) => g.name === gateName);
+    if (!entry) {
+      return {isOpen: false, hasError: false};
+    }
+    return {isOpen: entry.enabled, hasError: false};
+  };
+}
+function parseSpecifier(specifier) {
+  if (!specifier.startsWith(`${GATE_PACKAGE}/`)) {
+    return void 0;
+  }
+  const gateName = specifier.replace(`${GATE_PACKAGE}/`, "");
+  if (!gateName || !GATE_NAME_PATTERN.test(gateName)) {
+    return void 0;
+  }
+  return {gateName, package: GATE_PACKAGE};
+}
+function generateModule(resolution) {
+  const {isOpen, hasError = false} = resolution;
+  if (hasError) {
+    return `export function isOpen(map) {
+  return map != null && 'fallback' in map ? map.fallback : false;
+}
+export function hasError() { return true; }
+export default { isOpen, hasError: hasError };
+`;
+  }
+  return `export function isOpen(map) { return ${isOpen}; }
+export function hasError() { return false; }
+export default { isOpen, hasError: hasError };
+`;
+}

package/build/es/index.d.ts

@@ -0,0 +1,25 @@
+import type { AbstractModuleId, ModuleCompiled, ModuleEntry, ModuleProvider, ProviderContext, RuntimeParams } from '@lwrjs/types';
+import type { GateResolver, GateConfigEntry, GateResolverOptions } from './utils.js';
+export type { GateResolver, GateConfigEntry, GateResolverOptions };
+export interface GateProviderOptions {
+    /**
+     * Path to gates.json in the user's project (e.g. '$rootDir/src/gates.json').
+     * When provided, gates are resolved from this file. Format matches Core Gater:
+     * [{ name, enabled, description? }]
+     */
+    gateConfigPath?: string;
+    /**
+     * Custom gate resolver. Overrides gateConfigPath when provided.
+     * Each container (webruntime, MRT, etc.) can supply its own resolver.
+     */
+    resolver?: GateResolver;
+}
+export default class GateModuleProvider implements ModuleProvider {
+    name: string;
+    version: string;
+    private resolver;
+    constructor(options: GateProviderOptions | undefined, { config, runtimeEnvironment: { lwrVersion } }: ProviderContext);
+    getModuleEntry({ specifier }: AbstractModuleId, _runtimeParams?: RuntimeParams): Promise<ModuleEntry | undefined>;
+    getModule({ specifier, namespace, name }: AbstractModuleId, runtimeParams?: RuntimeParams): Promise<ModuleCompiled | undefined>;
+}
+//# sourceMappingURL=index.d.ts.map

package/build/es/index.js

@@ -0,0 +1,61 @@
+import { hashContent } from '@lwrjs/shared-utils';
+import { parseSpecifier, generateModule, createJsonGateResolver } from './utils.js';
+export default class GateModuleProvider {
+    constructor(options = {}, { config, runtimeEnvironment: { lwrVersion } }) {
+        this.name = 'gate-module-provider';
+        this.version = lwrVersion;
+        const gateConfigPath = options.gateConfigPath ?? '$rootDir/src/gates.json';
+        if (options.resolver) {
+            this.resolver = options.resolver;
+        }
+        else {
+            this.resolver = createJsonGateResolver({
+                gateConfigPath,
+                rootDir: config.rootDir,
+            });
+        }
+    }
+    async getModuleEntry({ specifier }, _runtimeParams = {}) {
+        const gateInfo = parseSpecifier(specifier);
+        if (!gateInfo) {
+            return undefined;
+        }
+        return {
+            id: `${specifier}|gate`,
+            virtual: true,
+            entry: `<virtual>/${gateInfo.package}/${gateInfo.gateName}.js`,
+            specifier,
+            version: this.version,
+        };
+    }
+    async getModule({ specifier, namespace, name = specifier }, runtimeParams = {}) {
+        const gateInfo = parseSpecifier(specifier);
+        if (!gateInfo) {
+            return undefined;
+        }
+        let compiledSource;
+        try {
+            const resolution = await Promise.resolve(this.resolver(gateInfo.gateName, runtimeParams));
+            compiledSource = generateModule(resolution);
+        }
+        catch {
+            compiledSource = generateModule({ isOpen: false, hasError: true });
+        }
+        const moduleEntry = await this.getModuleEntry({ specifier }, runtimeParams);
+        if (!moduleEntry) {
+            return undefined;
+        }
+        return {
+            id: moduleEntry.id,
+            specifier,
+            namespace,
+            name,
+            version: this.version,
+            originalSource: compiledSource,
+            moduleEntry,
+            ownHash: hashContent(compiledSource),
+            compiledSource,
+        };
+    }
+}
+//# sourceMappingURL=index.js.map

package/build/es/utils.d.ts

@@ -0,0 +1,58 @@
+import type { RuntimeParams } from '@lwrjs/types';
+export declare const GATE_PACKAGE = "@salesforce/gate";
+export interface GateInfo {
+    gateName: string;
+    package: string;
+}
+export interface GateResolution {
+    isOpen: boolean;
+    hasError?: boolean;
+}
+/**
+ * Gate config entry from gates.json (matches Core Gater format).
+ */
+export interface GateConfigEntry {
+    name: string;
+    enabled: boolean;
+    description?: string;
+    teamId?: string;
+    tags?: string[];
+    version?: number;
+    responseType?: string;
+}
+export interface GateResolverOptions {
+    gateConfigPath: string;
+    rootDir: string;
+}
+/**
+ * Resolver function that each container (webruntime, MRT, etc.) can implement
+ * to provide gate resolution from their own data source (Core, metadata, etc.)
+ */
+export type GateResolver = (gateName: string, runtimeParams: RuntimeParams) => Promise<GateResolution> | GateResolution;
+/**
+ * Default stub resolver for development and testing.
+ * Returns closed gate with no error until real resolution is wired per container.
+ */
+export declare const stubGateResolver: GateResolver;
+/**
+ * Create a resolver that reads gates from a JSON file in the user's project.
+ */
+export declare function createJsonGateResolver(options: GateResolverOptions): GateResolver;
+/**
+ * Parse a specifier into gate info.
+ * Returns undefined if the specifier is not for @salesforce/gate.
+ *
+ * @param specifier - e.g. '@salesforce/gate/myFeatureGate'
+ */
+export declare function parseSpecifier(specifier: string): GateInfo | undefined;
+/**
+ * Generate ESM module source for a gate with the standard @salesforce/gate contract.
+ *
+ * Contract (matches Core GateSourceProvider):
+ * - isOpen(map) - function that returns true/false when resolved, or map.fallback when hasError
+ * - hasError() - function that returns true when gate resolution failed
+ *
+ * @see https://confluence.internal.salesforce.com/display/gater/Gater+Overview
+ */
+export declare function generateModule(resolution: GateResolution): string;
+//# sourceMappingURL=utils.d.ts.map

package/build/es/utils.js

@@ -0,0 +1,89 @@
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { readFile, normalizeDirectory } from '@lwrjs/shared-utils';
+/** Gate name format: alphanumeric with dots/underscores (e.g. myFeatureGate, namespace.gateName) */
+const GATE_NAME_PATTERN = /^[a-zA-Z0-9._-]+$/;
+export const GATE_PACKAGE = '@salesforce/gate';
+/**
+ * Default stub resolver for development and testing.
+ * Returns closed gate with no error until real resolution is wired per container.
+ */
+export const stubGateResolver = async () => ({
+    isOpen: false,
+    hasError: false,
+});
+/**
+ * Create a resolver that reads gates from a JSON file in the user's project.
+ */
+export function createJsonGateResolver(options) {
+    const { gateConfigPath, rootDir } = options;
+    const resolvedPath = resolve(normalizeDirectory(gateConfigPath, rootDir));
+    let cache = null;
+    const loadGates = () => {
+        if (cache)
+            return cache;
+        if (!existsSync(resolvedPath)) {
+            cache = [];
+            return cache;
+        }
+        try {
+            const content = readFile(resolvedPath);
+            const parsed = JSON.parse(content);
+            cache = Array.isArray(parsed) ? parsed : [];
+            return cache;
+        }
+        catch {
+            cache = [];
+            return cache;
+        }
+    };
+    return (gateName) => {
+        const gates = loadGates();
+        const entry = gates.find((g) => g.name === gateName);
+        if (!entry) {
+            return { isOpen: false, hasError: false };
+        }
+        return { isOpen: entry.enabled, hasError: false };
+    };
+}
+/**
+ * Parse a specifier into gate info.
+ * Returns undefined if the specifier is not for @salesforce/gate.
+ *
+ * @param specifier - e.g. '@salesforce/gate/myFeatureGate'
+ */
+export function parseSpecifier(specifier) {
+    if (!specifier.startsWith(`${GATE_PACKAGE}/`)) {
+        return undefined;
+    }
+    const gateName = specifier.replace(`${GATE_PACKAGE}/`, '');
+    if (!gateName || !GATE_NAME_PATTERN.test(gateName)) {
+        return undefined;
+    }
+    return { gateName, package: GATE_PACKAGE };
+}
+/**
+ * Generate ESM module source for a gate with the standard @salesforce/gate contract.
+ *
+ * Contract (matches Core GateSourceProvider):
+ * - isOpen(map) - function that returns true/false when resolved, or map.fallback when hasError
+ * - hasError() - function that returns true when gate resolution failed
+ *
+ * @see https://confluence.internal.salesforce.com/display/gater/Gater+Overview
+ */
+export function generateModule(resolution) {
+    const { isOpen, hasError = false } = resolution;
+    if (hasError) {
+        return `export function isOpen(map) {
+  return map != null && 'fallback' in map ? map.fallback : false;
+}
+export function hasError() { return true; }
+export default { isOpen, hasError: hasError };
+`;
+    }
+    return `export function isOpen(map) { return ${isOpen}; }
+export function hasError() { return false; }
+export default { isOpen, hasError: hasError };
+`;
+}
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -0,0 +1,46 @@
+{
+    "name": "@lwrjs/gate-module-provider",
+    "license": "MIT",
+    "publishConfig": {
+        "access": "public"
+    },
+    "version": "0.22.9",
+    "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr.git",
+        "directory": "packages/@lwrjs/gate-module-provider"
+    },
+    "bugs": {
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr/issues"
+    },
+    "type": "module",
+    "types": "build/es/index.d.ts",
+    "main": "build/cjs/index.cjs",
+    "module": "build/es/index.js",
+    "exports": {
+        ".": {
+            "import": "./build/es/index.js",
+            "require": "./build/cjs/index.cjs"
+        }
+    },
+    "files": [
+        "build/**/*.js",
+        "build/**/*.cjs",
+        "build/**/*.d.ts"
+    ],
+    "scripts": {
+        "build": "tsc -b"
+    },
+    "dependencies": {
+        "@lwrjs/diagnostics": "0.22.9",
+        "@lwrjs/shared-utils": "0.22.9"
+    },
+    "devDependencies": {
+        "@lwrjs/types": "0.22.9"
+    },
+    "engines": {
+        "node": ">=22.0.0"
+    },
+    "gitHead": "d0c112cd7b6eb940d6e554d0bbd93fb535465fdc"
+}