@stina/extension-api 0.22.1 → 0.23.0

package/dist/schemas/index.cjs

@@ -0,0 +1,711 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/schemas/index.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  AllowedCSSPropertySchema: () => AllowedCSSPropertySchema,
+  AuthorSchema: () => AuthorSchema,
+  ButtonPropsSchema: () => ButtonPropsSchema,
+  CapabilityPermissionSchema: () => CapabilityPermissionSchema,
+  CheckboxPropsSchema: () => CheckboxPropsSchema,
+  CollapsiblePropsSchema: () => CollapsiblePropsSchema,
+  CommandDefinitionSchema: () => CommandDefinitionSchema,
+  ConditionalGroupPropsSchema: () => ConditionalGroupPropsSchema,
+  DateTimeInputPropsSchema: () => DateTimeInputPropsSchema,
+  DividerPropsSchema: () => DividerPropsSchema,
+  EnginesSchema: () => EnginesSchema,
+  ExtensionActionCallSchema: () => ExtensionActionCallSchema,
+  ExtensionActionRefSchema: () => ExtensionActionRefSchema,
+  ExtensionComponentChildrenSchema: () => ExtensionComponentChildrenSchema,
+  ExtensionComponentDataSchema: () => ExtensionComponentDataSchema,
+  ExtensionComponentIteratorSchema: () => ExtensionComponentIteratorSchema,
+  ExtensionComponentStyleSchema: () => ExtensionComponentStyleSchema,
+  ExtensionContributionsSchema: () => ExtensionContributionsSchema,
+  ExtensionDataSourceSchema: () => ExtensionDataSourceSchema,
+  ExtensionManifestSchema: () => ExtensionManifestSchema,
+  GridPropsSchema: () => GridPropsSchema,
+  HeaderPropsSchema: () => HeaderPropsSchema,
+  HorizontalStackPropsSchema: () => HorizontalStackPropsSchema,
+  IconButtonPropsSchema: () => IconButtonPropsSchema,
+  IconButtonTypeSchema: () => IconButtonTypeSchema,
+  IconPropsSchema: () => IconPropsSchema,
+  LabelPropsSchema: () => LabelPropsSchema,
+  LocalizedStringSchema: () => LocalizedStringSchema,
+  MarkdownPropsSchema: () => MarkdownPropsSchema,
+  ModalPropsSchema: () => ModalPropsSchema,
+  NetworkPermissionSchema: () => NetworkPermissionSchema,
+  PERMISSION_PATTERNS: () => PERMISSION_PATTERNS,
+  PanelActionDataSourceSchema: () => PanelActionDataSourceSchema,
+  PanelActionSchema: () => PanelActionSchema,
+  PanelComponentViewSchema: () => PanelComponentViewSchema,
+  PanelDefinitionSchema: () => PanelDefinitionSchema,
+  PanelPropsSchema: () => PanelPropsSchema,
+  PanelUnknownViewSchema: () => PanelUnknownViewSchema,
+  PanelViewSchema: () => PanelViewSchema,
+  ParagraphPropsSchema: () => ParagraphPropsSchema,
+  PermissionSchema: () => PermissionSchema,
+  PillPropsSchema: () => PillPropsSchema,
+  PillVariantSchema: () => PillVariantSchema,
+  PlatformSchema: () => PlatformSchema,
+  PromptContributionSchema: () => PromptContributionSchema,
+  PromptSectionSchema: () => PromptSectionSchema,
+  ProviderConfigPropertySchema: () => ProviderConfigPropertySchema,
+  ProviderConfigPropertyTypeSchema: () => ProviderConfigPropertyTypeSchema,
+  ProviderConfigSchemaSchema: () => ProviderConfigSchemaSchema,
+  ProviderConfigSelectOptionSchema: () => ProviderConfigSelectOptionSchema,
+  ProviderConfigValidationSchema: () => ProviderConfigValidationSchema,
+  ProviderDefinitionSchema: () => ProviderDefinitionSchema,
+  SelectPropsSchema: () => SelectPropsSchema,
+  SettingCreateMappingSchema: () => SettingCreateMappingSchema,
+  SettingDefinitionSchema: () => SettingDefinitionSchema,
+  SettingOptionsMappingSchema: () => SettingOptionsMappingSchema,
+  SettingValidationSchema: () => SettingValidationSchema,
+  StoragePermissionSchema: () => StoragePermissionSchema,
+  SystemPermissionSchema: () => SystemPermissionSchema,
+  TextInputPropsSchema: () => TextInputPropsSchema,
+  TogglePropsSchema: () => TogglePropsSchema,
+  ToolDefinitionSchema: () => ToolDefinitionSchema,
+  ToolSettingsActionDataSourceSchema: () => ToolSettingsActionDataSourceSchema,
+  ToolSettingsComponentViewSchema: () => ToolSettingsComponentViewSchema,
+  ToolSettingsListMappingSchema: () => ToolSettingsListMappingSchema,
+  ToolSettingsListViewSchema: () => ToolSettingsListViewSchema,
+  ToolSettingsViewDefinitionSchema: () => ToolSettingsViewDefinitionSchema,
+  ToolSettingsViewSchema: () => ToolSettingsViewSchema,
+  UserDataPermissionSchema: () => UserDataPermissionSchema,
+  VALID_PERMISSIONS: () => VALID_PERMISSIONS,
+  VerticalStackPropsSchema: () => VerticalStackPropsSchema,
+  isValidPermission: () => isValidPermission
+});
+module.exports = __toCommonJS(schemas_exports);
+
+// src/schemas/manifest.schema.ts
+var import_zod4 = require("zod");
+
+// src/schemas/permissions.schema.ts
+var import_zod = require("zod");
+var VALID_PERMISSIONS = [
+  "network:*",
+  "network:localhost",
+  "storage.collections",
+  "secrets.manage",
+  "user.profile.read",
+  "user.location.read",
+  "chat.history.read",
+  "chat.current.read",
+  "chat.message.write",
+  "provider.register",
+  "tools.register",
+  "actions.register",
+  "settings.register",
+  "commands.register",
+  "panels.register",
+  "events.emit",
+  "scheduler.register",
+  "background.workers",
+  "files.read",
+  "files.write",
+  "clipboard.read",
+  "clipboard.write"
+];
+var PERMISSION_PATTERNS = [
+  /^network:localhost:\d+$/,
+  // network:localhost:11434
+  /^network:[a-zA-Z0-9.-]+$/,
+  // network:api.example.com
+  /^network:[a-zA-Z0-9.-]+:\d+$/
+  // network:api.example.com:8080
+];
+var NetworkPermissionSchema = import_zod.z.string().refine(
+  (val) => {
+    if (val === "network:*" || val === "network:localhost") {
+      return true;
+    }
+    return PERMISSION_PATTERNS.some((pattern) => pattern.test(val));
+  },
+  { message: "Invalid network permission format" }
+).describe('Network access permission (e.g., "network:*", "network:localhost:11434")');
+var StoragePermissionSchema = import_zod.z.enum(["storage.collections", "secrets.manage"]).describe("Storage permission");
+var UserDataPermissionSchema = import_zod.z.enum(["user.profile.read", "user.location.read", "chat.history.read", "chat.current.read"]).describe("User data access permission");
+var CapabilityPermissionSchema = import_zod.z.enum([
+  "provider.register",
+  "tools.register",
+  "actions.register",
+  "settings.register",
+  "commands.register",
+  "panels.register",
+  "events.emit",
+  "scheduler.register",
+  "chat.message.write",
+  "background.workers"
+]).describe("Capability permission");
+var SystemPermissionSchema = import_zod.z.enum(["files.read", "files.write", "clipboard.read", "clipboard.write"]).describe("System permission");
+var NETWORK_PERMISSION_REGEX = /^network:[a-zA-Z0-9.-]+(:\d+)?$/;
+var PermissionSchema = import_zod.z.union([
+  import_zod.z.enum(VALID_PERMISSIONS),
+  import_zod.z.string().regex(NETWORK_PERMISSION_REGEX, "Invalid network permission format")
+]).describe("Extension permission");
+function isValidPermission(permission) {
+  return PermissionSchema.safeParse(permission).success;
+}
+
+// src/schemas/contributions.schema.ts
+var import_zod3 = require("zod");
+
+// src/schemas/components.schema.ts
+var import_zod2 = require("zod");
+var AllowedCSSPropertySchema = import_zod2.z.enum([
+  // Colors
+  "color",
+  "background-color",
+  "background",
+  "border-color",
+  // Borders
+  "border",
+  "border-width",
+  "border-style",
+  "border-radius",
+  "border-top",
+  "border-right",
+  "border-bottom",
+  "border-left",
+  "border-top-left-radius",
+  "border-top-right-radius",
+  "border-bottom-left-radius",
+  "border-bottom-right-radius",
+  // Spacing
+  "padding",
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left",
+  "margin",
+  "margin-top",
+  "margin-right",
+  "margin-bottom",
+  "margin-left",
+  "gap",
+  "row-gap",
+  "column-gap",
+  // Typography
+  "font-size",
+  "font-weight",
+  "font-style",
+  "text-align",
+  "text-decoration",
+  "line-height",
+  "letter-spacing",
+  "white-space",
+  "word-break",
+  "overflow-wrap",
+  // Layout (safe properties)
+  "width",
+  "height",
+  "min-width",
+  "min-height",
+  "max-width",
+  "max-height",
+  "flex",
+  "flex-grow",
+  "flex-shrink",
+  "flex-basis",
+  "flex-wrap",
+  "align-self",
+  "justify-self",
+  "align-items",
+  "justify-content",
+  // Visual
+  "opacity",
+  "visibility",
+  "overflow",
+  "overflow-x",
+  "overflow-y",
+  "box-shadow",
+  "outline",
+  "cursor",
+  "border-collapse",
+  "border-spacing"
+]);
+var ExtensionComponentStyleSchema = import_zod2.z.record(AllowedCSSPropertySchema, import_zod2.z.string()).describe("Safe CSS styles for the component");
+var ExtensionComponentDataSchema = import_zod2.z.lazy(
+  () => import_zod2.z.object({
+    component: import_zod2.z.string().describe("Component type name"),
+    style: ExtensionComponentStyleSchema.optional()
+  }).passthrough().describe("Extension component definition")
+);
+var ExtensionActionCallSchema = import_zod2.z.object({
+  action: import_zod2.z.string().describe("Name of the registered action"),
+  params: import_zod2.z.record(import_zod2.z.unknown()).optional().describe("Parameters to pass")
+}).describe("Action call with parameters");
+var ExtensionActionRefSchema = import_zod2.z.union([import_zod2.z.string(), ExtensionActionCallSchema]).describe("Action reference");
+var ExtensionComponentIteratorSchema = import_zod2.z.object({
+  each: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.array(import_zod2.z.unknown())]).describe("Data source to iterate over"),
+  as: import_zod2.z.string().describe("Variable name for current item in scope"),
+  items: import_zod2.z.array(ExtensionComponentDataSchema).describe("Components to render for each item")
+}).describe("Iterator for rendering lists");
+var ExtensionComponentChildrenSchema = import_zod2.z.union([import_zod2.z.array(ExtensionComponentDataSchema), ExtensionComponentIteratorSchema]).describe("Child components or iterator");
+var ExtensionDataSourceSchema = import_zod2.z.object({
+  action: import_zod2.z.string().describe("Action to call for fetching data"),
+  params: import_zod2.z.record(import_zod2.z.unknown()).optional().describe("Parameters to pass to the action"),
+  refreshOn: import_zod2.z.array(import_zod2.z.string()).optional().describe("Event names that trigger a refresh")
+}).describe("Data source definition");
+var HeaderPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Header"),
+  level: import_zod2.z.number().min(1).max(6).describe("Heading level (1-6)"),
+  title: import_zod2.z.string().describe("Header title"),
+  description: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.array(import_zod2.z.string())]).optional().describe("Description text"),
+  icon: import_zod2.z.string().optional().describe("Icon name"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Header component");
+var LabelPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Label"),
+  text: import_zod2.z.string().describe("Label text"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Label component");
+var ParagraphPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Paragraph"),
+  text: import_zod2.z.string().describe("Paragraph text"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Paragraph component");
+var ButtonPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Button"),
+  text: import_zod2.z.string().describe("Button text"),
+  onClickAction: ExtensionActionRefSchema.describe("Action to call on click"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Button component");
+var TextInputPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("TextInput"),
+  label: import_zod2.z.string().describe("Input label"),
+  placeholder: import_zod2.z.string().optional().describe("Placeholder text"),
+  value: import_zod2.z.string().optional().describe("Current value"),
+  onChangeAction: ExtensionActionRefSchema.describe("Action to call on change"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("TextInput component");
+var DateTimeInputPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("DateTimeInput"),
+  label: import_zod2.z.string().describe("Input label"),
+  value: import_zod2.z.string().optional().describe("Current value"),
+  onChangeAction: ExtensionActionRefSchema.describe("Action to call on change"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("DateTimeInput component");
+var SelectPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Select"),
+  label: import_zod2.z.string().describe("Select label"),
+  options: import_zod2.z.array(import_zod2.z.object({ label: import_zod2.z.string(), value: import_zod2.z.string() })).describe("Available options"),
+  selectedValue: import_zod2.z.string().optional().describe("Currently selected value"),
+  onChangeAction: ExtensionActionRefSchema.describe("Action to call on change"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Select component");
+var VerticalStackPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("VerticalStack"),
+  gap: import_zod2.z.number().optional().describe("Gap between children"),
+  children: ExtensionComponentChildrenSchema.describe("Child components"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("VerticalStack layout component");
+var HorizontalStackPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("HorizontalStack"),
+  gap: import_zod2.z.number().optional().describe("Gap between children"),
+  children: ExtensionComponentChildrenSchema.describe("Child components"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("HorizontalStack layout component");
+var GridPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Grid"),
+  columns: import_zod2.z.number().describe("Number of columns"),
+  gap: import_zod2.z.number().optional().describe("Gap between items"),
+  children: ExtensionComponentChildrenSchema.describe("Child components"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Grid layout component");
+var DividerPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Divider"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Divider component");
+var IconPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Icon"),
+  name: import_zod2.z.string().describe("Icon name"),
+  title: import_zod2.z.string().optional().describe("Icon title"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Icon component");
+var IconButtonTypeSchema = import_zod2.z.enum(["normal", "primary", "danger", "accent"]).describe("Button type");
+var IconButtonPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("IconButton"),
+  icon: import_zod2.z.string().describe("Icon name"),
+  tooltip: import_zod2.z.string().describe("Tooltip text"),
+  active: import_zod2.z.boolean().optional().describe("Whether the button is active"),
+  disabled: import_zod2.z.boolean().optional().describe("Whether the button is disabled"),
+  type: IconButtonTypeSchema.optional().describe("Button style type"),
+  onClickAction: ExtensionActionRefSchema.describe("Action to call on click"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("IconButton component");
+var PanelActionSchema = import_zod2.z.object({
+  icon: import_zod2.z.string().describe("Icon name"),
+  tooltip: import_zod2.z.string().describe("Tooltip text"),
+  action: ExtensionActionRefSchema.describe("Action to call"),
+  type: IconButtonTypeSchema.optional().describe("Button style type")
+}).describe("Panel action button");
+var PanelPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Panel"),
+  title: import_zod2.z.string().describe("Panel title"),
+  description: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.array(import_zod2.z.string())]).optional().describe("Description text"),
+  icon: import_zod2.z.string().optional().describe("Icon name"),
+  actions: import_zod2.z.array(PanelActionSchema).optional().describe("Action buttons"),
+  content: ExtensionComponentDataSchema.optional().describe("Panel content"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Panel component");
+var TogglePropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Toggle"),
+  label: import_zod2.z.string().optional().describe("Toggle label"),
+  description: import_zod2.z.string().optional().describe("Description text"),
+  checked: import_zod2.z.boolean().optional().describe("Whether the toggle is checked"),
+  disabled: import_zod2.z.boolean().optional().describe("Whether the toggle is disabled"),
+  onChangeAction: ExtensionActionRefSchema.describe("Action to call on change"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Toggle component");
+var CollapsiblePropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Collapsible"),
+  title: import_zod2.z.string().describe("Title displayed in the header"),
+  description: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.array(import_zod2.z.string())]).optional().describe("Description text"),
+  icon: import_zod2.z.string().optional().describe("Icon name"),
+  defaultExpanded: import_zod2.z.boolean().optional().describe("Whether expanded by default"),
+  content: ExtensionComponentDataSchema.optional().describe("Content when expanded"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Collapsible component");
+var PillVariantSchema = import_zod2.z.enum(["default", "primary", "success", "warning", "danger", "accent"]).describe("Pill color variant");
+var PillPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Pill"),
+  text: import_zod2.z.string().describe("Pill text"),
+  icon: import_zod2.z.string().optional().describe("Icon name"),
+  variant: PillVariantSchema.optional().describe("Color variant"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Pill component");
+var CheckboxPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Checkbox"),
+  label: import_zod2.z.string().describe("Checkbox label"),
+  checked: import_zod2.z.boolean().optional().describe("Whether the checkbox is checked"),
+  disabled: import_zod2.z.boolean().optional().describe("Whether the checkbox is disabled"),
+  strikethrough: import_zod2.z.boolean().optional().describe("Strike through label when checked"),
+  onChangeAction: ExtensionActionRefSchema.describe("Action to call on change"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Checkbox component");
+var MarkdownPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Markdown"),
+  content: import_zod2.z.string().describe("Markdown content"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Markdown component");
+var ModalPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("Modal"),
+  title: import_zod2.z.string().describe("Modal title"),
+  open: import_zod2.z.boolean().optional().describe("Whether the modal is open"),
+  maxWidth: import_zod2.z.string().optional().describe("Max width of the modal"),
+  body: ExtensionComponentDataSchema.optional().describe("Modal body content"),
+  footer: ExtensionComponentDataSchema.optional().describe("Modal footer content"),
+  onCloseAction: ExtensionActionRefSchema.optional().describe("Action to call on close"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("Modal component");
+var ConditionalGroupPropsSchema = import_zod2.z.object({
+  component: import_zod2.z.literal("ConditionalGroup"),
+  condition: import_zod2.z.string().describe("Condition expression to evaluate"),
+  children: ExtensionComponentChildrenSchema.describe("Children to render when condition is true"),
+  style: ExtensionComponentStyleSchema.optional()
+}).passthrough().describe("ConditionalGroup component");
+
+// src/schemas/contributions.schema.ts
+var LocalizedStringSchema = import_zod3.z.union([import_zod3.z.string(), import_zod3.z.record(import_zod3.z.string())]).describe("String or localized string map");
+var SettingOptionsMappingSchema = import_zod3.z.object({
+  itemsKey: import_zod3.z.string().describe("Key for items array in tool result data"),
+  valueKey: import_zod3.z.string().describe("Key for option value"),
+  labelKey: import_zod3.z.string().describe("Key for option label"),
+  descriptionKey: import_zod3.z.string().optional().describe("Optional key for description")
+}).describe("Mapping for select field options");
+var SettingCreateMappingSchema = import_zod3.z.object({
+  resultKey: import_zod3.z.string().optional().describe("Key for result data object"),
+  valueKey: import_zod3.z.string().describe('Key for option value (defaults to "id")')
+}).describe("Mapping for create tool response");
+var SettingValidationSchema = import_zod3.z.object({
+  required: import_zod3.z.boolean().optional().describe("Whether the field is required"),
+  min: import_zod3.z.number().optional().describe("Minimum value (number) or length (string)"),
+  max: import_zod3.z.number().optional().describe("Maximum value (number) or length (string)"),
+  pattern: import_zod3.z.string().optional().describe("Regex pattern for validation")
+}).describe("Validation rules");
+var SettingDefinitionSchema = import_zod3.z.lazy(
+  () => import_zod3.z.object({
+    id: import_zod3.z.string().describe("Setting ID (namespaced automatically)"),
+    title: import_zod3.z.string().describe("Display title"),
+    description: import_zod3.z.string().optional().describe("Help text"),
+    type: import_zod3.z.enum(["string", "number", "boolean", "select"]).describe("Setting type"),
+    default: import_zod3.z.unknown().optional().describe("Default value"),
+    options: import_zod3.z.array(import_zod3.z.object({ value: import_zod3.z.string(), label: import_zod3.z.string() })).optional().describe("For select type: available options"),
+    optionsToolId: import_zod3.z.string().optional().describe("For select type: load options from tool"),
+    optionsParams: import_zod3.z.record(import_zod3.z.unknown()).optional().describe("Params for options tool"),
+    optionsMapping: SettingOptionsMappingSchema.optional().describe("Mapping for options tool response"),
+    createToolId: import_zod3.z.string().optional().describe("Tool ID for creating a new option"),
+    createLabel: import_zod3.z.string().optional().describe("Label for create action"),
+    createFields: import_zod3.z.array(SettingDefinitionSchema).optional().describe("Fields for create form"),
+    createParams: import_zod3.z.record(import_zod3.z.unknown()).optional().describe("Static params for create tool"),
+    createMapping: SettingCreateMappingSchema.optional().describe("Mapping for create tool response"),
+    validation: SettingValidationSchema.optional().describe("Validation rules")
+  }).superRefine((data, ctx) => {
+    const hasCreateFields = data.createToolId !== void 0 || data.createLabel !== void 0 || data.createFields !== void 0 || data.createParams !== void 0 || data.createMapping !== void 0;
+    if (hasCreateFields && data.type !== "select") {
+      ctx.addIssue({
+        code: import_zod3.z.ZodIssueCode.custom,
+        message: 'create* fields (createToolId, createLabel, createFields, createParams, createMapping) are only valid for type "select"',
+        path: ["type"]
+      });
+    }
+    if (data.type === "select") {
+      const hasOptions = data.options && data.options.length > 0;
+      const hasOptionsToolId = data.optionsToolId !== void 0;
+      if (!hasOptions && !hasOptionsToolId) {
+        ctx.addIssue({
+          code: import_zod3.z.ZodIssueCode.custom,
+          message: 'Setting of type "select" must have "options" or "optionsToolId"',
+          path: ["type"]
+        });
+      }
+    }
+  }).describe("Setting definition")
+);
+var ToolSettingsListMappingSchema = import_zod3.z.object({
+  itemsKey: import_zod3.z.string().describe("Key for items array in tool result data"),
+  countKey: import_zod3.z.string().optional().describe("Key for total count"),
+  idKey: import_zod3.z.string().describe("Key for item ID"),
+  labelKey: import_zod3.z.string().describe("Key for item label"),
+  descriptionKey: import_zod3.z.string().optional().describe("Key for item description"),
+  secondaryKey: import_zod3.z.string().optional().describe("Key for secondary label")
+}).describe("Mapping from tool list data to UI fields");
+var ToolSettingsActionDataSourceSchema = import_zod3.z.object({
+  action: import_zod3.z.string().describe("Action ID to call for fetching data"),
+  params: import_zod3.z.record(import_zod3.z.unknown()).optional().describe("Parameters to pass to the action"),
+  refreshOn: import_zod3.z.array(import_zod3.z.string()).optional().describe("Event names that trigger refresh")
+}).describe("Action-based data source");
+var ToolSettingsListViewSchema = import_zod3.z.object({
+  kind: import_zod3.z.literal("list").describe("View kind"),
+  listToolId: import_zod3.z.string().describe("Tool ID for listing items"),
+  getToolId: import_zod3.z.string().optional().describe("Tool ID for fetching details"),
+  upsertToolId: import_zod3.z.string().optional().describe("Tool ID for creating/updating items"),
+  deleteToolId: import_zod3.z.string().optional().describe("Tool ID for deleting items"),
+  mapping: ToolSettingsListMappingSchema.describe("Mapping from tool data to UI"),
+  searchParam: import_zod3.z.string().optional().describe("Param name for search query"),
+  limitParam: import_zod3.z.string().optional().describe("Param name for limit"),
+  idParam: import_zod3.z.string().optional().describe("Param name for get/delete ID"),
+  listParams: import_zod3.z.record(import_zod3.z.unknown()).optional().describe("Static params for list tool")
+}).describe("List view backed by tools");
+var ToolSettingsComponentViewSchema = import_zod3.z.object({
+  kind: import_zod3.z.literal("component").describe("View kind"),
+  data: import_zod3.z.record(ToolSettingsActionDataSourceSchema).optional().describe("Data sources"),
+  content: ExtensionComponentDataSchema.describe("Root component to render")
+}).describe("Component-based tool settings view");
+var ToolSettingsViewSchema = import_zod3.z.union([ToolSettingsListViewSchema, ToolSettingsComponentViewSchema]).describe("Tool settings view");
+var ToolSettingsViewDefinitionSchema = import_zod3.z.object({
+  id: import_zod3.z.string().describe("Unique view ID within the extension"),
+  title: import_zod3.z.string().describe("Display title"),
+  description: import_zod3.z.string().optional().describe("Help text"),
+  view: ToolSettingsViewSchema.describe("View configuration"),
+  fields: import_zod3.z.array(SettingDefinitionSchema).optional().describe("Fields for create/edit forms")
+}).describe("Tool settings view definition");
+var PanelActionDataSourceSchema = import_zod3.z.object({
+  action: import_zod3.z.string().describe("Action ID to call for fetching data"),
+  params: import_zod3.z.record(import_zod3.z.unknown()).optional().describe("Parameters to pass to the action"),
+  refreshOn: import_zod3.z.array(import_zod3.z.string()).optional().describe("Event names that trigger refresh")
+}).describe("Panel data source");
+var PanelComponentViewSchema = import_zod3.z.object({
+  kind: import_zod3.z.literal("component").describe("View kind"),
+  data: import_zod3.z.record(PanelActionDataSourceSchema).optional().describe("Data sources"),
+  content: ExtensionComponentDataSchema.describe("Root component to render")
+}).describe("Component-based panel view");
+var PanelUnknownViewSchema = import_zod3.z.object({
+  kind: import_zod3.z.string().describe("View kind")
+}).passthrough().describe("Unknown panel view");
+var PanelViewSchema = import_zod3.z.union([PanelComponentViewSchema, PanelUnknownViewSchema]).describe("Panel view");
+var PanelDefinitionSchema = import_zod3.z.object({
+  id: import_zod3.z.string().describe("Unique panel ID within the extension"),
+  title: import_zod3.z.string().describe("Display title"),
+  icon: import_zod3.z.string().optional().describe("Icon name (from huge-icons)"),
+  view: PanelViewSchema.describe("Panel view schema")
+}).describe("Panel definition");
+var ProviderConfigPropertyTypeSchema = import_zod3.z.enum(["string", "number", "boolean", "select", "password", "url"]).describe("Property type");
+var ProviderConfigSelectOptionSchema = import_zod3.z.object({
+  value: import_zod3.z.string().describe("Value stored in settings"),
+  label: import_zod3.z.string().describe("Display label")
+}).describe("Select option");
+var ProviderConfigValidationSchema = import_zod3.z.object({
+  pattern: import_zod3.z.string().optional().describe("Regex pattern the value must match"),
+  minLength: import_zod3.z.number().optional().describe("Minimum string length"),
+  maxLength: import_zod3.z.number().optional().describe("Maximum string length"),
+  min: import_zod3.z.number().optional().describe("Minimum number value"),
+  max: import_zod3.z.number().optional().describe("Maximum number value")
+}).describe("Validation rules");
+var ProviderConfigPropertySchema = import_zod3.z.object({
+  type: ProviderConfigPropertyTypeSchema.describe("Property type"),
+  title: import_zod3.z.string().describe("Display label"),
+  description: import_zod3.z.string().optional().describe("Help text"),
+  default: import_zod3.z.unknown().optional().describe("Default value"),
+  required: import_zod3.z.boolean().optional().describe("Whether the field is required"),
+  placeholder: import_zod3.z.string().optional().describe("Placeholder text"),
+  options: import_zod3.z.array(ProviderConfigSelectOptionSchema).optional().describe("For select type"),
+  validation: ProviderConfigValidationSchema.optional().describe("Validation rules")
+}).describe("Provider config property");
+var ProviderConfigSchemaSchema = import_zod3.z.object({
+  properties: import_zod3.z.record(ProviderConfigPropertySchema).describe("Property definitions"),
+  order: import_zod3.z.array(import_zod3.z.string()).optional().describe("Display order of properties")
+}).describe("Provider configuration schema");
+var ProviderDefinitionSchema = import_zod3.z.object({
+  id: import_zod3.z.string().describe("Provider ID"),
+  name: import_zod3.z.string().describe("Display name"),
+  description: import_zod3.z.string().optional().describe("Description"),
+  suggestedDefaultModel: import_zod3.z.string().optional().describe("Suggested default model"),
+  defaultSettings: import_zod3.z.record(import_zod3.z.unknown()).optional().describe("Default settings"),
+  configSchema: ProviderConfigSchemaSchema.optional().describe("Configuration UI schema")
+}).describe("Provider definition");
+var ToolDefinitionSchema = import_zod3.z.object({
+  id: import_zod3.z.string().describe("Tool ID"),
+  name: LocalizedStringSchema.describe("Display name"),
+  description: LocalizedStringSchema.describe("Description for Stina"),
+  parameters: import_zod3.z.record(import_zod3.z.unknown()).optional().describe("Parameter schema (JSON Schema)")
+}).describe("Tool definition");
+var CommandDefinitionSchema = import_zod3.z.object({
+  id: import_zod3.z.string().describe('Command ID (e.g., "weather" for /weather)'),
+  name: import_zod3.z.string().describe("Display name"),
+  description: import_zod3.z.string().describe("Description")
+}).describe("Command definition");
+var PromptSectionSchema = import_zod3.z.enum(["system", "behavior", "tools"]).describe("Prompt section placement");
+var PromptContributionSchema = import_zod3.z.object({
+  id: import_zod3.z.string().describe("Unique ID within the extension"),
+  title: import_zod3.z.string().optional().describe("Optional title for the prompt chunk"),
+  section: PromptSectionSchema.optional().describe("Prompt section placement"),
+  text: import_zod3.z.string().optional().describe("Plain text prompt content"),
+  i18n: import_zod3.z.record(import_zod3.z.string()).optional().describe("Localized prompt content"),
+  order: import_zod3.z.number().optional().describe("Ordering hint (lower comes first)")
+}).describe("Prompt contribution");
+var StorageCollectionConfigSchema = import_zod3.z.object({
+  indexes: import_zod3.z.array(import_zod3.z.string()).optional().describe("Fields to index for fast queries")
+}).describe("Collection configuration");
+var StorageContributionsSchema = import_zod3.z.object({
+  collections: import_zod3.z.record(StorageCollectionConfigSchema).describe("Collection definitions")
+}).describe("Storage contributions");
+var ExtensionContributionsSchema = import_zod3.z.object({
+  settings: import_zod3.z.array(SettingDefinitionSchema).optional().describe("User-configurable settings"),
+  toolSettings: import_zod3.z.array(ToolSettingsViewDefinitionSchema).optional().describe("Tool settings views"),
+  panels: import_zod3.z.array(PanelDefinitionSchema).optional().describe("Right panel contributions"),
+  providers: import_zod3.z.array(ProviderDefinitionSchema).optional().describe("AI providers"),
+  tools: import_zod3.z.array(ToolDefinitionSchema).optional().describe("Tools for Stina to use"),
+  commands: import_zod3.z.array(CommandDefinitionSchema).optional().describe("Slash commands"),
+  prompts: import_zod3.z.array(PromptContributionSchema).optional().describe("Prompt contributions"),
+  storage: StorageContributionsSchema.optional().describe("Storage collection declarations")
+}).describe("What an extension can contribute to Stina");
+
+// src/schemas/manifest.schema.ts
+var PlatformSchema = import_zod4.z.enum(["web", "electron", "tui"]).describe("Supported platform");
+var AuthorSchema = import_zod4.z.object({
+  name: import_zod4.z.string().min(1).describe("Author name"),
+  url: import_zod4.z.string().url().optional().describe("Author URL")
+}).describe("Author information");
+var EnginesSchema = import_zod4.z.object({
+  stina: import_zod4.z.string().describe("Minimum Stina version required")
+}).describe("Engine requirements");
+var ExtensionManifestSchema = import_zod4.z.object({
+  id: import_zod4.z.string().regex(/^[a-z0-9-]+$/, "ID must be lowercase alphanumeric with hyphens").describe('Unique identifier (e.g., "ollama-provider")'),
+  name: import_zod4.z.string().min(1).describe("Human-readable name"),
+  version: import_zod4.z.string().regex(/^\d+\.\d+\.\d+/, 'Must be semver format (e.g., "1.0.0")').describe("Version string (semver)"),
+  description: import_zod4.z.string().min(1).describe("Short description"),
+  author: AuthorSchema.describe("Author information"),
+  repository: import_zod4.z.string().url().optional().describe("Repository URL"),
+  license: import_zod4.z.string().optional().describe("License identifier"),
+  engines: EnginesSchema.optional().describe("Minimum Stina version required"),
+  platforms: import_zod4.z.array(PlatformSchema).optional().describe("Supported platforms"),
+  main: import_zod4.z.string().describe("Entry point file (relative to extension root)"),
+  permissions: import_zod4.z.array(PermissionSchema).describe("Required permissions"),
+  contributes: ExtensionContributionsSchema.optional().describe("What the extension contributes")
+}).describe("Extension manifest format");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AllowedCSSPropertySchema,
+  AuthorSchema,
+  ButtonPropsSchema,
+  CapabilityPermissionSchema,
+  CheckboxPropsSchema,
+  CollapsiblePropsSchema,
+  CommandDefinitionSchema,
+  ConditionalGroupPropsSchema,
+  DateTimeInputPropsSchema,
+  DividerPropsSchema,
+  EnginesSchema,
+  ExtensionActionCallSchema,
+  ExtensionActionRefSchema,
+  ExtensionComponentChildrenSchema,
+  ExtensionComponentDataSchema,
+  ExtensionComponentIteratorSchema,
+  ExtensionComponentStyleSchema,
+  ExtensionContributionsSchema,
+  ExtensionDataSourceSchema,
+  ExtensionManifestSchema,
+  GridPropsSchema,
+  HeaderPropsSchema,
+  HorizontalStackPropsSchema,
+  IconButtonPropsSchema,
+  IconButtonTypeSchema,
+  IconPropsSchema,
+  LabelPropsSchema,
+  LocalizedStringSchema,
+  MarkdownPropsSchema,
+  ModalPropsSchema,
+  NetworkPermissionSchema,
+  PERMISSION_PATTERNS,
+  PanelActionDataSourceSchema,
+  PanelActionSchema,
+  PanelComponentViewSchema,
+  PanelDefinitionSchema,
+  PanelPropsSchema,
+  PanelUnknownViewSchema,
+  PanelViewSchema,
+  ParagraphPropsSchema,
+  PermissionSchema,
+  PillPropsSchema,
+  PillVariantSchema,
+  PlatformSchema,
+  PromptContributionSchema,
+  PromptSectionSchema,
+  ProviderConfigPropertySchema,
+  ProviderConfigPropertyTypeSchema,
+  ProviderConfigSchemaSchema,
+  ProviderConfigSelectOptionSchema,
+  ProviderConfigValidationSchema,
+  ProviderDefinitionSchema,
+  SelectPropsSchema,
+  SettingCreateMappingSchema,
+  SettingDefinitionSchema,
+  SettingOptionsMappingSchema,
+  SettingValidationSchema,
+  StoragePermissionSchema,
+  SystemPermissionSchema,
+  TextInputPropsSchema,
+  TogglePropsSchema,
+  ToolDefinitionSchema,
+  ToolSettingsActionDataSourceSchema,
+  ToolSettingsComponentViewSchema,
+  ToolSettingsListMappingSchema,
+  ToolSettingsListViewSchema,
+  ToolSettingsViewDefinitionSchema,
+  ToolSettingsViewSchema,
+  UserDataPermissionSchema,
+  VALID_PERMISSIONS,
+  VerticalStackPropsSchema,
+  isValidPermission
+});
+//# sourceMappingURL=index.cjs.map