@jay-framework/wix-data 0.15.0

package/dist/index.js

@@ -0,0 +1,1561 @@
+import * as fs from "fs";
+import * as path from "path";
+import { collections, items } from "@wix/data";
+import * as yaml from "js-yaml";
+import { createJayService, makeJayStackComponent, RenderPipeline, makeJayQuery, ActionError, makeJayInit, makeContractGenerator } from "@jay-framework/fullstack-component";
+import { registerService, getService } from "@jay-framework/stack-server-runtime";
+import { createJayContext } from "@jay-framework/runtime";
+import "@jay-framework/component";
+import { WIX_CLIENT_SERVICE } from "@jay-framework/wix-server-client";
+const CONFIG_DIR = "config";
+const CONFIG_FILE_NAME$1 = "wix-data.yaml";
+const DOCS_FILE_NAME = "wix-data-collections.md";
+function getConfigPath() {
+  return path.join(process.cwd(), CONFIG_DIR, CONFIG_FILE_NAME$1);
+}
+async function loadConfig(wixClient) {
+  const configPath = getConfigPath();
+  if (fs.existsSync(configPath)) {
+    console.log(`[wix-data] Loading config from ${configPath}`);
+    return loadConfigFromFile(configPath);
+  }
+  console.log(`[wix-data] No config found at ${configPath}, generating default...`);
+  const { config: defaultConfig, collectionData } = await generateDefaultConfig(wixClient);
+  await saveConfig(defaultConfig, configPath);
+  const docsPath = path.join(process.cwd(), CONFIG_DIR, DOCS_FILE_NAME);
+  await saveDocumentation(collectionData, docsPath);
+  return defaultConfig;
+}
+function loadConfigFromFile(configPath) {
+  try {
+    const fileContent = fs.readFileSync(configPath, "utf-8");
+    const parsed = yaml.load(fileContent);
+    if (!parsed || !parsed.collections) {
+      console.warn("[wix-data] Invalid config file, using empty config");
+      return { collections: [] };
+    }
+    console.log(`[wix-data] Loaded ${parsed.collections.length} collections from config`);
+    return parsed;
+  } catch (error) {
+    console.error("[wix-data] Failed to load config file:", error);
+    return { collections: [] };
+  }
+}
+async function saveConfig(config, configPath) {
+  try {
+    const configDir = path.dirname(configPath);
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+    const yamlContent = generateConfigYaml(config);
+    fs.writeFileSync(configPath, yamlContent, "utf-8");
+    console.log(`[wix-data] Saved default config to ${configPath}`);
+  } catch (error) {
+    console.error("[wix-data] Failed to save config file:", error);
+  }
+}
+function generateConfigYaml(config) {
+  const header = `# Wix Data Plugin Configuration
+# 
+# This file was auto-generated from your Wix Data collections.
+# Edit this file to configure which collections are visible and how they behave.
+#
+# Collection visibility:
+#   visible: false (default) - Collection is hidden, no contracts generated
+#   visible: true - Collection is active, contracts will be generated
+#
+# Components (only used when visible: true):
+#   itemPage: true     - Generate item page component
+#   indexPage: true    - Generate index/list page component
+#   categoryPage: true - Generate category page component
+#   tableWidget: true  - Generate table widget component
+#   cardWidget: true   - Generate card widget component
+#
+# References:
+#   mode: link  - Include only the reference ID (default)
+#   mode: embed - Fetch and include full referenced item data
+#
+
+`;
+  const yamlBody = yaml.dump(config, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false
+  });
+  return header + yamlBody;
+}
+async function generateDefaultConfig(wixClient) {
+  const collectionsClient = wixClient.use(collections);
+  try {
+    const result = await collectionsClient.listDataCollections({});
+    const dataCollections = result.collections || [];
+    console.log(`[wix-data] Found ${dataCollections.length} collections from Wix API`);
+    const userCollections = dataCollections.filter((c) => c._id && !c._id.startsWith("_"));
+    const collectionData = [];
+    const collectionConfigs = [];
+    userCollections.forEach((collection) => {
+      const collectionId = collection._id;
+      const fields = collection.fields || [];
+      const referenceFields = fields.filter(
+        (f) => f.type === "REFERENCE" || f.type === "MULTI_REFERENCE"
+      );
+      const references = referenceFields.map((f) => ({
+        fieldName: f.key || "",
+        mode: "link"
+      }));
+      const docReferences = referenceFields.map((f) => {
+        const meta = f;
+        const targetCollection = meta.typeMetadata?.reference?.referencedCollectionId || meta.typeMetadata?.multiReference?.referencedCollectionId || "unknown";
+        return {
+          fieldName: f.key || "",
+          fieldDisplayName: f.displayName || f.key || "",
+          targetCollection,
+          isMulti: f.type === "MULTI_REFERENCE"
+        };
+      });
+      collectionData.push({
+        id: collectionId,
+        displayName: collection.displayName || collectionId,
+        fields: fields.map((f) => ({
+          key: f.key || "",
+          displayName: f.displayName || f.key || "",
+          type: f.type || "unknown"
+        })),
+        references: docReferences
+      });
+      const slugField = fields.find((f) => f.key === "slug")?.key || fields.find((f) => f.key === "title")?.key || "_id";
+      const config = {
+        collectionId,
+        visible: false,
+        pathPrefix: `/${collectionId.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`,
+        slugField,
+        components: {}
+      };
+      if (references.length > 0) {
+        config.references = references;
+      }
+      collectionConfigs.push(config);
+    });
+    console.log(
+      `[wix-data] Generated config for ${collectionConfigs.length} collections (all hidden by default)`
+    );
+    return {
+      config: { collections: collectionConfigs },
+      collectionData
+    };
+  } catch (error) {
+    console.error("[wix-data] Failed to fetch collections from Wix Data API:", error);
+    return {
+      config: { collections: [] },
+      collectionData: []
+    };
+  }
+}
+async function saveDocumentation(collectionData, docsPath) {
+  if (collectionData.length === 0) {
+    return;
+  }
+  try {
+    const markdown = generateDocumentationMarkdown(collectionData);
+    fs.writeFileSync(docsPath, markdown, "utf-8");
+    console.log(`[wix-data] Saved collection documentation to ${docsPath}`);
+  } catch (error) {
+    console.error("[wix-data] Failed to save documentation file:", error);
+  }
+}
+function generateDocumentationMarkdown(collectionData) {
+  const sections = [];
+  sections.push(`# Wix Data Collections
+
+This document was auto-generated from your Wix Data collections.
+It provides an overview of your data model and relationships.
+
+Generated: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+---
+`);
+  sections.push(`## Collections Overview
+
+| Collection | Display Name | Fields | References |
+|------------|--------------|--------|------------|
+${collectionData.map((c) => `| ${c.id} | ${c.displayName} | ${c.fields.length} | ${c.references.length} |`).join("\n")}
+
+---
+`);
+  sections.push(`## Relationships Diagram
+
+\`\`\`mermaid
+flowchart LR
+${generateMermaidDiagram(collectionData)}
+\`\`\`
+
+---
+`);
+  sections.push(`## Collection Details
+`);
+  collectionData.forEach((collection) => {
+    sections.push(`### ${collection.displayName} (\`${collection.id}\`)
+
+**Fields:**
+
+| Field | Display Name | Type |
+|-------|--------------|------|
+${collection.fields.map((f) => `| ${f.key} | ${f.displayName} | ${f.type} |`).join("\n")}
+`);
+    if (collection.references.length > 0) {
+      sections.push(`
+**References:**
+
+| Field | Target Collection | Type |
+|-------|-------------------|------|
+${collection.references.map(
+        (r) => `| ${r.fieldName} (${r.fieldDisplayName}) | ${r.targetCollection} | ${r.isMulti ? "Multi-Reference" : "Reference"} |`
+      ).join("\n")}
+`);
+    }
+    sections.push(`
+---
+`);
+  });
+  return sections.join("\n");
+}
+function generateMermaidDiagram(collectionData) {
+  const lines = [];
+  const collectionIds = new Set(collectionData.map((c) => c.id));
+  collectionData.forEach((collection) => {
+    const nodeId = sanitizeMermaidId(collection.id);
+    const label = sanitizeMermaidLabel(collection.displayName || collection.id);
+    lines.push(`    ${nodeId}["${label}"]`);
+  });
+  lines.push("");
+  collectionData.forEach((collection) => {
+    const sourceId = sanitizeMermaidId(collection.id);
+    collection.references.forEach((ref) => {
+      if (collectionIds.has(ref.targetCollection)) {
+        const targetId = sanitizeMermaidId(ref.targetCollection);
+        const arrow = ref.isMulti ? "-->|*|" : "-->|1|";
+        ref.fieldDisplayName || ref.fieldName;
+        lines.push(`    ${sourceId} ${arrow} ${targetId}`);
+        lines.push(
+          `    linkStyle ${lines.filter((l) => l.includes("-->")).length - 1} stroke:#666`
+        );
+      }
+    });
+  });
+  const filteredLines = lines.filter((l) => !l.includes("linkStyle"));
+  return filteredLines.join("\n");
+}
+function sanitizeMermaidId(id) {
+  return id.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function sanitizeMermaidLabel(label) {
+  return label.replace(/"/g, "'").replace(/\[/g, "(").replace(/\]/g, ")").replace(/[{}]/g, "").replace(/[<>]/g, "");
+}
+function validateCollectionConfig(config) {
+  const errors = [];
+  if (!config.collectionId) {
+    errors.push("collectionId is required");
+  }
+  if (!config.pathPrefix) {
+    errors.push("pathPrefix is required");
+  } else if (!config.pathPrefix.startsWith("/")) {
+    errors.push("pathPrefix must start with /");
+  }
+  if (!config.slugField) {
+    errors.push("slugField is required");
+  }
+  if (!config.components) {
+    errors.push("components configuration is required");
+  }
+  if (config.category) {
+    if (!config.category.referenceField) {
+      errors.push("category.referenceField is required when category is configured");
+    }
+    if (!config.category.categorySlugField) {
+      errors.push("category.categorySlugField is required when category is configured");
+    }
+  }
+  return errors;
+}
+function validateConfig(config) {
+  const errors = [];
+  if (!config.collections || config.collections.length === 0) {
+    errors.push("At least one collection must be configured");
+    return errors;
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  config.collections.forEach((collection) => {
+    if (seenIds.has(collection.collectionId)) {
+      errors.push(`Duplicate collectionId: ${collection.collectionId}`);
+    }
+    seenIds.add(collection.collectionId);
+    const collectionErrors = validateCollectionConfig(collection);
+    errors.push(...collectionErrors.map((e) => `${collection.collectionId}: ${e}`));
+  });
+  const seenPaths = /* @__PURE__ */ new Set();
+  config.collections.filter((c) => c.visible).forEach((collection) => {
+    if (seenPaths.has(collection.pathPrefix)) {
+      errors.push(`Duplicate pathPrefix: ${collection.pathPrefix}`);
+    }
+    seenPaths.add(collection.pathPrefix);
+  });
+  return errors;
+}
+function getVisibleCollections(config) {
+  return config.collections.filter((c) => c.visible === true);
+}
+function mapWixTypeToJayType(wixType) {
+  const typeMap = {
+    TEXT: "string",
+    NUMBER: "number",
+    BOOLEAN: "boolean",
+    DATE: "string",
+    DATETIME: "string",
+    TIME: "string",
+    RICH_TEXT: "string",
+    RICH_CONTENT: "string",
+    URL: "string",
+    DOCUMENT: "string",
+    ARRAY: "string",
+    OBJECT: "string",
+    TAGS: "string"
+  };
+  return typeMap[wixType] || "string";
+}
+function getFieldCategory(key, wixType) {
+  if (key.startsWith("_")) return "system";
+  switch (wixType) {
+    case "IMAGE":
+      return "image";
+    case "VIDEO":
+    case "AUDIO":
+      return "media";
+    case "ADDRESS":
+      return "address";
+    case "REFERENCE":
+      return "reference";
+    case "MULTI_REFERENCE":
+      return "multiReference";
+    case "RICH_TEXT":
+    case "RICH_CONTENT":
+      return "richContent";
+    default:
+      return "simple";
+  }
+}
+function getReferencedCollectionId(field) {
+  const metadata = field.typeMetadata;
+  if (!metadata) return void 0;
+  if (field.type === "REFERENCE") {
+    return metadata.reference?.referencedCollectionId;
+  }
+  if (field.type === "MULTI_REFERENCE") {
+    return metadata.multiReference?.referencedCollectionId;
+  }
+  return void 0;
+}
+async function processSchema(collection, config, collectionFetcher) {
+  const refConfigMap = new Map((config.references || []).map((r) => [r.fieldName, r]));
+  const fields = await Promise.all(
+    (collection.fields || []).map(async (f) => {
+      const key = f.key || "";
+      const wixType = f.type || "TEXT";
+      const category = getFieldCategory(key, wixType);
+      const refConfig = refConfigMap.get(key);
+      const isEmbedded = (category === "reference" || category === "multiReference") && refConfig?.mode === "embed";
+      const field = {
+        key,
+        displayName: f.displayName,
+        jayType: mapWixTypeToJayType(wixType),
+        wixType,
+        category,
+        embedded: isEmbedded,
+        referenceConfig: isEmbedded ? refConfig : void 0
+      };
+      if (isEmbedded && collectionFetcher && refConfig) {
+        const referencedCollectionId = getReferencedCollectionId(f);
+        if (referencedCollectionId) {
+          const referencedCollection = await collectionFetcher(referencedCollectionId);
+          if (referencedCollection) {
+            const nestedConfig = {
+              collectionId: referencedCollection._id || referencedCollectionId,
+              pathPrefix: "",
+              slugField: "",
+              references: refConfig.references,
+              // Pass nested references
+              components: {}
+            };
+            field.embeddedSchema = await processSchema(
+              referencedCollection,
+              nestedConfig,
+              collectionFetcher
+            );
+          }
+        }
+      }
+      return field;
+    })
+  );
+  return {
+    collectionId: collection._id || config.collectionId,
+    displayName: collection.displayName,
+    config,
+    fields,
+    hasCategory: !!config.category,
+    category: config.category
+  };
+}
+const WIX_DATA_SERVICE_MARKER = createJayService("Wix Data Service");
+let itemsClientInstance;
+let collectionsClientInstance;
+function getItemsClient(wixClient) {
+  if (!itemsClientInstance) {
+    itemsClientInstance = wixClient.use(items);
+  }
+  return itemsClientInstance;
+}
+function getCollectionsClient(wixClient) {
+  if (!collectionsClientInstance) {
+    collectionsClientInstance = wixClient.use(collections);
+  }
+  return collectionsClientInstance;
+}
+function provideWixDataService(wixClient, config) {
+  const itemsClient = getItemsClient(wixClient);
+  const collectionsClient = getCollectionsClient(wixClient);
+  const collectionCache = /* @__PURE__ */ new Map();
+  const processedSchemaCache = /* @__PURE__ */ new Map();
+  async function fetchCollection(collectionId) {
+    if (collectionCache.has(collectionId)) {
+      return collectionCache.get(collectionId) || null;
+    }
+    try {
+      const collection = await collectionsClient.getDataCollection(collectionId);
+      if (!collection) {
+        collectionCache.set(collectionId, null);
+        return null;
+      }
+      collectionCache.set(collectionId, collection);
+      return collection;
+    } catch (error) {
+      console.error(`[wix-data] Failed to fetch collection ${collectionId}:`, error);
+      collectionCache.set(collectionId, null);
+      return null;
+    }
+  }
+  const service = {
+    items: itemsClient,
+    collections: collectionsClient,
+    config,
+    getCollectionConfig(collectionId) {
+      return config.collections.find((c) => c.collectionId === collectionId);
+    },
+    async getCollection(collectionId) {
+      return fetchCollection(collectionId);
+    },
+    async getProcessedSchema(collectionId) {
+      if (processedSchemaCache.has(collectionId)) {
+        return processedSchemaCache.get(collectionId) || null;
+      }
+      const collectionConfig = config.collections.find(
+        (c) => c.collectionId === collectionId
+      );
+      if (!collectionConfig) {
+        processedSchemaCache.set(collectionId, null);
+        return null;
+      }
+      const collection = await fetchCollection(collectionId);
+      if (!collection) {
+        console.warn(`[wix-data] Collection not found: ${collectionId}`);
+        processedSchemaCache.set(collectionId, null);
+        return null;
+      }
+      const processed = await processSchema(collection, collectionConfig, fetchCollection);
+      processedSchemaCache.set(collectionId, processed);
+      return processed;
+    },
+    async getProcessedSchemas(filter) {
+      const matchingConfigs = config.collections.filter(filter);
+      const results = await Promise.all(
+        matchingConfigs.map((c) => service.getProcessedSchema(c.collectionId))
+      );
+      return results.filter((s) => s !== null);
+    }
+  };
+  registerService(WIX_DATA_SERVICE_MARKER, service);
+  return service;
+}
+const WIX_DATA_CONTEXT = createJayContext();
+async function* loadItemParams(services) {
+  const [wixData, contractInfo] = services;
+  if (!contractInfo?.metadata) {
+    console.warn("[wix-data] loadItemParams called without contract metadata");
+    yield [];
+    return;
+  }
+  const { collectionId } = contractInfo.metadata;
+  const config = wixData.getCollectionConfig(collectionId);
+  if (!config) {
+    console.error(`[wix-data] No config found for collection: ${collectionId}`);
+    yield [];
+    return;
+  }
+  try {
+    const result = await wixData.items.query(collectionId).find();
+    yield result.items.map((item) => ({
+      slug: item[config.slugField] || item._id
+    }));
+  } catch (error) {
+    console.error(`[wix-data] Failed to load slugs for ${collectionId}:`, error);
+    yield [];
+  }
+}
+async function renderSlowlyChanging$3(props, wixData) {
+  const { collectionId } = props.metadata;
+  const Pipeline = RenderPipeline.for();
+  return Pipeline.try(async () => {
+    const config = wixData.getCollectionConfig(collectionId);
+    if (!config) {
+      throw new Error(`Collection not configured: ${collectionId}`);
+    }
+    const result = await wixData.items.query(collectionId).eq(config.slugField, props.slug).find();
+    if (!result.items.length) {
+      throw new Error("Item not found");
+    }
+    const item = result.items[0];
+    const viewState = await mapItemToViewState$1(item, config, wixData);
+    return { item, viewState, collectionId };
+  }).recover((error) => {
+    console.error(`[wix-data] Item not found: ${props.slug}`, error);
+    return Pipeline.clientError(404, "Item not found");
+  }).toPhaseOutput(({ item, viewState, collectionId: colId }) => ({
+    viewState,
+    carryForward: {
+      itemId: item._id,
+      collectionId: colId
+    }
+  }));
+}
+async function mapItemToViewState$1(item, config, wixData) {
+  const processableEntries = Object.entries(item).filter(([key]) => !key.startsWith("_") || key === "_id");
+  const mappedEntries = await Promise.all(processableEntries.map(async ([key, value]) => {
+    const refConfig = config.references?.find((r) => r.fieldName === key);
+    if (refConfig?.mode === "embed" && value) {
+      return [key, await fetchReference(value, wixData)];
+    } else if (isImageValue$2(value)) {
+      return [key, mapImageValue(value)];
+    } else {
+      return [key, value];
+    }
+  }));
+  return {
+    _id: item._id,
+    ...Object.fromEntries(mappedEntries)
+  };
+}
+function isImageValue$2(value) {
+  return typeof value === "object" && value !== null && ("src" in value || "url" in value);
+}
+function mapImageValue(value) {
+  return {
+    url: value.src || value.url || "",
+    altText: value.alt || "",
+    width: value.width,
+    height: value.height
+  };
+}
+async function fetchReference(refValue, wixData) {
+  try {
+    if (Array.isArray(refValue)) {
+      const items2 = await Promise.all(refValue.map(async (id) => {
+        try {
+          const result = await wixData.items.get("", id);
+          return result.dataItem ? {
+            _id: result.dataItem._id,
+            ...result.dataItem.data
+          } : null;
+        } catch {
+          return null;
+        }
+      }));
+      return items2.filter(Boolean);
+    } else if (typeof refValue === "string") {
+      const result = await wixData.items.get("", refValue);
+      return result.dataItem ? {
+        _id: result.dataItem._id,
+        ...result.dataItem.data
+      } : null;
+    }
+  } catch (error) {
+    console.error("[wix-data] Failed to fetch reference:", error);
+  }
+  return null;
+}
+const collectionItem = makeJayStackComponent().withProps().withServices(WIX_DATA_SERVICE_MARKER).withLoadParams(loadItemParams).withSlowlyRender(renderSlowlyChanging$3);
+function parseWixMediaUrl(url) {
+  if (!url) return null;
+  const match = url.match(
+    /^wix:(image|video|document|audio):\/\/v1\/([^/]+)\/([^#]+)(?:#(.*))?$/
+  );
+  if (!match) return null;
+  const [, type, mediaId, fileName, hashParams] = match;
+  const result = {
+    type,
+    mediaId,
+    fileName: decodeURIComponent(fileName)
+  };
+  if (hashParams) {
+    const params = new URLSearchParams(hashParams);
+    const originWidth = params.get("originWidth");
+    const originHeight = params.get("originHeight");
+    if (originWidth) result.originWidth = parseInt(originWidth, 10);
+    if (originHeight) result.originHeight = parseInt(originHeight, 10);
+    const posterUri = params.get("posterUri");
+    const posterWidth = params.get("posterWidth");
+    const posterHeight = params.get("posterHeight");
+    if (posterUri) result.posterUri = decodeURIComponent(posterUri);
+    if (posterWidth) result.posterWidth = parseInt(posterWidth, 10);
+    if (posterHeight) result.posterHeight = parseInt(posterHeight, 10);
+  }
+  return result;
+}
+function formatWixMediaUrl(_id, url, resize) {
+  const resizeFragment = "";
+  if (url == null ? void 0 : url.startsWith("wix:")) {
+    const parsed = parseWixMediaUrl(url);
+    if (parsed) {
+      return `https://static.wixstatic.com/media/${parsed.mediaId}${resizeFragment}`;
+    }
+  }
+  if ((url == null ? void 0 : url.startsWith("http://")) || (url == null ? void 0 : url.startsWith("https://"))) {
+    return url;
+  }
+  return "";
+}
+function getComponentFields(config) {
+  if (config === void 0 || config === false) return void 0;
+  if (config === true) return void 0;
+  return config.fields;
+}
+function isComponentEnabled(config) {
+  if (config === void 0 || config === false) return false;
+  return true;
+}
+const queryItems = makeJayQuery("wixData.queryItems").withServices(WIX_DATA_SERVICE_MARKER).withHandler(
+  async (input, wixData) => {
+    const {
+      collectionId,
+      limit = 20,
+      offset = 0,
+      sortField,
+      sortDirection = "ASC",
+      filter = {},
+      categoryId,
+      categoryField
+    } = input;
+    try {
+      let query = wixData.items.query(collectionId).limit(limit).skip(offset);
+      if (sortField) {
+        query = sortDirection === "DESC" ? query.descending(sortField) : query.ascending(sortField);
+      }
+      if (categoryId && categoryField) {
+        query = query.hasSome(categoryField, [categoryId]);
+      }
+      query = Object.entries(filter).filter(([, value]) => value !== void 0 && value !== null).reduce((q, [field, value]) => q.eq(field, value), query);
+      const result = await query.find();
+      const totalCount = result.totalCount ?? result.items.length;
+      return {
+        items: result.items,
+        totalCount,
+        offset,
+        hasMore: offset + result.items.length < totalCount
+      };
+    } catch (error) {
+      console.error("[wixData.queryItems] Query failed:", error);
+      throw new ActionError("QUERY_FAILED", "Failed to query items");
+    }
+  }
+);
+const getItemBySlug = makeJayQuery("wixData.getItemBySlug").withServices(WIX_DATA_SERVICE_MARKER).withCaching({ maxAge: 300, staleWhileRevalidate: 600 }).withHandler(
+  async (input, wixData) => {
+    const { collectionId, slug } = input;
+    if (!slug) {
+      throw new ActionError("INVALID_INPUT", "Slug is required");
+    }
+    const config = wixData.getCollectionConfig(collectionId);
+    if (!config) {
+      throw new ActionError(
+        "INVALID_CONFIG",
+        `Collection not configured: ${collectionId}`
+      );
+    }
+    try {
+      const result = await wixData.items.query(collectionId).eq(config.slugField, slug).find();
+      if (!result.items.length) {
+        return { item: null };
+      }
+      return { item: result.items[0] };
+    } catch (error) {
+      console.error("[wixData.getItemBySlug] Failed to get item:", error);
+      return { item: null };
+    }
+  }
+);
+const getCategories = makeJayQuery("wixData.getCategories").withServices(WIX_DATA_SERVICE_MARKER).withCaching({ maxAge: 3600 }).withHandler(
+  async (input, wixData) => {
+    const { collectionId } = input;
+    const config = wixData.getCollectionConfig(collectionId);
+    if (!config) {
+      throw new ActionError(
+        "INVALID_CONFIG",
+        `Collection not configured: ${collectionId}`
+      );
+    }
+    if (!config.category) {
+      return { categories: [] };
+    }
+    try {
+      const result = await wixData.items.query(collectionId).limit(1e3).find();
+      const categoryCounts = /* @__PURE__ */ new Map();
+      const categoryIds = /* @__PURE__ */ new Set();
+      result.items.forEach((item) => {
+        const catValue = item[config.category.referenceField];
+        const catIds = Array.isArray(catValue) ? catValue : typeof catValue === "string" ? [catValue] : [];
+        catIds.forEach((catId) => {
+          categoryIds.add(catId);
+          categoryCounts.set(catId, (categoryCounts.get(catId) || 0) + 1);
+        });
+      });
+      const categoryResults = await Promise.all(
+        Array.from(categoryIds).map(async (catId) => {
+          try {
+            const catResult = await wixData.items.get("", catId);
+            const catData = catResult.dataItem?.data;
+            if (!catData) return null;
+            return {
+              _id: catId,
+              slug: catData[config.category.categorySlugField] || catId,
+              title: catData.title || catData.name || catId,
+              itemCount: categoryCounts.get(catId) || 0
+            };
+          } catch {
+            return null;
+          }
+        })
+      );
+      const categories = categoryResults.filter((c) => c !== null);
+      categories.sort((a, b) => b.itemCount - a.itemCount);
+      return { categories };
+    } catch (error) {
+      console.error("[wixData.getCategories] Failed to load categories:", error);
+      throw new ActionError("LOAD_FAILED", "Failed to load categories");
+    }
+  }
+);
+const PAGE_SIZE = 20;
+async function* loadListParams(services) {
+  const [wixData, contractInfo] = services;
+  if (!contractInfo?.metadata) {
+    console.warn("[wix-data] loadListParams called without contract metadata");
+    yield [];
+    return;
+  }
+  const { collectionId } = contractInfo.metadata;
+  const config = wixData.getCollectionConfig(collectionId);
+  if (!config) {
+    console.error(`[wix-data] No config found for collection: ${collectionId}`);
+    yield [];
+    return;
+  }
+  const params = [];
+  if (isComponentEnabled(config.components.indexPage)) {
+    params.push({});
+  }
+  if (isComponentEnabled(config.components.categoryPage) && config.category) {
+    try {
+      const result = await wixData.items.query(collectionId).limit(1e3).find();
+      const categoryIds = /* @__PURE__ */ new Set();
+      result.items.forEach((item) => {
+        const catValue = item[config.category.referenceField];
+        const catIds = Array.isArray(catValue) ? catValue : typeof catValue === "string" ? [catValue] : [];
+        catIds.forEach((id) => categoryIds.add(id));
+      });
+      const categoryResults = await Promise.all(Array.from(categoryIds).map(async (catId) => {
+        try {
+          const catResult = await wixData.items.get("", catId);
+          return catResult.dataItem?.data?.[config.category.categorySlugField];
+        } catch {
+          return void 0;
+        }
+      }));
+      categoryResults.filter((slug) => !!slug).forEach((slug) => params.push({ category: slug }));
+    } catch (error) {
+      console.error(`[wix-data] Failed to load category params:`, error);
+    }
+  }
+  yield params;
+}
+async function renderSlowlyChanging$2(props, wixData) {
+  const { collectionId } = props.metadata;
+  const Pipeline = RenderPipeline.for();
+  return Pipeline.try(async () => {
+    const config = wixData.getCollectionConfig(collectionId);
+    if (!config) {
+      throw new Error(`Collection not configured: ${collectionId}`);
+    }
+    const componentConfig = config.components.indexPage || config.components.categoryPage;
+    const fieldWhitelist = getComponentFields(componentConfig);
+    let categoryData;
+    let categoryId;
+    const categoryField = config.category?.referenceField;
+    if (props.category && config.category) {
+      const catQuery = wixData.items.query(config.category.referenceField.split(".")[0] || collectionId).eq(config.category.categorySlugField, props.category);
+      const catResult = await catQuery.find();
+      if (catResult.items.length > 0) {
+        const cat = catResult.items[0];
+        categoryId = cat._id;
+        categoryData = {
+          _id: cat._id,
+          slug: props.category,
+          title: cat.data?.title || cat.data?.name || props.category,
+          description: cat.data?.description || ""
+        };
+      }
+    }
+    const result = await queryItems({
+      collectionId,
+      limit: PAGE_SIZE,
+      offset: 0,
+      categoryId,
+      categoryField
+    });
+    const items2 = result.items.map((item) => mapItemToViewState(item, config.pathPrefix, config.slugField, fieldWhitelist));
+    const breadcrumbs = [
+      { slug: "", title: "Home", url: "/" },
+      {
+        slug: collectionId.toLowerCase(),
+        title: config.collectionId,
+        url: config.pathPrefix
+      }
+    ];
+    if (categoryData) {
+      breadcrumbs.push({
+        slug: categoryData.slug,
+        title: categoryData.title,
+        url: `${config.pathPrefix}/category/${categoryData.slug}`
+      });
+    }
+    return {
+      items: items2,
+      totalCount: result.totalCount,
+      category: categoryData,
+      breadcrumbs,
+      offset: items2.length,
+      // Initial offset is the number of items loaded
+      categoryId,
+      categoryField,
+      pathPrefix: config.pathPrefix,
+      slugField: config.slugField,
+      fieldWhitelist
+    };
+  }).recover((error) => {
+    console.error(`[wix-data] Failed to load list:`, error);
+    return Pipeline.clientError(500, "Failed to load items");
+  }).toPhaseOutput((data) => ({
+    viewState: {
+      items: data.items,
+      totalCount: data.totalCount,
+      category: data.category,
+      breadcrumbs: data.breadcrumbs
+    },
+    carryForward: {
+      collectionId,
+      categoryId: data.categoryId,
+      categoryField: data.categoryField,
+      offset: data.offset,
+      totalCount: data.totalCount,
+      pathPrefix: data.pathPrefix,
+      slugField: data.slugField,
+      fieldWhitelist: data.fieldWhitelist
+    }
+  }));
+}
+async function renderFastChanging$1(props, slowCarryForward, wixData) {
+  const Pipeline = RenderPipeline.for();
+  const hasMore = slowCarryForward.offset < slowCarryForward.totalCount;
+  return Pipeline.ok({
+    loadedItems: [],
+    // Empty initially - items loaded via "load more"
+    hasMore,
+    isLoading: false,
+    loadedCount: 0
+  }).toPhaseOutput((viewState) => ({
+    viewState,
+    carryForward: {
+      collectionId: slowCarryForward.collectionId,
+      categoryId: slowCarryForward.categoryId,
+      categoryField: slowCarryForward.categoryField,
+      offset: slowCarryForward.offset,
+      totalCount: slowCarryForward.totalCount,
+      pathPrefix: slowCarryForward.pathPrefix,
+      slugField: slowCarryForward.slugField,
+      fieldWhitelist: slowCarryForward.fieldWhitelist
+    }
+  }));
+}
+function isImageValue$1(value) {
+  if (typeof value === "string" && value.startsWith("wix:image://"))
+    return true;
+  if (typeof value === "object" && value !== null && ("src" in value || "url" in value))
+    return true;
+  return false;
+}
+function mapImageField(imgValue, altText) {
+  if (!imgValue)
+    return void 0;
+  if (typeof imgValue === "string") {
+    const parsed = parseWixMediaUrl(imgValue);
+    return {
+      url: formatWixMediaUrl("", imgValue),
+      altText: altText || "",
+      width: parsed?.originWidth,
+      height: parsed?.originHeight
+    };
+  }
+  if (typeof imgValue === "object" && imgValue !== null) {
+    const img = imgValue;
+    const srcUrl = img.src || img.url || "";
+    const parsed = parseWixMediaUrl(srcUrl);
+    return {
+      url: formatWixMediaUrl("", srcUrl),
+      altText: img.alt || altText || "",
+      width: parsed?.originWidth ?? img.width,
+      height: parsed?.originHeight ?? img.height
+    };
+  }
+  return void 0;
+}
+function mapItemToViewState(item, pathPrefix, slugField, whitelist) {
+  const mapped = {
+    _id: item._id,
+    url: `${pathPrefix}/${item[slugField] || item._id}`
+  };
+  const keysToInclude = whitelist || Object.keys(item).filter((k) => !k.startsWith("_"));
+  const titleValue = item.title || item.name;
+  const altText = typeof titleValue === "string" ? titleValue : "";
+  keysToInclude.forEach((key) => {
+    const value = item[key];
+    if (isImageValue$1(value)) {
+      mapped[key] = mapImageField(value, altText);
+    } else {
+      mapped[key] = value || "";
+    }
+  });
+  return mapped;
+}
+const collectionList = makeJayStackComponent().withProps().withServices(WIX_DATA_SERVICE_MARKER).withLoadParams(loadListParams).withSlowlyRender(renderSlowlyChanging$2).withFastRender(renderFastChanging$1);
+function dataTag(key, type, description, indent = 2) {
+  const prefix = " ".repeat(indent);
+  const desc = description ? `, description: ${description}` : "";
+  return `${prefix}- {tag: ${key}, type: data, dataType: ${type}${desc}}`;
+}
+function dataTagWithPhase(key, type, phase, description, indent = 2) {
+  const prefix = " ".repeat(indent);
+  const desc = `, description: ${description}`;
+  return `${prefix}- {tag: ${key}, type: data, dataType: ${type}, phase: ${phase}${desc}}`;
+}
+function interactiveTag(key, elementType, description, indent = 2) {
+  const prefix = " ".repeat(indent);
+  const desc = description ? `, description: ${description}` : "";
+  return `${prefix}- {tag: ${key}, type: interactive, elementType: ${elementType}${desc}}`;
+}
+function variantTag(key, type, phase, description, indent = 2) {
+  const prefix = " ".repeat(indent);
+  const desc = description ? `, description: ${description}` : "";
+  return `${prefix}- {tag: ${key}, type: variant, dataType: ${type}, phase: ${phase}${desc}}`;
+}
+function imageSubContract(key, description, indent = 2) {
+  const prefix = " ".repeat(indent);
+  const innerPrefix = " ".repeat(indent + 2);
+  return `${prefix}- tag: ${key}
+${prefix}  type: sub-contract
+${prefix}  description: ${description || key}
+${prefix}  tags:
+${innerPrefix}- {tag: url, type: data, dataType: string}
+${innerPrefix}- {tag: altText, type: data, dataType: string}
+${innerPrefix}- {tag: width, type: data, dataType: number}
+${innerPrefix}- {tag: height, type: data, dataType: number}`;
+}
+function mediaSubContract(key, description, indent = 2) {
+  const prefix = " ".repeat(indent);
+  const innerPrefix = " ".repeat(indent + 2);
+  return `${prefix}- tag: ${key}
+${prefix}  type: sub-contract
+${prefix}  description: ${description || key}
+${prefix}  tags:
+${innerPrefix}- {tag: url, type: data, dataType: string}
+${innerPrefix}- {tag: title, type: data, dataType: string}`;
+}
+function addressSubContract(key, description, indent = 2) {
+  const prefix = " ".repeat(indent);
+  const innerPrefix = " ".repeat(indent + 2);
+  return `${prefix}- tag: ${key}
+${prefix}  type: sub-contract
+${prefix}  description: ${description || key}
+${prefix}  tags:
+${innerPrefix}- {tag: formatted, type: data, dataType: string}
+${innerPrefix}- {tag: city, type: data, dataType: string}
+${innerPrefix}- {tag: country, type: data, dataType: string}`;
+}
+function embeddedReferenceSubContract(field, indent = 2) {
+  const prefix = " ".repeat(indent);
+  const isMulti = field.category === "multiReference";
+  const repeated = isMulti ? `
+${prefix}  repeated: true
+${prefix}  trackBy: _id` : "";
+  let innerTags;
+  if (field.embeddedSchema) {
+    innerTags = schemaToTags(field.embeddedSchema, indent + 2);
+  } else {
+    const innerPrefix = " ".repeat(indent + 2);
+    innerTags = [
+      `${innerPrefix}- {tag: _id, type: data, dataType: string}`,
+      `${innerPrefix}- {tag: title, type: data, dataType: string}`,
+      `${innerPrefix}- {tag: slug, type: data, dataType: string}`
+    ];
+  }
+  return `${prefix}- tag: ${field.key}
+${prefix}  type: sub-contract${repeated}
+${prefix}  description: ${field.displayName || field.key}
+${prefix}  tags:
+${innerTags.join("\n")}`;
+}
+function categorySubContract(indent = 2) {
+  const prefix = " ".repeat(indent);
+  const innerPrefix = " ".repeat(indent + 2);
+  return `${prefix}- tag: category
+${prefix}  type: sub-contract
+${prefix}  description: Current category
+${prefix}  tags:
+${innerPrefix}- {tag: _id, type: data, dataType: string}
+${innerPrefix}- {tag: slug, type: data, dataType: string}
+${innerPrefix}- {tag: title, type: data, dataType: string}
+${innerPrefix}- {tag: description, type: data, dataType: string}
+${innerPrefix}- {tag: categoryLink, type: interactive, elementType: HTMLAnchorElement}`;
+}
+function breadcrumbsSubContract(indent = 2) {
+  const prefix = " ".repeat(indent);
+  const innerPrefix = " ".repeat(indent + 2);
+  return `${prefix}- tag: breadcrumbs
+${prefix}  type: sub-contract
+${prefix}  repeated: true
+${prefix}  trackBy: slug
+${prefix}  description: Navigation breadcrumbs
+${prefix}  tags:
+${innerPrefix}- {tag: slug, type: data, dataType: string}
+${innerPrefix}- {tag: title, type: data, dataType: string}
+${innerPrefix}- {tag: url, type: data, dataType: string}
+${innerPrefix}- {tag: link, type: interactive, elementType: HTMLAnchorElement}`;
+}
+function fieldToTag(field, indent = 2) {
+  switch (field.category) {
+    case "system":
+      return field.key === "_id" ? dataTag("_id", "string", "Item ID", indent) : "";
+    case "image":
+      return imageSubContract(field.key, field.displayName, indent);
+    case "media":
+      return mediaSubContract(field.key, field.displayName, indent);
+    case "address":
+      return addressSubContract(field.key, field.displayName, indent);
+    case "reference":
+    case "multiReference":
+      return field.embedded ? embeddedReferenceSubContract(field, indent) : dataTag(
+        field.key,
+        "string",
+        `Reference ID${field.category === "multiReference" ? "s" : ""}`,
+        indent
+      );
+    case "richContent":
+      return dataTag(field.key, "string", field.displayName, indent);
+    default:
+      return dataTag(field.key, field.jayType, field.displayName, indent);
+  }
+}
+function schemaToTags(schema, indent = 2) {
+  const tags = [];
+  tags.push(dataTag("_id", "string", "Item ID", indent));
+  schema.fields.filter((f) => f.category !== "system").forEach((f) => {
+    const tag = fieldToTag(f, indent);
+    if (tag) tags.push(tag);
+  });
+  return tags;
+}
+function isCardField(f) {
+  return f.category !== "system" && f.category !== "reference" && f.category !== "multiReference" && f.category !== "richContent";
+}
+function isTableField(f) {
+  return f.category === "simple";
+}
+function isContentField(f) {
+  return f.category !== "system";
+}
+function toPascalCase(str) {
+  return str.split(/[-_\s]+/).map((s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase()).join("");
+}
+const DEFAULT_PAGE_SIZE = 20;
+async function renderSlowlyChanging$1(props, wixData) {
+  const { collectionId } = props.metadata;
+  const pageSize = props.pageSize || DEFAULT_PAGE_SIZE;
+  const Pipeline = RenderPipeline.for();
+  return Pipeline.try(async () => {
+    const schema = await wixData.getProcessedSchema(collectionId);
+    if (!schema) {
+      throw new Error(`Collection not configured: ${collectionId}`);
+    }
+    const config = schema.config;
+    const tableFields = schema.fields.filter(isTableField);
+    const columns = tableFields.map((field) => ({
+      fieldName: field.key,
+      label: field.displayName || field.key,
+      sortable: ["TEXT", "NUMBER", "DATE", "DATETIME"].includes(field.wixType)
+    }));
+    const columnNames = tableFields.map((field) => field.key);
+    const result = await wixData.items.query(collectionId).limit(pageSize).find();
+    const rows = result.items.map((item) => ({
+      _id: item._id,
+      url: `${config.pathPrefix}/${item[config.slugField] || item._id}`,
+      cells: columnNames.map((fieldName) => ({
+        fieldName,
+        value: formatCellValue(item[fieldName])
+      }))
+    }));
+    const totalCount = result.totalCount || rows.length;
+    const totalPages = Math.ceil(totalCount / pageSize);
+    return {
+      columns,
+      rows,
+      totalCount,
+      pageSize,
+      totalPages,
+      columnNames
+    };
+  }).recover((error) => {
+    console.error(`[wix-data] Failed to load table data:`, error);
+    return Pipeline.clientError(500, "Failed to load table data");
+  }).toPhaseOutput((data) => ({
+    viewState: {
+      columns: data.columns,
+      rows: data.rows,
+      totalCount: data.totalCount,
+      pageSize: data.pageSize,
+      totalPages: data.totalPages
+    },
+    carryForward: {
+      collectionId,
+      columns: data.columnNames,
+      pageSize: data.pageSize,
+      totalCount: data.totalCount
+    }
+  }));
+}
+function formatCellValue(value) {
+  if (value === null || value === void 0)
+    return "";
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "Yes" : "No";
+  if (value instanceof Date)
+    return value.toLocaleDateString();
+  if (typeof value === "object")
+    return JSON.stringify(value);
+  return String(value);
+}
+async function renderFastChanging(props, slowCarryForward, _wixData) {
+  const Pipeline = RenderPipeline.for();
+  return Pipeline.ok({
+    currentPage: 1,
+    hasPrev: false,
+    hasNext: slowCarryForward.totalCount > slowCarryForward.pageSize,
+    sortField: null,
+    sortDirection: "NONE"
+  }).toPhaseOutput((viewState) => ({
+    viewState,
+    carryForward: slowCarryForward
+  }));
+}
+const collectionTable = makeJayStackComponent().withProps().withServices(WIX_DATA_SERVICE_MARKER).withSlowlyRender(renderSlowlyChanging$1).withFastRender(renderFastChanging);
+async function renderSlowlyChanging(props, wixData) {
+  const { collectionId } = props.metadata;
+  const Pipeline = RenderPipeline.for();
+  return Pipeline.try(async () => {
+    const config = wixData.getCollectionConfig(collectionId);
+    if (!config) {
+      throw new Error(`Collection not configured: ${collectionId}`);
+    }
+    let item;
+    if (props.itemId) {
+      item = await wixData.items.get(collectionId, props.itemId);
+    } else if (props.slug) {
+      const result = await wixData.items.query(collectionId).eq(config.slugField, props.slug).find();
+      item = result.items[0] || null;
+    }
+    if (!item) {
+      throw new Error("Item not found");
+    }
+    const dataFields = Object.entries(item).filter(([key]) => !key.startsWith("_")).map(([key, value]) => {
+      if (isImageValue(value)) {
+        return [key, { url: value.src || value.url || "", altText: value.alt || "" }];
+      }
+      return [key, value];
+    });
+    const viewState = {
+      _id: item._id,
+      url: `${config.pathPrefix}/${item[config.slugField] || item._id}`,
+      ...Object.fromEntries(dataFields)
+    };
+    return { viewState, itemId: item._id };
+  }).recover((error) => {
+    console.error(`[wix-data] Failed to load card item:`, error);
+    return Pipeline.clientError(404, "Item not found");
+  }).toPhaseOutput(({ viewState, itemId }) => ({
+    viewState,
+    carryForward: { itemId }
+  }));
+}
+function isImageValue(value) {
+  return typeof value === "object" && value !== null && ("src" in value || "url" in value);
+}
+const collectionCard = makeJayStackComponent().withProps().withServices(WIX_DATA_SERVICE_MARKER).withSlowlyRender(renderSlowlyChanging);
+const init = makeJayInit().withServer(async () => {
+  console.log("[wix-data] Initializing Wix Data service...");
+  const wixClient = getService(WIX_CLIENT_SERVICE);
+  const config = await loadConfig(wixClient);
+  provideWixDataService(wixClient, config);
+  const visibleCount = config.collections.filter((c) => c.visible).length;
+  console.log(`[wix-data] Server initialization complete. ${visibleCount}/${config.collections.length} collections visible.`);
+  return {
+    collections: config.collections.filter((c) => c.visible).map((c) => c.collectionId)
+  };
+});
+const CONFIG_FILE_NAME = "wix-data.yaml";
+async function setupWixData(ctx) {
+  const configPath = path.join(ctx.configDir, CONFIG_FILE_NAME);
+  if (ctx.initError) {
+    if (!fs.existsSync(configPath)) {
+      return {
+        status: "needs-config",
+        message: "wix-data requires wix-server-client to be configured first. Run: jay-stack setup wix-server-client"
+      };
+    }
+    return {
+      status: "error",
+      message: `Service init failed: ${ctx.initError.message}`
+    };
+  }
+  try {
+    getService(WIX_DATA_SERVICE_MARKER);
+  } catch {
+    return {
+      status: "error",
+      message: "WixDataService not available. Check initialization."
+    };
+  }
+  const dataService = getService(WIX_DATA_SERVICE_MARKER);
+  const visibleCount = dataService.config.collections.filter((c) => c.visible).length;
+  const totalCount = dataService.config.collections.length;
+  return {
+    status: "configured",
+    message: `${totalCount} collections found (${visibleCount} visible)`
+  };
+}
+async function generateWixDataReferences(ctx) {
+  if (ctx.initError) {
+    throw new Error(`init failed: ${ctx.initError.message}`);
+  }
+  let dataService;
+  try {
+    dataService = getService(WIX_DATA_SERVICE_MARKER);
+  } catch {
+    throw new Error("WixDataService not available. Run jay-stack setup first.");
+  }
+  fs.mkdirSync(ctx.referencesDir, { recursive: true });
+  const config = dataService.config;
+  const collectionSummaries = [];
+  for (const collConfig of config.collections) {
+    const collection = await dataService.getCollection(collConfig.collectionId);
+    if (!collection) continue;
+    const fields = (collection.fields || []).map((f) => ({
+      key: f.key || "",
+      displayName: f.displayName || f.key || "",
+      type: f.type || "unknown"
+    }));
+    const referenceFields = (collection.fields || []).filter(
+      (f) => f.type === "REFERENCE" || f.type === "MULTI_REFERENCE"
+    );
+    const references = referenceFields.map((f) => {
+      const meta = f;
+      return {
+        fieldName: f.key || "",
+        targetCollection: meta.typeMetadata?.reference?.referencedCollectionId || meta.typeMetadata?.multiReference?.referencedCollectionId || "unknown",
+        isMulti: f.type === "MULTI_REFERENCE"
+      };
+    });
+    const components = {};
+    if (collConfig.components) {
+      if (collConfig.components.itemPage) components.itemPage = true;
+      if (collConfig.components.indexPage) components.indexPage = true;
+      if (collConfig.components.categoryPage) components.categoryPage = true;
+      if (collConfig.components.tableWidget) components.tableWidget = true;
+      if (collConfig.components.cardWidget) components.cardWidget = true;
+    }
+    collectionSummaries.push({
+      collectionId: collConfig.collectionId,
+      visible: collConfig.visible ?? false,
+      pathPrefix: collConfig.pathPrefix,
+      slugField: collConfig.slugField,
+      fields,
+      references,
+      components
+    });
+  }
+  const collectionsPath = path.join(ctx.referencesDir, "collections.yaml");
+  fs.writeFileSync(
+    collectionsPath,
+    yaml.dump(
+      {
+        _generated: (/* @__PURE__ */ new Date()).toISOString(),
+        _description: "CMS collection schemas for agent discovery. Shows field types, references, and visibility.",
+        totalCollections: collectionSummaries.length,
+        visibleCollections: collectionSummaries.filter((c) => c.visible).length,
+        collections: collectionSummaries
+      },
+      { indent: 2, lineWidth: 120, noRefs: true }
+    ),
+    "utf-8"
+  );
+  return {
+    referencesCreated: [`agent-kit/references/${ctx.pluginName}/collections.yaml`],
+    message: `${collectionSummaries.length} collections (${collectionSummaries.filter((c) => c.visible).length} visible)`
+  };
+}
+function buildContract$3(schema) {
+  const tags = [
+    dataTag("_id", "string", "Item ID"),
+    interactiveTag("itemLink", "HTMLAnchorElement", "Link to item")
+  ];
+  schema.fields.filter(isContentField).forEach((f) => {
+    const tag = fieldToTag(f);
+    if (tag) tags.push(tag);
+  });
+  if (schema.hasCategory) {
+    tags.push(categorySubContract());
+  }
+  tags.push(breadcrumbsSubContract());
+  return `name: ${toPascalCase(schema.collectionId)}Item
+description: Item page for ${schema.displayName || schema.collectionId}
+tags:
+${tags.join("\n")}`;
+}
+const generator$3 = makeContractGenerator().withServices(WIX_DATA_SERVICE_MARKER).generateWith(async (wixDataService) => {
+  const schemas = await wixDataService.getProcessedSchemas(
+    (c) => c.visible === true && !!c.components.itemPage
+  );
+  return schemas.map((schema) => {
+    const name = toPascalCase(schema.collectionId) + "Item";
+    console.log(`[wix-data] Generated item contract: ${name}`);
+    return {
+      name,
+      yaml: buildContract$3(schema),
+      description: `Item page for ${schema.displayName || schema.collectionId}`,
+      metadata: { collectionId: schema.collectionId }
+    };
+  });
+});
+function getListComponentConfig(schema) {
+  return schema.config.components.indexPage || schema.config.components.categoryPage;
+}
+function buildCardTags(schema, indent = 6) {
+  const componentConfig = getListComponentConfig(schema);
+  const whitelist = getComponentFields(componentConfig);
+  const cardTags = [
+    dataTag("_id", "string", void 0, indent),
+    dataTag("url", "string", "Full URL to item page", indent),
+    interactiveTag("itemLink", "HTMLAnchorElement", void 0, indent)
+  ];
+  const fieldsToInclude = whitelist ? schema.fields.filter((f) => whitelist.includes(f.key)) : schema.fields.filter(isCardField);
+  fieldsToInclude.forEach((field) => {
+    const tag = fieldToTag(field, indent);
+    if (tag) cardTags.push(tag);
+  });
+  return cardTags;
+}
+function buildItemsSubContract(schema, tagName, phase, description) {
+  const cardTags = buildCardTags(schema);
+  const phaseAttr = phase ? `
+    phase: ${phase}` : "";
+  const desc = phase ? "Additional items loaded on the client" : "Initial items (rendered server-side)";
+  return `  - tag: ${tagName}
+    type: sub-contract
+    repeated: true
+    trackBy: _id${phaseAttr}
+    description: ${desc}
+    tags:
+${cardTags.join("\n")}`;
+}
+function buildContract$2(schema) {
+  const tags = [];
+  tags.push(buildItemsSubContract(schema, "items"));
+  tags.push(buildItemsSubContract(schema, "loadedItems", "fast+interactive"));
+  tags.push(dataTag("totalCount", "number", "Total items"));
+  tags.push(variantTag("hasMore", "boolean", "fast+interactive", "More items available"));
+  tags.push(variantTag("isLoading", "boolean", "fast+interactive", "Loading state"));
+  tags.push(
+    dataTagWithPhase("loadedCount", "number", "fast+interactive", "Items currently loaded")
+  );
+  tags.push(interactiveTag("loadMoreButton", "HTMLButtonElement", "Load more trigger"));
+  if (schema.hasCategory) {
+    tags.push(categorySubContract());
+  }
+  tags.push(breadcrumbsSubContract());
+  return `name: ${toPascalCase(schema.collectionId)}List
+description: List page for ${schema.displayName || schema.collectionId}
+tags:
+${tags.join("\n")}`;
+}
+const generator$2 = makeContractGenerator().withServices(WIX_DATA_SERVICE_MARKER).generateWith(async (wixDataService) => {
+  const schemas = await wixDataService.getProcessedSchemas(
+    (c) => c.visible === true && (isComponentEnabled(c.components.indexPage) || isComponentEnabled(c.components.categoryPage))
+  );
+  return schemas.map((schema) => {
+    const name = toPascalCase(schema.collectionId) + "List";
+    console.log(`[wix-data] Generated list contract: ${name}`);
+    return {
+      name,
+      yaml: buildContract$2(schema),
+      description: `List page for ${schema.displayName || schema.collectionId}`,
+      metadata: { collectionId: schema.collectionId }
+    };
+  });
+});
+function buildContract$1(schema) {
+  const tags = [];
+  tags.push(`  - tag: columns
+    type: sub-contract
+    repeated: true
+    trackBy: fieldName
+    description: Table column definitions
+    tags:
+      - {tag: fieldName, type: data, dataType: string}
+      - {tag: label, type: data, dataType: string}
+      - {tag: sortable, type: variant, dataType: boolean}
+      - {tag: sortDirection, type: variant, dataType: "enum (NONE | ASC | DESC)", phase: fast+interactive}
+      - {tag: headerButton, type: interactive, elementType: HTMLButtonElement}`);
+  tags.push(`  - tag: rows
+    type: sub-contract
+    repeated: true
+    trackBy: _id
+    description: Table rows
+    tags:
+      - {tag: _id, type: data, dataType: string}
+      - {tag: url, type: data, dataType: string}
+      - {tag: rowLink, type: interactive, elementType: HTMLAnchorElement}
+      - tag: cells
+        type: sub-contract
+        repeated: true
+        trackBy: fieldName
+        tags:
+          - {tag: fieldName, type: data, dataType: string}
+          - {tag: value, type: data, dataType: string}`);
+  tags.push(dataTag("totalCount", "number"));
+  tags.push(dataTag("pageSize", "number"));
+  tags.push(dataTag("totalPages", "number"));
+  tags.push(variantTag("currentPage", "number", "fast+interactive"));
+  tags.push(variantTag("hasPrev", "boolean", "fast+interactive"));
+  tags.push(variantTag("hasNext", "boolean", "fast+interactive"));
+  tags.push(interactiveTag("prevButton", "HTMLButtonElement"));
+  tags.push(interactiveTag("nextButton", "HTMLButtonElement"));
+  if (schema.hasCategory) {
+    tags.push(categorySubContract());
+  }
+  return `name: ${toPascalCase(schema.collectionId)}Table
+description: Table widget for ${schema.displayName || schema.collectionId}
+tags:
+${tags.join("\n")}`;
+}
+const generator$1 = makeContractGenerator().withServices(WIX_DATA_SERVICE_MARKER).generateWith(async (wixDataService) => {
+  const schemas = await wixDataService.getProcessedSchemas(
+    (c) => c.visible === true && !!c.components.tableWidget
+  );
+  return schemas.map((schema) => {
+    const name = toPascalCase(schema.collectionId) + "Table";
+    console.log(`[wix-data] Generated table contract: ${name}`);
+    return {
+      name,
+      yaml: buildContract$1(schema),
+      description: `Table widget for ${schema.displayName || schema.collectionId}`,
+      metadata: { collectionId: schema.collectionId }
+    };
+  });
+});
+function buildContract(schema) {
+  const tags = [
+    dataTag("_id", "string"),
+    dataTag("url", "string", "Full URL to item page"),
+    interactiveTag("itemLink", "HTMLAnchorElement")
+  ];
+  schema.fields.filter(isCardField).forEach((f) => {
+    const tag = fieldToTag(f);
+    if (tag) tags.push(tag);
+  });
+  return `name: ${toPascalCase(schema.collectionId)}Card
+description: Card widget for ${schema.displayName || schema.collectionId}
+tags:
+${tags.join("\n")}`;
+}
+const generator = makeContractGenerator().withServices(WIX_DATA_SERVICE_MARKER).generateWith(async (wixDataService) => {
+  const schemas = await wixDataService.getProcessedSchemas(
+    (c) => c.visible === true && !!c.components.cardWidget
+  );
+  return schemas.map((schema) => {
+    const name = toPascalCase(schema.collectionId) + "Card";
+    console.log(`[wix-data] Generated card contract: ${name}`);
+    return {
+      name,
+      yaml: buildContract(schema),
+      description: `Card widget for ${schema.displayName || schema.collectionId}`,
+      metadata: { collectionId: schema.collectionId }
+    };
+  });
+});
+export {
+  WIX_DATA_CONTEXT,
+  WIX_DATA_SERVICE_MARKER,
+  generator as cardContractGenerator,
+  collectionCard,
+  collectionItem,
+  collectionList,
+  collectionTable,
+  generateWixDataReferences,
+  getCategories,
+  getItemBySlug,
+  getVisibleCollections,
+  init,
+  isCardField,
+  isContentField,
+  isTableField,
+  generator$3 as itemContractGenerator,
+  generator$2 as listContractGenerator,
+  loadConfig,
+  processSchema,
+  provideWixDataService,
+  queryItems,
+  setupWixData,
+  generator$1 as tableContractGenerator,
+  toPascalCase,
+  validateCollectionConfig,
+  validateConfig
+};