@get-bb/plugin-sdk 0.4.9 → 0.4.11

package/dist/testing/index.js

@@ -66,6 +66,7 @@ var PLUGIN_AGENT_DYNAMIC_INSTRUCTIONS_MAX_CHARS = 4096;
 var PLUGIN_AGENT_TOOL_PARAMETERS_MAX_BYTES = 128 * 1024;
 var MENTION_PROVIDER_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
 var PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9-]{1,63}$/;
+var PLUGIN_PROVIDER_BRIDGE_OPTIONS_MAX_BYTES = 64 * 1024;
 var SETTING_KEY_PATTERN = /^[a-zA-Z0-9_-]+$/;
 var settingsBaseFields = {
   label: z2.string().min(1),
@@ -267,6 +268,383 @@ function validateProviderLiteralArray(args) {
   }
   return Object.freeze(normalized);
 }
+function normalizeProviderBridgeOptions(providerId, value, label = "experimental_bridgeOptions") {
+  const active = /* @__PURE__ */ new Set();
+  function visit(current, path) {
+    if (current === null || typeof current === "string" || typeof current === "boolean") {
+      return current;
+    }
+    if (typeof current === "number") {
+      if (!Number.isFinite(current)) {
+        throw new Error(
+          `provider "${providerId}" ${label}${path} must be finite JSON`
+        );
+      }
+      return current;
+    }
+    if (typeof current !== "object") {
+      throw new Error(
+        `provider "${providerId}" ${label}${path} must be JSON`
+      );
+    }
+    if (active.has(current)) {
+      throw new Error(
+        `provider "${providerId}" experimental_bridgeOptions must not contain cycles`
+      );
+    }
+    active.add(current);
+    try {
+      if (Array.isArray(current)) {
+        const normalized3 = current.map(
+          (entry, index) => visit(entry, `${path}[${index}]`)
+        );
+        Object.freeze(normalized3);
+        return normalized3;
+      }
+      const prototype = Object.getPrototypeOf(current);
+      if (prototype !== Object.prototype && prototype !== null) {
+        throw new Error(
+          `provider "${providerId}" ${label}${path} must contain only plain JSON objects`
+        );
+      }
+      const normalized2 = Object.fromEntries(
+        Object.entries(current).map(([key, entry]) => [
+          key,
+          visit(entry, `${path}.${key}`)
+        ])
+      );
+      Object.freeze(normalized2);
+      return normalized2;
+    } finally {
+      active.delete(current);
+    }
+  }
+  const normalized = visit(value, "");
+  if (normalized === null || Array.isArray(normalized) || typeof normalized !== "object") {
+    throw new Error(
+      `provider "${providerId}" ${label} must be an object`
+    );
+  }
+  if (Buffer.byteLength(JSON.stringify(normalized), "utf8") > PLUGIN_PROVIDER_BRIDGE_OPTIONS_MAX_BYTES) {
+    throw new Error(
+      `provider "${providerId}" ${label} exceeds ${PLUGIN_PROVIDER_BRIDGE_OPTIONS_MAX_BYTES} bytes`
+    );
+  }
+  return normalized;
+}
+var PROVIDER_STRING_MAX_CHARS = 512;
+var PROVIDER_EXTENSION_KIND_NAME_PATTERN = /^[a-z0-9-]+$/u;
+var PROVIDER_EXTENSION_KINDS_MAX = 32;
+function requireNonBlankString(args) {
+  const { providerId, field, value } = args;
+  if (typeof value !== "string" || value.trim().length === 0 || value.length > PROVIDER_STRING_MAX_CHARS) {
+    throw new Error(
+      `provider "${providerId}" ${field} must be a non-blank string of at most ${PROVIDER_STRING_MAX_CHARS} characters`
+    );
+  }
+  return value;
+}
+function validateProviderStrings(providerId, value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(
+      `provider "${providerId}" experimental_strings must be an object`
+    );
+  }
+  const record = Object.fromEntries(
+    Object.entries(value)
+  );
+  const required = (field) => requireNonBlankString({
+    providerId,
+    field: `experimental_strings.${field}`,
+    value: record[field]
+  });
+  const optional = (field) => record[field] === void 0 ? void 0 : requireNonBlankString({
+    providerId,
+    field: `experimental_strings.${field}`,
+    value: record[field]
+  });
+  let iconTint;
+  if (record.iconTint !== void 0) {
+    const tint = record.iconTint;
+    if (typeof tint !== "object" || tint === null || Array.isArray(tint)) {
+      throw new Error(
+        `provider "${providerId}" experimental_strings.iconTint must be { light, dark }`
+      );
+    }
+    const tintRecord = Object.fromEntries(
+      Object.entries(tint)
+    );
+    iconTint = Object.freeze({
+      light: requireNonBlankString({
+        providerId,
+        field: "experimental_strings.iconTint.light",
+        value: tintRecord.light
+      }),
+      dark: requireNonBlankString({
+        providerId,
+        field: "experimental_strings.iconTint.dark",
+        value: tintRecord.dark
+      })
+    });
+  }
+  const brandPrefix = optional("brandPrefix");
+  const planModeCopy = optional("planModeCopy");
+  return Object.freeze({
+    signInHint: required("signInHint"),
+    expiredHint: required("expiredHint"),
+    installUrl: required("installUrl"),
+    ...brandPrefix === void 0 ? {} : { brandPrefix },
+    ...planModeCopy === void 0 ? {} : { planModeCopy },
+    ...iconTint === void 0 ? {} : { iconTint }
+  });
+}
+function validateProviderOptionDescriptors(args) {
+  const { providerId, field, value } = args;
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error(
+      `provider "${providerId}" ${field} must be a non-empty array of { id, label, description? }`
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = value.map(
+    (entry, index) => {
+      if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+        throw new Error(
+          `provider "${providerId}" ${field}[${index}] must be { id, label, description? }`
+        );
+      }
+      const record = Object.fromEntries(
+        Object.entries(entry)
+      );
+      const id = requireNonBlankString({
+        providerId,
+        field: `${field}[${index}].id`,
+        value: record.id
+      });
+      if (seen.has(id)) {
+        throw new Error(
+          `provider "${providerId}" ${field} id ${JSON.stringify(id)} is duplicated`
+        );
+      }
+      seen.add(id);
+      const label = requireNonBlankString({
+        providerId,
+        field: `${field}[${index}].label`,
+        value: record.label
+      });
+      const description = record.description === void 0 ? void 0 : requireNonBlankString({
+        providerId,
+        field: `${field}[${index}].description`,
+        value: record.description
+      });
+      return Object.freeze({
+        id,
+        label,
+        ...description === void 0 ? {} : { description }
+      });
+    }
+  );
+  return Object.freeze(normalized);
+}
+function validateProviderExtensionKinds(providerId, value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(
+      `provider "${providerId}" experimental_extensionKinds must be an object keyed by kind name`
+    );
+  }
+  const entries = Object.entries(value);
+  if (entries.length > PROVIDER_EXTENSION_KINDS_MAX) {
+    throw new Error(
+      `provider "${providerId}" experimental_extensionKinds declares more than ${PROVIDER_EXTENSION_KINDS_MAX} kinds`
+    );
+  }
+  const normalized = {};
+  for (const [name, declaration] of entries) {
+    if (!PROVIDER_EXTENSION_KIND_NAME_PATTERN.test(name)) {
+      throw new Error(
+        `provider "${providerId}" experimental_extensionKinds name ${JSON.stringify(name)} must match ${PROVIDER_EXTENSION_KIND_NAME_PATTERN}`
+      );
+    }
+    if (typeof declaration !== "object" || declaration === null || Array.isArray(declaration)) {
+      throw new Error(
+        `provider "${providerId}" experimental_extensionKinds.${name} must be { item?, state? }`
+      );
+    }
+    const item = Reflect.get(declaration, "item");
+    const state = Reflect.get(declaration, "state");
+    if (item === void 0 && state === void 0) {
+      throw new Error(
+        `provider "${providerId}" experimental_extensionKinds.${name} must declare an item schema, a state schema, or both`
+      );
+    }
+    if (item !== void 0 && !isStandardSchema(item)) {
+      throw new Error(
+        `provider "${providerId}" experimental_extensionKinds.${name}.item must be a Standard Schema v1 validator`
+      );
+    }
+    if (state !== void 0 && !isStandardSchema(state)) {
+      throw new Error(
+        `provider "${providerId}" experimental_extensionKinds.${name}.state must be a Standard Schema v1 validator`
+      );
+    }
+    normalized[name] = Object.freeze({
+      ...item === void 0 ? {} : { item },
+      ...state === void 0 ? {} : { state }
+    });
+  }
+  return Object.freeze(normalized);
+}
+var PROVIDER_FALLBACK_MODELS_MAX = 64;
+var PROVIDER_ENV_PASSTHROUGH_MAX = 32;
+var PROVIDER_ENV_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/u;
+function validateProviderEnvPassthrough(providerId, value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(
+      `provider "${providerId}" experimental_env must be { passthrough: [...] }`
+    );
+  }
+  const passthrough = Reflect.get(value, "passthrough");
+  if (!Array.isArray(passthrough)) {
+    throw new Error(
+      `provider "${providerId}" experimental_env.passthrough must be an array of variable names`
+    );
+  }
+  if (passthrough.length > PROVIDER_ENV_PASSTHROUGH_MAX) {
+    throw new Error(
+      `provider "${providerId}" experimental_env.passthrough names more than ${PROVIDER_ENV_PASSTHROUGH_MAX} variables`
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of passthrough) {
+    if (typeof name !== "string" || !PROVIDER_ENV_NAME_PATTERN.test(name)) {
+      throw new Error(
+        `provider "${providerId}" experimental_env.passthrough entries must match ${PROVIDER_ENV_NAME_PATTERN}`
+      );
+    }
+    if (seen.has(name)) {
+      throw new Error(
+        `provider "${providerId}" experimental_env.passthrough repeats ${JSON.stringify(name)}`
+      );
+    }
+    seen.add(name);
+  }
+  return Object.freeze([...seen]);
+}
+function validateProviderFallbackModels(providerId, value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(
+      `provider "${providerId}" experimental_models must be { fallback: [...] }`
+    );
+  }
+  const fallback = Reflect.get(value, "fallback");
+  if (!Array.isArray(fallback)) {
+    throw new Error(
+      `provider "${providerId}" experimental_models.fallback must be an array`
+    );
+  }
+  if (fallback.length > PROVIDER_FALLBACK_MODELS_MAX) {
+    throw new Error(
+      `provider "${providerId}" experimental_models.fallback lists more than ${PROVIDER_FALLBACK_MODELS_MAX} models`
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  let defaults = 0;
+  const normalized = fallback.map((entry, index) => {
+    const field = `experimental_models.fallback[${index}]`;
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      throw new Error(`provider "${providerId}" ${field} must be an object`);
+    }
+    const record = Object.fromEntries(
+      Object.entries(entry)
+    );
+    const id = requireNonBlankString({
+      providerId,
+      field: `${field}.id`,
+      value: record.id
+    });
+    if (seen.has(id)) {
+      throw new Error(
+        `provider "${providerId}" experimental_models.fallback id ${JSON.stringify(id)} is duplicated`
+      );
+    }
+    seen.add(id);
+    const displayName = requireNonBlankString({
+      providerId,
+      field: `${field}.displayName`,
+      value: record.displayName
+    });
+    const description = requireNonBlankString({
+      providerId,
+      field: `${field}.description`,
+      value: record.description
+    });
+    const efforts = record.supportedReasoningEfforts;
+    if (!Array.isArray(efforts) || efforts.length === 0) {
+      throw new Error(
+        `provider "${providerId}" ${field}.supportedReasoningEfforts must be a non-empty array`
+      );
+    }
+    const levels = /* @__PURE__ */ new Set();
+    const supportedReasoningEfforts = efforts.map(
+      (effort, effortIndex) => {
+        if (typeof effort !== "object" || effort === null || Array.isArray(effort)) {
+          throw new Error(
+            `provider "${providerId}" ${field}.supportedReasoningEfforts[${effortIndex}] must be { reasoningEffort, description }`
+          );
+        }
+        const reasoningEffort = Reflect.get(effort, "reasoningEffort");
+        if (typeof reasoningEffort !== "string" || !PLUGIN_PROVIDER_REASONING_LEVEL_VALUES.includes(
+          reasoningEffort
+        )) {
+          throw new Error(
+            `provider "${providerId}" ${field}.supportedReasoningEfforts[${effortIndex}].reasoningEffort must be one of ${PLUGIN_PROVIDER_REASONING_LEVEL_VALUES.join(", ")}`
+          );
+        }
+        const level = reasoningEffort;
+        if (levels.has(level)) {
+          throw new Error(
+            `provider "${providerId}" ${field}.supportedReasoningEfforts repeats ${JSON.stringify(level)}`
+          );
+        }
+        levels.add(level);
+        return Object.freeze({
+          reasoningEffort: level,
+          description: requireNonBlankString({
+            providerId,
+            field: `${field}.supportedReasoningEfforts[${effortIndex}].description`,
+            value: Reflect.get(effort, "description")
+          })
+        });
+      }
+    );
+    const defaultReasoningEffort = record.defaultReasoningEffort;
+    if (typeof defaultReasoningEffort !== "string" || !levels.has(defaultReasoningEffort)) {
+      throw new Error(
+        `provider "${providerId}" ${field}.defaultReasoningEffort must be one of its supportedReasoningEfforts`
+      );
+    }
+    if (typeof record.isDefault !== "boolean") {
+      throw new Error(
+        `provider "${providerId}" ${field}.isDefault must be a boolean`
+      );
+    }
+    if (record.isDefault) defaults += 1;
+    return Object.freeze({
+      id,
+      displayName,
+      description,
+      supportedReasoningEfforts: Object.freeze(supportedReasoningEfforts),
+      defaultReasoningEffort,
+      isDefault: record.isDefault
+    });
+  });
+  if (normalized.length > 0 && defaults !== 1) {
+    throw new Error(
+      `provider "${providerId}" experimental_models.fallback must mark exactly one model isDefault (found ${defaults})`
+    );
+  }
+  return Object.freeze(normalized);
+}
 function validatePluginProviderDeclaration(declaration) {
   if (typeof declaration !== "object" || declaration === null) {
     throw new Error("provider declaration must be an object");
@@ -277,6 +655,12 @@ function validatePluginProviderDeclaration(declaration) {
       `invalid provider id ${JSON.stringify(id)} \u2014 use 2-64 lowercase letters, digits, and "-", starting with a letter or digit`
     );
   }
+  const family = declaration.experimental_family;
+  if (family !== void 0 && (typeof family !== "string" || !PROVIDER_ID_PATTERN.test(family))) {
+    throw new Error(
+      `provider "${id}" experimental_family must use the provider id grammar (2-64 lowercase letters, digits, and "-")`
+    );
+  }
   const displayName = typeof declaration.displayName === "string" ? declaration.displayName.trim() : "";
   if (displayName.length === 0 || displayName.length > PLUGIN_PROVIDER_DISPLAY_NAME_MAX_CHARS) {
     throw new Error(
@@ -304,13 +688,30 @@ function validatePluginProviderDeclaration(declaration) {
   if (typeof capabilities !== "object" || capabilities === null) {
     throw new Error(`provider "${id}" capabilities must be an object`);
   }
+  const experimentalProviderHealth = capabilities.experimental_providerHealth ?? false;
+  const experimentalProviderUsage = capabilities.experimental_providerUsage ?? false;
+  const experimentalProviderInstallation = capabilities.experimental_providerInstallation ?? false;
+  if (typeof experimentalProviderHealth !== "boolean") {
+    throw new Error(
+      `provider "${id}" capabilities.experimental_providerHealth must be a boolean`
+    );
+  }
+  if (typeof experimentalProviderUsage !== "boolean") {
+    throw new Error(
+      `provider "${id}" capabilities.experimental_providerUsage must be a boolean`
+    );
+  }
+  if (typeof experimentalProviderInstallation !== "boolean") {
+    throw new Error(
+      `provider "${id}" capabilities.experimental_providerInstallation must be a boolean`
+    );
+  }
   const booleanCapabilityFields = [
     "supportsServiceTier",
     "supportsNativeUserQuestion",
     "supportsManualCompaction",
     "supportsThreadArchive",
-    "supportsThreadRename",
-    "supportsWorkflows"
+    "supportsThreadRename"
   ];
   for (const field of booleanCapabilityFields) {
     if (typeof capabilities[field] !== "boolean") {
@@ -325,13 +726,15 @@ function validatePluginProviderDeclaration(declaration) {
     );
   }
   const normalizedCapabilities = Object.freeze({
+    experimental_providerHealth: experimentalProviderHealth,
+    experimental_providerUsage: experimentalProviderUsage,
+    experimental_providerInstallation: experimentalProviderInstallation,
     supportsServiceTier: capabilities.supportsServiceTier,
     supportsNativeUserQuestion: capabilities.supportsNativeUserQuestion,
     fork: capabilities.fork,
     supportsManualCompaction: capabilities.supportsManualCompaction,
     supportsThreadArchive: capabilities.supportsThreadArchive,
     supportsThreadRename: capabilities.supportsThreadRename,
-    supportsWorkflows: capabilities.supportsWorkflows,
     permissionModes: validateProviderLiteralArray({
       providerId: id,
       field: "capabilities.permissionModes",
@@ -354,12 +757,60 @@ function validatePluginProviderDeclaration(declaration) {
     allowed: PLUGIN_PROVIDER_COMPOSER_ACTION_VALUES,
     requireNonEmpty: false
   });
+  const bridgeOptions = declaration.experimental_bridgeOptions === void 0 ? void 0 : normalizeProviderBridgeOptions(
+    id,
+    declaration.experimental_bridgeOptions
+  );
+  const visibility = declaration.experimental_visibility ?? "always";
+  if (visibility !== "always" && visibility !== "installed") {
+    throw new Error(
+      `provider "${id}" experimental_visibility must be "always" or "installed"`
+    );
+  }
+  if (visibility === "installed" && !normalizedCapabilities.experimental_providerHealth) {
+    throw new Error(
+      `provider "${id}" experimental_visibility "installed" requires experimental_providerHealth`
+    );
+  }
+  const strings = declaration.experimental_strings === void 0 ? void 0 : validateProviderStrings(id, declaration.experimental_strings);
+  const serviceTiers = declaration.experimental_serviceTiers === void 0 ? void 0 : validateProviderOptionDescriptors({
+    providerId: id,
+    field: "experimental_serviceTiers",
+    value: declaration.experimental_serviceTiers
+  });
+  const reasoningLevels = declaration.experimental_reasoningLevels === void 0 ? void 0 : validateProviderOptionDescriptors({
+    providerId: id,
+    field: "experimental_reasoningLevels",
+    value: declaration.experimental_reasoningLevels
+  });
+  const extensionKinds = declaration.experimental_extensionKinds === void 0 ? void 0 : validateProviderExtensionKinds(
+    id,
+    declaration.experimental_extensionKinds
+  );
+  const fallbackModels = declaration.experimental_models === void 0 ? void 0 : validateProviderFallbackModels(id, declaration.experimental_models);
+  const envPassthrough = declaration.experimental_env === void 0 ? void 0 : validateProviderEnvPassthrough(id, declaration.experimental_env);
+  const deriveProviderOptions = declaration.experimental_deriveProviderOptions;
+  if (deriveProviderOptions !== void 0 && typeof deriveProviderOptions !== "function") {
+    throw new Error(
+      `provider "${id}" experimental_deriveProviderOptions must be a function (context) => providerOptions`
+    );
+  }
   return Object.freeze({
     id,
     displayName,
+    ...family === void 0 ? {} : { experimental_family: family },
     ...icon === void 0 ? {} : { icon },
+    ...bridgeOptions === void 0 ? {} : { experimental_bridgeOptions: bridgeOptions },
+    experimental_visibility: visibility,
     capabilities: normalizedCapabilities,
-    composerActions
+    composerActions,
+    ...strings === void 0 ? {} : { experimental_strings: strings },
+    ...serviceTiers === void 0 ? {} : { experimental_serviceTiers: serviceTiers },
+    ...reasoningLevels === void 0 ? {} : { experimental_reasoningLevels: reasoningLevels },
+    ...extensionKinds === void 0 ? {} : { experimental_extensionKinds: extensionKinds },
+    ...fallbackModels === void 0 ? {} : { experimental_models: Object.freeze({ fallback: fallbackModels }) },
+    ...envPassthrough === void 0 ? {} : { experimental_env: Object.freeze({ passthrough: envPassthrough }) },
+    ...deriveProviderOptions === void 0 ? {} : { experimental_deriveProviderOptions: deriveProviderOptions }
   });
 }
 function isStandardSchema(value) {
@@ -1299,6 +1750,25 @@ function createFakePluginHostInternal(options, sharedState) {
   const providerRegistrations = [];
   let agentConfigurationProvider = null;
   let instructionProvider = null;
+  function registerProviderDeclaration(declaration) {
+    assertLive();
+    const normalized = validatePluginProviderDeclaration(declaration);
+    if (providerRegistrations.some((existing) => existing.id === normalized.id)) {
+      throw new Error(
+        `Provider "${normalized.id}" is already registered; a plugin cannot shadow an existing provider.`
+      );
+    }
+    providerRegistrations.push(normalized);
+    let disposed2 = false;
+    const dispose = () => {
+      if (disposed2) return;
+      disposed2 = true;
+      const index = providerRegistrations.indexOf(normalized);
+      if (index !== -1) providerRegistrations.splice(index, 1);
+    };
+    disposeHooks.push(dispose);
+    return { dispose };
+  }
   const agents = {
     configure(provider) {
       assertLive();
@@ -1325,23 +1795,7 @@ function createFakePluginHostInternal(options, sharedState) {
       instructionProvider = provider;
     },
     experimental_registerProvider(declaration) {
-      assertLive();
-      const normalized = validatePluginProviderDeclaration(declaration);
-      if (providerRegistrations.some((existing) => existing.id === normalized.id)) {
-        throw new Error(
-          `Provider "${normalized.id}" is already registered; a plugin cannot shadow an existing provider.`
-        );
-      }
-      providerRegistrations.push(normalized);
-      let disposed2 = false;
-      const dispose = () => {
-        if (disposed2) return;
-        disposed2 = true;
-        const index = providerRegistrations.indexOf(normalized);
-        if (index !== -1) providerRegistrations.splice(index, 1);
-      };
-      disposeHooks.push(dispose);
-      return { dispose };
+      return registerProviderDeclaration(declaration);
     },
     registerTool(tool) {
       assertLive();
@@ -1712,6 +2166,11 @@ function createFakePluginHostInternal(options, sharedState) {
       handlers.push(handler);
     }
   };
+  const providers = {
+    register(declaration) {
+      return registerProviderDeclaration(declaration);
+    }
+  };
   const bb = {
     pluginId,
     log,
@@ -1723,6 +2182,7 @@ function createFakePluginHostInternal(options, sharedState) {
     background,
     cli,
     agents,
+    providers,
     ui,
     events,
     status,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@get-bb/plugin-sdk",
-  "version": "0.4.9",
+  "version": "0.4.11",
   "homepage": "https://github.com/get-bb/bb#readme",
   "bugs": {
     "url": "https://github.com/get-bb/bb/issues"
@@ -32,6 +32,12 @@
       "import": "./dist/provider-bridge.js",
       "default": "./dist/provider-bridge.js"
     },
+    "./provider-bridge/testing": {
+      "source": "./src/provider-bridge-testing.ts",
+      "types": "./bundled-types/bb-plugin-sdk-provider-bridge-testing.d.ts",
+      "import": "./dist/provider-bridge-testing.js",
+      "default": "./dist/provider-bridge-testing.js"
+    },
     "./app": {
       "source": "./src/app.ts",
       "types": "./bundled-types/bb-plugin-sdk-app.d.ts",
@@ -56,6 +62,12 @@
       "import": "./dist/internal/composer-view.js",
       "default": "./dist/internal/composer-view.js"
     },
+    "./internal/file-navigation-validation": {
+      "source": "./src/internal/file-navigation-validation.ts",
+      "types": "./bundled-types/bb-plugin-sdk-internal-file-navigation-validation.d.ts",
+      "import": "./dist/internal/file-navigation-validation.js",
+      "default": "./dist/internal/file-navigation-validation.js"
+    },
     "./internal/host-policy": {
       "source": "./src/internal/host-policy.ts",
       "types": "./bundled-types/bb-plugin-sdk-internal-host-policy.d.ts",