@foir/sdk 0.1.0

package/dist/auth.js

@@ -0,0 +1,309 @@
+// src/graphql/foir-request.ts
+import { print } from "graphql";
+function isFoirPreview(env) {
+  return env.FOIR_PREVIEW === "true";
+}
+var FoirRequestError = class extends Error {
+  /** HTTP status code, when the request failed at the HTTP layer. */
+  status;
+  /** GraphQL errors, when the request failed with a no-data error envelope. */
+  graphQLErrors;
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = "FoirRequestError";
+    this.cause = options?.cause;
+    this.status = options?.status;
+    this.graphQLErrors = options?.graphQLErrors;
+  }
+};
+async function foirRequest(env, document, variables, options) {
+  const endpoint = env.PLATFORM_API_URL;
+  const apiKey = isFoirPreview(env) ? env.PLATFORM_PREVIEW_API_KEY ?? env.PLATFORM_API_KEY : env.PLATFORM_API_KEY;
+  if (!endpoint || !apiKey) {
+    throw new FoirRequestError(
+      "[foir] PLATFORM_API_URL or PLATFORM_API_KEY is not set \u2014 add them to .env"
+    );
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    "x-api-key": apiKey
+  };
+  if (isFoirPreview(env)) {
+    headers["X-Foir-Schema-Channel"] = "draft";
+  }
+  if (options?.bearerToken) {
+    headers["Authorization"] = `Bearer ${options.bearerToken}`;
+  }
+  let res;
+  try {
+    res = await fetch(endpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query: print(document), variables })
+    });
+  } catch (err) {
+    throw new FoirRequestError("[foir] network error", { cause: err });
+  }
+  if (!res.ok) {
+    throw new FoirRequestError(`[foir] HTTP ${res.status} ${res.statusText}`, {
+      status: res.status
+    });
+  }
+  const json = await res.json();
+  if (json.errors?.length) {
+    const msg = json.errors.map((e) => e.message).join("; ");
+    if (json.data) {
+      console.warn(`[foir] GraphQL partial errors (data returned): ${msg}`);
+    } else {
+      throw new FoirRequestError(`[foir] GraphQL errors: ${msg}`, {
+        graphQLErrors: json.errors
+      });
+    }
+  }
+  if (!json.data) {
+    throw new FoirRequestError("[foir] empty GraphQL response");
+  }
+  return json.data;
+}
+
+// src/auth/operations.ts
+import { parse } from "graphql";
+var AUTH_RESULT_FIELDS = "token refreshToken customerId email";
+var CustomerLoginDocument = parse(
+  `mutation CustomerLogin($email: String!, $password: String!) {
+    customerLogin(email: $email, password: $password) { ${AUTH_RESULT_FIELDS} }
+  }`
+);
+var CustomerRegisterDocument = parse(
+  `mutation CustomerRegister($email: String!, $password: String!) {
+    customerRegister(email: $email, password: $password) { ${AUTH_RESULT_FIELDS} }
+  }`
+);
+var CustomerRefreshTokenDocument = parse(
+  `mutation CustomerRefreshToken($refreshToken: String!) {
+    customerRefreshToken(refreshToken: $refreshToken) { ${AUTH_RESULT_FIELDS} }
+  }`
+);
+var CustomerRequestOTPDocument = parse(
+  `mutation CustomerRequestOTP($email: String!) {
+    customerRequestOTP(email: $email)
+  }`
+);
+var CustomerLoginOTPDocument = parse(
+  `mutation CustomerLoginOTP($email: String!, $otp: String!) {
+    customerLoginOTP(email: $email, otp: $otp) { ${AUTH_RESULT_FIELDS} }
+  }`
+);
+var CustomerLoginWithProviderDocument = parse(
+  `mutation CustomerLoginWithProvider($input: ProviderLoginInput!) {
+    customerLoginWithProvider(input: $input) { redirectUrl token }
+  }`
+);
+var CustomerProviderCallbackDocument = parse(
+  `mutation CustomerProviderCallback($input: ProviderCallbackInput!) {
+    customerProviderCallback(input: $input) { ${AUTH_RESULT_FIELDS} }
+  }`
+);
+var CustomerProviderVerifyOTPDocument = parse(
+  `mutation CustomerProviderVerifyOTP($input: ProviderOTPVerifyInput!) {
+    customerProviderVerifyOTP(input: $input) { ${AUTH_RESULT_FIELDS} }
+  }`
+);
+var AuthProvidersDocument = parse(
+  `query AuthProviders {
+    authProviders { key name type isDefault }
+  }`
+);
+
+// src/auth/auth.ts
+var TOKEN_KEY = "foir:token";
+var REFRESH_KEY = "foir:refreshToken";
+var CUSTOMER_ID_KEY = "foir:customerId";
+var EMAIL_KEY = "foir:email";
+async function customerLogin(env, vars) {
+  return (await foirRequest(env, CustomerLoginDocument, vars)).customerLogin;
+}
+async function customerRegister(env, vars) {
+  return (await foirRequest(env, CustomerRegisterDocument, vars)).customerRegister;
+}
+async function customerRequestOTP(env, email) {
+  return (await foirRequest(env, CustomerRequestOTPDocument, { email })).customerRequestOTP;
+}
+async function customerLoginOTP(env, vars) {
+  return (await foirRequest(env, CustomerLoginOTPDocument, vars)).customerLoginOTP;
+}
+async function customerRefreshToken(env, refreshToken) {
+  return (await foirRequest(env, CustomerRefreshTokenDocument, { refreshToken })).customerRefreshToken;
+}
+async function customerLoginWithProvider(env, input) {
+  return (await foirRequest(env, CustomerLoginWithProviderDocument, { input })).customerLoginWithProvider;
+}
+async function customerProviderCallback(env, input) {
+  return (await foirRequest(env, CustomerProviderCallbackDocument, { input })).customerProviderCallback;
+}
+async function customerProviderVerifyOTP(env, input) {
+  return (await foirRequest(env, CustomerProviderVerifyOTPDocument, { input })).customerProviderVerifyOTP;
+}
+async function getAuthProviders(env) {
+  return (await foirRequest(env, AuthProvidersDocument, {})).authProviders;
+}
+async function saveSession(adapter, result) {
+  await adapter.set(TOKEN_KEY, result.token);
+  await adapter.set(REFRESH_KEY, result.refreshToken);
+  await adapter.set(CUSTOMER_ID_KEY, result.customerId);
+  await adapter.set(EMAIL_KEY, result.email);
+  return { id: result.customerId, email: result.email };
+}
+async function clearSession(adapter) {
+  await adapter.unset(TOKEN_KEY);
+  await adapter.unset(REFRESH_KEY);
+  await adapter.unset(CUSTOMER_ID_KEY);
+  await adapter.unset(EMAIL_KEY);
+}
+async function getSessionToken(adapter) {
+  return await adapter.get(TOKEN_KEY) ?? null;
+}
+async function getSessionCustomer(adapter) {
+  const id = await adapter.get(CUSTOMER_ID_KEY) ?? null;
+  const email = await adapter.get(EMAIL_KEY) ?? null;
+  if (!id) return null;
+  return { id, email: email ?? "" };
+}
+async function loginWithPassword(adapter, env, vars) {
+  return saveSession(adapter, await customerLogin(env, vars));
+}
+async function registerWithPassword(adapter, env, vars) {
+  return saveSession(adapter, await customerRegister(env, vars));
+}
+async function loginWithOTP(adapter, env, vars) {
+  return saveSession(adapter, await customerLoginOTP(env, vars));
+}
+async function refreshSession(adapter, env) {
+  const refreshToken = await adapter.get(REFRESH_KEY) ?? null;
+  if (!refreshToken) return null;
+  try {
+    const result = await customerRefreshToken(env, refreshToken);
+    await saveSession(adapter, result);
+    return { token: result.token, refreshToken: result.refreshToken };
+  } catch {
+    await clearSession(adapter);
+    return null;
+  }
+}
+function isAuthExpiredError(err) {
+  if (!(err instanceof FoirRequestError)) return false;
+  if (err.status === 401) return true;
+  return (err.graphQLErrors ?? []).some(
+    (e) => /authentication required/i.test(e.message)
+  );
+}
+async function authedRequest(adapter, env, document, variables) {
+  const token = await getSessionToken(adapter);
+  try {
+    return await foirRequest(env, document, variables, {
+      bearerToken: token ?? void 0
+    });
+  } catch (err) {
+    if (!isAuthExpiredError(err)) throw err;
+    const refreshed = await refreshSession(adapter, env);
+    if (!refreshed) throw err;
+    return foirRequest(env, document, variables, {
+      bearerToken: refreshed.token
+    });
+  }
+}
+async function requireAuth(adapter, options) {
+  const token = await getSessionToken(adapter);
+  const customer = await getSessionCustomer(adapter);
+  if (!token || !customer) {
+    await options.onUnauthenticated();
+    throw new Error("[foir] onUnauthenticated must not return");
+  }
+  if (options.resolveUser) {
+    return options.resolveUser({ token, customer });
+  }
+  return { id: customer.id, email: customer.email, isAdmin: false };
+}
+async function requireAdmin(adapter, options) {
+  const user = await requireAuth(adapter, options);
+  if (!user.isAdmin) {
+    await options.onForbidden();
+    throw new Error("[foir] onForbidden must not return");
+  }
+  return user;
+}
+
+// src/auth/hosted.ts
+var DEFAULT_COOKIE_NAME = "foir_customer_session";
+var DEFAULT_SESSION_PATH = "/session/token";
+function hostedLoginUrl(config, returnTo) {
+  const dest = new URL(config.loginOrigin);
+  if (returnTo && returnTo !== "/") {
+    dest.searchParams.set("returnTo", returnTo);
+  }
+  return dest.toString();
+}
+async function fetchHostedSession(request, config) {
+  const cookieName = config.cookieName ?? DEFAULT_COOKIE_NAME;
+  const sessionPath = config.sessionPath ?? DEFAULT_SESSION_PATH;
+  const cookie = request.headers.get("Cookie") ?? "";
+  const match = cookie.match(
+    new RegExp(`(?:^|;\\s*)${escapeRegExp(cookieName)}=([^;]+)`)
+  );
+  if (!match) return null;
+  try {
+    const res = await fetch(`${config.loginOrigin}${sessionPath}`, {
+      headers: {
+        Cookie: `${cookieName}=${match[1]}`,
+        "X-Foir-Session": "1"
+      }
+    });
+    if (!res.ok) return null;
+    const json = await res.json();
+    if (!json.access_token || !json.customer_id) return null;
+    return {
+      token: json.access_token,
+      customerId: json.customer_id,
+      email: json.email ?? ""
+    };
+  } catch {
+    return null;
+  }
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export {
+  AuthProvidersDocument,
+  CustomerLoginDocument,
+  CustomerLoginOTPDocument,
+  CustomerLoginWithProviderDocument,
+  CustomerProviderCallbackDocument,
+  CustomerProviderVerifyOTPDocument,
+  CustomerRefreshTokenDocument,
+  CustomerRegisterDocument,
+  CustomerRequestOTPDocument,
+  authedRequest,
+  clearSession,
+  customerLogin,
+  customerLoginOTP,
+  customerLoginWithProvider,
+  customerProviderCallback,
+  customerProviderVerifyOTP,
+  customerRefreshToken,
+  customerRegister,
+  customerRequestOTP,
+  fetchHostedSession,
+  getAuthProviders,
+  getSessionCustomer,
+  getSessionToken,
+  hostedLoginUrl,
+  loginWithOTP,
+  loginWithPassword,
+  refreshSession,
+  registerWithPassword,
+  requireAdmin,
+  requireAuth,
+  saveSession
+};

package/dist/chunk-ADO5FJNM.js

@@ -0,0 +1,30 @@
+// src/codegen/shared.ts
+import { isUnionType } from "graphql";
+var DEFAULT_UNIONS = ["Block"];
+var DEFAULT_GRAPHQL_IMPORT = "./graphql";
+var DEFAULT_SDK_IMPORT = "@foir/sdk/content";
+function collectBlockMembers(schema, unionNames) {
+  const members = /* @__PURE__ */ new Set();
+  const missing = [];
+  for (const name of unionNames) {
+    const type = schema.getType(name);
+    if (!type || !isUnionType(type)) {
+      missing.push(name);
+      continue;
+    }
+    for (const member of type.getTypes()) members.add(member.name);
+  }
+  if (members.size === 0) {
+    throw new Error(
+      `[foir codegen] no union members found. Looked for union(s): ${unionNames.join(", ")}` + (missing.length ? ` (not found or not a union: ${missing.join(", ")})` : "") + `. Run \`foir push\` and confirm the block union name.`
+    );
+  }
+  return [...members].sort();
+}
+
+export {
+  DEFAULT_UNIONS,
+  DEFAULT_GRAPHQL_IMPORT,
+  DEFAULT_SDK_IMPORT,
+  collectBlockMembers
+};

package/dist/client.d.ts

@@ -0,0 +1,83 @@
+import { TypedDocumentNode } from '@graphql-typed-document-node/core';
+
+/**
+ * Foir GraphQL client — a single typed fetch wrapper for SSR/edge loaders.
+ *
+ * No GraphQL client (Apollo/urql) required: the Foir public API is a plain
+ * `POST` with an `x-api-key` header, and the dominant consumers (Hydrogen on
+ * Oxygen, React Router loaders, TanStack Start on CF Workers) fetch in
+ * server-only loaders and render — so Apollo's `InMemoryCache`/`useQuery`
+ * reactivity is dead weight, and a shared cache on a stateless multi-tenant
+ * edge worker is a cross-tenant hazard. This helper carries only the
+ * Foir-specific transport concerns (auth header, preview schema channel,
+ * error shape). Consumers on a GraphQL client (Apollo / urql / react-query /
+ * graphql-request) use the generated `TypedDocumentNode`s directly with their
+ * own client and replicate the two Foir-specific headers below — the
+ * `x-api-key` and, in preview, `X-Foir-Schema-Channel: draft`.
+ *
+ * Deduplicates the hand-copied `lib/foir/client.ts` that shipped identically
+ * across the Foir storefronts.
+ */
+
+interface FoirEnv {
+    PLATFORM_API_URL?: string;
+    PLATFORM_API_KEY?: string;
+    PLATFORM_PREVIEW_API_KEY?: string;
+    FOIR_PREVIEW?: string;
+}
+/**
+ * Returns true when `FOIR_PREVIEW=true` is set in the environment.
+ *
+ * Preview is selected at the environment level, not per-request: load a
+ * preview env file that sets `FOIR_PREVIEW=true` + a `sk_…`
+ * `PLATFORM_PREVIEW_API_KEY` with `drafts:read` instead of the default env.
+ * The site-wide mode keeps draft semantics consistent — every loader sees
+ * the same preview/published view of the world. Intended for non-production
+ * surfaces only.
+ */
+declare function isFoirPreview(env: FoirEnv): boolean;
+/** Default Foir CDN origin used to absolutise relative media URLs. */
+declare const FOIR_CDN_BASE = "https://cdn.foir.dev/";
+/**
+ * Foir returns `hlsManifestUrl` as a relative path while every other media
+ * URL is absolute. Prefix relative paths with the CDN host so the browser
+ * doesn't request them from the consumer's own origin. Already-absolute URLs
+ * pass through untouched. `cdnBase` is overridable for non-default CDN hosts.
+ */
+declare function absolutiseFoirMediaUrl(url: string | null | undefined, cdnBase?: string): string | undefined;
+interface FoirGraphQLErrorItem {
+    message: string;
+    path?: Array<string | number>;
+}
+declare class FoirRequestError extends Error {
+    /** HTTP status code, when the request failed at the HTTP layer. */
+    readonly status?: number;
+    /** GraphQL errors, when the request failed with a no-data error envelope. */
+    readonly graphQLErrors?: ReadonlyArray<FoirGraphQLErrorItem>;
+    readonly cause?: unknown;
+    constructor(message: string, options?: {
+        cause?: unknown;
+        status?: number;
+        graphQLErrors?: ReadonlyArray<FoirGraphQLErrorItem>;
+    });
+}
+/**
+ * Execute a typed GraphQL document against the Foir platform.
+ *
+ * Throws `FoirRequestError` on HTTP failure or GraphQL errors so the caller
+ * can decide whether to rethrow or fall back to local defaults. GraphQL can
+ * return partial data alongside errors; when data is present the errors are
+ * logged and the data returned (callers handle nulls), and we only throw when
+ * there's no data at all.
+ */
+interface FoirRequestOptions {
+    /**
+     * Customer bearer token. api-public still needs the `x-api-key` to resolve
+     * the project; the bearer adds the customer identity for self-scoped reads
+     * (e.g. `myProfile`). Used by `@foir/sdk/auth`'s post-login profile fetch.
+     */
+    bearerToken?: string;
+}
+declare function foirRequest<TData, TVariables>(env: FoirEnv, document: TypedDocumentNode<TData, TVariables>, variables?: TVariables, options?: FoirRequestOptions): Promise<TData>;
+
+export { FOIR_CDN_BASE, type FoirEnv, FoirRequestError, type FoirRequestOptions, absolutiseFoirMediaUrl, foirRequest, isFoirPreview };

package/dist/client.js

@@ -0,0 +1,81 @@
+// src/graphql/foir-request.ts
+import { print } from "graphql";
+function isFoirPreview(env) {
+  return env.FOIR_PREVIEW === "true";
+}
+var FOIR_CDN_BASE = "https://cdn.foir.dev/";
+function absolutiseFoirMediaUrl(url, cdnBase = FOIR_CDN_BASE) {
+  if (!url) return void 0;
+  if (/^https?:\/\//i.test(url)) return url;
+  return cdnBase + url.replace(/^\/+/, "");
+}
+var FoirRequestError = class extends Error {
+  /** HTTP status code, when the request failed at the HTTP layer. */
+  status;
+  /** GraphQL errors, when the request failed with a no-data error envelope. */
+  graphQLErrors;
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = "FoirRequestError";
+    this.cause = options?.cause;
+    this.status = options?.status;
+    this.graphQLErrors = options?.graphQLErrors;
+  }
+};
+async function foirRequest(env, document, variables, options) {
+  const endpoint = env.PLATFORM_API_URL;
+  const apiKey = isFoirPreview(env) ? env.PLATFORM_PREVIEW_API_KEY ?? env.PLATFORM_API_KEY : env.PLATFORM_API_KEY;
+  if (!endpoint || !apiKey) {
+    throw new FoirRequestError(
+      "[foir] PLATFORM_API_URL or PLATFORM_API_KEY is not set \u2014 add them to .env"
+    );
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    "x-api-key": apiKey
+  };
+  if (isFoirPreview(env)) {
+    headers["X-Foir-Schema-Channel"] = "draft";
+  }
+  if (options?.bearerToken) {
+    headers["Authorization"] = `Bearer ${options.bearerToken}`;
+  }
+  let res;
+  try {
+    res = await fetch(endpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query: print(document), variables })
+    });
+  } catch (err) {
+    throw new FoirRequestError("[foir] network error", { cause: err });
+  }
+  if (!res.ok) {
+    throw new FoirRequestError(`[foir] HTTP ${res.status} ${res.statusText}`, {
+      status: res.status
+    });
+  }
+  const json = await res.json();
+  if (json.errors?.length) {
+    const msg = json.errors.map((e) => e.message).join("; ");
+    if (json.data) {
+      console.warn(`[foir] GraphQL partial errors (data returned): ${msg}`);
+    } else {
+      throw new FoirRequestError(`[foir] GraphQL errors: ${msg}`, {
+        graphQLErrors: json.errors
+      });
+    }
+  }
+  if (!json.data) {
+    throw new FoirRequestError("[foir] empty GraphQL response");
+  }
+  return json.data;
+}
+export {
+  FOIR_CDN_BASE,
+  FoirRequestError,
+  absolutiseFoirMediaUrl,
+  foirRequest,
+  isFoirPreview
+};

