vite-plugin-shopify-easel 0.1.0-beta.1

package/dist/index.js

@@ -0,0 +1,1363 @@
+// src/build.ts
+import { existsSync as existsSync4, readFileSync as readFileSync5, readdirSync, rmSync as rmSync4 } from "fs";
+import { join as join4 } from "path";
+
+// src/validation.ts
+var SAFE_OUTPUT_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SAFE_ASSET_FILENAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var SAFE_LIQUID_FILENAME = /^[a-z0-9][a-z0-9_-]*\.liquid$/;
+
+// src/virtual.ts
+var INTERNAL_PREFIX = "\0easel:";
+var PUBLIC_PREFIX = "/@easel/";
+function virtualBundleId(name) {
+  return `${INTERNAL_PREFIX}${name}`;
+}
+function easelBundleModules(getBundles) {
+  return {
+    name: "easel:bundle-modules",
+    enforce: "pre",
+    resolveId(id) {
+      const bundles = getBundles();
+      if (id.startsWith(PUBLIC_PREFIX)) {
+        const name = id.slice(PUBLIC_PREFIX.length);
+        if (bundles.some((bundle) => bundle.name === name)) {
+          return virtualBundleId(name);
+        }
+      }
+      if (id.startsWith(INTERNAL_PREFIX)) return id;
+      const normalizedId = normalizeModulePath(id);
+      const isBundleInput = bundles.flatMap(bundleInputs).some((path) => normalizeModulePath(path) === normalizedId);
+      return isBundleInput ? { id: normalizedId, moduleSideEffects: true } : void 0;
+    },
+    load(id) {
+      if (!id.startsWith(INTERNAL_PREFIX)) return void 0;
+      const name = id.slice(INTERNAL_PREFIX.length);
+      const bundle = getBundles().find((candidate) => candidate.name === name);
+      if (bundle === void 0) {
+        throw new Error(`[easel] unknown virtual bundle "${name}"`);
+      }
+      return `${bundleInputs(bundle).map((path) => `import ${JSON.stringify(path)};`).join("\n")}
+`;
+    }
+  };
+}
+function bundleInputs(bundle) {
+  return [bundle.script, bundle.style].filter(
+    (path) => path !== void 0
+  );
+}
+function normalizeModulePath(path) {
+  return path.replaceAll("\\", "/");
+}
+
+// src/liquid.ts
+var MAX_LIQUID_BYTES = 2e5;
+function renderProductionLiquid(manifest) {
+  const entries = validatedManifestEntries(manifest);
+  const defaultEntry = entries[0]?.[0];
+  if (defaultEntry === void 0) {
+    throw new Error("[easel] cannot render Liquid without an entry");
+  }
+  const lines = loaderHeader("Generated asset loader managed by Easel.", defaultEntry);
+  for (const [name, entry] of entries) {
+    lines.push(`  {% when ${liquidEntryLiteral(name)} %}`);
+    for (const style of entry.styles) {
+      lines.push(
+        `    {{ ${liquidAssetLiteral(style, "stylesheet", ".css")} | asset_url | stylesheet_tag }}`
+      );
+    }
+    for (const imported of entry.imports) {
+      lines.push(
+        `    <link rel="modulepreload" href="{{ ${liquidAssetLiteral(imported, "module import", ".js")} | asset_url }}">`
+      );
+    }
+    if (entry.script !== void 0) {
+      lines.push(
+        `    <script src="{{ ${liquidAssetLiteral(entry.script, "entry script", ".js")} | asset_url }}" type="module" defer></script>`
+      );
+    }
+  }
+  return finishLoader(lines);
+}
+function renderDevelopmentLiquid(names, origin) {
+  const entries = validatedEntryNames(names);
+  const defaultEntry = entries[0];
+  if (defaultEntry === void 0) {
+    throw new Error("[easel] cannot render Liquid without an entry");
+  }
+  const safeOrigin = normalizeOrigin(origin);
+  const lines = loaderHeader(
+    "Generated development asset loader managed by Easel.",
+    defaultEntry,
+    [`<script src="${safeOrigin}/@vite/client" type="module"></script>`]
+  );
+  for (const name of entries) {
+    lines.push(`  {% when ${liquidEntryLiteral(name)} %}`);
+    lines.push(
+      `    <script src="${safeOrigin}${PUBLIC_PREFIX}${encodeURIComponent(name)}" type="module"></script>`
+    );
+  }
+  return finishLoader(lines);
+}
+function loaderHeader(description, defaultEntry, preamble = []) {
+  return [
+    "{% doc %}",
+    description,
+    "@param {string} [entry] - Named Easel bundle to render.",
+    "{% enddoc %}",
+    "{% liquid",
+    `  assign easel_entry = entry | default: ${liquidEntryLiteral(defaultEntry)}`,
+    "%}",
+    ...preamble,
+    "{% case easel_entry %}"
+  ];
+}
+function finishLoader(lines) {
+  lines.push(
+    "  {% else %}",
+    '    <!-- [easel] Unknown bundle "{{ easel_entry | escape }}". -->',
+    "{% endcase %}",
+    ""
+  );
+  return assertLiquidSize(lines.join("\n"));
+}
+function validatedManifestEntries(manifest) {
+  if (manifest.schemaVersion !== 1) {
+    throw new Error(
+      `[easel] unsupported manifest schema version: ${JSON.stringify(manifest.schemaVersion)}`
+    );
+  }
+  const entries = Object.entries(manifest.entries);
+  validatedEntryNames(entries.map(([name]) => name));
+  return entries;
+}
+function validatedEntryNames(names) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    if (!SAFE_OUTPUT_NAME.test(name)) {
+      throw new Error(`[easel] cannot render unsafe Liquid bundle name: ${name}`);
+    }
+    if (seen.has(name)) {
+      throw new Error(`[easel] cannot render duplicate Liquid bundle name: ${name}`);
+    }
+    seen.add(name);
+  }
+  return names;
+}
+function liquidEntryLiteral(name) {
+  if (!SAFE_OUTPUT_NAME.test(name)) {
+    throw new Error(`[easel] cannot render unsafe Liquid bundle name: ${name}`);
+  }
+  return `'${name}'`;
+}
+function liquidAssetLiteral(filename, role, extension) {
+  if (!SAFE_ASSET_FILENAME.test(filename) || !filename.endsWith(extension)) {
+    throw new Error(`[easel] cannot render unsafe ${role} filename: ${filename}`);
+  }
+  return `'${filename}'`;
+}
+function normalizeOrigin(origin) {
+  let url;
+  try {
+    url = new URL(origin);
+  } catch {
+    throw new Error(`[easel] invalid Vite development origin: ${origin}`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`[easel] Vite development origin must use HTTP or HTTPS: ${origin}`);
+  }
+  if (url.username !== "" || url.password !== "" || url.pathname !== "/" || url.search !== "" || url.hash !== "") {
+    throw new Error(
+      `[easel] Vite development origin cannot contain credentials, a path, a query, or a fragment: ${origin}`
+    );
+  }
+  return url.origin;
+}
+function assertLiquidSize(content) {
+  const size = Buffer.byteLength(content);
+  if (size > MAX_LIQUID_BYTES) {
+    throw new Error(
+      `[easel] generated Liquid is ${size} bytes; reduce the number of bundles below ${MAX_LIQUID_BYTES} bytes`
+    );
+  }
+  return content;
+}
+
+// src/manifest.ts
+function createEaselManifest(viteManifest, bundles, emittedFiles = []) {
+  const entries = {};
+  const generated = new Set(emittedFiles);
+  for (const bundle of bundles) {
+    const chunk = findEntry(viteManifest, bundle.name);
+    const { styles, imports } = collectStaticDependencies(viteManifest, chunk);
+    if (bundle.script === void 0) {
+      generated.delete(chunk.file);
+    } else {
+      generated.add(chunk.file);
+    }
+    for (const style of styles) generated.add(style);
+    for (const imported of imports) generated.add(imported);
+    collectGeneratedFiles(viteManifest, chunk, generated);
+    entries[bundle.name] = {
+      ...bundle.script === void 0 ? {} : { script: chunk.file },
+      styles,
+      imports
+    };
+  }
+  return {
+    schemaVersion: 1,
+    entries,
+    generated: [...generated].sort()
+  };
+}
+function findEntry(manifest, name) {
+  const chunk = Object.values(manifest).find(
+    (candidate) => candidate.isEntry === true && candidate.name === name
+  );
+  if (chunk === void 0) {
+    throw new Error(`[easel] Vite manifest does not contain bundle "${name}"`);
+  }
+  return chunk;
+}
+function collectStaticDependencies(manifest, entry) {
+  const styles = /* @__PURE__ */ new Set();
+  const imports = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (chunk) => {
+    for (const key of chunk.imports ?? []) {
+      if (visited.has(key)) continue;
+      visited.add(key);
+      const imported = requiredChunk(manifest, key);
+      imports.add(imported.file);
+      visit(imported);
+    }
+    for (const style of chunk.css ?? []) styles.add(style);
+  };
+  visit(entry);
+  return { styles: [...styles], imports: [...imports] };
+}
+function collectGeneratedFiles(manifest, entry, files) {
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (chunk) => {
+    for (const asset of chunk.assets ?? []) files.add(asset);
+    for (const style of chunk.css ?? []) files.add(style);
+    for (const key of [...chunk.imports ?? [], ...chunk.dynamicImports ?? []]) {
+      if (visited.has(key)) continue;
+      visited.add(key);
+      const imported = requiredChunk(manifest, key);
+      files.add(imported.file);
+      visit(imported);
+    }
+  };
+  visit(entry);
+}
+function requiredChunk(manifest, key) {
+  const chunk = manifest[key];
+  if (chunk === void 0) {
+    throw new Error(`[easel] Vite manifest import is missing: ${key}`);
+  }
+  return chunk;
+}
+
+// src/output.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4, rmSync as rmSync3 } from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+
+// src/lock.ts
+import { randomUUID } from "crypto";
+import {
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { dirname, join } from "path";
+function acquireCommitLock(lockPath) {
+  mkdirSync(dirname(lockPath), { recursive: true });
+  const token = randomUUID();
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      createLock(lockPath, token);
+      return () => releaseLock(lockPath, token);
+    } catch (error) {
+      if (!isAlreadyExistsError(error)) throw error;
+      if (!isStaleLock(lockPath)) {
+        throw new Error(`[easel] another build is publishing this theme: ${lockPath}`);
+      }
+      rmSync(lockPath, { recursive: true });
+    }
+  }
+  throw new Error(`[easel] could not acquire the theme commit lock: ${lockPath}`);
+}
+function createLock(lockPath, token) {
+  mkdirSync(lockPath);
+  try {
+    writeFileSync(
+      join(lockPath, "owner.json"),
+      `${JSON.stringify({ pid: process.pid, token })}
+`
+    );
+  } catch (error) {
+    rmSync(lockPath, { recursive: true });
+    throw error;
+  }
+}
+function releaseLock(lockPath, token) {
+  if (readLockOwner(lockPath)?.token === token) {
+    rmSync(lockPath, { recursive: true });
+  }
+}
+function isStaleLock(lockPath) {
+  const metadata = lstatSync(lockPath);
+  if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+    throw new Error(`[easel] commit lock must be a real directory: ${lockPath}`);
+  }
+  const owner = readLockOwner(lockPath);
+  if (owner === void 0) {
+    return Date.now() - statSync(lockPath).mtimeMs > 3e4;
+  }
+  try {
+    process.kill(owner.pid, 0);
+    return false;
+  } catch (error) {
+    return isNodeError(error) && error.code === "ESRCH";
+  }
+}
+function readLockOwner(lockPath) {
+  try {
+    const value = JSON.parse(
+      readFileSync(join(lockPath, "owner.json"), "utf8")
+    );
+    if (isLockOwner(value)) return value;
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function isLockOwner(value) {
+  return typeof value === "object" && value !== null && "pid" in value && typeof value.pid === "number" && Number.isInteger(value.pid) && value.pid > 0 && "token" in value && typeof value.token === "string" && value.token.length > 0;
+}
+function isAlreadyExistsError(error) {
+  return isNodeError(error) && error.code === "EEXIST";
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/ownership.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { sep } from "path";
+function readOwnershipLedger(options) {
+  const path = options.ledgerPath;
+  if (!existsSync(path)) return void 0;
+  let value;
+  try {
+    value = JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    throw new Error(`[easel] ownership ledger is not valid JSON: ${path}`);
+  }
+  if (!isRecord(value) || value.themePath !== options.themePath) {
+    throw invalidLedger(options);
+  }
+  if (value.schemaVersion === 1 && isLegacyGeneratedList(value.generated)) {
+    return {
+      schemaVersion: 2,
+      themePath: options.themePath,
+      prefix: options.prefix,
+      liquidFilename: options.liquidFilename,
+      generated: value.generated
+    };
+  }
+  if (!isCurrentLedger(value)) throw invalidLedger(options);
+  return value;
+}
+function ownedAssetPath(options, file) {
+  return namespacedAssetPath(options.prefix, file);
+}
+function ownedLiquidPath(options) {
+  return `snippets/${options.liquidFilename}`;
+}
+function assertAssetWritable(destinationPath, relativePath, content, previousFiles) {
+  if (existsSync(destinationPath) && !previousFiles.has(relativePath) && !readFileSync2(destinationPath).equals(content)) {
+    throw new Error(
+      `[easel] refusing to overwrite a file Easel does not own: ${destinationPath}`
+    );
+  }
+}
+function assertLiquidWritable(absolutePath, relativePath, previousFiles) {
+  if (!existsSync(absolutePath) || previousFiles.has(relativePath)) return;
+  if (isGeneratedLiquid(readFileSync2(absolutePath, "utf8"))) return;
+  throw new Error(
+    `[easel] refusing to overwrite a Liquid file Easel does not own: ${absolutePath}`
+  );
+}
+function isGeneratedLiquid(content) {
+  return content.startsWith("{% doc %}\nGenerated asset loader managed by Easel.\n") || isDevelopmentLiquid(content);
+}
+function isDevelopmentLiquid(content) {
+  return content.startsWith(
+    "{% doc %}\nGenerated development asset loader managed by Easel.\n"
+  );
+}
+function isCurrentLedger(value) {
+  if (value.schemaVersion !== 2 || typeof value.themePath !== "string" || typeof value.prefix !== "string" || typeof value.liquidFilename !== "string") {
+    return false;
+  }
+  const namespace = value.prefix.slice(0, -1);
+  return value.prefix.endsWith("-") && SAFE_OUTPUT_NAME.test(namespace) && SAFE_LIQUID_FILENAME.test(value.liquidFilename) && isGeneratedList(value.generated, value.prefix, value.liquidFilename);
+}
+function isLegacyGeneratedList(value) {
+  if (!Array.isArray(value) || !value.every((file) => typeof file === "string")) {
+    return false;
+  }
+  const snippets = value.filter((file) => file.startsWith("snippets/"));
+  return snippets.length === 1 && SAFE_LIQUID_FILENAME.test(snippets[0]?.slice("snippets/".length) ?? "") && value.every(
+    (file) => /^assets\/[a-z0-9][a-z0-9._-]*$/.test(file) || file === snippets[0]
+  );
+}
+function isGeneratedList(value, prefix, liquidFilename) {
+  return Array.isArray(value) && value.every(
+    (file) => typeof file === "string" && isOwnedThemePath(file, prefix, liquidFilename)
+  );
+}
+function isOwnedThemePath(file, prefix, liquidFilename) {
+  if (file === `snippets/${liquidFilename}`) return true;
+  if (!file.startsWith("assets/")) return false;
+  try {
+    return namespacedAssetPath(prefix, file.slice("assets/".length)) === file;
+  } catch {
+    return false;
+  }
+}
+function namespacedAssetPath(prefix, file) {
+  const normalized = file.split(sep).join("/");
+  if (!SAFE_ASSET_FILENAME.test(normalized) || !normalized.startsWith(prefix) || normalized === prefix) {
+    throw new Error(`[easel] generated asset is outside Easel's namespace: ${file}`);
+  }
+  return `assets/${normalized}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function invalidLedger(options) {
+  return new Error(
+    `[easel] invalid ownership ledger for ${options.themePath}: ${options.ledgerPath}`
+  );
+}
+
+// src/transaction.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  existsSync as existsSync2,
+  lstatSync as lstatSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  renameSync,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { dirname as dirname2, join as join2, relative, resolve, sep as sep2 } from "path";
+function snapshotFiles(paths) {
+  return new Map(
+    [...new Set(paths)].map((path) => [
+      path,
+      existsSync2(path) ? readFileSync3(path) : void 0
+    ])
+  );
+}
+function restoreSnapshots(snapshots) {
+  for (const [path, content] of snapshots) {
+    if (content === void 0) {
+      if (existsSync2(path)) rmSync2(path);
+    } else {
+      writeIfChanged(path, content);
+    }
+  }
+}
+function writeTransactionJournal(options, snapshots) {
+  const temporary = `${options.transactionPath}-${randomUUID2()}`;
+  mkdirSync2(temporary, { recursive: true });
+  try {
+    const entries = [];
+    let index = 0;
+    for (const [path, content] of snapshots) {
+      const location = journalLocation(options, path);
+      if (content === void 0) {
+        entries.push({ ...location, existed: false });
+      } else {
+        const blob = `${index}.bin`;
+        writeFileSync2(join2(temporary, blob), content);
+        entries.push({ ...location, existed: true, blob });
+        index += 1;
+      }
+    }
+    const journal = {
+      schemaVersion: 1,
+      themePath: options.themePath,
+      entries
+    };
+    writeFileSync2(
+      join2(temporary, "journal.json"),
+      `${JSON.stringify(journal, null, 2)}
+`
+    );
+    renameSync(temporary, options.transactionPath);
+  } finally {
+    if (existsSync2(temporary)) rmSync2(temporary, { recursive: true });
+  }
+}
+function runFileTransaction(options, paths, action) {
+  const snapshots = snapshotFiles(paths);
+  writeTransactionJournal(options, snapshots);
+  try {
+    action();
+    rmSync2(options.transactionPath, { recursive: true });
+  } catch (error) {
+    try {
+      restoreSnapshots(snapshots);
+      rmSync2(options.transactionPath, { recursive: true, force: true });
+    } catch (rollbackError) {
+      throw new AggregateError(
+        [error, rollbackError],
+        "[easel] output commit failed and could not be rolled back completely"
+      );
+    }
+    throw error;
+  }
+}
+function recoverInterruptedCommit(options) {
+  if (!existsSync2(options.transactionPath)) return;
+  const metadata = lstatSync2(options.transactionPath);
+  if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+    throw new Error(
+      `[easel] transaction journal must be a real directory: ${options.transactionPath}`
+    );
+  }
+  let value;
+  try {
+    value = JSON.parse(
+      readFileSync3(join2(options.transactionPath, "journal.json"), "utf8")
+    );
+  } catch {
+    throw new Error(
+      `[easel] interrupted transaction journal is invalid: ${options.transactionPath}`
+    );
+  }
+  if (!isTransactionJournal(value) || value.themePath !== options.themePath) {
+    throw new Error(
+      `[easel] interrupted transaction journal is invalid: ${options.transactionPath}`
+    );
+  }
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const entry of value.entries) {
+    const path = resolveJournalLocation(options, entry);
+    if (!entry.existed) {
+      snapshots.set(path, void 0);
+      continue;
+    }
+    if (entry.blob === void 0 || !/^\d+\.bin$/.test(entry.blob)) {
+      throw new Error(
+        `[easel] interrupted transaction journal is invalid: ${options.transactionPath}`
+      );
+    }
+    const blobPath = join2(options.transactionPath, entry.blob);
+    if (!existsSync2(blobPath)) {
+      throw new Error(`[easel] interrupted transaction snapshot is missing: ${blobPath}`);
+    }
+    snapshots.set(path, readFileSync3(blobPath));
+  }
+  restoreSnapshots(snapshots);
+  rmSync2(options.transactionPath, { recursive: true });
+}
+function safeResolve(root, path) {
+  const base = resolve(root);
+  const result = resolve(base, path);
+  const relativePath = relative(base, result);
+  if (relativePath === ".." || relativePath.startsWith(`..${sep2}`)) {
+    throw new Error(`[easel] output escapes its allowed root: ${path}`);
+  }
+  return result;
+}
+function writeIfChanged(path, content) {
+  const next = Buffer.isBuffer(content) ? content : Buffer.from(content);
+  if (existsSync2(path) && readFileSync3(path).equals(next)) return;
+  mkdirSync2(dirname2(path), { recursive: true });
+  const temporary = `${path}.easel-${process.pid}-${Date.now()}`;
+  writeFileSync2(temporary, next);
+  try {
+    if (process.platform === "win32" && existsSync2(path)) {
+      replaceFileOnWindows(temporary, path);
+    } else {
+      renameSync(temporary, path);
+    }
+  } finally {
+    if (existsSync2(temporary)) rmSync2(temporary);
+  }
+}
+function journalLocation(options, path) {
+  const statePath = relativeWithin(dirname2(options.ledgerPath), path);
+  if (statePath !== void 0) {
+    return assertJournalLocation({ scope: "state", path: statePath });
+  }
+  const themePath = relativeWithin(options.themePath, path);
+  if (themePath !== void 0) {
+    return assertJournalLocation({ scope: "theme", path: themePath });
+  }
+  throw new Error(`[easel] cannot journal output outside Easel's roots: ${path}`);
+}
+function resolveJournalLocation(options, entry) {
+  assertJournalLocation(entry);
+  const root = entry.scope === "theme" ? options.themePath : dirname2(options.ledgerPath);
+  const path = safeResolve(root, entry.path);
+  if (relativeWithin(root, path) !== entry.path) {
+    throw new Error(
+      `[easel] interrupted transaction journal contains an invalid path: ${entry.path}`
+    );
+  }
+  return path;
+}
+function assertJournalLocation(location) {
+  const valid = location.scope === "theme" ? isJournalThemePath(location.path) : ["outputs.json", "production.txt", "production.liquid", "manifest.json"].includes(
+    location.path
+  );
+  if (!valid) {
+    throw new Error(
+      `[easel] transaction journal contains an invalid path: ${location.path}`
+    );
+  }
+  return location;
+}
+function isJournalThemePath(path) {
+  const [directory, filename, extra] = path.split("/");
+  if (filename === void 0 || extra !== void 0) return false;
+  if (directory === "assets") return SAFE_ASSET_FILENAME.test(filename);
+  return directory === "snippets" && SAFE_LIQUID_FILENAME.test(filename);
+}
+function relativeWithin(root, path) {
+  const value = relative(resolve(root), resolve(path));
+  if (value === "" || value === ".." || value.startsWith(`..${sep2}`)) {
+    return void 0;
+  }
+  return value.split(sep2).join("/");
+}
+function isTransactionJournal(value) {
+  if (typeof value !== "object" || value === null || !("schemaVersion" in value) || value.schemaVersion !== 1 || !("themePath" in value) || typeof value.themePath !== "string" || !("entries" in value) || !Array.isArray(value.entries)) {
+    return false;
+  }
+  return value.entries.every((entry) => isTransactionEntry(entry));
+}
+function isTransactionEntry(entry) {
+  return typeof entry === "object" && entry !== null && "scope" in entry && (entry.scope === "theme" || entry.scope === "state") && "path" in entry && typeof entry.path === "string" && "existed" in entry && typeof entry.existed === "boolean" && (!("blob" in entry) || entry.blob === void 0 || typeof entry.blob === "string");
+}
+function replaceFileOnWindows(temporary, destination) {
+  const backup = `${temporary}.previous`;
+  renameSync(destination, backup);
+  try {
+    renameSync(temporary, destination);
+    rmSync2(backup);
+  } catch (error) {
+    if (existsSync2(destination)) rmSync2(destination);
+    renameSync(backup, destination);
+    throw error;
+  }
+}
+
+// src/output.ts
+function commitProductionOutput(options, manifest, liquid) {
+  const releaseLock2 = acquireCommitLock(options.commitLockPath);
+  try {
+    recoverInterruptedCommit(options);
+    migrateLegacyProductionBackup(options);
+    const previous = readOwnershipLedger(options);
+    const previousFiles = new Set(previous?.generated ?? []);
+    const assets = prepareAssets(options, manifest.generated);
+    const nextFiles = /* @__PURE__ */ new Set([
+      ...assets.map((asset) => asset.relativePath),
+      ownedLiquidPath(options)
+    ]);
+    assertProductionOutputWritable(options, assets, previousFiles);
+    const stalePaths = [...previousFiles].filter((file) => !nextFiles.has(file)).map((file) => safeResolve(options.themePath, file));
+    runFileTransaction(
+      options,
+      changedOutputPaths(options, assets, stalePaths),
+      () => publishProductionOutput(options, manifest, liquid, assets, stalePaths, nextFiles)
+    );
+  } finally {
+    releaseLock2();
+  }
+}
+function assertDevelopmentLiquidWritable(options) {
+  migrateLegacyProductionBackup(options);
+  const previous = readOwnershipLedger(options);
+  assertLiquidWritable(
+    options.liquidPath,
+    ownedLiquidPath(options),
+    new Set(previous?.generated ?? [])
+  );
+}
+function writeDevelopmentLiquid(options, content) {
+  assertDevelopmentLiquidWritable(options);
+  const currentContent = readOptionalFile(options.liquidPath);
+  preserveProductionLiquid(options, currentContent);
+  const productionContent = currentContent !== void 0 && isDevelopmentLiquid(currentContent.toString()) ? readProductionLiquidBackup(options) : currentContent;
+  writeIfChanged(options.liquidPath, content);
+  return () => restoreDevelopmentLiquid(options.liquidPath, content, productionContent);
+}
+function prepareAssets(options, generatedFiles) {
+  return generatedFiles.map((file) => {
+    const sourcePath = safeResolve(options.stagingPath, file);
+    if (!existsSync3(sourcePath)) {
+      throw new Error(`[easel] generated Vite asset is missing: ${sourcePath}`);
+    }
+    return {
+      relativePath: ownedAssetPath(options, file),
+      destinationPath: safeResolve(join3(options.themePath, "assets"), file),
+      content: readFileSync4(sourcePath)
+    };
+  });
+}
+function assertProductionOutputWritable(options, assets, previousFiles) {
+  for (const asset of assets) {
+    assertAssetWritable(
+      asset.destinationPath,
+      asset.relativePath,
+      asset.content,
+      previousFiles
+    );
+  }
+  assertLiquidWritable(options.liquidPath, ownedLiquidPath(options), previousFiles);
+}
+function changedOutputPaths(options, assets, stalePaths) {
+  return [
+    ...assets.map((asset) => asset.destinationPath),
+    options.liquidPath,
+    options.productionLiquidPath,
+    options.manifestPath,
+    ...stalePaths,
+    options.ledgerPath
+  ];
+}
+function publishProductionOutput(options, manifest, liquid, assets, stalePaths, nextFiles) {
+  for (const asset of assets) {
+    writeIfChanged(asset.destinationPath, asset.content);
+  }
+  writeIfChanged(options.liquidPath, liquid);
+  writeIfChanged(options.productionLiquidPath, liquid);
+  writeIfChanged(options.manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+  for (const stale of stalePaths) {
+    if (existsSync3(stale)) rmSync3(stale);
+  }
+  const ledger = {
+    schemaVersion: 2,
+    themePath: options.themePath,
+    prefix: options.prefix,
+    liquidFilename: options.liquidFilename,
+    generated: [...nextFiles].sort()
+  };
+  writeIfChanged(options.ledgerPath, `${JSON.stringify(ledger, null, 2)}
+`);
+}
+function preserveProductionLiquid(options, currentContent) {
+  if (currentContent !== void 0 && isGeneratedLiquid(currentContent.toString()) && !isDevelopmentLiquid(currentContent.toString())) {
+    writeIfChanged(options.productionLiquidPath, currentContent);
+  } else if (currentContent === void 0 && existsSync3(options.productionLiquidPath)) {
+    rmSync3(options.productionLiquidPath);
+  }
+}
+function restoreDevelopmentLiquid(liquidPath, developmentContent, productionContent) {
+  if (!existsSync3(liquidPath)) return;
+  if (readFileSync4(liquidPath, "utf8") !== developmentContent) return;
+  if (productionContent === void 0) {
+    rmSync3(liquidPath);
+  } else {
+    writeIfChanged(liquidPath, productionContent);
+  }
+}
+function migrateLegacyProductionBackup(options) {
+  const legacyPath = join3(dirname3(options.productionLiquidPath), "production.liquid");
+  if (!existsSync3(legacyPath)) return;
+  const legacyContent = readFileSync4(legacyPath);
+  if (!isGeneratedLiquid(legacyContent.toString())) {
+    throw new Error(
+      `[easel] legacy production backup is not generated by Easel: ${legacyPath}`
+    );
+  }
+  if (!existsSync3(options.productionLiquidPath)) {
+    writeIfChanged(options.productionLiquidPath, legacyContent);
+  }
+  rmSync3(legacyPath);
+}
+function readProductionLiquidBackup(options) {
+  const content = readOptionalFile(options.productionLiquidPath);
+  return content !== void 0 && isGeneratedLiquid(content.toString()) && !isDevelopmentLiquid(content.toString()) ? content : void 0;
+}
+function readOptionalFile(path) {
+  return existsSync3(path) ? readFileSync4(path) : void 0;
+}
+
+// src/build.ts
+function finalizeProductionBuild(options, config, publish) {
+  try {
+    if (!publish) return;
+    const viteManifest = readViteManifest(options.stagingPath);
+    const manifest = createEaselManifest(
+      viteManifest,
+      options.bundles,
+      listEmittedFiles(options.stagingPath)
+    );
+    commitProductionOutput(options, manifest, renderProductionLiquid(manifest));
+  } finally {
+    removeStagingDirectory(options.stagingPath, config);
+  }
+}
+function readViteManifest(stagingPath) {
+  const path = join4(stagingPath, ".vite", "manifest.json");
+  if (!existsSync4(path)) {
+    throw new Error(`[easel] Vite did not write its build manifest: ${path}`);
+  }
+  try {
+    return JSON.parse(readFileSync5(path, "utf8"));
+  } catch (error) {
+    throw new Error(`[easel] Vite wrote an invalid build manifest: ${path}`, {
+      cause: error
+    });
+  }
+}
+function removeStagingDirectory(stagingPath, config) {
+  try {
+    rmSync4(stagingPath, { recursive: true, force: true });
+  } catch (error) {
+    config.logger.warn(
+      `[easel] could not remove staging directory ${stagingPath}: ${errorMessage(error)}`
+    );
+  }
+}
+function listEmittedFiles(stagingPath) {
+  const files = [];
+  for (const entry of readdirSync(stagingPath, { withFileTypes: true })) {
+    if (entry.name === ".vite" && entry.isDirectory()) continue;
+    if (!entry.isFile()) {
+      throw new Error(`[easel] unexpected output in staging directory: ${entry.name}`);
+    }
+    files.push(entry.name);
+  }
+  return files;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/options.ts
+import { createHash, randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync5, lstatSync as lstatSync3, realpathSync, statSync as statSync2 } from "fs";
+import { isAbsolute, join as join5, relative as relative2, resolve as resolve2, sep as sep3 } from "path";
+var DEFAULT_SOURCE = "src";
+var DEFAULT_NAMESPACE = "easel";
+var DEFAULT_REFRESH_SIGNAL = ".easel/shopify-ready";
+var DEFAULT_REFRESH_DELAY = 100;
+function resolveEaselOptions(options, projectRoot) {
+  const root = realpathSync(resolve2(projectRoot));
+  const configuredThemePath = resolveFrom(root, options.theme ?? ".");
+  assertTheme(configuredThemePath);
+  const themePath = realpathSync(configuredThemePath);
+  const configuredSourcePath = resolveFrom(root, options.source ?? DEFAULT_SOURCE);
+  const namespace = options.namespace ?? DEFAULT_NAMESPACE;
+  assertSource(configuredSourcePath);
+  const sourcePath = realpathSync(configuredSourcePath);
+  assertNamespace(namespace);
+  const liquidFilename = `${namespace}-assets.liquid`;
+  const prefix = `${namespace}-`;
+  const refresh = resolveRefresh(options.refresh, root);
+  const bundles = resolveBundles(options.bundles, sourcePath);
+  const statePaths = resolveEaselStatePaths(root, themePath);
+  return {
+    projectRoot: root,
+    themePath,
+    sourcePath,
+    ...statePaths,
+    liquidPath: join5(themePath, "snippets", liquidFilename),
+    liquidFilename,
+    namespace,
+    prefix,
+    refresh,
+    bundles
+  };
+}
+function resolveRefresh(configured, projectRoot) {
+  if (configured === false) {
+    return {
+      enabled: false,
+      signalPath: join5(projectRoot, DEFAULT_REFRESH_SIGNAL),
+      delay: DEFAULT_REFRESH_DELAY
+    };
+  }
+  const options = configured === true || configured === void 0 ? {} : configured;
+  const delay = options.delay ?? DEFAULT_REFRESH_DELAY;
+  if (!Number.isInteger(delay) || delay < 0 || delay > 1e4) {
+    throw new Error(
+      "[easel] refresh.delay must be an integer from 0 to 10000 milliseconds"
+    );
+  }
+  return {
+    enabled: true,
+    signalPath: resolveFrom(projectRoot, options.signal ?? DEFAULT_REFRESH_SIGNAL),
+    delay
+  };
+}
+function resolveBundles(configured, sourcePath) {
+  const bundles = configured ?? { theme: resolveDefaultBundle(sourcePath) };
+  const entries = Object.entries(bundles);
+  if (entries.length === 0) {
+    throw new Error("[easel] bundles must contain at least one named bundle");
+  }
+  const resolved = entries.map(([name, bundle]) => {
+    if (!SAFE_OUTPUT_NAME.test(name)) {
+      throw new Error(
+        `[easel] invalid bundle name "${name}"; use lowercase letters, numbers, and hyphens`
+      );
+    }
+    if (bundle.script === void 0 && bundle.style === void 0) {
+      throw new Error(`[easel] bundle "${name}" needs a script, a style, or both`);
+    }
+    return {
+      name,
+      ...resolveBundleFiles(name, bundle, sourcePath)
+    };
+  });
+  const scriptOwners = /* @__PURE__ */ new Map();
+  for (const bundle of resolved) {
+    if (bundle.script === void 0) continue;
+    const owner = scriptOwners.get(bundle.script);
+    if (owner !== void 0) {
+      throw new Error(
+        `[easel] bundles "${owner}" and "${bundle.name}" use the same script; each named bundle needs a distinct script entry`
+      );
+    }
+    scriptOwners.set(bundle.script, bundle.name);
+  }
+  return resolved;
+}
+function resolveDefaultBundle(sourcePath) {
+  const typescriptEntry = join5(sourcePath, "main.ts");
+  const javascriptEntry = join5(sourcePath, "main.js");
+  const styleEntry = join5(sourcePath, "style.css");
+  const hasTypescript = isFile(typescriptEntry);
+  const hasJavascript = isFile(javascriptEntry);
+  if (hasTypescript && hasJavascript) {
+    throw new Error(
+      `[easel] both main.ts and main.js exist in ${sourcePath}; configure bundles to choose one explicitly`
+    );
+  }
+  if (!hasTypescript && !hasJavascript) {
+    throw new Error(
+      `[easel] expected main.ts or main.js in ${sourcePath}; configure source or bundles for a different layout`
+    );
+  }
+  if (!isFile(styleEntry)) {
+    throw new Error(
+      `[easel] expected style.css in ${sourcePath}; configure bundles explicitly to build without a stylesheet`
+    );
+  }
+  return {
+    script: hasTypescript ? typescriptEntry : javascriptEntry,
+    style: styleEntry
+  };
+}
+function resolveBundleFiles(name, bundle, sourcePath) {
+  const resolved = {};
+  if (bundle.script !== void 0) {
+    resolved.script = resolveInput(name, "script", bundle.script, sourcePath);
+  }
+  if (bundle.style !== void 0) {
+    resolved.style = resolveInput(name, "style", bundle.style, sourcePath);
+  }
+  return resolved;
+}
+function resolveInput(bundleName, kind, input, sourcePath) {
+  const path = resolveFrom(sourcePath, input);
+  if (!isFile(path)) {
+    throw new Error(`[easel] ${kind} for bundle "${bundleName}" does not exist: ${path}`);
+  }
+  return realpathSync(path);
+}
+function resolveEaselStatePaths(projectRoot, themePath) {
+  const easelPath = join5(projectRoot, ".easel");
+  const themeId = createHash("sha256").update(themePath).digest("hex").slice(0, 16);
+  const stagingParent = join5(easelPath, "build", themeId);
+  const themeStatePath = join5(easelPath, "themes", themeId);
+  assertEaselStatePaths([
+    easelPath,
+    join5(easelPath, "build"),
+    stagingParent,
+    join5(easelPath, "themes"),
+    themeStatePath
+  ]);
+  return {
+    stagingPath: join5(stagingParent, randomUUID3()),
+    ledgerPath: join5(themeStatePath, "outputs.json"),
+    commitLockPath: join5(themeStatePath, "commit.lock"),
+    manifestPath: join5(themeStatePath, "manifest.json"),
+    productionLiquidPath: join5(themeStatePath, "production.txt"),
+    transactionPath: join5(themeStatePath, "transaction")
+  };
+}
+function assertTheme(themePath) {
+  for (const directory of ["assets", "layout", "snippets"]) {
+    const path = join5(themePath, directory);
+    const metadata = lstatSync3(path, { throwIfNoEntry: false });
+    if (metadata?.isSymbolicLink()) {
+      throw new Error(
+        `[easel] Shopify theme output directory cannot be a symbolic link: ${path}`
+      );
+    }
+    if (metadata === void 0 || !metadata.isDirectory()) {
+      throw new Error(
+        `[easel] invalid Shopify theme at ${themePath}: missing ${directory}/`
+      );
+    }
+  }
+}
+function assertEaselStatePaths(paths) {
+  for (const path of paths) {
+    const metadata = lstatSync3(path, { throwIfNoEntry: false });
+    if (metadata === void 0) continue;
+    if (metadata.isSymbolicLink() || !metadata.isDirectory()) {
+      throw new Error(`[easel] state directory must be a real directory: ${path}`);
+    }
+  }
+}
+function assertSource(sourcePath) {
+  if (!existsSync5(sourcePath) || !statSync2(sourcePath).isDirectory()) {
+    throw new Error(`[easel] source directory does not exist: ${sourcePath}`);
+  }
+}
+function assertNamespace(namespace) {
+  if (!SAFE_OUTPUT_NAME.test(namespace)) {
+    throw new Error(
+      "[easel] namespace must use lowercase letters, numbers, and single hyphens"
+    );
+  }
+}
+function resolveFrom(base, path) {
+  return isAbsolute(path) ? resolve2(path) : resolve2(base, path);
+}
+function isFile(path) {
+  return existsSync5(path) && statSync2(path).isFile();
+}
+function projectRelative(path, projectRoot) {
+  const value = relative2(projectRoot, path);
+  return value.split(sep3).join("/");
+}
+
+// src/refresh.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname4 } from "path";
+var POLL_INTERVAL = 50;
+function watchRefreshSignal(signalPath, delay, refresh) {
+  mkdirSync3(dirname4(signalPath), { recursive: true });
+  if (!existsSync6(signalPath)) writeFileSync3(signalPath, "");
+  let previous = readStats(signalPath);
+  let timer;
+  const poller = setInterval(() => {
+    const current = readStats(signalPath);
+    if (sameStats(current, previous)) return;
+    previous = current;
+    clearTimeout(timer);
+    timer = setTimeout(refresh, delay);
+  }, POLL_INTERVAL);
+  poller.unref();
+  return () => {
+    clearTimeout(timer);
+    clearInterval(poller);
+  };
+}
+function readStats(path) {
+  try {
+    return statSync3(path);
+  } catch {
+    return void 0;
+  }
+}
+function sameStats(current, previous) {
+  if (current === void 0 || previous === void 0) return current === previous;
+  return current.mtimeMs === previous.mtimeMs && current.ctimeMs === previous.ctimeMs && current.size === previous.size;
+}
+
+// src/development.ts
+function configureDevelopmentServer(server, options) {
+  if (server.httpServer === null) {
+    throw new Error(
+      "[easel] Vite middleware mode is not supported; Easel requires the development server lifecycle"
+    );
+  }
+  assertDevelopmentLiquidWritable(options);
+  const stopWatching = configureRefresh(server, options);
+  let restoreDevelopmentLiquid2;
+  server.httpServer.once("listening", () => {
+    restoreDevelopmentLiquid2 = writeDevelopmentLiquid(
+      options,
+      renderDevelopmentLiquid(
+        options.bundles.map((bundle) => bundle.name),
+        developmentOrigin(server)
+      )
+    );
+  });
+  server.httpServer.once("close", () => {
+    stopWatching?.();
+    restoreDevelopmentLiquid2?.();
+  });
+}
+function configureRefresh(server, options) {
+  if (!options.refresh.enabled) return void 0;
+  const stopWatching = watchRefreshSignal(
+    options.refresh.signalPath,
+    options.refresh.delay,
+    () => server.ws.send({ type: "full-reload", path: "*" })
+  );
+  server.config.logger.info(
+    `[easel] Shopify refresh signal: ${projectRelative(
+      options.refresh.signalPath,
+      options.projectRoot
+    )}`
+  );
+  return stopWatching;
+}
+function developmentOrigin(server) {
+  const origin = server.config.server.origin ?? server.resolvedUrls?.local[0] ?? server.resolvedUrls?.network[0];
+  if (origin === void 0) {
+    throw new Error(
+      "[easel] Vite did not expose a development URL; set server.origin explicitly"
+    );
+  }
+  return origin;
+}
+
+// src/vite-config.ts
+function prepareViteConfig(easelOptions, userConfig, command) {
+  const options = resolveEaselOptions(easelOptions, userConfig.root ?? process.cwd());
+  switch (command) {
+    case "build":
+      assertCompatibleBuildConfig(userConfig);
+      break;
+    case "serve":
+      break;
+  }
+  return {
+    options,
+    config: createViteConfig(userConfig, options, command)
+  };
+}
+function validateResolvedViteConfig(config, options) {
+  switch (config.command) {
+    case "build":
+      assertResolvedBuildConfig(config, options);
+      assertNoLaterPostBuildHooks(config);
+      break;
+    case "serve":
+      break;
+  }
+}
+function createViteConfig(config, options, command) {
+  const stableCssEntryIds = new Set(
+    options.bundles.map((bundle) => `easel:${bundle.name}`)
+  );
+  const input = Object.fromEntries(
+    options.bundles.map((bundle) => [bundle.name, virtualBundleId(bundle.name)])
+  );
+  return {
+    ...command === "build" ? { base: "./" } : {},
+    build: {
+      outDir: options.stagingPath,
+      emptyOutDir: true,
+      assetsDir: "",
+      manifest: true,
+      rollupOptions: {
+        input,
+        output: {
+          entryFileNames: `${options.prefix}[name].js`,
+          chunkFileNames: `${options.prefix}[name]-[hash].js`,
+          assetFileNames(asset) {
+            const original = asset.names[0] ?? asset.name ?? "asset";
+            if (!original.endsWith(".css")) {
+              return `${options.prefix}[name]-[hash][extname]`;
+            }
+            return isEntryStylesheet(asset.originalFileNames, stableCssEntryIds) ? `${options.prefix}[name].css` : `${options.prefix}[name]-[hash].css`;
+          }
+        }
+      }
+    },
+    server: {
+      ...config.server?.cors === void 0 ? { cors: shopifyCorsPolicy() } : {},
+      fs: {
+        allow: easelFileSystemAllowList(config.server?.fs?.allow ?? [], options)
+      }
+    }
+  };
+}
+function isEntryStylesheet(originalFileNames, stableCssEntryIds) {
+  return originalFileNames.some((file) => {
+    const normalized = file.replaceAll("\\", "/");
+    return stableCssEntryIds.has(normalized.slice(normalized.lastIndexOf("/") + 1));
+  });
+}
+function shopifyCorsPolicy() {
+  return {
+    origin: [
+      /^https?:\/\/(?:[^.]+\.)*myshopify\.com$/,
+      /^https:\/\/admin\.shopify\.com$/,
+      /^https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\])(?::\d+)?$/
+    ]
+  };
+}
+function easelFileSystemAllowList(configured, options) {
+  const existing = new Set(configured);
+  return unique([options.projectRoot, options.sourcePath]).filter(
+    (path) => !existing.has(path)
+  );
+}
+function assertCompatibleBuildConfig(config) {
+  const build = config.build;
+  const conflict = firstViolation([
+    [
+      config.base !== void 0 && config.base !== "./",
+      'Vite base must be "./" for Shopify CDN assets'
+    ],
+    [
+      build?.outDir !== void 0,
+      "build.outDir conflicts with Easel staging; configure the Shopify theme with easel({ theme }) instead"
+    ],
+    [
+      build?.emptyOutDir !== void 0,
+      "build.emptyOutDir is managed by Easel for safe staging"
+    ],
+    [
+      build?.assetsDir !== void 0,
+      "build.assetsDir is managed by Easel for flat Shopify assets"
+    ],
+    [build?.manifest !== void 0, "build.manifest is managed by Easel"],
+    [build?.write === false, "build.write must remain enabled"],
+    [
+      build?.rollupOptions?.input !== void 0,
+      "build.rollupOptions.input conflicts with Easel bundles"
+    ],
+    [
+      build?.rollupOptions?.output !== void 0,
+      "build.rollupOptions.output is managed by Easel"
+    ]
+  ]);
+  if (conflict !== void 0) throw new Error(`[easel] ${conflict}`);
+}
+function assertResolvedBuildConfig(config, options) {
+  const violation = firstViolation([
+    [config.base !== "./", 'resolved Vite base must be "./"'],
+    [
+      config.build.outDir !== options.stagingPath,
+      "another Vite plugin changed Easel's staging directory"
+    ],
+    [
+      config.build.assetsDir !== "",
+      "another Vite plugin changed Easel's flat asset layout"
+    ],
+    [
+      config.build.emptyOutDir !== true,
+      "another Vite plugin disabled Easel's staging cleanup"
+    ],
+    [
+      config.build.manifest !== true,
+      "another Vite plugin changed Easel's manifest setting"
+    ],
+    [config.build.write === false, "build.write must remain enabled"]
+  ]);
+  if (violation !== void 0) throw new Error(`[easel] ${violation}`);
+}
+function firstViolation(checks) {
+  return checks.find(([violated]) => violated)?.[1];
+}
+function assertNoLaterPostBuildHooks(config) {
+  const easelIndex = config.plugins.findIndex(
+    (plugin) => plugin.name === "easel:shopify-theme"
+  );
+  const unsafe = config.plugins.slice(easelIndex + 1).filter(hasPostOutputHook);
+  if (unsafe.length > 0) {
+    throw new Error(
+      `[easel] Easel must run after plugins with post-order output hooks: ${unsafe.map((plugin) => plugin.name).join(", ")}. Move easel() after those plugins.`
+    );
+  }
+}
+function hasPostOutputHook(plugin) {
+  return [plugin.writeBundle, plugin.closeBundle].some(
+    (hook) => typeof hook === "object" && hook.order === "post"
+  );
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+
+// src/plugin.ts
+function easel(options = {}) {
+  let resolvedOptions;
+  let resolvedConfig;
+  const build = {
+    failed: false,
+    outputHooksCompleted: false
+  };
+  const requireOptions = () => {
+    if (resolvedOptions === void 0) {
+      throw new Error("[easel] plugin options have not been resolved");
+    }
+    return resolvedOptions;
+  };
+  const integration = {
+    name: "easel:shopify-theme",
+    enforce: "post",
+    config(config, environment) {
+      const prepared = prepareViteConfig(options, config, environment.command);
+      resolvedOptions = prepared.options;
+      return prepared.config;
+    },
+    configResolved(config) {
+      resolvedConfig = config;
+      validateResolvedViteConfig(config, requireOptions());
+    },
+    configureServer(server) {
+      configureDevelopmentServer(server, requireOptions());
+    },
+    buildStart() {
+      build.failed = false;
+      build.outputHooksCompleted = false;
+    },
+    buildEnd(error) {
+      if (error !== void 0) build.failed = true;
+    },
+    writeBundle: {
+      order: "post",
+      sequential: true,
+      handler() {
+        build.outputHooksCompleted = true;
+      }
+    },
+    closeBundle: {
+      order: "post",
+      sequential: true,
+      handler() {
+        const config = resolvedConfig;
+        if (config?.command !== "build") return;
+        finalizeProductionBuild(
+          requireOptions(),
+          config,
+          !build.failed && build.outputHooksCompleted
+        );
+      }
+    }
+  };
+  return [easelBundleModules(() => requireOptions().bundles), integration];
+}
+export {
+  easel as default,
+  easel
+};
+//# sourceMappingURL=index.js.map