@crvouga/mockingbird-service-shopify 0.0.0-stage → 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog — @crvouga/mockingbird-service-shopify
+
+## 0.0.1 (2026-11-15)
+
+Initial release.

package/DISCOVERY.md

@@ -0,0 +1,107 @@
+# @crvouga/mockingbird-service-shopify discovery
+
+This is the installed-package index for coding agents and tooling. All relative links resolve
+inside `node_modules/@crvouga/mockingbird-service-shopify/`; no repository checkout is needed to discover the emulator's
+supported surface or documented behavior.
+
+## Run it in a fleet
+
+The recommended way to run this emulator is in a fleet, next to the other emulators the
+application calls: one `mockingbird.json`, one process, each emulator on its own port.
+
+```sh
+npm install -D @crvouga/mockingbird-fleet @crvouga/mockingbird-service-shopify
+```
+
+`mockingbird.json` (add one entry per installed emulator; `"port": 0` picks a free port):
+
+```json
+{
+  "services": {
+    "shopify": { "port": 0 }
+  }
+}
+```
+
+```sh
+npx mockingbird-fleet serve --config mockingbird.json --dashboard --ready-file ready.json
+```
+
+Read this emulator's URL from `services.<name>.url` in `ready.json` and point the client at it.
+`adminBase` in the same file is the fleet controller, which resets, snapshots and restores every
+emulator in one call, and `dashboard` is one page with every HTTP emulator's admin UI and the
+notifications the application sent. The guide: <https://mockingbird.chrisvouga.dev/docs/fleets>. The README covers running this
+emulator alone or in-process.
+
+## Capability and behavior sources
+
+| Question | Authoritative file | What it contains |
+| --- | --- | --- |
+| Behaviour and integration | [`README.md`](README.md) | Routes, state transitions, auth, webhooks, controls, presets and deliberate omissions. |
+| Exact capabilities | [`SUPPORT.md`](SUPPORT.md) | Supported, unsupported and parity-covered operations or commands, including reasons for gaps. |
+| Wire contract | [`openapi.yaml`](openapi.yaml) | Machine-readable paths, methods, schemas, responses and parity annotations. |
+| Public API | [`dist/index.d.ts`](dist/index.d.ts) | The installed package's exact TypeScript exports and signatures. |
+| Package metadata | [`package.json`](package.json) | Runtime/entry-point claims, vendor links, parity scope/tier and `mockingbird.discovery`. |
+
+Read these together: the contract/capability matrix says *what* is available, while the README
+defines stateful behavior, lifecycle rules, test controls, and intentional oracle differences.
+If prose and an executable surface disagree, report a parity mismatch instead of adding a
+consumer-side workaround.
+
+## Parity and oracle
+
+- Declared parity surface: **Admin GraphQL orders, metafields, and webhook subscriptions**.
+- Parity tier: **cold** (the repository controls when live checks run).
+- Oracle: **Live vendor API or sandbox**.
+- Repository command: `bun run parity:service -- shopify`.
+- Evidence model: Run from a Mockingbird checkout; credentials come only from .env.local or GitHub Actions secrets. Missing credentials exit 2.
+
+The npm package contains evidence summaries and the exact contract, not credentials or the
+repository-only parity harness. Self-parity/property and acceptance tests run in the Mockingbird
+repository; live parity is an additional oracle check, not a substitute for the packaged matrix.
+
+## Runtime introspection
+
+- `GET /__admin/health`
+- `GET /__admin`
+- `GET /__admin/controls`
+- `GET /__admin/state`
+- `GET /__admin/requests`
+- `GET /__admin/metrics`
+- `GET /__admin/faults/presets`
+- `GET /__admin/ui`
+
+For HTTP services, use `x-mockingbird-namespace` (or the documented credential/path carrier) so
+parallel tests do not share state. Admin state, journal, metrics and fault-preset endpoints are
+designed for assertions and diagnosis by consuming test suites.
+
+## Admin controls
+
+Every HTTP emulator takes the same controls, and each means the same thing at boot
+(`createRuntime({ adminControls })`, `serve --admin-controls`), over `/__admin`, and in a request header:
+
+| Control | Admin API | Request header | Interface |
+| --- | --- | --- | --- |
+| Isolate state by key | `GET /__admin/namespaces` | `x-mockingbird-namespace: <key>` | [Namespaces](https://mockingbird.chrisvouga.dev/docs/admin-controls/namespaces) |
+| Reset to boot | `POST /__admin/reset` | `x-mockingbird-reset: true` | [Reset](https://mockingbird.chrisvouga.dev/docs/admin-controls/reset) |
+| Snapshot and restore | `POST /__admin/snapshots`, `POST /__admin/snapshots/<id>/restore` | `x-mockingbird-snapshot: <name>`, `x-mockingbird-restore: <name>` | [Snapshot and restore](https://mockingbird.chrisvouga.dev/docs/admin-controls/snapshot-and-restore) |
+| Move the clock | `POST /__admin/clock` | `x-mockingbird-time: <instant>`, `x-mockingbird-advance: <duration>` | [Clock](https://mockingbird.chrisvouga.dev/docs/admin-controls/clock) |
+| Read or branch from old state | `GET /__admin/timeline` | `x-mockingbird-at: <checkpoint>`, `x-mockingbird-branch: <name>` | [Checkpoints and branches](https://mockingbird.chrisvouga.dev/docs/admin-controls/checkpoints-and-branches) |
+| Inject a fault | `POST /__admin/faults` | `x-mockingbird-fault: <fault>` | [Faults](https://mockingbird.chrisvouga.dev/docs/admin-controls/faults) |
+| Latency and timeouts | `PUT /__admin/latency` | `x-mockingbird-delay: <duration>`, `x-mockingbird-timeout: <duration>` | [Latency and timeouts](https://mockingbird.chrisvouga.dev/docs/admin-controls/latency-and-timeouts) |
+| Replay from a seed | `PUT /__admin/controls` | `x-mockingbird-seed: <seed>` | [Seed and determinism](https://mockingbird.chrisvouga.dev/docs/admin-controls/seed-and-determinism) |
+| See what happened | `GET /__admin/requests`, `GET /__admin/state` | | [Journal, metrics and state](https://mockingbird.chrisvouga.dev/docs/admin-controls/journal-and-state) |
+
+`GET /__admin` lists every route and header with a one-line summary, and `GET /__admin/controls`
+is the namespace's current control document. The same seed and the same requests give the same
+bytes. Setting controls as an emulator starts is [Boot](https://mockingbird.chrisvouga.dev/docs/admin-controls/boot); every route and header is in
+the [Reference](https://mockingbird.chrisvouga.dev/docs/admin-controls/reference). The full guide: <https://mockingbird.chrisvouga.dev/docs/admin-controls>.
+
+## Report a mismatch or missing capability
+
+Follow the [agent reporting contract](https://github.com/crvouga/mockingbird/blob/main/docs/REPORTING_ISSUES.md). Include package version,
+operation/command, a minimal redacted request, actual emulator result, expected oracle result or vendor
+documentation, and whether the mismatch appears in the matrix. Never include keys, tokens,
+customer data, prompts, PHI, card data, or unredacted recordings.
+
+Service key: `shopify`.

package/README.md

@@ -1,3 +1,170 @@
-# Temporary Holding Version
+# @crvouga/mockingbird-service-shopify
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> Local emulators. Real API contracts. Part of [Mockingbird](https://github.com/crvouga/mockingbird).
+
+Stateful emulator of the Shopify Admin GraphQL API for a backend that fulfils orders through
+Shopify: it creates orders (directly or through draft orders), reads their fulfilment status and
+tracking, looks up product variants, sets metafields and manages webhook subscriptions. Order and
+fulfilment webhooks go to the store's own subscriptions, signed with `X-Shopify-Hmac-Sha256`.
+Status: **wip**.
+
+## Install
+
+```bash
+npm install -D @crvouga/mockingbird-service-shopify
+```
+
+ESM only. Node >= 22 or Bun >= 1.2. Serve with `npx mockingbird-shopify serve`, `createServer`
+from `./server`, or mount `createRuntime()` in any Fetch-compatible process.
+
+## Usage
+
+Shopify's official [`@shopify/admin-api-client`](https://www.npmjs.com/package/@shopify/admin-api-client)
+always calls `https://<storeDomain>`, so point its `customFetchApi` at the emulator. Any non-empty
+`X-Shopify-Access-Token` authenticates unless `PUT /__admin/settings {"accessTokens": [...]}`
+restricts it.
+
+```ts
+import { createAdminApiClient } from "@shopify/admin-api-client"
+import { createServer } from "@crvouga/mockingbird-service-shopify/server"
+
+const server = await createServer()
+const storeDomain = "mockingbird-test.myshopify.com"
+
+// The application's own client. Only the transport changes: requests to the store go to the
+// emulator instead of Shopify.
+const shopify = createAdminApiClient({
+  storeDomain,
+  apiVersion: "2026-10",
+  accessToken: "shpat_test",
+  customFetchApi: (url, init) => fetch(url.replace(`https://${storeDomain}`, server.url), init),
+})
+
+const { data } = await shopify.request(
+  `mutation Create($order: OrderCreateOrderInput!) {
+    orderCreate(order: $order) {
+      order { id name displayFulfillmentStatus }
+      userErrors { field message code }
+    }
+  }`,
+  {
+    variables: {
+      order: {
+        email: "buyer@example.test",
+        lineItems: [{ variantId: "gid://shopify/ProductVariant/41000000001", quantity: 1 }],
+      },
+    },
+  },
+)
+console.log(data.orderCreate.order)
+// → {id: "gid://shopify/Order/5000000001", name: "#1001", displayFulfillmentStatus: "UNFULFILLED"}
+
+// Test setup: mark the order shipped, as the warehouse would.
+await fetch(`${server.url}/__admin/orders/5000000001/fulfill`, {
+  method: "POST",
+  headers: { "content-type": "application/json" },
+  body: JSON.stringify({ trackingCompany: "UPS", trackingNumber: "1Z0000000000000001" }),
+})
+
+await server.close()
+```
+
+With plain `fetch`, call `POST ${server.url}/admin/api/2026-10/graphql.json` with
+`X-Shopify-Access-Token` and a `{query, variables}` body.
+
+### GraphQL surface
+
+`POST /admin/api/{version}/graphql.json` executes any document that validates against the subset
+schema (`SHOPIFY_SDL`, with Shopify's own type, field, enum and input names) using the reference
+`graphql` implementation, so aliases, fragments, variables and validation errors behave like the
+real API. `version` is a quarterly version (`2026-10`) or `unstable`.
+
+| Field | Behaviour |
+| --- | --- |
+| `shop` | The store's name, `myshopifyDomain` and currency (settings). |
+| `orderCreate(order, options)` | Line items reference a `variantId` (price from the variant unless `priceSet` overrides it) or are custom (`title` + `priceSet`). Stores email, phone, note, tags, currency, `financialStatus` (default `PAID`), shipping address and metafields; the order starts `UNFULFILLED`, named `#1001`, `#1002`, …. Problems come back as `userErrors { field message code }` (`["order", "lineItems", "0", "variantId"]` / `NOT_FOUND`, an empty or non-positive line `BLANK`/`INVALID`) and nothing is stored. Announces `orders/create`. |
+| `draftOrderCreate(input)` | An `OPEN` draft (`#D1`, …) with variant or custom (`originalUnitPrice`) lines and metafields. |
+| `draftOrderComplete(id, paymentPending, sourceName)` | Turns the draft into an order (`PAID`, or `PENDING` with `paymentPending: true`), sets `status: COMPLETED` and `order`. Completing twice, or an unknown draft, is a `userError`. |
+| `order(id)` / `draftOrder(id)` | `displayFulfillmentStatus`, `displayFinancialStatus`, `cancelledAt`, `cancelReason`, prices (`totalPriceSet`), `lineItems`, `fulfillments { status displayStatus trackingInfo { company number url } }`, `shippingAddress`, `metafield(namespace, key)` and `metafields`. A malformed gid is a GraphQL error (`Invalid global id`); an unknown one is `null`. |
+| `productVariants(first/last, after/before, query, reverse)` / `productVariant(id)` | The seeded catalogue. `query` takes `sku:`, `product_id:`, `title:`, `barcode:`, `id:` and free text; another search field is an explicit `MOCKINGBIRD_UNSUPPORTED` GraphQL error. |
+| `metafieldsSet(metafields)` | Upserts by owner + namespace + key on orders, draft orders, products and variants. At most 25 per call. Validates `single_line_text_field`, `multi_line_text_field`, `number_integer`, `number_decimal`, `boolean`, `date`, `date_time`, `url` and `json` values; any error (with `elementIndex`) rejects the whole call. A missing namespace is the app-reserved `app--<appId>`. |
+| `webhookSubscriptionCreate(topic, webhookSubscription)` / `webhookSubscriptionDelete(id)` / `webhookSubscriptions(…)` / `webhookSubscription(id)` | Topics `ORDERS_CREATE`, `ORDERS_FULFILLED`, `ORDERS_CANCELLED`, `FULFILLMENTS_CREATE`, `FULFILLMENTS_UPDATE`. `callbackUrl` (or `uri`) must be an http(s) URL; the same topic and address twice answers `Address for this topic has already been taken`. `includeFields` trims the delivered body. Filters `topics` and `callbackUrl`. |
+
+Connections require `first` or `last` (at most 250) and page with opaque cursors. Every response
+carries `extensions.cost` (`requestedQueryCost`, `actualQueryCost`, `throttleStatus`).
+
+A missing or unknown token answers HTTP 401
+`{"errors": "[API] Invalid API key or access token (unrecognized login or wrong password)"}`; a
+body without `query` answers 400 `{"errors": {"query": "Required parameter missing or invalid"}}`.
+
+Seed fixtures: products `gid://shopify/Product/7000000001` (Mockingbird Tee; variants
+`…/ProductVariant/41000000001` `MB-TEE-S` and `…/41000000002` `MB-TEE-M`, 25.00) and
+`…/Product/7000000002` (Mockingbird Mug; variant `…/41000000003` `MB-MUG`, 12.50).
+
+### Webhooks
+
+Webhooks are delivered to the subscriptions the application creates with
+`webhookSubscriptionCreate`, as Shopify's REST JSON (`snake_case` order or fulfilment bodies with
+`admin_graphql_api_id`). Each delivery carries `X-Shopify-Topic`, `X-Shopify-Hmac-Sha256` (base64
+HMAC-SHA256 of the raw body under the app's client secret, setting `apiSecret`, default
+`mockingbird_shopify_api_secret`), `X-Shopify-Shop-Domain`, `X-Shopify-API-Version` (the version
+the subscription was created with), `X-Shopify-Webhook-Id`, `X-Shopify-Event-Id` and
+`X-Shopify-Triggered-At`.
+
+| Topic | When |
+| --- | --- |
+| `orders/create` | `orderCreate`, `draftOrderComplete` |
+| `fulfillments/create`, then `orders/fulfilled` | `POST /__admin/orders/:id/fulfill` |
+| `fulfillments/update` | `POST /__admin/fulfillments/:id/update` |
+| `orders/cancelled` | `POST /__admin/orders/:id/cancel` |
+
+An endpoint added with `PUT /__admin/webhook-endpoints` also receives a copy of each delivery.
+`GET /__admin/webhooks/events`, replay, flush and the delivery-fault presets work as for every
+emulator.
+
+### Admin controls
+
+| Route | Effect |
+| --- | --- |
+| `POST /__admin/orders/:id/fulfill` `{trackingCompany?, trackingNumber?, trackingUrl?}` | Fulfils every line (`displayFulfillmentStatus: FULFILLED`), records a `SUCCESS` fulfilment with its tracking. `:id` is the numeric id or the URL-encoded gid. 409 when cancelled or already fulfilled. |
+| `POST /__admin/fulfillments/:id/update` `{displayStatus?, trackingCompany?, trackingNumber?, trackingUrl?}` | Moves the shipment (`IN_TRANSIT`, `OUT_FOR_DELIVERY`, `DELIVERED`, …) or replaces its tracking. |
+| `POST /__admin/orders/:id/cancel` `{reason?}` | Cancels an unfulfilled order (`CUSTOMER`, `DECLINED`, `FRAUD`, `INVENTORY`, `STAFF`, `OTHER`; default `OTHER`). |
+| `GET /__admin/orders/:id` | The order as its webhook body renders it. |
+| `POST /__admin/fail-next-mutation` `{"kind": "userErrors", message?, field?, code?}` or `{"kind": "throttled"}` | The next mutation document (queries are unaffected) answers that `userError` on every mutation field, or the `THROTTLED` error, without changing state. |
+| `GET/PUT /__admin/settings` | `accessTokens`, `apiSecret`, `shopName`, `shopDomain`, `currency`, `appId`. |
+
+Presets (`POST /__admin/faults {"preset": "<name>", "count"?: n}`): `throttled` (HTTP 200,
+`errors[{message: "Throttled", extensions: {code: "THROTTLED"}}]`, `actualQueryCost: null`),
+`invalid_access_token` (401), `server_error` (500), `webhook_duplicate`, `webhook_reorder` and
+`webhook_drop`, plus the standard ones.
+
+Namespaces use `x-mockingbird-namespace`, `/__admin/ns/<name>/admin/api/…`, or the access token
+through `PUT /__admin/credentials {"credentials": {"<token>": "<namespace>"}}`.
+
+## API
+
+The main entry exports `ShopifyAPI`, `ShopifyState`, `createRuntime`, `SHOPIFY_NAMESPACE`,
+`SHOPIFY_PRESETS`, `SHOPIFY_SDL`, `shopifySchema`, `DEFAULT_SETTINGS`, `ACCESS_TOKEN_HEADER`,
+`THROTTLE_STATUS`, `accessTokenOf`, `shopifyTimestamp`, `signWebhook`, `gid`, `parseGid`,
+`restOrder`, `restFulfillment`, `restTopic`, the generated `document`, `operationIds` and
+`supportedOperationIds`, and the record, settings and option types.
+`@crvouga/mockingbird-service-shopify/server` exports `createServer`, `serveTarget`,
+`DEFAULT_PORT`, and the server option/result types.
+
+## Deliberately not modelled
+
+- Every behaviour above is a **best guess from Shopify's Admin GraphQL documentation, not
+  oracle-verified** against a development store: the exact `userErrors` messages and codes, the
+  default `financialStatus` of `orderCreate`, and the query cost numbers in particular.
+- Query cost calculation and the leaky bucket: the cost is 1 per query field and 10 per mutation
+  field, and the bucket is never drained; use the `throttled` preset or
+  `POST /__admin/fail-next-mutation` to exercise throttling.
+- Payments, transactions, refunds, inventory reservation, taxes, discounts, shipping lines,
+  customers, and fulfilment orders or fulfilment services; fulfilments are created only through
+  the admin control, never by a mutation.
+- Webhook topics other than the five above, XML webhooks (an explicit `MOCKINGBIRD_UNSUPPORTED`
+  error), Pub/Sub and EventBridge endpoints, and HMAC verification of the app's own OAuth flow.
+  Shopify requires `https` callback addresses; the emulator also accepts `http` so a local
+  receiver works.
+- The REST Admin API, the Storefront API, bulk operations and GraphQL subscriptions.
+- Metafield definitions, `compareDigest`, and list or reference metafield types.

package/SUPPORT.md

@@ -0,0 +1,11 @@
+# Shopify Admin GraphQL API (Mockingbird subset) — operation support
+
+Generated from `openapi.yaml`; do not edit by hand.
+
+- operations in spec: **1**
+- supported by the emulator: **1**
+- parity enabled: **1**
+
+| operationId | route | emulator | parity | notes |
+| --- | --- | --- | --- | --- |
+| `AdminGraphql` | `POST /admin/api/{version}/graphql.json` | ✅ supported | ⚠️ unsafe (opt-in) | Creates orders and webhook subscriptions in the store |

package/dist/chunk-DQ2XG467.js

@@ -0,0 +1,67 @@
+import {
+  createRuntime
+} from "./chunk-GSVXSSVL.js";
+
+// src/server.ts
+import { listen } from "@crvouga/mockingbird-runtime/adapter-node";
+var DEFAULT_PORT = 12159;
+var createServer = async (options = {}) => {
+  const { port, host, ...rest } = options;
+  const runtime = createRuntime(rest);
+  const listening = await listen(runtime, {
+    port: port ?? 0,
+    ...host !== void 0 ? { host } : {}
+  });
+  return { ...listening, runtime };
+};
+var text = (value) => typeof value === "string" ? value : void 0;
+var serveTarget = {
+  name: "shopify",
+  defaultPort: DEFAULT_PORT,
+  options: {
+    "access-token": {
+      type: "string",
+      value: "<token>",
+      description: "The only X-Shopify-Access-Token to accept (default: any non-empty token)"
+    },
+    "api-secret": {
+      type: "string",
+      value: "<secret>",
+      description: "The app's client secret: the X-Shopify-Hmac-Sha256 key for webhooks"
+    },
+    "shop-domain": {
+      type: "string",
+      value: "<shop>.myshopify.com",
+      description: "Sent as X-Shopify-Shop-Domain and returned by shop { myshopifyDomain }"
+    }
+  },
+  create: (values, common) => {
+    const token = text(values["access-token"]);
+    const secret = text(values["api-secret"]);
+    const domain = text(values["shop-domain"]);
+    return createRuntime({
+      settings: {
+        ...token ? { accessTokens: [token] } : {},
+        ...secret ? { apiSecret: secret } : {},
+        ...domain ? { shopDomain: domain } : {}
+      },
+      ...common.adminPrefix !== void 0 ? { adminPrefix: common.adminPrefix } : {},
+      ...common.adminKey !== void 0 ? { adminKey: common.adminKey } : {},
+      ...common.adminControls !== void 0 ? { adminControls: common.adminControls } : {},
+      ...common.seed !== void 0 ? { seed: common.seed } : {},
+      ...common.onLog ? { onLog: common.onLog } : {}
+    });
+  },
+  banner: () => [
+    "GraphQL: POST /admin/api/<version>/graphql.json with X-Shopify-Access-Token",
+    "webhooks: webhookSubscriptionCreate, signed with X-Shopify-Hmac-Sha256 (--api-secret)",
+    "namespaces: x-mockingbird-namespace, /__admin/ns/<name>/admin/api/\u2026, or PUT /__admin/credentials {<token>: <ns>}"
+  ]
+};
+
+export {
+  DEFAULT_PORT,
+  createServer,
+  serveTarget
+};
+//# sourceMappingURL=chunk-DQ2XG467.js.map

package/dist/chunk-DQ2XG467.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/server.ts"],
+  "sourcesContent": ["/// <reference types=\"node\" />\nimport { type Listening, listen, type ServeTarget } from \"@crvouga/mockingbird-adapter-node\"\nimport { createRuntime, type ShopifyRuntime, type ShopifyRuntimeOptions } from \"./runtime.js\"\n\n/** Port `mockingbird-shopify serve` listens on when none is given. */\nexport const DEFAULT_PORT = 12159\n\nexport type ShopifyServerOptions = ShopifyRuntimeOptions & {\n  /** Default `0`: the OS picks a free port. */\n  port?: number\n  /** Default `127.0.0.1`. */\n  host?: string\n}\n\nexport type ShopifyServer = Listening & { runtime: ShopifyRuntime }\n\n/** Serve the Shopify Admin GraphQL emulator over `node:http`. */\nexport const createServer = async (options: ShopifyServerOptions = {}): Promise<ShopifyServer> => {\n  const { port, host, ...rest } = options\n  const runtime = createRuntime(rest)\n  const listening = await listen(runtime, {\n    port: port ?? 0,\n    ...(host !== undefined ? { host } : {}),\n  })\n  return { ...listening, runtime }\n}\n\nconst text = (value: string | boolean | undefined) =>\n  typeof value === \"string\" ? value : undefined\n\n/** How `serve` (and `serve --config`) builds the Shopify emulator from flags. */\nexport const serveTarget: ServeTarget = {\n  name: \"shopify\",\n  defaultPort: DEFAULT_PORT,\n  options: {\n    \"access-token\": {\n      type: \"string\",\n      value: \"<token>\",\n      description: \"The only X-Shopify-Access-Token to accept (default: any non-empty token)\",\n    },\n    \"api-secret\": {\n      type: \"string\",\n      value: \"<secret>\",\n      description: \"The app's client secret: the X-Shopify-Hmac-Sha256 key for webhooks\",\n    },\n    \"shop-domain\": {\n      type: \"string\",\n      value: \"<shop>.myshopify.com\",\n      description: \"Sent as X-Shopify-Shop-Domain and returned by shop { myshopifyDomain }\",\n    },\n  },\n  create: (values, common) => {\n    const token = text(values[\"access-token\"])\n    const secret = text(values[\"api-secret\"])\n    const domain = text(values[\"shop-domain\"])\n    return createRuntime({\n      settings: {\n        ...(token ? { accessTokens: [token] } : {}),\n        ...(secret ? { apiSecret: secret } : {}),\n        ...(domain ? { shopDomain: domain } : {}),\n      },\n      ...(common.adminPrefix !== undefined ? { adminPrefix: common.adminPrefix } : {}),\n      ...(common.adminKey !== undefined ? { adminKey: common.adminKey } : {}),\n      ...(common.adminControls !== undefined ? { adminControls: common.adminControls } : {}),\n      ...(common.seed !== undefined ? { seed: common.seed } : {}),\n      ...(common.onLog ? { onLog: common.onLog } : {}),\n    })\n  },\n  banner: () => [\n    \"GraphQL: POST /admin/api/<version>/graphql.json with X-Shopify-Access-Token\",\n    \"webhooks: webhookSubscriptionCreate, signed with X-Shopify-Hmac-Sha256 (--api-secret)\",\n    \"namespaces: x-mockingbird-namespace, /__admin/ns/<name>/admin/api/\u2026, or PUT /__admin/credentials {<token>: <ns>}\",\n  ],\n}\n"],
+  "mappings": ";;;;;AACA,SAAyB,cAAgC;AAIlD,IAAM,eAAe;AAYrB,IAAM,eAAe,OAAO,UAAgC,CAAC,MAA8B;AAChG,QAAM,EAAE,MAAM,MAAM,GAAG,KAAK,IAAI;AAChC,QAAM,UAAU,cAAc,IAAI;AAClC,QAAM,YAAY,MAAM,OAAO,SAAS;AAAA,IACtC,MAAM,QAAQ;AAAA,IACd,GAAI,SAAS,SAAY,EAAE,KAAK,IAAI,CAAC;AAAA,EACvC,CAAC;AACD,SAAO,EAAE,GAAG,WAAW,QAAQ;AACjC;AAEA,IAAM,OAAO,CAAC,UACZ,OAAO,UAAU,WAAW,QAAQ;AAG/B,IAAM,cAA2B;AAAA,EACtC,MAAM;AAAA,EACN,aAAa;AAAA,EACb,SAAS;AAAA,IACP,gBAAgB;AAAA,MACd,MAAM;AAAA,MACN,OAAO;AAAA,MACP,aAAa;AAAA,IACf;AAAA,IACA,cAAc;AAAA,MACZ,MAAM;AAAA,MACN,OAAO;AAAA,MACP,aAAa;AAAA,IACf;AAAA,IACA,eAAe;AAAA,MACb,MAAM;AAAA,MACN,OAAO;AAAA,MACP,aAAa;AAAA,IACf;AAAA,EACF;AAAA,EACA,QAAQ,CAAC,QAAQ,WAAW;AAC1B,UAAM,QAAQ,KAAK,OAAO,cAAc,CAAC;AACzC,UAAM,SAAS,KAAK,OAAO,YAAY,CAAC;AACxC,UAAM,SAAS,KAAK,OAAO,aAAa,CAAC;AACzC,WAAO,cAAc;AAAA,MACnB,UAAU;AAAA,QACR,GAAI,QAAQ,EAAE,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC;AAAA,QACzC,GAAI,SAAS,EAAE,WAAW,OAAO,IAAI,CAAC;AAAA,QACtC,GAAI,SAAS,EAAE,YAAY,OAAO,IAAI,CAAC;AAAA,MACzC;AAAA,MACA,GAAI,OAAO,gBAAgB,SAAY,EAAE,aAAa,OAAO,YAAY,IAAI,CAAC;AAAA,MAC9E,GAAI,OAAO,aAAa,SAAY,EAAE,UAAU,OAAO,SAAS,IAAI,CAAC;AAAA,MACrE,GAAI,OAAO,kBAAkB,SAAY,EAAE,eAAe,OAAO,cAAc,IAAI,CAAC;AAAA,MACpF,GAAI,OAAO,SAAS,SAAY,EAAE,MAAM,OAAO,KAAK,IAAI,CAAC;AAAA,MACzD,GAAI,OAAO,QAAQ,EAAE,OAAO,OAAO,MAAM,IAAI,CAAC;AAAA,IAChD,CAAC;AAAA,EACH;AAAA,EACA,QAAQ,MAAM;AAAA,IACZ;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;",
+  "names": []
+}