package/dist/codegen/block-registry.d.ts

@@ -0,0 +1,27 @@
+import { GraphQLSchema } from 'graphql';
+import { B as BlockPluginConfig } from '../shared-DkWlEd2Z.js';
+
+/**
+ * `@foir/sdk/codegen/block-registry` — a graphql-codegen plugin.
+ *
+ * Introspects the project's public schema, collects every member of the block
+ * union(s), and emits an EXHAUSTIVE `BlockRegistry` type — one key per block
+ * `__typename`, each typed `BlockComponent<ThatBlock, Ctx>`. Because the type
+ * requires every key, a project that adds an inline model (→ a new block
+ * `__typename`) breaks the consumer's build until the new component is wired:
+ * exhaustiveness by construction, replacing the hand-synced switch the
+ * storefront's `BlockDigester` used to carry.
+ *
+ * Wired automatically by `foirCodegen()`. The generated file imports the block
+ * types from the codegen output (`./graphql`) and `BlockComponent` from
+ * `@foir/sdk/content`, so it pairs directly with `createContentRenderer`.
+ */
+
+interface BlockRegistryConfig extends BlockPluginConfig {
+    /** Name of the generated registry type. Default `BlockRegistry`. */
+    registryName?: string;
+}
+/** graphql-codegen plugin entrypoint. */
+declare const plugin: (schema: GraphQLSchema, _documents: unknown, config?: BlockRegistryConfig) => string;
+
+export { type BlockRegistryConfig, plugin };

