Lab deploy độc lập

mkdir independent-deploy-lab
cd independent-deploy-lab
npm init -y
mkdir -p public/shell/s17 public/cart/r7 public/runtime src candidates evidence
npm install --save-dev --save-exact playwright
npx playwright install chromium

<!doctype html>
<html lang="vi">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Independent deploy lab</title>
  </head>
  <body>
    <h1>Shop — shell s17</h1>
    <p id="status" role="status">Đang khởi động…</p>
    <section aria-label="Cart"><div id="cart"></div></section>
    <section aria-label="Catalog"><div id="catalog"></div></section>
    <script type="module" src="/shell/s17/main.mjs"></script>
  </body>
</html>

export const release = 'r7';
export const contractVersion = 1;

export function mount(container) {
  let count = 0;
  let active = true;
  const label = document.createElement('p');
  const render = () => { label.textContent = `Cart r7 — ${count} sản phẩm`; };
  container.replaceChildren(label);
  render();

  return {
    add(item) {
      if (!active) throw new Error('CART_UNMOUNTED');
      if (item?.sku !== 'book-01' || item.quantity !== 1) {
        throw new Error('CART_PAYLOAD_INVALID');
      }
      count += item.quantity;
      render();
    },
    unmount() {
      if (!active) return;
      active = false;
      container.replaceChildren();
    },
  };
}

const status = document.querySelector('#status');
const catalogRoot = document.querySelector('#catalog');

function parseConfig(raw) {
  if (raw?.schemaVersion !== 1 ||
      typeof raw.revision !== 'string' || !raw.revision.trim()) {
    throw new Error('CONFIG_SCHEMA_INVALID');
  }

  const remotes = {};
  for (const name of ['catalog', 'cart']) {
    const spec = raw.remotes?.[name];
    if (!spec || !/^r[1-9]\d*$/.test(spec.release) ||
        spec.contractVersion !== 1 || typeof spec.entry !== 'string') {
      throw new Error(`CONFIG_REMOTE_INVALID:${name}`);
    }
    const expectedPath = `/${name}/${spec.release}/entry.mjs`;
    const url = new URL(spec.entry, location.origin);
    if (url.origin !== location.origin || url.pathname !== expectedPath ||
        url.search || url.hash || url.username || url.password) {
      throw new Error(`CONFIG_URL_INVALID:${name}`);
    }
    remotes[name] = Object.freeze({
      release: spec.release,
      contractVersion: 1,
      entry: url.href,
    });
  }
  return Object.freeze({
    revision: raw.revision,
    remotes: Object.freeze(remotes),
  });
}

async function load(spec) {
  const remote = await import(spec.entry);
  if (remote.release !== spec.release || remote.contractVersion !== 1 ||
      typeof remote.mount !== 'function') {
    throw new Error(`REMOTE_CONTRACT_INVALID:${spec.release}`);
  }
  return remote;
}

let snapshot;
try {
  const preview = new URL(location.href).searchParams.get('preview');
  if (preview !== null && !['r18', 'r19', 'r20'].includes(preview)) {
    throw new Error('PREVIEW_INVALID');
  }
  const configPath = preview
    ? `/runtime/preview-${preview}.json`
    : '/runtime/config.json';
  const response = await fetch(configPath, {
    cache: 'no-store',
    signal: AbortSignal.timeout(5000), // Deadline minh họa cho lab.
  });
  if (!response.ok) throw new Error(`CONFIG_HTTP_${response.status}`);
  snapshot = parseConfig(await response.json());

  const cartModule = await load(snapshot.remotes.cart);
  const cart = cartModule.mount(document.querySelector('#cart'));
  if (typeof cart?.add !== 'function' || typeof cart.unmount !== 'function') {
    throw new Error('CART_HANDLE_INVALID');
  }

  const catalogModule = await load(snapshot.remotes.catalog);
  const catalog = catalogModule.mount(catalogRoot, {
    onAdd: item => cart.add(item),
  });
  if (typeof catalog?.unmount !== 'function') {
    throw new Error('CATALOG_HANDLE_INVALID');
  }

  status.textContent = `s17 | catalog ${catalogModule.release} | ` +
    `cart ${cartModule.release} | config ${snapshot.revision}`;
  console.info('release-set', {
    shell: 's17', catalog: catalogModule.release,
    cart: cartModule.release, config: snapshot.revision,
  });
} catch (error) {
  catalogRoot.textContent = 'Catalog tạm thời không khả dụng.';
  status.textContent = `Bootstrap lỗi: ${error.message}`;
  console.error('bootstrap-failed', {
    config: snapshot?.revision, error: error.message,
  });
}

