local-storefront 0.2.0 → 0.3.0-rc.2

package/docs/quickstart-app.md

@@ -0,0 +1,271 @@
+# Quickstart: a public app (React Router template)
+
+Shopify's [React Router app template](https://github.com/Shopify/shopify-app-template-react-router)
+run end to end on your machine: the embedded app in a local admin, its webhooks and Events,
+billing, a theme app extension in a theme, the app proxy, and a Playwright test. No development
+store, no tunnel, no Partner account.
+
+## 1. Set up the template
+
+```bash
+git clone https://github.com/Shopify/shopify-app-template-react-router my-app   # or `shopify app init`
+cd my-app
+npm install
+npm run setup                                   # the Prisma session storage
+npm install --save-dev local-storefront
+```
+
+lsf and the backend both read the app's `.env`. `shopify app env pull` writes it; by hand:
+
+```ini
+SHOPIFY_API_KEY=0123456789abcdef0123456789abcdef
+SHOPIFY_API_SECRET=local-secret
+SCOPES=write_products
+```
+
+`shopify app config link` fills `client_id`, `name` and `handle` in `shopify.app.toml`. Without
+it, add `name = "My app"` and `handle = "my-app"` there: the admin's URL and the plan page use
+the handle.
+
+## 2. Make the one edit
+
+The library sends the Admin API and the token exchange to `https://<shop>`. Send them to lsf, in
+the body of `app/shopify.server.ts`, after the imports:
+
+```ts
+import { setAbstractFetchFunc } from "@shopify/shopify-api/runtime";
+
+// Local development against lsf: the Admin API and OAuth of every shop go to it.
+const lsf = process.env.LSF_URL; // http://127.0.0.1:9292
+if (lsf) {
+  setAbstractFetchFunc((input, init) => {
+    const url = new URL(input instanceof Request ? input.url : String(input));
+    if (!url.hostname.endsWith(".myshopify.com")) return fetch(input, init);
+    const headers = new Headers(init?.headers);
+    headers.set("x-forwarded-host", url.host); // the shop, for OAuth
+    return fetch(`${lsf}${url.pathname}${url.search}`, { ...init, headers });
+  });
+}
+```
+
+Without `LSF_URL`, the app talks to Shopify as before. Until the edit is there, lsf's admin
+says so; it reads the file again at each load, so the banner goes once the edit is saved. A
+backend started without `LSF_URL` sends its calls to Shopify: when a page of it fails and lsf has
+received nothing from it since the admin opened the app, lsf's admin and its terminal name
+`LSF_URL`. Nothing else changes: lsf's admin gives the pages its App Bridge and Polaris.
+
+## 3. Run lsf and the backend
+
+```bash
+npx local-storefront app dev --app . --app-url http://localhost:3000
+LSF_URL=http://127.0.0.1:9292 SHOPIFY_APP_URL=http://localhost:3000 PORT=3000 npx react-router dev
+```
+
+Not `npm run dev`: that is `shopify app dev`, which talks to Shopify. Open the `embedded:` URL
+lsf prints, <http://127.0.0.1:9292/admin/apps/my-app>. The app opens in a local admin, with its
+navigation and title bar. Click **Generate a product**: the admin shows "Product created".
+**Edit product** (`shopify.intents.invoke("edit:shopify/Product")`) shows what lsf has of the
+product; lsf has no product editor, so closing it answers `{code: "closed"}`.
+
+## 4. Webhooks and Events
+
+The template's `[events]` subscription runs on the price change of **Generate a product**: the
+backend prints `Received PRODUCT Event for local-supply-co.myshopify.com`. The webhooks of
+`shopify.app.toml` go to `--app-url`, signed with `SHOPIFY_API_SECRET`:
+
+```bash
+curl -X POST http://127.0.0.1:9292/__lsf/admin/uninstall   # app/uninstalled: the template deletes its sessions
+curl -X POST http://127.0.0.1:9292/__lsf/admin/install
+curl http://127.0.0.1:9292/__lsf/webhooks                  # every delivery, and what the backend answered
+```
+
+The uninstall revokes every token of the app. The install brings back the token lsf printed at
+start, so that a script or a test that read it keeps working. The tokens of the backend's token
+exchange stay revoked: the next page of the app exchanges a session token again, as on Shopify.
+
+## 5. Billing
+
+With managed pricing, declare the plans of the Partner Dashboard in a file:
+
+```toml
+# pricing.toml
+[[plans]]
+handle = "free"
+name = "Free"
+price = 0
+
+[[plans]]
+handle = "pro"
+name = "Pro"
+price = 9
+trial_days = 7
+welcome_link = "/app"
+```
+
+Start lsf with `--pricing-plans pricing.toml`, and send the merchant to the plan page as on
+Shopify:
+
+```ts
+// app/routes/app.plans.tsx
+import type { LoaderFunctionArgs } from "react-router";
+import { authenticate } from "../shopify.server";
+
+export const loader = async ({ request }: LoaderFunctionArgs) => {
+  const { redirect } = await authenticate.admin(request);
+  return redirect("shopify://admin/charges/my-app/pricing_plans", { target: "_top" });
+};
+```
+
+`/admin/apps/my-app/app/plans` lands on lsf's plan page. **Choose Pro**, then **Approve**: the
+shop gets an active `Pro` subscription, and the browser goes to `/app` with `charge_id` and
+`plan_handle`. A test skips the page: `POST /__lsf/admin/pricing-plans/pro/select`. The Billing
+API (`billing.request`): [approve a charge](admin.md#approve-a-charge).
+
+## 6. A theme app extension and the app proxy
+
+An app block is a file of a theme app extension: `extensions/rating/shopify.extension.toml` with
+`name = "Rating"` and `type = "theme"`, and `extensions/rating/blocks/rating.liquid`:
+
+```liquid
+<p class="my-app-rating">{{ block.settings.heading }} ★★★★☆</p>
+
+{% schema %}
+{
+  "name": "Rating",
+  "target": "section",
+  "settings": [{ "type": "text", "id": "heading", "label": "Heading", "default": "Rated" }]
+}
+{% endschema %}
+```
+
+A theme names it in a JSON template, as the theme editor writes it. In Horizon's
+`templates/product.json`, add this section (`_blocks` is Horizon's section that takes app
+blocks) and put `"rating"` in `order`:
+
+```json
+"rating": {
+  "type": "_blocks",
+  "blocks": {
+    "rating_1": { "type": "shopify://apps/my-app/blocks/rating/0", "settings": { "heading": "Loved by customers" } }
+  },
+  "block_order": ["rating_1"]
+}
+```
+
+For the app proxy, add to `shopify.app.toml`, and a route that answers Liquid:
+
+```toml
+[app_proxy]
+url = "/proxy"
+prefix = "apps"
+subpath = "my-app"
+```
+
+```ts
+// app/routes/proxy.$.tsx
+import type { LoaderFunctionArgs } from "react-router";
+import { authenticate } from "../shopify.server";
+
+export const loader = async ({ request }: LoaderFunctionArgs) => {
+  const { liquid } = await authenticate.public.appProxy(request);
+  return liquid("<h1>Hello from my app</h1><p>{{ shop.name }}</p>");
+};
+```
+
+Serve the theme with the app, in place of `app dev`:
+
+```bash
+npx local-storefront serve --theme ../horizon --app . --app-url http://localhost:3000
+```
+
+A product page shows the block, and <http://127.0.0.1:9292/apps/my-app> shows the proxy's answer
+in the theme's layout. In the app's folder, `npx local-storefront check --theme ../horizon --app .`
+checks the app blocks the theme names, and `npx local-storefront app build` checks the extension
+as Shopify does.
+
+## 7. A Playwright test
+
+```bash
+npm install --save-dev @playwright/test && npx playwright install chromium
+```
+
+```ts
+// playwright.config.ts
+import { defineConfig } from '@playwright/test';
+
+// The app's values (SHOPIFY_API_KEY, SHOPIFY_API_SECRET, SCOPES): react-router-serve reads no .env.
+process.loadEnvFile('.env');
+
+export default defineConfig({
+  testDir: 'e2e',
+  workers: 1, // one lsf, one shop: the tests change it in turn
+  use: {
+    // For the test's own requests to the backend: the template answers 410 to HeadlessChrome.
+    userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36',
+  },
+  webServer: [
+    {
+      command: 'npx local-storefront app dev --app . --port 9393 --app-url http://localhost:3001 --polaris offline --static --quiet',
+      url: 'http://127.0.0.1:9393/__lsf/status',
+    },
+    {
+      // A build, not the dev server: on a cold start, Vite's dev server optimizes the
+      // dependencies a page asks for and reloads the page, under the test.
+      command: 'npx prisma migrate deploy && npx react-router build && npx react-router-serve ./build/server/index.js',
+      url: 'http://localhost:3001/',
+      env: { PORT: '3001', SHOPIFY_APP_URL: 'http://localhost:3001', LSF_URL: 'http://127.0.0.1:9393' },
+      timeout: 120_000,
+    },
+  ],
+});
+```
+
+```ts
+// e2e/app.spec.ts
+import { test, expect } from '@playwright/test';
+
+const LSF = 'http://127.0.0.1:9393';
+
+test('the app generates a product', async ({ page, request }) => {
+  const errors: string[] = [];
+  page.on('console', (message) => message.type() === 'error' && errors.push(message.text()));
+  const { last } = await (await request.get(`${LSF}/__lsf/webhooks`)).json();
+
+  await page.goto(`${LSF}/admin/apps/my-app/app`);
+  await expect(page.frameLocator('iframe').getByText('Get started with products')).toBeVisible();
+  await page.getByRole('button', { name: 'Generate a product' }).click(); // the admin's title bar
+  await expect(page.getByText('Product created')).toBeVisible(); // the admin's toast
+
+  // The price change sends the template's Product Event to webhooks.products.update.tsx.
+  const events = await request.get(`${LSF}/__lsf/webhooks?topic=Product&since=${last}&wait=1`);
+  const { deliveries } = await events.json();
+  expect(deliveries[0].state).toBe('delivered');
+  expect(errors).toEqual([]); // nothing failed in the page
+});
+```
+
+`npx playwright test` builds the app and runs it with `react-router-serve`. Not the dev server:
+on a cold checkout, as in CI, Vite optimizes the dependencies the first page asks for, answers
+`504 Outdated Optimize Dep` and reloads the page, and the test clicks a page that never
+hydrates. The build takes a few seconds, has no HMR port, and runs next to your dev server.
+`--polaris offline` serves Polaris from lsf: no request leaves the machine.
+
+In CI, write the `.env` first (it is not committed): the values of step 1 are lsf's, not
+secrets.
+
+```yaml
+- run: npm ci && npm run setup
+- run: printf 'SHOPIFY_API_KEY=0123456789abcdef0123456789abcdef\nSHOPIFY_API_SECRET=local-secret\nSCOPES=write_products\n' > .env
+- run: npx playwright install --with-deps chromium && npx playwright test
+```
+
+## Next
+
+- [Admin API](admin.md): the embedded admin, App Bridge, tokens, webhooks, billing, managed
+  pricing and the Partner API, the app proxy.
+- [Storefront](storefront.md#theme-app-extensions): app embed blocks, app-data metafields, why a
+  block renders nothing.
+- [Quickstart: Functions and checkout UI extensions](quickstart-functions.md), for the app's
+  extensions.
+- [`examples/admin-backend`](https://github.com/0xtlt/local-storefront/tree/main/examples/admin-backend):
+  a backend with Shopify's libraries, run against lsf end to end.

package/docs/quickstart-functions.md

@@ -0,0 +1,207 @@
+# Quickstart: Functions and checkout UI extensions
+
+From a Shopify app with a discount Function and a checkout UI extension to a local checkout that
+runs them, and a check that fails in CI when the Function decides wrong. No store, no Partner
+account, no network.
+
+The examples use an app with two extensions, as `shopify app generate extension` makes them: a
+discount Function in TypeScript (`discount-typescript`) and a checkout UI extension in Preact
+(`ui-preact`). Without an app, copy these two folders of the
+[playground](https://github.com/0xtlt/local-storefront/tree/main/examples/checkout-playground/extensions)
+into the `extensions/` of a folder that has a `shopify.app.toml`.
+
+lsf runs the extensions whose `api_version` is `2026-10` or `2027-01`. On another version, a
+Function does not run and a UI extension is not offered to the checkout: `validate` says so, and
+`app check` fails with the reason (`api_version "2026-07" is not supported (supported: 2026-10,
+2027-01)`). Change the `api_version` of its `shopify.extension.toml` to one of the two.
+
+## 1. Install and write scenarios
+
+In the app's folder:
+
+```bash
+npm install --save-dev local-storefront
+npx local-storefront app init
+```
+
+```text
+./shopify-local: created, with the demo store
+  wrote   checkouts/guest.json
+  …
+  wrote   checkouts/discount-automatic.json
+  wrote   checkouts/discount-code.json
+  wrote   checkouts/all-extensions.json
+  skipped cart-transform: the app has no cart transform Function
+  …
+./shopify-local/checkouts: wrote 11 scenarios, kept 0 existing ones, for 1 Function and 1 checkout UI extension of My app
+```
+
+A scenario is a cart, a buyer, a country and the extensions to run, in one file of
+`shopify-local/checkouts/`. `app init` writes a set made for the app's extensions.
+
+## 2. Give the discount its settings
+
+A discount Function runs only for a discount that names it. `discount-automatic.json` has one;
+give it the metafield the Function reads its settings from. The playground's reads
+`$app:config` / `settings`; yours reads what its input query names:
+
+```json
+"checkout": {
+  "discounts": [
+    {
+      "function": "discount-typescript",
+      "title": "Quantity discount (TypeScript)",
+      "code": null,
+      "metafields": {
+        "$app:config.settings": { "type": "json", "value": { "percentage": 10, "minimumQuantity": 3 } }
+      }
+    }
+  ]
+}
+```
+
+## 3. Build and serve
+
+```bash
+npx local-storefront app build        # every Function and UI extension, without Node
+npx local-storefront app dev --watch
+```
+
+Open <http://127.0.0.1:9292/>: the home page lists what is wrong first, then the scenarios.
+Open one to get its checkout, with the Function's discount on the lines and the extension's
+banner. `--watch` builds an extension again when you save it, and reloads the page:
+
+```text
+↻ building discount-typescript…
+✓ discount-typescript built in 0.1s
+```
+
+## 4. Run the Function once
+
+```bash
+npx local-storefront app function run discount-typescript --scenario discount-automatic
+```
+
+It prints the input, the output, the logs and the instructions of the run, then the checkout:
+
+```text
+== checkout
+  6 × Canvas Tote Bag  144.00 USD → 129.60 USD
+  3 × Ceramic Mug (Oat)  66.00 USD → 59.40 USD
+  2 × Linen Overshirt (S)  136.00 USD
+  discount 10% off 3 or more: -21.00 USD (Product, discount-typescript)
+  …
+  subtotal 346.00 USD · discounts -21.00 USD · shipping 0.00 USD · tax 0.00 USD · total 325.00 USD
+```
+
+When a file of the Function changed after its module was built, `app function run` builds it
+first, as `shopify app function run` does (`build:  discount-typescript: … changed after its
+module was built: building it first`).
+
+Keep the input lsf built, and run the Function on it later, as `shopify app function run
+--input` does:
+
+```bash
+npx local-storefront app function run discount-typescript --scenario discount-automatic \
+  --save-input tests/fixtures/six-totes.json
+npx local-storefront app function run discount-typescript --input tests/fixtures/six-totes.json
+```
+
+`--save-input` creates the folders of its file. `--input -` reads the input from stdin, and
+`--format json` prints the run as JSON. A Function with several targets needs `--export <name>`.
+In an app with one Function, the handle can be left out.
+
+A fixture of the unit tests of Shopify's templates (`{"payload": {"export", "target", "input",
+"output"}}`) is checked: its `output` must be the run's, and its `target` and `export` the
+Function's. `--input` with a folder runs each of its `*.json` fixtures:
+
+```bash
+npx local-storefront app function run --input tests/fixtures
+```
+
+```text
+pass     tests/fixtures/six-totes.json
+fails    tests/fixtures/fifteen.json: the output is not the one the fixture expects:
+           operations[0].productDiscountsAdd.candidates[0].value.percentage.value
+             expected: 15
+             actual:   10
+ran 2 fixtures of discount-typescript: 1 passed, 1 failed
+```
+
+## 5. Say what the checkout must look like
+
+Add `expect` to the scenario:
+
+```json
+"expect": {
+  "discounts": { "includes": [{ "title": "10% off 3 or more", "amount": "21.00" }] },
+  "lines": { "includes": [{ "sku": "TOTE-NAT", "total": "129.60" }] },
+  "totals": { "total": "325.00" }
+}
+```
+
+```bash
+npx local-storefront app check
+```
+
+```text
+checked 11 of 11 scenarios in 0.0 s: every Function ran, 3 expectations met
+```
+
+When the Function decides wrong, `app check` says where, and exits with `1`:
+
+```text
+expect   discount-automatic: totals.total
+         expected: "300.00"
+         actual:   "325.00"
+checked 11 of 11 scenarios in 0.0 s: 0 failures, 0 invalid scenarios, 1 of 3 expectations unmet
+```
+
+`expect` also checks payment methods, express buttons, delivery options and errors, each with
+`includes`, `excludes` and `equals` ([expected results](checkout.md#expected-results)).
+
+## 6. Run it in CI
+
+Commit `package.json`, `package-lock.json` and `shopify-local/`. `dist/` is not committed:
+`--build` builds the extensions first.
+
+```yaml
+# .github/workflows/checkout.yml
+name: checkout
+on: [push, pull_request]
+jobs:
+  checkout:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
+        with:
+          node-version: 24
+          cache: npm
+      - run: npm ci
+      - run: npx local-storefront validate          # the store data, the scenarios and the app
+      - run: npx local-storefront app check --build # every Function of every scenario, and each `expect`
+```
+
+`app check` fails on a Function that traps, runs past Shopify's instruction limit or answers an
+output its schema refuses, and on an `expect` that is not met. It also fails on an extension
+the checkout does not offer (an `api_version` lsf does not run, no module or bundle), on a
+Function whose files changed after its module was built (`stale`: give `--build`), and on what
+Shopify rejects in a theme app extension. It needs no store and no network.
+
+## Coming from Shopify's CLI
+
+`lsf app dev --watch` stands for `shopify app dev`, `lsf app build` for `shopify app build`, and
+`lsf app function run --input` for `shopify app function run` (which builds a changed Function
+first too). `app function typegen` and
+`app function schema` work offline. There is no development store, tunnel or deploy. The full
+table, with what lsf does not do: [coming from Shopify's CLI](checkout.md#coming-from-shopifys-cli).
+
+## Next
+
+- [Checkout](checkout.md): scenarios, what runs and why, discounts, network access, the
+  customer account.
+- [Set up the checkout](checkout.md#set-up-the-checkout): shipping rates, payment methods, and
+  the settings of a UI extension.
+- [What to test on a real store](checkout.md#what-to-test-on-a-real-store) before a release.
+- [Quickstart: an Admin API backend](quickstart-admin-api.md), for the app's backend.

package/docs/quickstart-theme.md

@@ -0,0 +1,177 @@
+# Quickstart: a theme
+
+From a theme folder to a storefront you edit live and a test that runs in CI. The examples use
+Shopify's Horizon theme; any theme works the same way.
+
+## 1. Serve the theme
+
+In the theme folder:
+
+```bash
+npm install --save-dev local-storefront
+npx local-storefront serve --live-reload
+```
+
+```text
+theme:  .
+data:   built-in demo store (the `init` command writes an editable copy)
+serving: theme
+ready:  http://127.0.0.1:9292/   (status and control API: http://127.0.0.1:9292/__lsf)
+```
+
+Open <http://127.0.0.1:9292>. With `--live-reload`, a page reloads when you save a file of the
+theme or of the store data, and a small panel lists the errors of the page. Leave it off in
+tests.
+
+Write `npx local-storefront`, not `npx lsf`: `lsf` is another package on npm.
+
+## 2. Write the store data
+
+```bash
+npx local-storefront init
+```
+
+```text
+./shopify-local: wrote 16 files, kept 0 existing ones, refreshed schema/
+```
+
+`shopify-local/` is the store: `store.json`, one file per product in `products/`,
+`customers.json`, `collections.json`, menus, pages and blogs. Edit them, or replace the demo's
+products with yours. Then check them:
+
+```bash
+npx local-storefront validate
+```
+
+```text
+./shopify-local: valid (8 products, 7 collections, 3 pages, 1 blog, 4 customers, 2 menus, 0 checkout scenarios)
+```
+
+A mistake has its file, its place and a hint, and the command exits with `1`:
+
+```text
+error[unknown_field]: unknown field "titel"
+  --> products/blue-shirt.json at /titel
+  hint: did you mean "title"?
+```
+
+## 3. Check and format the Liquid
+
+```bash
+npx local-storefront check          # 383 files checked, 0 problems
+npx local-storefront fmt --check    # 28 files to format, 256 already formatted
+```
+
+`check` finds the Liquid Shopify's strict parser rejects (`check --fix` rewrites it), the filters
+that do not exist, the `{% schema %}` Shopify refuses on upload (an unknown setting type, a
+`select` default that is not an option), and the snippets, sections, blocks, assets and
+translation keys the theme names but does not have. `fmt --check` exits with `1` on a theme nobody formatted, as Horizon is: run
+`npx local-storefront fmt` once, in a commit of its own.
+
+## 4. Write a browser test
+
+Each test gets its own cart and customer. One request puts the session in the state the test
+needs.
+
+```bash
+npm install --save-dev @playwright/test
+```
+
+```ts
+// playwright.config.ts
+import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+  fullyParallel: true,
+  use: { baseURL: 'http://127.0.0.1:9393' },
+  webServer: {
+    command: 'npx local-storefront serve --port 9393 --static --quiet --strict',
+    url: 'http://127.0.0.1:9393/__lsf/status',
+    reuseExistingServer: !process.env.CI,
+  },
+});
+```
+
+```ts
+// tests/cart.spec.ts
+import { test, expect } from '@playwright/test';
+
+test('a logged-in customer sees their cart', async ({ page }) => {
+  // The demo store's customer and SKU: put your own.
+  const response = await page.request.put('/__lsf/session', {
+    data: {
+      customer: 'jane.doe@example.com',
+      cart: { items: [{ variant: 'TEE-BLK-M', quantity: 2 }] },
+    },
+  });
+  expect(response.ok()).toBeTruthy(); // 422, with the reason, for a SKU the data does not have
+
+  await page.goto('/cart');
+  const lines = page.getByRole('main').getByRole('table');
+  await expect(lines.getByRole('link', { name: 'Organic Cotton T-Shirt', exact: true })).toBeVisible();
+});
+```
+
+```bash
+npx playwright test
+```
+
+`--static` reads the files once, `--strict` refuses to start on store data with errors, and
+port `9393` keeps the tests away from your dev server on `9292`.
+
+## 5. Run it in CI
+
+Commit `package.json`, `package-lock.json` and `shopify-local/`.
+
+```yaml
+# .github/workflows/storefront.yml
+name: storefront
+on: [push, pull_request]
+jobs:
+  storefront:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
+        with:
+          node-version: 24
+          cache: npm
+      - run: npm ci
+      - run: npx local-storefront validate --format github
+      - run: npx local-storefront check --format github
+      # - run: npx local-storefront fmt --check   # once the theme is formatted
+      - name: Render every page, and fail on a Liquid error
+        run: |
+          npx local-storefront routes --all > routes.txt
+          failed=0
+          while read -r route; do
+            npx local-storefront render "$route" --strict --format github > /dev/null || failed=1
+          done < routes.txt
+          exit $failed
+      - run: npx playwright install --with-deps chromium
+      - run: npx playwright test
+```
+
+`--format github` shows each problem on its line of the pull request. `routes --all` lists
+every page, each again in the other languages of the store, a search, and the sections the
+theme fetches (product recommendations, predictive search). The step stops at once if `routes`
+cannot run (a wrong `--theme`), then renders every route, and fails at the end if one of them
+has a Liquid error or is the theme's 404.
+
+## What `shopify theme dev` does that lsf does not
+
+- **The theme editor.** There is none: edit the JSON templates and `config/settings_data.json`
+  by hand. `request.design_mode` is always `false`.
+- **A real store.** The products, customers and orders are your JSON files, not a development
+  store's. Nothing is uploaded, and there is no `theme push` or `theme pull`.
+- **Shopify's checkout.** Without an app, `/checkout` sums up the cart.
+- **Theme Check's other rules** (performance, accessibility, deprecated tags): use
+  `shopify theme check` for those.
+
+## Next
+
+- [Data format](data-format.md): products, customers, menus, metafields, markets.
+- [Testing](testing.md): sessions, data for one test, slow networks.
+- [Strict Liquid](strict-liquid.md), [formatting](formatting.md), [performance](performance.md).
+- [Storefront](storefront.md): accounts, the password page, theme app extensions.
+- [CLI reference](cli.md): every option and exit code.