package/dist/codegen/block-registry.js

@@ -0,0 +1,35 @@
+import {
+  DEFAULT_GRAPHQL_IMPORT,
+  DEFAULT_SDK_IMPORT,
+  DEFAULT_UNIONS,
+  collectBlockMembers
+} from "../chunk-ADO5FJNM.js";
+
+// src/codegen/block-registry.ts
+var plugin = (schema, _documents, config = {}) => {
+  const members = collectBlockMembers(schema, config.unions ?? DEFAULT_UNIONS);
+  const graphqlImport = config.graphqlImport ?? DEFAULT_GRAPHQL_IMPORT;
+  const sdkImport = config.sdkImport ?? DEFAULT_SDK_IMPORT;
+  const registryName = config.registryName ?? "BlockRegistry";
+  return [
+    "/* eslint-disable */",
+    "// Generated by @foir/sdk/codegen/block-registry. Do not edit by hand.",
+    "// Regenerated on every codegen run \u2014 omitting a block type is a compile error.",
+    `import type { BlockComponent } from '${sdkImport}';`,
+    `import type {`,
+    ...members.map((m) => `  ${m},`),
+    `} from '${graphqlImport}';`,
+    "",
+    `/**`,
+    ` * Exhaustive map of every block \`__typename\` in the project schema to the`,
+    ` * component that renders it. Pass an instance to \`createContentRenderer\`.`,
+    ` */`,
+    `export type ${registryName}<Ctx = unknown> = {`,
+    ...members.map((m) => `  ${m}: BlockComponent<${m}, Ctx>;`),
+    `};`,
+    ""
+  ].join("\n");
+};
+export {
+  plugin
+};