export const release = __RELEASE__;
export const contractVersion = __CONTRACT_VERSION__;
const title = __TITLE__;

export function mount(container, { onAdd }) {
  if (typeof onAdd !== 'function') throw new Error('ON_ADD_REQUIRED');
  let active = true;
  const root = document.createElement('article');
  const heading = document.createElement('h2');
  const add = document.createElement('button');
  const details = document.createElement('button');
  const output = document.createElement('p');
  heading.textContent = `Catalog ${release} — ${title}`;
  add.textContent = 'Thêm vào giỏ';
  details.textContent = 'Xem chi tiết';
  output.setAttribute('role', 'status');

  const onClickAdd = () => {
    if (active) onAdd({ sku: 'book-01', quantity: 1 });
  };
  const onClickDetails = async () => {
    try {
      const module = await import('./details.mjs');
      if (active) output.textContent = module.description;
    } catch {
      if (active) output.textContent = 'Không tải được chi tiết.';
    }
  };
  add.addEventListener('click', onClickAdd);
  details.addEventListener('click', onClickDetails);
  root.append(heading, add, details, output);
  container.replaceChildren(root);

  return {
    unmount() {
      if (!active) return;
      active = false;
      add.removeEventListener('click', onClickAdd);
      details.removeEventListener('click', onClickDetails);
      root.remove();
    },
  };
}

import { readFile, mkdir, writeFile } from 'node:fs/promises';
import { join } from 'node:path';

const release = process.argv[2];
const variants = {
  r18: { title: 'Sách lập trình', major: 1 },
  r19: { title: 'Sách lập trình — có mô tả mới', major: 1 },
  r20: { title: 'Breaking API', major: 2 },
};
const variant = variants[release];
if (!variant) throw new Error('RELEASE_UNKNOWN');

let entry = await readFile('src/catalog-entry.mjs', 'utf8');
entry = entry
  .replace('__RELEASE__', JSON.stringify(release))
  .replace('__CONTRACT_VERSION__', String(variant.major))
  .replace('__TITLE__', JSON.stringify(variant.title));
if (variant.major === 2) {
  entry = entry.replace('export function mount(', 'export function mountV2(');
}
const directory = join('public', 'catalog', release);
await mkdir('public/catalog', { recursive: true });
await mkdir(directory); // EEXIST là lỗi: không overwrite release đã publish.
await writeFile(join(directory, 'entry.mjs'), entry);
await writeFile(join(directory, 'details.mjs'),
  `export const description = ${JSON.stringify(`Chi tiết từ ${release}`)};\n`);
console.log(`Published catalog ${release}; selection chưa thay đổi.`);

import { createServer } from 'node:http';
import { readFile } from 'node:fs/promises';
import { resolve, extname } from 'node:path';

const root = resolve('public');
const types = {
  '.html': 'text/html; charset=utf-8',
  '.json': 'application/json; charset=utf-8',
  '.mjs': 'text/javascript; charset=utf-8',
};

