@jay-framework/wix-deploy 0.18.0

package/dist/artifact-store.js

@@ -0,0 +1,214 @@
+import { items } from "@wix/data";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+function makeItemId(version, relativePath) {
+  return crypto.createHash("sha256").update(`v${version}/${relativePath}`).digest("hex").slice(0, 32);
+}
+class WixDataArtifactStore {
+  collectionId;
+  version;
+  cacheDir;
+  dataClient;
+  moduleRegistry;
+  manifestCache;
+  moduleCache = /* @__PURE__ */ new Map();
+  fetchPromises = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.collectionId = options.collectionId;
+    this.version = options.version;
+    this.cacheDir = options.cacheDir;
+    this.dataClient = options.wixClient.use({ items });
+    this.moduleRegistry = options.moduleRegistry || {};
+    fs.mkdirSync(this.cacheDir, { recursive: true });
+  }
+  // ========================================================================
+  // ArtifactStore interface (reads)
+  // ========================================================================
+  async readManifest() {
+    if (this.manifestCache) return this.manifestCache;
+    const content = await this.ensureFile("route-manifest.json");
+    this.manifestCache = JSON.parse(content);
+    return this.manifestCache;
+  }
+  async readCacheData(relativePath) {
+    const cacheContent = await this.ensureFile(relativePath);
+    try {
+      const cacheData = JSON.parse(cacheContent);
+      return {
+        slowViewState: cacheData.slowViewState || {},
+        carryForward: cacheData.carryForward || {}
+      };
+    } catch {
+      return { slowViewState: {}, carryForward: {} };
+    }
+  }
+  async readPagePartsConfig(relativePath) {
+    const content = await this.ensureFile(relativePath);
+    return JSON.parse(content);
+  }
+  async loadServerElement(relativePath) {
+    return this.loadModule(relativePath, true);
+  }
+  async loadModule(modulePath, _local) {
+    if (this.moduleRegistry[modulePath]) {
+      return this.moduleRegistry[modulePath];
+    }
+    const cached = this.moduleCache.get(modulePath);
+    if (cached) return cached;
+    await this.ensureFile(modulePath);
+    const fullPath = path.join(this.cacheDir, modulePath);
+    const mod = await import(
+      /* @vite-ignore */
+      fullPath
+    );
+    this.moduleCache.set(modulePath, mod);
+    return mod;
+  }
+  getAssetPath(relativePath) {
+    return path.join(this.cacheDir, relativePath);
+  }
+  getBuildDir() {
+    return this.cacheDir;
+  }
+  // ========================================================================
+  // Eager loading (cold start)
+  // ========================================================================
+  async loadEagerFiles() {
+    console.log(
+      `[WixDataArtifactStore] Loading eager files v${this.version} from "${this.collectionId}"...`
+    );
+    let totalLoaded = 0;
+    let hasMore = true;
+    let offset = 0;
+    const limit = 50;
+    while (hasMore) {
+      const result = await this.dataClient.items.query(this.collectionId).eq("category", "eager").eq("version", this.version).skip(offset).limit(limit).find();
+      for (const item of result.items) {
+        this.writeToCache(item.path, item.content);
+        totalLoaded++;
+      }
+      hasMore = result.items.length === limit;
+      offset += limit;
+    }
+    console.log(`[WixDataArtifactStore] Loaded ${totalLoaded} eager files`);
+  }
+  // ========================================================================
+  // Writes (for upload-backend and renderer)
+  // ========================================================================
+  /**
+   * Write a single file to the data collection.
+   */
+  async writeFile(relativePath, content, category) {
+    const ext = path.extname(relativePath).slice(1);
+    const item = {
+      _id: makeItemId(this.version, relativePath),
+      version: this.version,
+      path: relativePath,
+      content,
+      fileType: ext || "unknown",
+      sizeBytes: Buffer.byteLength(content),
+      category
+    };
+    await this.dataClient.items.save(this.collectionId, item);
+  }
+  /**
+   * Write a batch of files to the data collection.
+   * Returns the number of successfully written files.
+   */
+  async writeFiles(files) {
+    const dataItems = files.map((f) => ({
+      _id: makeItemId(this.version, f.path),
+      version: this.version,
+      path: f.path,
+      content: f.content,
+      fileType: path.extname(f.path).slice(1) || "unknown",
+      sizeBytes: Buffer.byteLength(f.content),
+      category: f.category
+    }));
+    try {
+      await this.dataClient.items.bulkSave(this.collectionId, dataItems);
+      return dataItems.length;
+    } catch {
+      let count = 0;
+      for (const item of dataItems) {
+        try {
+          await this.dataClient.items.save(this.collectionId, item);
+          count++;
+        } catch {
+        }
+      }
+      return count;
+    }
+  }
+  // ========================================================================
+  // Internal: lazy file fetching
+  // ========================================================================
+  async ensureFile(relativePath) {
+    const fullPath = path.join(this.cacheDir, relativePath);
+    if (fs.existsSync(fullPath)) {
+      return fs.readFileSync(fullPath, "utf8");
+    }
+    const existing = this.fetchPromises.get(relativePath);
+    if (existing) return existing;
+    const promise = this.fetchFromCollection(relativePath);
+    this.fetchPromises.set(relativePath, promise);
+    try {
+      return await promise;
+    } finally {
+      this.fetchPromises.delete(relativePath);
+    }
+  }
+  async fetchFromCollection(relativePath) {
+    const id = makeItemId(this.version, relativePath);
+    const t0 = Date.now();
+    const item = await this.dataClient.items.get(
+      this.collectionId,
+      id
+    );
+    const t1 = Date.now();
+    if (!item?.content) {
+      throw new Error(
+        `File not found in data collection: v${this.version}/${relativePath} (id: ${id})`
+      );
+    }
+    this.writeToCache(relativePath, item.content);
+    console.log(
+      `[WixDataArtifactStore] Fetched v${this.version}/${relativePath} (${t1 - t0}ms)`
+    );
+    return item.content;
+  }
+  writeToCache(relativePath, content) {
+    const fullPath = path.join(this.cacheDir, relativePath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    if (relativePath.endsWith("page-parts.json")) {
+      try {
+        const config = JSON.parse(content);
+        const rewriteParts = (parts) => {
+          for (const part of parts) {
+            if (part.modulePath && part.source === "npm") {
+              const npmMatch = part.modulePath.match(/\/@jay-framework\/([^/]+)\//);
+              if (npmMatch) {
+                part.modulePath = `@jay-framework/${npmMatch[1]}`;
+              } else {
+                const pkgMatch = part.modulePath.match(/\/packages\/(wix-[^/]+)\//);
+                if (pkgMatch) {
+                  part.modulePath = `@jay-framework/${pkgMatch[1]}`;
+                }
+              }
+            }
+          }
+        };
+        if (config.parts) rewriteParts(config.parts);
+        if (config.instanceComponents) rewriteParts(config.instanceComponents);
+        content = JSON.stringify(config);
+      } catch {
+      }
+    }
+    fs.writeFileSync(fullPath, content, "utf8");
+  }
+}
+export {
+  WixDataArtifactStore,
+  makeItemId
+};

package/dist/index.d.ts

@@ -0,0 +1,112 @@
+import { WixClient } from '@wix/sdk';
+import { ArtifactStore, RouteManifest, CacheEntry, ServerElementModule } from '@jay-framework/production-server/serve';
+import * as _jay_framework_fullstack_component from '@jay-framework/fullstack-component';
+import { ConsoleContext } from '@jay-framework/fullstack-component';
+import { WixClientService } from '@jay-framework/wix-server-client';
+
+/**
+ * WixDataArtifactStore — implements ArtifactStore for Wix BaaS deployments.
+ *
+ * Manages both reads (for serving) and writes (for upload/renderer) of
+ * backend build artifacts in a Wix data collection. All items are versioned
+ * so that a new version can be uploaded while the current version serves.
+ *
+ * Data collection schema:
+ *   _id:       string  — "{version}__{path}" (unique key)
+ *   version:   string  — build version (semver)
+ *   path:      string  — relative file path within backend dir
+ *   content:   string  — file content (text)
+ *   fileType:  string  — extension (js, json)
+ *   sizeBytes: number  — content byte length
+ *   category:  string  — 'eager' | 'lazy'
+ */
+
+interface WixDataArtifactStoreOptions {
+    wixClient: WixClient;
+    collectionId: string;
+    cacheDir: string;
+    version: string;
+    moduleRegistry?: Record<string, any>;
+}
+declare class WixDataArtifactStore implements ArtifactStore {
+    readonly collectionId: string;
+    readonly version: string;
+    private readonly cacheDir;
+    private readonly dataClient;
+    private readonly moduleRegistry;
+    private manifestCache?;
+    private moduleCache;
+    private fetchPromises;
+    constructor(options: WixDataArtifactStoreOptions);
+    readManifest(): Promise<RouteManifest>;
+    readCacheData(relativePath: string): Promise<CacheEntry>;
+    readPagePartsConfig(relativePath: string): Promise<any>;
+    loadServerElement(relativePath: string): Promise<ServerElementModule>;
+    loadModule(modulePath: string, _local?: boolean): Promise<any>;
+    getAssetPath(relativePath: string): string;
+    getBuildDir(): string;
+    loadEagerFiles(): Promise<void>;
+    /**
+     * Write a single file to the data collection.
+     */
+    writeFile(relativePath: string, content: string, category: 'eager' | 'lazy'): Promise<void>;
+    /**
+     * Write a batch of files to the data collection.
+     * Returns the number of successfully written files.
+     */
+    writeFiles(files: Array<{
+        path: string;
+        content: string;
+        category: 'eager' | 'lazy';
+    }>): Promise<number>;
+    private ensureFile;
+    private fetchFromCollection;
+    private writeToCache;
+}
+
+interface BuildEntryInput {
+    collectionId?: string;
+    staticBaseUrl?: string;
+    excludePlugins?: string;
+}
+declare const buildEntry: _jay_framework_fullstack_component.JayCliCommand<BuildEntryInput> & _jay_framework_fullstack_component.JayCliCommandDefinition<BuildEntryInput, [ConsoleContext]>;
+
+interface UploadBackendInput {
+    collectionId?: string;
+    dryRun?: boolean;
+}
+declare const uploadBackend: _jay_framework_fullstack_component.JayCliCommand<UploadBackendInput> & _jay_framework_fullstack_component.JayCliCommandDefinition<UploadBackendInput, [WixClientService, ConsoleContext]>;
+
+interface DeployBaasInput {
+    dryRun?: boolean;
+}
+declare const deployBaas: _jay_framework_fullstack_component.JayCliCommand<DeployBaasInput> & _jay_framework_fullstack_component.JayCliCommandDefinition<DeployBaasInput, [ConsoleContext]>;
+
+interface DeployInput {
+    collectionId?: string;
+    staticBaseUrl?: string;
+    excludePlugins?: string;
+    dryRun?: boolean;
+}
+declare const deploy: _jay_framework_fullstack_component.JayCliCommand<DeployInput> & _jay_framework_fullstack_component.JayCliCommandDefinition<DeployInput, [WixClientService, ConsoleContext]>;
+
+/**
+ * wix-deploy setup hook
+ *
+ * Runs after wix-server-client setup. Reads wix.config.json to populate
+ * clientId and siteId in config/.wix.yaml (if they're still placeholders),
+ * then validates the data collection exists.
+ */
+interface SetupContext {
+    configDir: string;
+    projectRoot: string;
+    initError?: Error;
+}
+interface SetupResult {
+    status: 'configured' | 'needs-config' | 'error';
+    message?: string;
+    configCreated?: string[];
+}
+declare function setupWixDeploy(ctx: SetupContext): Promise<SetupResult>;
+
+export { WixDataArtifactStore, type WixDataArtifactStoreOptions, buildEntry, deploy, deployBaas, setupWixDeploy, uploadBackend };

package/dist/index.js

@@ -0,0 +1,965 @@
+import { WixDataArtifactStore } from "./artifact-store.js";
+import { makeCliCommand, CONSOLE_CONTEXT } from "@jay-framework/fullstack-component";
+import { WIX_CLIENT_SERVICE } from "@jay-framework/wix-server-client";
+import { createHttpClient } from "@wix/http-client";
+import { createAppDeployment, completeAppDeployment } from "@wix/ambassador-velo-backend-v1-app-deployment/http";
+import { createComponentsOverride } from "@wix/ambassador-devcenter-components-overrides-v1-components-override/http";
+import { getLatestProductionVersion } from "@wix/ambassador-devcenter-apps-v1-app-version/http";
+import { release } from "@wix/ambassador-ctp-gradual-rollout-v1-baas-release/http";
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import yaml from "js-yaml";
+import { getService } from "@jay-framework/stack-server-runtime";
+import { items } from "@wix/data";
+const DEFAULT_COLLECTION_ID = "jay-backend-files";
+const DEFAULT_CACHE_DIR = "/tmp/jay-backend";
+const DEFAULT_EXCLUDE_PLUGINS = ["aiditor", "ui-kit", "wix-deploy"];
+function sortPluginsByDeps(plugins) {
+  const priorityPackages = ["@jay-framework/wix-server-client"];
+  const sorted = [];
+  for (const pkg of priorityPackages) {
+    const p = plugins.find((p2) => p2.packageName === pkg);
+    if (p) sorted.push(p);
+  }
+  for (const p of plugins) {
+    if (!sorted.includes(p)) sorted.push(p);
+  }
+  return sorted;
+}
+function generateStubContents(modulePath) {
+  const throwStub = '() => { throw new Error("build-time only"); }';
+  const stubs = {
+    "@jay-framework/compiler-jay-html": [
+      "export default {};",
+      `export const parseJayFile = ${throwStub};`,
+      `export const JAY_IMPORT_RESOLVER = {};`,
+      `export const generateServerElementFile = ${throwStub};`,
+      `export const injectHeadfullFSTemplates = ${throwStub};`,
+      `export const discoverHeadlessInstances = ${throwStub};`,
+      `export const assignCoordinatesToJayHtml = ${throwStub};`,
+      `export const parseAction = ${throwStub};`,
+      `export const parseContract = ${throwStub};`
+    ].join("\n"),
+    "@jay-framework/compiler-shared": [
+      "export default {};",
+      `export const checkValidationErrors = (x) => x;`,
+      `export const formatCode = (code) => code;`
+    ].join("\n"),
+    "@jay-framework/compiler-jay-stack": [
+      "export default {};",
+      `export const jayStackCompiler = ${throwStub};`
+    ].join("\n"),
+    "@jay-framework/compiler-analyze-exported-types": [
+      "export default {};",
+      `export const extractActionsFromSource = ${throwStub};`
+    ].join("\n"),
+    "@jay-framework/compiler": [
+      "export default {};",
+      `export const jayRuntime = ${throwStub};`
+    ].join("\n")
+  };
+  return stubs[modulePath] || "export default {};";
+}
+function generateEntrySource(plugins, actionPackages, serverElements, collectionId, staticBaseUrl, version) {
+  const pluginImports = plugins.map(
+    (p, i) => `import { init as pluginInit_${i} } from '${p.packageName}';`
+  );
+  const moduleImports = plugins.map(
+    (p, i) => `import * as pluginModule_${i} from '${p.packageName}';`
+  );
+  const seImports = serverElements.map(
+    (se, i) => `import * as serverElement_${i} from '${se.absolutePath}';`
+  );
+  const pluginsArray = plugins.map((p, i) => `    { name: '${p.name}', init: pluginInit_${i} },`);
+  const registryEntries = [
+    ...plugins.map((p, i) => `    '${p.packageName}': pluginModule_${i},`),
+    ...serverElements.map((se, i) => `    '${se.relativePath}': serverElement_${i},`)
+  ];
+  const actionsArray = actionPackages.map((pkg) => {
+    const idx = plugins.findIndex((p) => p.packageName === pkg);
+    return `    { module: pluginModule_${idx}, name: '${pkg}' },`;
+  });
+  return `// Auto-generated BaaS entry — do not edit
+// Generated by @jay-framework/wix-deploy build-entry
+
+// Plugin imports (init + full modules for page-parts resolution)
+${pluginImports.join("\n")}
+${moduleImports.join("\n")}
+
+// Server element imports (bundled with ssr-runtime)
+${seImports.join("\n")}
+
+// Framework imports
+import {
+    matchRequest,
+    fetchPageRequest,
+    fetchActionRequest,
+    isActionRequest,
+    initializeServicesFromModules,
+    registerActionsFromModules,
+    FilesystemArtifactStore,
+} from '@jay-framework/production-server/serve';
+import { parseCookies, getService } from '@jay-framework/stack-server-runtime';
+import { WIX_CLIENT_SERVICE } from '@jay-framework/wix-server-client';
+import { WixDataArtifactStore } from '@jay-framework/wix-deploy/artifact-store';
+
+// Module registry — npm packages + server elements (all bundled by esbuild)
+const MODULE_REGISTRY = {
+${registryEntries.join("\n")}
+};
+
+// Configuration
+const COLLECTION_ID = process.env.JAY_COLLECTION_ID || '${collectionId}';
+const STATIC_BASE_URL = process.env.STATIC_BASE_URL || '${staticBaseUrl}';
+const VERSION = process.env.JAY_BUILD_VERSION || '${version}';
+const LOCAL_BACKEND_DIR = process.env.JAY_BACKEND_DIR || '';
+
+let artifacts;
+let initialized = false;
+let initError = null;
+
+async function initialize() {
+    if (initialized) return;
+
+    // Set CWD to entry.mjs dir so config/.wix.yaml is found by wix-server-client
+    const entryDir = new URL('.', import.meta.url).pathname;
+    if (entryDir && process.cwd() !== entryDir) {
+        try { process.chdir(entryDir); } catch {}
+    }
+    console.log('[BaaS] CWD:', process.cwd());
+
+    // BaaS skips dotfiles during upload — copy wix.yaml to .wix.yaml if needed
+    const fs = await import('node:fs');
+    const configDir = process.cwd() + '/config';
+    const dotYaml = configDir + '/.wix.yaml';
+    const plainYaml = configDir + '/wix.yaml';
+    if (!fs.existsSync(dotYaml) && fs.existsSync(plainYaml)) {
+        fs.copyFileSync(plainYaml, dotYaml);
+        console.log('[BaaS] Copied config/wix.yaml to config/.wix.yaml');
+    }
+
+    // Initialize plugins first — wix-server-client reads config/.wix.yaml and creates WixClient
+    console.log('[BaaS] Initializing plugins...');
+    await initializeServicesFromModules([
+${pluginsArray.join("\n")}
+    ], 'BaaS');
+
+    // Register actions
+    console.log('[BaaS] Registering actions...');
+    await registerActionsFromModules([
+${actionsArray.join("\n")}
+    ]);
+
+    // Create artifact store — uses the WixClient that wix-server-client just initialized
+    if (LOCAL_BACKEND_DIR) {
+        console.log('[BaaS] Using filesystem artifact store:', LOCAL_BACKEND_DIR);
+        artifacts = new FilesystemArtifactStore(LOCAL_BACKEND_DIR);
+    } else {
+        console.log('[BaaS] Creating WixDataArtifactStore...');
+        const wixClientService = getService(WIX_CLIENT_SERVICE);
+        console.log('[BaaS] WixClientService:', wixClientService ? 'found' : 'MISSING');
+        artifacts = new WixDataArtifactStore({
+            wixClient: wixClientService,
+            collectionId: COLLECTION_ID,
+            version: VERSION,
+            cacheDir: '${DEFAULT_CACHE_DIR}',
+            moduleRegistry: MODULE_REGISTRY,
+        });
+        console.log('[BaaS] Loading eager files...');
+        await artifacts.loadEagerFiles();
+    }
+
+    initialized = true;
+    console.log('[BaaS] Initialization complete');
+}
+
+function errorPage(title, err, path) {
+    const html = '<!doctype html><html><head><meta charset="UTF-8"><title>' + title + '</title>'
+        + '<style>body{font-family:monospace;max-width:800px;margin:40px auto;padding:0 20px}'
+        + 'h1{color:#c00}pre{background:#f5f5f5;padding:16px;overflow-x:auto;border-radius:4px}'
+        + '.path{color:#666}</style></head><body>'
+        + '<h1>' + title + '</h1>'
+        + '<p class="path">' + path + '</p>'
+        + '<p><strong>' + (err.message || '') + '</strong></p>'
+        + '<pre>' + (err.stack || '') + '</pre>'
+        + '</body></html>';
+    return new Response(html, { status: 500, headers: { 'Content-Type': 'text/html' } });
+}
+
+async function handler(request) {
+    const url = new URL(request.url);
+
+    // Diagnostic endpoint — runs before init
+    if (url.pathname === '/_jay/debug') {
+        const fs = await import('node:fs');
+        const entryDir = new URL('.', import.meta.url).pathname;
+        const info = {
+            cwd: process.cwd(),
+            entryUrl: import.meta.url,
+            entryDir,
+            initialized,
+            hasArtifacts: !!artifacts,
+            initError: initError?.message || null,
+        };
+        try { info.cwdFiles = fs.readdirSync(process.cwd()); } catch (e) { info.cwdFiles = e.message; }
+        try { info.configDirFiles = fs.readdirSync(process.cwd() + '/config'); } catch (e) { info.configDirFiles = e.message; }
+        try { info.entryDirFiles = fs.readdirSync(entryDir); } catch (e) { info.entryDirFiles = e.message; }
+        try { info.entryConfigFiles = fs.readdirSync(entryDir + '/config'); } catch (e) { info.entryConfigFiles = e.message; }
+        try { info.userCodeFiles = fs.readdirSync('/user-code'); } catch (e) { info.userCodeFiles = e.message; }
+        try { info.userCodeConfigFiles = fs.readdirSync('/user-code/config'); } catch (e) { info.userCodeConfigFiles = e.message; }
+        return new Response(JSON.stringify(info, null, 2), { headers: { 'Content-Type': 'application/json' } });
+    }
+
+    try {
+        await initialize();
+    } catch (e) {
+        if (!initError) {
+            initError = e;
+            console.error('[BaaS] INIT FAILED:', e.message, e.stack);
+        }
+        return errorPage('Initialization Failed', e, url.pathname);
+    }
+
+    try {
+        if (isActionRequest(url.pathname)) return fetchActionRequest(request);
+
+        const manifest = await artifacts.readManifest();
+        const match = matchRequest(manifest, url.pathname);
+        if (!match) return new Response('Not Found', { status: 404 });
+
+        const cookies = parseCookies(request.headers.get('cookie') || '');
+        return fetchPageRequest(match, manifest, url, artifacts, STATIC_BASE_URL, cookies);
+    } catch (e) {
+        console.error('[BaaS] REQUEST FAILED:', url.pathname, e.message, e.stack);
+        return errorPage('Request Failed', e, url.pathname);
+    }
+}
+
+export default { fetch: handler };
+export { handler as fetch };
+`;
+}
+function generateServeSource(frontendDir, backendDir) {
+  const lines = [
+    "#!/usr/bin/env node",
+    "// Local test server for the BaaS entry — run with: node dist/serve.mjs",
+    'import http from "node:http";',
+    'import fs from "node:fs";',
+    'import path from "node:path";',
+    'import { Readable } from "node:stream";',
+    "",
+    'process.env.STATIC_BASE_URL = process.env.STATIC_BASE_URL || "/";',
+    `process.env.JAY_BACKEND_DIR = process.env.JAY_BACKEND_DIR || "${backendDir}";`,
+    'const entry = await import("./entry.mjs");',
+    "const handler = entry.default?.fetch || entry.fetch;",
+    'const PORT = parseInt(process.env.PORT || "4000", 10);',
+    `const FRONTEND_DIR = "${frontendDir}";`,
+    "",
+    "const MIME = {",
+    '    ".js": "application/javascript", ".mjs": "application/javascript",',
+    '    ".css": "text/css", ".html": "text/html", ".json": "application/json",',
+    '    ".png": "image/png", ".jpg": "image/jpeg", ".svg": "image/svg+xml",',
+    '    ".woff2": "font/woff2", ".woff": "font/woff",',
+    "};",
+    "",
+    "function serveStatic(pathname, res) {",
+    "    const fp = path.join(FRONTEND_DIR, pathname);",
+    "    if (!fs.existsSync(fp) || !fs.statSync(fp).isFile()) return false;",
+    '    res.writeHead(200, { "Content-Type": MIME[path.extname(fp)] || "application/octet-stream" });',
+    "    fs.createReadStream(fp).pipe(res);",
+    "    return true;",
+    "}",
+    "",
+    "http.createServer(async (req, res) => {",
+    '    const url = new URL(req.url, "http://" + req.headers.host);',
+    "    if (serveStatic(url.pathname, res)) return;",
+    "    const headers = new Headers();",
+    "    for (const [k, v] of Object.entries(req.headers)) {",
+    '        if (v) headers.set(k, Array.isArray(v) ? v.join(", ") : v);',
+    "    }",
+    "    const init = { method: req.method, headers };",
+    '    if (req.method !== "GET" && req.method !== "HEAD") {',
+    '        init.body = Readable.toWeb(req); init.duplex = "half";',
+    "    }",
+    "    try {",
+    "        const response = await handler(new Request(url, init));",
+    "        const rh = {}; response.headers.forEach((v, k) => { rh[k] = v; });",
+    "        res.writeHead(response.status, rh);",
+    "        if (response.body) {",
+    "            const reader = response.body.getReader();",
+    "            while (true) { const { done, value } = await reader.read(); if (done) break; res.write(value); }",
+    "        }",
+    "        res.end();",
+    '    } catch (err) { console.error("Handler error:", err); res.writeHead(500); res.end("Internal Server Error"); }',
+    "}).listen(PORT, () => {",
+    '    console.log("Local test server at http://localhost:" + PORT);',
+    '    console.log("Frontend: " + FRONTEND_DIR);',
+    "});"
+  ];
+  return lines.join("\n") + "\n";
+}
+const buildEntry = makeCliCommand("build-entry").withServices(CONSOLE_CONTEXT).withHandler(async (input, ctx) => {
+  const fs2 = await import("node:fs");
+  const path2 = await import("node:path");
+  const { createRequire } = await import("node:module");
+  const buildDir = ctx.build.backend;
+  const outFile = path2.resolve(ctx.projectRoot, "dist/entry.mjs");
+  const collectionId = input.collectionId || DEFAULT_COLLECTION_ID;
+  const staticBaseUrl = input.staticBaseUrl || "/";
+  const userExcludes = input.excludePlugins?.split(",") || [];
+  const excludePlugins = [...DEFAULT_EXCLUDE_PLUGINS, ...userExcludes];
+  ctx.log(`Build dir: ${buildDir}`);
+  ctx.log(`Output: ${outFile}`);
+  const manifestPath = path2.join(buildDir, "route-manifest.json");
+  if (!fs2.existsSync(manifestPath)) {
+    ctx.error(`route-manifest.json not found at ${manifestPath}`);
+    ctx.error("Run jay-stack build first.");
+    return { success: false };
+  }
+  const manifest = JSON.parse(fs2.readFileSync(manifestPath, "utf8"));
+  const metadataPath = path2.join(buildDir, "build-metadata.json");
+  let version = "1.0.0";
+  if (fs2.existsSync(metadataPath)) {
+    const metadata = JSON.parse(fs2.readFileSync(metadataPath, "utf8"));
+    version = String(metadata.version || "1.0.0");
+  }
+  const filteredPlugins = manifest.plugins.filter(
+    (p) => !excludePlugins.includes(p.name) && !excludePlugins.includes(p.packageName)
+  );
+  const plugins = sortPluginsByDeps(filteredPlugins);
+  const pluginPackages = new Set(plugins.map((p) => p.packageName));
+  const actionPackages = manifest.actions.filter((a) => a.isPlugin && a.packageName && pluginPackages.has(a.packageName)).map((a) => a.packageName).filter((v, i, arr) => arr.indexOf(v) === i);
+  const seSet = /* @__PURE__ */ new Set();
+  for (const route of manifest.routes) {
+    if (route.serverElementPath) seSet.add(route.serverElementPath);
+  }
+  const serverElements = [...seSet].map((rel) => ({
+    relativePath: rel,
+    absolutePath: path2.join(buildDir, rel)
+  }));
+  ctx.log(`Version: ${version}`);
+  ctx.log(`Plugins: ${plugins.map((p) => p.name).join(", ")}`);
+  ctx.log(`Action packages: ${actionPackages.join(", ")}`);
+  ctx.log(`Server elements: ${serverElements.length} routes`);
+  const entrySource = generateEntrySource(
+    plugins,
+    actionPackages,
+    serverElements,
+    collectionId,
+    staticBaseUrl,
+    version
+  );
+  const entryDir = path2.dirname(outFile);
+  fs2.mkdirSync(entryDir, { recursive: true });
+  const tempEntryPath = path2.join(entryDir, ".entry.generated.mjs");
+  fs2.writeFileSync(tempEntryPath, entrySource, "utf8");
+  const stubs = [
+    "@jay-framework/compiler-jay-html",
+    "@jay-framework/compiler-shared",
+    "@jay-framework/compiler-analyze-exported-types",
+    "@jay-framework/compiler-jay-stack",
+    "@jay-framework/compiler",
+    "@jay-framework/rollup-plugin",
+    "@jay-framework/vite-plugin",
+    "typescript",
+    "prettier",
+    "vite",
+    "lightningcss",
+    "fsevents"
+  ];
+  const stubFilter = new RegExp(
+    "^(" + stubs.map((s) => s.replace(/[/.]/g, "\\$&")).join("|") + ")$"
+  );
+  const stubBuildDepsPlugin = {
+    name: "stub-build-deps",
+    setup(build) {
+      build.onResolve({ filter: stubFilter }, (args) => ({
+        path: args.path,
+        namespace: "stub"
+      }));
+      build.onLoad({ filter: /.*/, namespace: "stub" }, (args) => ({
+        contents: generateStubContents(args.path),
+        loader: "js"
+      }));
+    }
+  };
+  const require2 = createRequire(import.meta.url);
+  const resolveAliasPlugin = {
+    name: "resolve-aliases",
+    setup(build) {
+      build.onResolve({ filter: /^@jay-framework\/production-server\/serve$/ }, () => {
+        return { path: require2.resolve("@jay-framework/production-server/serve") };
+      });
+      build.onResolve({ filter: /^@jay-framework\/wix-deploy\/artifact-store$/ }, () => {
+        return { path: require2.resolve("@jay-framework/wix-deploy/artifact-store") };
+      });
+    }
+  };
+  const esbuild = await import("esbuild");
+  const result = await esbuild.build({
+    entryPoints: [tempEntryPath],
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: "node20",
+    outfile: outFile,
+    external: ["node:*"],
+    banner: {
+      js: 'import { createRequire as __bundleCreateRequire } from "node:module";const require = __bundleCreateRequire(import.meta.url);'
+    },
+    plugins: [resolveAliasPlugin, stubBuildDepsPlugin],
+    minify: false,
+    treeShaking: true,
+    logLevel: "warning",
+    metafile: true
+  });
+  fs2.rmSync(tempEntryPath, { force: true });
+  const runtimeStubs = ["typescript", "prettier", "lightningcss"];
+  let patched = fs2.readFileSync(outFile, "utf8");
+  let patchCount = 0;
+  for (const mod of runtimeStubs) {
+    const pattern = new RegExp(`(\\w+)\\("${mod}"\\)`, "g");
+    const before = patched;
+    patched = patched.replace(pattern, "({})");
+    if (patched !== before) patchCount++;
+  }
+  if (patchCount > 0) {
+    fs2.writeFileSync(outFile, patched);
+    ctx.log(`Patched ${patchCount} runtime require() calls for build-time modules`);
+  }
+  const stat = fs2.statSync(outFile);
+  const sizeMB = (stat.size / 1024 / 1024).toFixed(1);
+  ctx.log(`Done: ${outFile} (${sizeMB} MB)`);
+  if (result.metafile) {
+    ctx.log(`Bundled ${Object.keys(result.metafile.inputs).length} input files`);
+    fs2.writeFileSync(
+      outFile.replace(/\.mjs$/, ".meta.json"),
+      JSON.stringify(result.metafile)
+    );
+  }
+  const wixConfigSrc = path2.join(ctx.projectRoot, "config", ".wix.yaml");
+  if (fs2.existsSync(wixConfigSrc)) {
+    const configDir = path2.join(entryDir, "config");
+    fs2.mkdirSync(configDir, { recursive: true });
+    fs2.copyFileSync(wixConfigSrc, path2.join(configDir, ".wix.yaml"));
+    fs2.copyFileSync(wixConfigSrc, path2.join(configDir, "wix.yaml"));
+    ctx.log(`Copied config/.wix.yaml to dist/config/`);
+  } else {
+    ctx.warn(
+      `config/.wix.yaml not found — wix-server-client init will fail on BaaS unless WIX_API_KEY env vars are set`
+    );
+  }
+  const serveFile = path2.join(ctx.projectRoot, "serve.mjs");
+  fs2.writeFileSync(serveFile, generateServeSource(ctx.build.frontend, buildDir));
+  ctx.log(`Generated ${serveFile} — run with: node serve.mjs`);
+  return { success: true, outFile, sizeMB };
+});
+const SKIP_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".jay-html"]);
+const MAX_BATCH_BYTES = 4e5;
+function categorize(relativePath) {
+  if (relativePath === "route-manifest.json") return "eager";
+  if (relativePath === "build-metadata.json") return "eager";
+  if (relativePath.startsWith("server/")) return "eager";
+  return "lazy";
+}
+function scanFileEntries(dir, base, fs2, path2) {
+  const entries = [];
+  for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path2.join(dir, entry.name);
+    const relativePath = base ? `${base}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      entries.push(...scanFileEntries(fullPath, relativePath, fs2, path2));
+    } else {
+      const ext = path2.extname(entry.name).toLowerCase();
+      if (SKIP_EXTENSIONS.has(ext)) continue;
+      const stat = fs2.statSync(fullPath);
+      entries.push({
+        relativePath,
+        fullPath,
+        sizeBytes: stat.size,
+        category: categorize(relativePath)
+      });
+    }
+  }
+  return entries;
+}
+function buildBatches(entries) {
+  const batches = [];
+  let currentBatch = [];
+  let currentSize = 0;
+  for (const entry of entries) {
+    if (currentBatch.length > 0 && currentSize + entry.sizeBytes > MAX_BATCH_BYTES) {
+      batches.push(currentBatch);
+      currentBatch = [];
+      currentSize = 0;
+    }
+    currentBatch.push(entry);
+    currentSize += entry.sizeBytes;
+  }
+  if (currentBatch.length > 0) batches.push(currentBatch);
+  return batches;
+}
+const uploadBackend = makeCliCommand("upload-backend").withServices(WIX_CLIENT_SERVICE, CONSOLE_CONTEXT).withHandler(
+  async (input, wixClient, ctx) => {
+    const fs2 = await import("node:fs");
+    const path2 = await import("node:path");
+    const buildDir = ctx.build.backend;
+    const collectionId = input.collectionId || DEFAULT_COLLECTION_ID;
+    const dryRun = input.dryRun || false;
+    const metadataPath = path2.join(buildDir, "build-metadata.json");
+    let version = "1.0.0";
+    if (fs2.existsSync(metadataPath)) {
+      const metadata = JSON.parse(fs2.readFileSync(metadataPath, "utf8"));
+      version = String(metadata.version || "1.0.0");
+    }
+    if (dryRun) ctx.log("DRY RUN — no uploads");
+    if (!fs2.existsSync(buildDir)) {
+      ctx.error(`Backend dir not found: ${buildDir}`);
+      return { success: false };
+    }
+    const entries = scanFileEntries(buildDir, "", fs2, path2);
+    const totalSize = entries.reduce((sum, f) => sum + f.sizeBytes, 0);
+    ctx.log(`${entries.length} files (${(totalSize / 1024 / 1024).toFixed(1)} MB)`);
+    if (dryRun) {
+      for (const f of entries.slice(0, 20)) {
+        ctx.log(
+          `  [${f.category}] ${f.relativePath} (${(f.sizeBytes / 1024).toFixed(0)} KB)`
+        );
+      }
+      if (entries.length > 20) ctx.log(`  ... and ${entries.length - 20} more`);
+      return { success: true, fileCount: entries.length, totalSize };
+    }
+    const store = new WixDataArtifactStore({
+      wixClient,
+      collectionId,
+      version,
+      cacheDir: "/tmp/upload-staging"
+    });
+    const batches = buildBatches(entries);
+    let uploaded = 0;
+    let errors = 0;
+    let lastReported = 0;
+    for (let i = 0; i < batches.length; i++) {
+      const batch = batches[i];
+      const files = batch.map((f) => ({
+        path: f.relativePath,
+        content: fs2.readFileSync(f.fullPath, "utf8"),
+        category: f.category
+      }));
+      const count = await store.writeFiles(files);
+      uploaded += count;
+      errors += batch.length - count;
+      if (uploaded - lastReported >= 100 || i === batches.length - 1) {
+        ctx.log(`${uploaded}/${entries.length} files uploaded`);
+        lastReported = uploaded;
+      }
+    }
+    if (errors > 0) ctx.log(`${errors} errors`);
+    return { success: errors === 0, uploaded, errors, version };
+  }
+);
+const BACKEND_WORKER_COMPONENT_ID = "ed5f3d0e-7b79-4717-9c00-c4cd7bbbe906";
+function md5(buffer) {
+  return crypto.createHash("md5").update(buffer).digest("hex");
+}
+function getMimeType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const types = {
+    ".mjs": "application/javascript",
+    ".js": "application/javascript",
+    ".json": "application/json",
+    ".html": "text/html",
+    ".css": "text/css",
+    ".yaml": "text/yaml",
+    ".yml": "text/yaml"
+  };
+  return types[ext] || "application/octet-stream";
+}
+function collectFiles(dir, base = "") {
+  const files = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path.join(dir, entry.name);
+    const relativePath = base ? `${base}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      files.push(...collectFiles(fullPath, relativePath));
+    } else {
+      const content = fs.readFileSync(fullPath);
+      files.push({
+        path: `/${relativePath}`,
+        content,
+        hash: md5(content),
+        contentType: getMimeType(entry.name),
+        size: content.length
+      });
+    }
+  }
+  return files;
+}
+const deployBaas = makeCliCommand("deploy-baas").withServices(CONSOLE_CONTEXT).withHandler(async (input, ctx) => {
+  const distDir = path.resolve(ctx.projectRoot, "dist");
+  const dryRun = input.dryRun || false;
+  if (!fs.existsSync(distDir)) {
+    ctx.error("dist/ not found. Run wix-deploy/build-entry first.");
+    return { success: false };
+  }
+  const wixConfigPath = path.join(ctx.projectRoot, "wix.config.json");
+  if (!fs.existsSync(wixConfigPath)) {
+    ctx.error("wix.config.json not found.");
+    return { success: false };
+  }
+  const wixConfig = JSON.parse(fs.readFileSync(wixConfigPath, "utf8"));
+  const appId = wixConfig.appId;
+  wixConfig.siteId;
+  const os = await import("node:os");
+  const accountPath = path.join(os.homedir(), ".wix", "auth", "account.json");
+  if (!fs.existsSync(accountPath)) {
+    ctx.error("No auth found. Run `wix login` first.");
+    return { success: false };
+  }
+  const authData = JSON.parse(fs.readFileSync(accountPath, "utf8"));
+  let accessToken = authData.accessToken;
+  const issuedAt = authData.issuedAt * 1e3;
+  const expiresAt = issuedAt + authData.expiresIn * 1e3;
+  if (Date.now() > expiresAt - 6e4) {
+    ctx.log("Access token expired, refreshing...");
+    const refreshResponse = await fetch("https://manage.wix.com/oauth2/token", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-XSRF-TOKEN": "nocheck",
+        Cookie: "XSRF-TOKEN=nocheck"
+      },
+      body: JSON.stringify({
+        clientId: "6f95cec8-3e98-48b9-b4e5-1fb92fcd9973",
+        grantType: "refresh_token",
+        refreshToken: authData.refreshToken
+      })
+    });
+    if (!refreshResponse.ok) {
+      ctx.error(
+        `Token refresh failed: ${refreshResponse.status}. Run \`wix login\` again.`
+      );
+      return { success: false };
+    }
+    const tokenData = await refreshResponse.json();
+    accessToken = tokenData.access_token;
+    authData.accessToken = accessToken;
+    authData.issuedAt = Math.floor(Date.now() / 1e3);
+    authData.expiresIn = tokenData.expires_in;
+    fs.writeFileSync(accountPath, JSON.stringify(authData, null, 2));
+    ctx.log("Token refreshed");
+  }
+  const httpClient = createHttpClient({
+    baseURL: "https://manage.wix.com",
+    getAppToken: async () => accessToken,
+    createHeaders: () => ({
+      "X-XSRF-TOKEN": "nocheck",
+      Cookie: "XSRF-TOKEN=nocheck"
+    })
+  });
+  const frontendDir = ctx.build.frontend;
+  const serverDir = distDir;
+  const clientFiles = fs.existsSync(frontendDir) ? collectFiles(frontendDir) : [];
+  const serverFiles = collectFiles(serverDir);
+  const files = [...clientFiles, ...serverFiles];
+  const totalSize = files.reduce((sum, f) => sum + f.size, 0);
+  ctx.log(
+    `${clientFiles.length} client + ${serverFiles.length} server files (${(totalSize / 1024 / 1024).toFixed(1)} MB)`
+  );
+  if (dryRun) {
+    for (const f of files) {
+      ctx.log(`  ${f.path} (${(f.size / 1024).toFixed(1)} KB)`);
+    }
+    return { success: true, fileCount: files.length, totalSize };
+  }
+  ctx.log("Creating deployment...");
+  const staticFilesMetadata = clientFiles.map((f) => ({
+    path: f.path,
+    hash: f.hash,
+    contentType: f.contentType,
+    size: f.size
+  }));
+  const { data: deployData } = await httpClient.request(
+    createAppDeployment({
+      appDeployment: { appProjectId: appId, staticFilesMetadata }
+    })
+  );
+  const appDeployment = deployData.appDeployment;
+  const uploadUrls = deployData.staticFilesUploadUrls || [];
+  const uploadToken = deployData.uploadAuthToken;
+  const uploadBuckets = deployData.uploadBuckets || [];
+  if (uploadUrls.length > 0) {
+    const isKubernetes = appDeployment?.cloudProviderOverride === "KUBERNETES";
+    if (isKubernetes) {
+      let uploaded = 0;
+      for (const uploadInfo of uploadUrls) {
+        const file = clientFiles.find(
+          (f) => f.path === uploadInfo.staticFileMetadata?.path
+        );
+        if (!file || !uploadInfo.uploadUrl) continue;
+        const response = await fetch(uploadInfo.uploadUrl, {
+          method: "PUT",
+          headers: { "Content-Type": file.contentType },
+          body: file.content
+        });
+        if (!response.ok) {
+          ctx.error(`  FAILED ${file.path}: ${response.status}`);
+        } else {
+          uploaded++;
+        }
+      }
+      ctx.log(`Uploaded ${uploaded} CDN files`);
+    } else {
+      const uploadUrl = uploadUrls[0].uploadUrl;
+      const buckets = uploadBuckets.length > 0 ? uploadBuckets : [{ hashes: clientFiles.map((f) => f.hash) }];
+      for (let i = 0; i < buckets.length; i++) {
+        const bucket = buckets[i];
+        const formData = new FormData();
+        for (const hash of bucket.hashes || []) {
+          const file = clientFiles.find((f) => f.hash === hash);
+          if (!file) continue;
+          formData.append(
+            hash,
+            new Blob([file.content], { type: file.contentType }),
+            hash
+          );
+        }
+        const response = await fetch(uploadUrl, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${uploadToken}` },
+          body: formData
+        });
+        if (!response.ok) {
+          ctx.error(`  Bucket ${i + 1} FAILED: ${response.status}`);
+        } else {
+          ctx.log(
+            `  Bucket ${i + 1}/${buckets.length}: ${bucket.hashes?.length} files`
+          );
+        }
+      }
+    }
+  }
+  ctx.log("Uploading server files...");
+  const backendFiles = serverFiles.map((f) => ({
+    path: f.path.startsWith("/") ? f.path.slice(1) : f.path,
+    content: f.content.toString("base64")
+  }));
+  const { data: completeData } = await httpClient.request(
+    completeAppDeployment({
+      appDeployment: { ...appDeployment, files: backendFiles },
+      staticsCompletionToken: uploadToken
+    })
+  );
+  const completedDeployment = completeData.appDeployment || {};
+  const deploymentId = appDeployment?.id;
+  const deploymentBaseUrl = completedDeployment.deploymentBaseUrl || appDeployment?.deploymentBaseUrl || "";
+  let appVersion = 0;
+  try {
+    const { data: versionData } = await httpClient.request(
+      getLatestProductionVersion({ appId })
+    );
+    appVersion = versionData.appVersion?.version || 0;
+  } catch {
+  }
+  ctx.log("Registering + releasing...");
+  const overrideId = crypto.randomUUID();
+  await httpClient.request(
+    createComponentsOverride({
+      componentsOverride: {
+        appId,
+        appVersion,
+        externalId: appId,
+        id: overrideId,
+        modifiedComponents: [
+          {
+            componentId: BACKEND_WORKER_COMPONENT_ID,
+            type: "BACKEND_WORKER",
+            data: {
+              backendWorker: {
+                deploymentId,
+                deploymentUrl: deploymentBaseUrl
+              }
+            }
+          }
+        ]
+      }
+    })
+  );
+  const { data: releaseData } = await httpClient.request(
+    release({
+      appId,
+      componentOverrideId: overrideId,
+      createMinorVersion: true
+    })
+  );
+  const releaseUrl = releaseData.releaseBaseUrl || deploymentBaseUrl;
+  ctx.log(`Released → ${releaseUrl}`);
+  return { success: true, deploymentId, baseUrl: releaseUrl };
+});
+function silentCtx(ctx) {
+  return { ...ctx, log: () => {
+  }, warn: () => {
+  } };
+}
+function prefixCtx(ctx, prefix) {
+  return { ...ctx, log: (msg) => ctx.log(`[deploy]   ${prefix} ${msg}`), warn: () => {
+  } };
+}
+function bumpPatch(version) {
+  const parts = version.split(".");
+  if (parts.length === 3) {
+    parts[2] = String(parseInt(parts[2], 10) + 1);
+    return parts.join(".");
+  }
+  return version + ".1";
+}
+const deploy = makeCliCommand("deploy").withServices(WIX_CLIENT_SERVICE, CONSOLE_CONTEXT).withHandler(async (input, wixClient, ctx) => {
+  const fs2 = await import("node:fs");
+  const path2 = await import("node:path");
+  const dryRun = input.dryRun || false;
+  const t0 = Date.now();
+  const metadataPath = path2.join(ctx.build.backend, "build-metadata.json");
+  if (!fs2.existsSync(metadataPath)) {
+    ctx.error(`[deploy] build-metadata.json not found. Run build:production first.`);
+    return { success: false };
+  }
+  const metadata = JSON.parse(fs2.readFileSync(metadataPath, "utf8"));
+  const buildVersion = String(metadata.version || "1.0.0");
+  const deployVersion = bumpPatch(buildVersion);
+  metadata.version = deployVersion;
+  fs2.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+  ctx.log(`[deploy] Version: ${buildVersion} → ${deployVersion}`);
+  ctx.log("[deploy] Bundling entry.mjs...");
+  const buildResult = await buildEntry.handler(
+    {
+      collectionId: input.collectionId,
+      staticBaseUrl: input.staticBaseUrl,
+      excludePlugins: input.excludePlugins
+    },
+    silentCtx(ctx)
+  );
+  if (!buildResult?.success) {
+    ctx.error("[deploy] Bundle failed");
+    return { success: false };
+  }
+  const bundleTime = ((Date.now() - t0) / 1e3).toFixed(1);
+  ctx.log(`[deploy] Bundled entry.mjs (${buildResult.sizeMB} MB) in ${bundleTime}s`);
+  ctx.log("[deploy] Uploading...");
+  const t1 = Date.now();
+  const [uploadResult, deployResult] = await Promise.all([
+    uploadBackend.handler(
+      { collectionId: input.collectionId, dryRun },
+      wixClient,
+      prefixCtx(ctx, "data |")
+    ),
+    dryRun ? { success: true, baseUrl: "(dry run)" } : deployBaas.handler({ dryRun }, prefixCtx(ctx, "baas |"))
+  ]);
+  if (!uploadResult?.success) ctx.error("[deploy] Backend data upload failed");
+  if (!deployResult?.success) ctx.error("[deploy] BaaS deployment failed");
+  const success = !!(uploadResult?.success && deployResult?.success);
+  const elapsed = ((Date.now() - t0) / 1e3).toFixed(1);
+  const deployTime = ((Date.now() - t1) / 1e3).toFixed(1);
+  ctx.log("");
+  if (success) {
+    ctx.log(`[deploy] Done in ${elapsed}s (bundle ${bundleTime}s + deploy ${deployTime}s)`);
+    ctx.log(
+      `[deploy] Version: ${deployVersion} | Entry: ${buildResult.sizeMB} MB | Backend files: ${uploadResult.uploaded}`
+    );
+    if (deployResult.baseUrl) {
+      ctx.log(`[deploy] URL: ${deployResult.baseUrl}`);
+    }
+  } else {
+    ctx.log(`[deploy] Failed after ${elapsed}s`);
+  }
+  return { success, ...deployResult };
+});
+async function setupWixDeploy(ctx) {
+  if (ctx.initError) {
+    return {
+      status: "error",
+      message: `Service init failed: ${ctx.initError.message}`
+    };
+  }
+  const wixConfigPath = path.join(ctx.projectRoot, "wix.config.json");
+  const wixYamlPath = path.join(ctx.configDir, ".wix.yaml");
+  if (!fs.existsSync(wixConfigPath)) {
+    return {
+      status: "needs-config",
+      message: "wix.config.json not found. Run: npm create @wix/new@latest init"
+    };
+  }
+  const wixConfig = JSON.parse(fs.readFileSync(wixConfigPath, "utf8"));
+  const appId = wixConfig.appId;
+  const siteId = wixConfig.siteId;
+  if (!appId) {
+    return {
+      status: "error",
+      message: "wix.config.json missing appId"
+    };
+  }
+  const configCreated = [];
+  if (fs.existsSync(wixYamlPath)) {
+    const content = fs.readFileSync(wixYamlPath, "utf8");
+    const config = yaml.load(content);
+    if (config) {
+      let changed = false;
+      const currentClientId = config.oauthStrategy?.clientId || "";
+      if (!currentClientId || currentClientId.startsWith("<")) {
+        if (!config.oauthStrategy) config.oauthStrategy = {};
+        config.oauthStrategy.clientId = appId;
+        changed = true;
+        configCreated.push("clientId");
+      }
+      const currentSiteId = config.apiKeyStrategy?.siteId || "";
+      if (siteId && (!currentSiteId || currentSiteId.startsWith("<"))) {
+        if (!config.apiKeyStrategy) config.apiKeyStrategy = {};
+        config.apiKeyStrategy.siteId = siteId;
+        changed = true;
+        configCreated.push("siteId");
+      }
+      if (changed) {
+        fs.writeFileSync(wixYamlPath, yaml.dump(config, { lineWidth: -1 }), "utf8");
+      }
+    }
+  }
+  if (fs.existsSync(wixYamlPath)) {
+    const config = yaml.load(fs.readFileSync(wixYamlPath, "utf8"));
+    const apiKey = config?.apiKeyStrategy?.apiKey || "";
+    if (!apiKey || apiKey.startsWith("<")) {
+      return {
+        status: "needs-config",
+        configCreated,
+        message: "API key required — create one at https://manage.wix.com/ and add to config/.wix.yaml"
+      };
+    }
+  }
+  let collectionOk = false;
+  try {
+    const wixClient = getService(WIX_CLIENT_SERVICE);
+    if (wixClient) {
+      const dataClient = wixClient.use({ items });
+      await dataClient.items.query(DEFAULT_COLLECTION_ID).limit(1).find();
+      collectionOk = true;
+    }
+  } catch {
+    return {
+      status: "needs-config",
+      configCreated,
+      message: `Data collection "${DEFAULT_COLLECTION_ID}" not found. Create it in the Wix dashboard with fields: path (text), content (text), fileType (text), sizeBytes (number), category (text), version (text)`
+    };
+  }
+  return {
+    status: "configured",
+    configCreated,
+    message: `Deploy target: wix.config.json (appId: ${appId.slice(0, 8)}...). Collection: ${DEFAULT_COLLECTION_ID} ${collectionOk ? "✓" : ""}`
+  };
+}
+export {
+  WixDataArtifactStore,
+  buildEntry,
+  deploy,
+  deployBaas,
+  setupWixDeploy,
+  uploadBackend
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@jay-framework/wix-deploy",
+  "version": "0.18.0",
+  "type": "module",
+  "description": "Wix BaaS deployment adapter for Jay Framework — WixDataArtifactStore and entry builder",
+  "license": "Apache-2.0",
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "plugin.yaml"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./artifact-store": "./dist/artifact-store.js",
+    "./plugin.yaml": "./plugin.yaml",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "npm run clean && npm run build:server && npm run build:types",
+    "build:server": "vite build --ssr",
+    "build:types": "tsup lib/index.ts --dts-only --format esm",
+    "build:check-types": "tsc",
+    "clean": "rimraf dist",
+    "confirm": "npm run clean && npm run build && npm run test",
+    "test": ":"
+  },
+  "dependencies": {
+    "@jay-framework/fullstack-component": "^0.18.0",
+    "@jay-framework/production-server": "^0.18.0",
+    "@jay-framework/stack-server-runtime": "^0.18.0",
+    "@jay-framework/wix-server-client": "^0.18.0",
+    "@wix/ambassador-ctp-gradual-rollout-v1-baas-release": "^1.0.12",
+    "@wix/ambassador-devcenter-apps-v1-app-version": "^1.0.115",
+    "@wix/ambassador-devcenter-components-overrides-v1-components-override": "^1.0.475",
+    "@wix/ambassador-velo-backend-v1-app-deployment": "^1.0.55",
+    "@wix/data": "^1.0.433",
+    "@wix/http-client": "^2.88.0",
+    "@wix/sdk": "^1.21.5",
+    "esbuild": "^0.21.0",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/plugin.yaml

@@ -0,0 +1,14 @@
+name: wix-deploy
+
+setup:
+  handler: setupWixDeploy
+
+commands:
+  - name: deploy
+    command: deploy.jay-command
+  - name: build-entry
+    command: build-entry.jay-command
+  - name: upload-backend
+    command: upload-backend.jay-command
+  - name: deploy-baas
+    command: deploy-baas.jay-command