package/dist/codegen/block-scaffold.d.ts

@@ -0,0 +1,28 @@
+import { GraphQLSchema } from 'graphql';
+import { B as BlockPluginConfig } from '../shared-DkWlEd2Z.js';
+
+/**
+ * `@foir/sdk/codegen/block-scaffold` — a one-shot graphql-codegen plugin.
+ *
+ * Emits a ContentRenderer shell: a stub component per block `__typename`, a
+ * `blockRegistry` of the (exhaustive) `BlockRegistry` type, and a
+ * `createContentRenderer` wiring. Unlike the block-registry plugin (which
+ * regenerates every run), this is a STARTING POINT the dev then owns — run it
+ * once via `foirScaffold()`, then implement each stub. It compiles out of the
+ * box (each stub is a typed no-op) so the build stays green while you fill them
+ * in. Adding a new block type later surfaces as a compile error on
+ * `blockRegistry` (via the regenerated `BlockRegistry` type), not here.
+ */
+
+interface BlockScaffoldConfig extends BlockPluginConfig {
+    /** Import path for the generated registry type. Default `./block-registry`. */
+    registryImport?: string;
+    /** Render-context type name threaded to every component. Default `unknown`. */
+    ctxType?: string;
+    /** Optional import line for the ctx type, e.g. `import type { Ctx } from '~/ctx'`. */
+    ctxImport?: string;
+}
+/** graphql-codegen plugin entrypoint. */
+declare const plugin: (schema: GraphQLSchema, _documents: unknown, config?: BlockScaffoldConfig) => string;
+
+export { type BlockScaffoldConfig, plugin };