createServer(async (request, response) => {
  try {
    if (!['GET', 'HEAD'].includes(request.method)) {
      response.writeHead(405, { 'Cache-Control': 'no-store' });
      return response.end();
    }
    const path = new URL(request.url, 'http://127.0.0.1:4173').pathname;
    const file = path === '/' ? '/index.html' : path;
    const isArtifact = /^\/(shell|catalog|cart)\/(s|r)[1-9]\d*\/[a-z-]+\.mjs$/.test(file);
    const isConfig = /^\/runtime\/(config|preview-r[1-9]\d*)\.json$/.test(file);
    if (file !== '/index.html' && !isArtifact && !isConfig) {
      response.writeHead(404, { 'Cache-Control': 'no-store' });
      return response.end('Not found');
    }
    const body = await readFile(resolve(root, `.${file}`));
    response.writeHead(200, {
      'Content-Type': types[extname(file)],
      'X-Content-Type-Options': 'nosniff',
      'Cache-Control': isArtifact
        ? 'public, max-age=31536000, immutable'
        : 'no-store',
    });
    response.end(request.method === 'HEAD' ? undefined : body);
  } catch (error) {
    response.writeHead(error.code === 'ENOENT' ? 404 : 500, {
      'Cache-Control': 'no-store',
    });
    response.end('File unavailable');
  }
}).listen(4173, '127.0.0.1', () => {
  console.log('Shop: http://127.0.0.1:4173');
});

{
  "schemaVersion": 1,
  "revision": "cfg-1",
  "remotes": {
    "catalog": {
      "release": "r18",
      "entry": "/catalog/r18/entry.mjs",
      "contractVersion": 1
    },
    "cart": {
      "release": "r7",
      "entry": "/cart/r7/entry.mjs",
      "contractVersion": 1
    }
  }
}

node build-catalog.mjs r18
node server.mjs

import { readFile, writeFile } from 'node:fs/promises';
import { resolve } from 'node:path';
import { pathToFileURL } from 'node:url';

const [release, revision] = process.argv.slice(2);
if (!/^r[1-9]\d*$/.test(release ?? '') ||
    !/^cfg-[1-9]\d*$/.test(revision ?? '')) {
  throw new Error('ARGS: node candidate.mjs <release> <cfg-revision>');
}
const current = JSON.parse(await readFile('public/runtime/config.json', 'utf8'));
if (current.schemaVersion !== 1 || revision === current.revision) {
  throw new Error('CONFIG_REVISION_INVALID');
}
// Chỉ import artifact do lab tin cậy tạo ra; không phải cách inspect code lạ.
const module = await import(pathToFileURL(
  resolve(`public/catalog/${release}/entry.mjs`),
).href);
if (module.release !== release || module.contractVersion !== 1 ||
    typeof module.mount !== 'function') {
  throw new Error(`CANDIDATE_CONTRACT_INVALID:${release}`);
}
const snapshot = {
  ...current,
  revision,
  remotes: {
    ...current.remotes,
    catalog: {
      release, entry: `/catalog/${release}/entry.mjs`, contractVersion: 1,
    },
  },
};
await writeFile(`candidates/${revision}.json`, JSON.stringify({
  baseRevision: current.revision, snapshot,
}, null, 2), { flag: 'wx' });
await writeFile(`public/runtime/preview-${release}.json`,
  JSON.stringify(snapshot, null, 2));
console.log(`Candidate ${revision} từ ${current.revision}; stable chưa đổi.`);

import { readFile, writeFile, rename, access } from 'node:fs/promises';

const revision = process.argv[2];
if (!/^cfg-[1-9]\d*$/.test(revision ?? '')) throw new Error('REVISION_INVALID');
const { baseRevision, snapshot } = JSON.parse(
  await readFile(`candidates/${revision}.json`, 'utf8'),
);
const current = JSON.parse(await readFile('public/runtime/config.json', 'utf8'));
if (current.revision !== baseRevision) throw new Error('BASE_REVISION_CHANGED');
if (snapshot.schemaVersion !== 1 || snapshot.revision !== revision ||
    revision === current.revision ||
    JSON.stringify(snapshot.remotes.cart) !== JSON.stringify(current.remotes.cart)) {
  throw new Error('CANDIDATE_INVALID');
}
const spec = snapshot.remotes.catalog;
if (!/^r[1-9]\d*$/.test(spec?.release ?? '') || spec.contractVersion !== 1 ||
    spec.entry !== `/catalog/${spec.release}/entry.mjs`) {
  throw new Error('CATALOG_DESCRIPTOR_INVALID');
}
for (const file of ['entry.mjs', 'details.mjs']) {
  await access(`public/catalog/${spec.release}/${file}`);
}
const temporary = `public/runtime/.config-${process.pid}.tmp`;
await writeFile(temporary, JSON.stringify(snapshot, null, 2), { flag: 'wx' });
await rename(temporary, 'public/runtime/config.json');
console.log(`Promoted ${revision}: catalog ${spec.release}, cart giữ nguyên.`);

import assert from 'node:assert/strict';
import { chromium } from 'playwright';

const release = process.argv[2];
if (!/^r[1-9]\d*$/.test(release ?? '')) throw new Error('RELEASE_INVALID');
const base = 'http://127.0.0.1:4173';
const browser = await chromium.launch();
try {
  const page = await browser.newPage();
  const errors = [];
  page.on('pageerror', error => errors.push(error.message));
  await page.goto(`${base}/?preview=${release}`);
  await page.waitForFunction(expected => {
    const text = document.querySelector('#status').textContent;
    if (text.startsWith('Bootstrap lỗi:')) throw new Error(text);
    return text.startsWith(`s17 | catalog ${expected} | cart r7 | config `);
  }, release);

  await page.getByRole('button', { name: 'Thêm vào giỏ' }).click();
  assert.equal(await page.locator('#cart').innerText(), 'Cart r7 — 1 sản phẩm');
  await page.getByRole('button', { name: 'Xem chi tiết' }).click();
  await page.waitForFunction(expected =>
    document.querySelector('#catalog').textContent.includes(`Chi tiết từ ${expected}`),
  release);

  const result = await page.evaluate(async expected => {
    const remote = await import(`/catalog/${expected}/entry.mjs`);
    const host = document.createElement('div');
    const sibling = document.createElement('span');
    sibling.textContent = 'Không thuộc catalog';
    const container = document.createElement('div');
    host.append(sibling, container);
    document.body.append(host);
    const calls = [];
    const handle = remote.mount(container, { onAdd: item => calls.push(item) });
    const button = container.querySelector('button');
    button.click();
    handle.unmount();
    handle.unmount();
    button.click(); // Button bị detach không được phát thêm callback.
    const result = {
      release: remote.release, major: remote.contractVersion,
      calls, empty: container.childElementCount === 0,
      siblingIntact: sibling.textContent === 'Không thuộc catalog' && host.contains(sibling),
    };
    host.remove();
    return result;
  }, release);
  assert.deepEqual(result, {
    release, major: 1,
    calls: [{ sku: 'book-01', quantity: 1 }],
    empty: true, siblingIntact: true,
  });
  assert.deepEqual(errors, []);
  console.log(`PASS: s17 + catalog ${release} + cart r7; journey, lazy module, lifecycle`);
} finally {
  await browser.close();
}

cp public/runtime/config.json evidence/config-before-breaking.json
node build-catalog.mjs r20
if node candidate.mjs r20 cfg-4; then
  echo 'FAIL: breaking candidate đã lọt qua gate'
  exit 1
else
  echo 'PASS: gate từ chối r20; kiểm tra lỗi CANDIDATE_CONTRACT_INVALID:r20'
fi
cmp public/runtime/config.json evidence/config-before-breaking.json

node candidate.mjs r18 cfg-5
node verify.mjs r18
node promote.mjs cfg-5