package/dist/codegen/block-scaffold.js

@@ -0,0 +1,45 @@
+import {
+  DEFAULT_GRAPHQL_IMPORT,
+  DEFAULT_SDK_IMPORT,
+  DEFAULT_UNIONS,
+  collectBlockMembers
+} from "../chunk-ADO5FJNM.js";
+
+// src/codegen/block-scaffold.ts
+var plugin = (schema, _documents, config = {}) => {
+  const members = collectBlockMembers(schema, config.unions ?? DEFAULT_UNIONS);
+  const graphqlImport = config.graphqlImport ?? DEFAULT_GRAPHQL_IMPORT;
+  const sdkImport = config.sdkImport ?? DEFAULT_SDK_IMPORT;
+  const registryImport = config.registryImport ?? "./block-registry";
+  const ctx = config.ctxType ?? "unknown";
+  const stub = (m) => [
+    `function ${m}View(props: BlockComponentProps<${m}, ${ctx}>) {`,
+    `  // TODO: render ${m} from props.block (props.ctx, props.priority available)`,
+    `  void props;`,
+    `  return null;`,
+    `}`
+  ].join("\n");
+  return [
+    "/* eslint-disable */",
+    "// Scaffolded once by @foir/sdk/codegen/block-scaffold \u2014 you own this file.",
+    "// Implement each stub; the build stays green until you do.",
+    `import { createContentRenderer, type BlockComponentProps } from '${sdkImport}';`,
+    `import type { BlockRegistry } from '${registryImport}';`,
+    `import type {`,
+    ...members.map((m) => `  ${m},`),
+    `} from '${graphqlImport}';`,
+    ...config.ctxImport ? ["", config.ctxImport] : [],
+    "",
+    ...members.map(stub),
+    "",
+    `export const blockRegistry: BlockRegistry<${ctx}> = {`,
+    ...members.map((m) => `  ${m}: ${m}View,`),
+    `};`,
+    "",
+    `export const ContentRenderer = createContentRenderer<${ctx}>(blockRegistry);`,
+    ""
+  ].join("\n");
+};
+export {
+  plugin
+};