@loopwise/sdk 0.1.0-beta.0 → 0.1.0-beta.2

package/README.md

@@ -1,37 +1,78 @@
 # @loopwise/sdk
 
-Storefront GraphQL client for Loopwise / Teachify. The SDK has no concept of
-"tenant" in its public surface — calls hit the same-origin BFF at
-`/api/graphql`, which derives the tenant from the request host and binds it
-to the response on the trusted server side.
+Storefront GraphQL client for Loopwise / Teachify. Pick your path:
 
-## Quick start
+| You are producing… | Install | Module spec |
+|---|---|---|
+| A single self-contained HTML file (no build step — for `deploy_static_page`, a Claude Design artifact, or a CodePen) | none — load from a CDN | `https://esm.sh/@loopwise/sdk@beta` |
+| A project with a bundler (Vite / Astro / Next.js / Remix) | `npm install @loopwise/sdk@beta` | `@loopwise/sdk` |
+| **React** UI in either of the above | (see [`@loopwise/sdk-react`](#react--coming-soon)) | — |
+
+Same package powers all three; the difference is the loader.
+
+## Quick start — bundler
 
 ```ts
 import { createClient } from '@loopwise/sdk';
 
+// Browser, same-origin (the page is served from the tenant origin):
 const loopwise = createClient({});
 const { items } = await loopwise.courses.list({ limit: 20 });
 ```
 
-That's the entire happy path. Whether the page is on `acme.kaik.io`,
-`acme.myteachify.com`, or `nii.school`, the BFF on each origin already knows
-which tenant it's serving — the SDK just talks to its own origin.
+That's the entire happy path **when the page is served from the tenant
+origin** (`acme.kaik.io`, `acme.myteachify.com`, `nii.school`, etc.). The BFF
+on that origin derives the tenant from the request host and binds it to the
+response on the trusted server side.
+
+## Quick start — single-file HTML (no build)
+
+```html
+<!doctype html>
+<script type="module">
+  import { createClient } from 'https://esm.sh/@loopwise/sdk@beta';
+
+  // Same-origin variant — works when the HTML is served from the tenant origin
+  // (e.g. acme.kaik.io). Empty config; BFF derives the tenant from host.
+  const loopwise = createClient({});
+  const { items } = await loopwise.courses.list({ limit: 20 });
+  document.body.textContent = items.map(c => c.title).join(', ');
+</script>
+```
 
-### Cross-origin / SSR (advanced)
+## Cross-origin (Loopwise Pages preview, SSR, build pipelines)
 
-When the SDK runs outside a tenant origin (build pipeline, third-party site,
-SSR worker), pass `tenant` explicitly so the SDK knows where to send the
-request. An `apiKey` is required outside the browser to bypass cookie auth.
+When the SDK runs **outside** a tenant origin, pass `tenant` explicitly so
+the SDK can pick the right Rails origin to call.
 
 ```ts
 const loopwise = createClient({
-  tenant: 'acme',
-  apiKey: process.env.LOOPWISE_API_KEY, // SSR / build only
+  tenant: 'acme',                       // required cross-origin
+  apiKey: process.env.LOOPWISE_API_KEY, // required in SSR / build (browser ignores)
 });
 ```
 
-## Cache option (`cache`)
+### Where this matters most: `deploy_static_page`
+
+Pages deployed via `deploy_static_page` live at `https://<script>.loopwise.page/`
+— that is **not** a tenant origin, so:
+
+- The BFF same-origin trick does not apply. You **must** pass `tenant`.
+- Browser cross-origin requests carry no first-party cookies, so anything
+  that requires a logged-in viewer (`cart`, `viewer.profile`,
+  authenticated mutations) **will not work** at preview time.
+- Public, anonymous reads (`courses.list`, `posts.list`, etc.) are fine.
+
+```ts
+// Inside an HTML bundle deployed to https://lw-acme-home.loopwise.page/
+const loopwise = createClient({ tenant: 'acme' });
+const { items } = await loopwise.courses.list({ limit: 20 }, { cache: 60 });
+```
+
+For preview UX that needs authenticated state, see
+[Preview modes](#preview-modes) below.
+
+## `cache` option
 
 Read-only resource calls accept an opt-in `cache` option that flips the
 request to a GraphQL-over-HTTP `GET` and asks the BFF to apply a
@@ -79,12 +120,46 @@ is the explicit, type-system-visible declaration of "this must never be cached".
 per Vercel POP, depending on traffic. Use shorter TTLs for time-sensitive
 content; use `cache: 'no-store'` for admin previews.
 
+## Preview modes
+
+Two preview surfaces exist, each with different capability:
+
+| Surface | Origin | Same-origin BFF? | Authenticated viewer? | Use for |
+|---|---|---|---|---|
+| **Loopwise Pages preview** | `<scriptName>.loopwise.page` | ❌ cross-origin | ❌ no first-party cookies | Anonymous storefront, marketing pages, public listings |
+| **Tenant-origin preview** | `<tenant-origin>/_preview/<scriptName>/` | ✅ same-origin | ✅ admin can preview as a logged-in viewer | Cart, checkout, member-gated content, full storefront |
+
+The tenant origin can be `<sub>.kaik.io`, `<sub>.myteachify.com`, or a
+custom FQDN like `nii.school`. `deploy_static_page` returns both
+surfaces (`preview_url` + `tenant_preview_url_template` with a
+`<TENANT_ORIGIN>` placeholder).
+
+Pick the surface that matches what you're testing — anonymous storefront
+reads on Surface A (faster, edge-cacheable), authenticated flows on
+Surface B (logged-in only, never edge-cached). Surface B requires
+relative asset paths in your bundle (the proxy injects `<base>` so
+relative paths resolve under `/_preview/<scriptName>/`; root-absolute
+paths like `/style.css` still go to the tenant root and 404).
+
+## React — coming soon
+
+A `@loopwise/sdk-react` companion package is planned, providing:
+
+- `<LoopwiseProvider client={loopwise}>` context provider
+- `useCourses({ limit })`, `useCourse({ slug })` hooks with Suspense support
+- `useBatch(...)` for composed queries
+- Cache and refetch control matching the underlying SDK's `cache` option
+
+Until it ships, the vanilla SDK works inside React — you'll just wire up
+your own state (`useEffect` + `useState`, TanStack Query, etc.).
+
 ## Public API
 
-- `createClient(config)` — storefront client. `config.tenant` is optional
-  in the browser (BFF derives it from host) and required in SSR / build.
+- `createClient(config)` — storefront client. `config.tenant` is optional in
+  the browser when the page is on a tenant origin (BFF derives it from
+  host); required cross-origin and in SSR / build.
 - `loopwise.courses.list(args, options?)` / `.get(args, options?)`.
 - `loopwise.batch(builders, options?)` — composes N queries into one HTTP request.
-- `loopwise.query<T>(document, variables?, operationName?, options?)` — raw GraphQL.
+- `loopwise.query<T>(document, variables?, operationName?, options?)` — raw GraphQL escape hatch.
 
 See `apps/sdk-runtime-poc/` for a runnable browser validation page.

package/dist/config.mjs

@@ -2,6 +2,5 @@
 function defineConfig(config) {
 	return config;
 }
-
 //#endregion
-export { defineConfig };
+export { defineConfig };

package/dist/index.d.mts

@@ -119,6 +119,34 @@ interface Lecturer {
   name: string;
   avatar: string | null;
 }
+interface Post {
+  id: string;
+  slug: string;
+  title: string;
+  subtitle: string | null;
+  excerpt: string | null;
+  /** Full body HTML. Truncated server-side when access is gated and the
+   * viewer doesn't have permission (login_required without auth, or paid
+   * without an active subscription). */
+  body: string;
+  /** Maps to schema `Post.cover_photo`. */
+  coverImage: string | null;
+  /** Unix timestamp (seconds since epoch). */
+  publishedAt: number;
+  /** Unix timestamp of the last update — schema sources this from the
+   * post's `updated_at`, so for any persisted record this is populated
+   * (typically equal to or after `publishedAt`). The `null` is included
+   * for forward-compat with a hypothetical "never modified" sentinel
+   * but isn't observed in current production data. */
+  modifiedAt: number | null;
+  /** Known values: `login_required`, `paid`, `public_access`. The
+   * `string & {}` escape hatch keeps autocomplete on the known set
+   * while accepting forward-compat values the schema may add. */
+  accessType: 'login_required' | 'paid' | 'public_access' | (string & {});
+  tags: string[] | null;
+  noindex: boolean;
+  author: Lecturer | null;
+}
 interface PageInfo {
   page: number;
   totalPages: number;
@@ -130,18 +158,42 @@ interface ListResult<T> {
   items: T[];
   pageInfo: PageInfo;
 }
+/** Simplified order status. Mirrors the storefront `Order.status` enum. */
+type OrderStatus = 'PAID' | 'PENDING' | 'FAILED' | 'REFUNDED';
+interface OrderItem {
+  /**
+   * Meta-pixel-aligned identifier (Lineitem#tracking_id server-side).
+   * Use directly in `content_ids` / `contents[].id` for Purchase events.
+   */
+  id: string;
+  name: string | null;
+  quantity: number;
+  /** Per-unit price in the order currency. Maps to FB Pixel `contents[].item_price`. */
+  amount: number;
+}
+interface Order {
+  /** Stable order identifier — currently equals `Payment#trade_no` server-side. */
+  id: string;
+  status: OrderStatus;
+  /** Total paid amount in the order currency. Maps to FB Pixel `value`. */
+  total: number;
+  currency: string;
+  items: OrderItem[];
+  /** Unix timestamp (seconds since epoch). */
+  createdAt: number;
+}
 //#endregion
 //#region src/resources/courses.d.ts
-declare const DEFAULT_LIST_FIELDS: Selection<Course>;
-declare const DEFAULT_GET_FIELDS: Selection<Course>;
-interface CourseListArgs<S extends Selection<Course> = typeof DEFAULT_LIST_FIELDS> {
+declare const DEFAULT_LIST_FIELDS$1: Selection<Course>;
+declare const DEFAULT_GET_FIELDS$2: Selection<Course>;
+interface CourseListArgs<S extends Selection<Course> = typeof DEFAULT_LIST_FIELDS$1> {
   limit?: number;
   page?: number;
   /** SDK `limit` maps to schema `perPage`. Schema also has its own `limit`
    * which we expose as `topN` if needed (not in v0). */
   select?: S;
 }
-interface CourseGetArgs<S extends Selection<Course> = typeof DEFAULT_GET_FIELDS> {
+interface CourseGetArgs<S extends Selection<Course> = typeof DEFAULT_GET_FIELDS$2> {
   slug: string;
   select?: S;
 }
@@ -156,19 +208,120 @@ declare class CoursesResource {
    * // Opt into GET + Cache-Control hint (60s):
    * await loopwise.courses.list({ limit: 20 }, { cache: 60 })
    */
-  list<S extends Selection<Course> = typeof DEFAULT_LIST_FIELDS>(args?: CourseListArgs<S>, options?: FetchOptions): QueryBuilder<ListResult<Selected<Course, S>>>;
+  list<S extends Selection<Course> = typeof DEFAULT_LIST_FIELDS$1>(args?: CourseListArgs<S>, options?: FetchOptions): QueryBuilder<ListResult<Selected<Course, S>>>;
+  /**
+   * Get a single course by slug.
+   *
+   * Throws `LoopwiseError("GRAPHQL")` when the slug is not found
+   * (Storefront `Queries::Course` raises `service_error("Course-003")`
+   * on a `null: false` field). Wrap with try/catch to render 404 routes:
+   *
+   * @example
+   * try {
+   *   const course = await loopwise.courses.get({ slug: 'finance' })
+   *   // ...
+   * } catch (e) {
+   *   if (e instanceof LoopwiseError && e.code === 'GRAPHQL') {
+   *     return Astro.redirect('/404')
+   *   }
+   *   throw e
+   * }
+   */
+  get<S extends Selection<Course> = typeof DEFAULT_GET_FIELDS$2>(args: CourseGetArgs<S>, options?: FetchOptions): QueryBuilder<Selected<Course, S>>;
+}
+//#endregion
+//#region src/resources/orders.d.ts
+declare const DEFAULT_GET_FIELDS$1: Selection<Order>;
+interface OrderGetArgs<S extends Selection<Order> = typeof DEFAULT_GET_FIELDS$1> {
+  /**
+   * Order identifier — the value passed via `?tradeNo=...` on the post-checkout
+   * redirect to the merchant's success URL. Internally equals
+   * `Payment#trade_no` server-side.
+   */
+  id: string;
+  select?: S;
+}
+declare class OrdersResource {
+  private client;
+  constructor(client: LoopwiseClient);
+  /**
+   * Look up a PII-safe order projection by id (the value the storefront
+   * appends to a merchant's `checkoutSuccessUrl` as `?tradeNo=...`).
+   *
+   * Returns `null`-shaped result via the GraphQL `null` payload when the
+   * id doesn't resolve in the current tenant — does NOT throw. Use the
+   * returned `status` to gate Meta Pixel `Purchase` events:
+   *
+   * @example
+   * const id = new URLSearchParams(location.search).get('tradeNo');
+   * if (!id) return;
+   * const order = await loopwise.orders.get({ id });
+   * if (order?.status === 'PAID') {
+   *   fbq('track', 'Purchase', {
+   *     value: order.total,
+   *     currency: order.currency,
+   *     contents: order.items.map(i => ({
+   *       id: i.id, name: i.name, quantity: i.quantity, item_price: i.amount,
+   *     })),
+   *     content_ids: order.items.map(i => i.id),
+   *     content_type: 'product',
+   *     num_items: order.items.reduce((s, i) => s + i.quantity, 0),
+   *   }, { eventID: order.id });
+   * }
+   */
+  get<S extends Selection<Order> = typeof DEFAULT_GET_FIELDS$1>(args: OrderGetArgs<S>, options?: FetchOptions): QueryBuilder<Selected<Order, S> | null>;
+}
+//#endregion
+//#region src/resources/posts.d.ts
+declare const DEFAULT_LIST_FIELDS: Selection<Post>;
+declare const DEFAULT_GET_FIELDS: Selection<Post>;
+interface PostListArgs<S extends Selection<Post> = typeof DEFAULT_LIST_FIELDS> {
+  limit?: number;
+  page?: number;
+  /** SDK `limit` maps to schema `perPage`. */
+  select?: S;
+}
+interface PostGetArgs<S extends Selection<Post> = typeof DEFAULT_GET_FIELDS> {
+  slug: string;
+  select?: S;
+}
+declare class PostsResource {
+  private client;
+  constructor(client: LoopwiseClient);
+  /**
+   * List published posts for the current tenant, ordered by publishedAt desc.
+   * @example
+   * const { items, pageInfo } = await loopwise.posts.list({ limit: 10 })
+   * @example
+   * await loopwise.posts.list({ limit: 10 }, { cache: 60 })
+   */
+  list<S extends Selection<Post> = typeof DEFAULT_LIST_FIELDS>(args?: PostListArgs<S>, options?: FetchOptions): QueryBuilder<ListResult<Selected<Post, S>>>;
   /**
-   * Get a single course by slug. Returns `null` if not found.
+   * Get a single post by slug.
+   *
+   * Throws `LoopwiseError("GRAPHQL")` when the slug is not found
+   * (Storefront `Queries::Post` raises `service_error("Post-000")` on a
+   * `null: false` field). Wrap with try/catch to render 404 routes:
+   *
    * @example
-   * const course = await loopwise.courses.get({ slug: 'finance' })
-   * if (!course) return Astro.redirect('/404')
+   * try {
+   *   const post = await loopwise.posts.get({ slug: 'hello-world' })
+   *   // ...
+   * } catch (e) {
+   *   if (e instanceof LoopwiseError && e.code === 'GRAPHQL') {
+   *     return Astro.redirect('/404')
+   *   }
+   *   throw e
+   * }
    */
-  get<S extends Selection<Course> = typeof DEFAULT_GET_FIELDS>(args: CourseGetArgs<S>, options?: FetchOptions): QueryBuilder<Selected<Course, S> | null>;
+  get<S extends Selection<Post> = typeof DEFAULT_GET_FIELDS>(args: PostGetArgs<S>, options?: FetchOptions): QueryBuilder<Selected<Post, S>>;
 }
 //#endregion
 //#region src/index.d.ts
 interface Loopwise {
   readonly courses: CoursesResource;
+  readonly orders: OrdersResource;
+  readonly posts: PostsResource;
   /**
    * Compose multiple resource queries into a single GraphQL HTTP request.
    * @example
@@ -190,4 +343,4 @@ interface Loopwise {
 }
 declare function createClient(config: LoopwiseConfig): Loopwise;
 //#endregion
-export { type Course, type FetchOptions, type Lecturer, type ListResult, Loopwise, type LoopwiseConfig, LoopwiseError, type PageInfo, QueryBuilder, type Selected, type Selection, createClient };
+export { type Course, type FetchOptions, type Lecturer, type ListResult, Loopwise, type LoopwiseConfig, LoopwiseError, type Order, type OrderItem, type OrderStatus, type PageInfo, type Post, QueryBuilder, type Selected, type Selection, createClient };

package/dist/index.mjs

@@ -15,14 +15,12 @@ var LoopwiseError = class extends Error {
 		this.requestId = detail.requestId;
 	}
 };
-
 //#endregion
 //#region src/runtime.ts
 function detectRuntime() {
 	if (typeof window !== "undefined" && typeof window.document !== "undefined") return "browser";
 	return "ssr";
 }
-
 //#endregion
 //#region src/client.ts
 const GET_URL_MAX_LENGTH = 2e3;
@@ -40,10 +38,11 @@ var LoopwiseClient = class {
 		this.endpoint = config.endpoint ?? this.defaultEndpoint();
 	}
 	defaultEndpoint() {
-		if (detectRuntime() === "browser") return "/api/graphql";
 		const tenant = this.config.tenant;
-		if (tenant.includes(".")) return `https://${tenant}/api/graphql`;
-		return `https://${tenant}.kaik.io/api/graphql`;
+		if (detectRuntime() === "browser" && !tenant) return "/api/graphql";
+		const t = tenant;
+		if (t.includes(".")) return `https://${t}/api/graphql`;
+		return `https://${t}.kaik.io/api/graphql`;
 	}
 	async execute(descriptor, options = {}) {
 		const document = renderSingleDocument(descriptor);
@@ -233,7 +232,6 @@ function literal(value) {
 	if (typeof value === "object") return `{ ${Object.entries(value).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}: ${literal(v)}`).join(", ")} }`;
 	throw new LoopwiseError("CONFIG", `Unsupported argument type for GraphQL literal: ${typeof value}`);
 }
-
 //#endregion
 //#region src/query.ts
 var QueryBuilder = class {
@@ -249,7 +247,6 @@ var QueryBuilder = class {
 		return this.fetcher.execute(this.descriptor, this.fetchOptions).then(onFulfilled, onRejected);
 	}
 };
-
 //#endregion
 //#region src/schema/courses.ts
 /** Map SDK Course selection -> schema field selection set. */
@@ -299,16 +296,15 @@ function mapCoursePage(raw) {
 		}
 	};
 }
-
 //#endregion
 //#region src/resources/courses.ts
-const DEFAULT_LIST_FIELDS = {
+const DEFAULT_LIST_FIELDS$1 = {
 	id: true,
 	slug: true,
 	title: true,
 	coverImage: true
 };
-const DEFAULT_GET_FIELDS = {
+const DEFAULT_GET_FIELDS$2 = {
 	id: true,
 	slug: true,
 	title: true,
@@ -320,13 +316,14 @@ const DEFAULT_GET_FIELDS = {
 		avatar: true
 	}
 };
-function tenantVars(client) {
+function tenantVars$2(client) {
 	return { subdomain: {
 		type: "String!",
 		value: client.config.tenant ?? ""
 	} };
 }
 var CoursesResource = class {
+	client;
 	constructor(client) {
 		this.client = client;
 	}
@@ -339,7 +336,7 @@ var CoursesResource = class {
 	* await loopwise.courses.list({ limit: 20 }, { cache: 60 })
 	*/
 	list(args = {}, options = {}) {
-		const selectionSet = `nodes { ${buildCourseSelection(args.select ?? DEFAULT_LIST_FIELDS)} } currentPage totalPages nodesCount hasNextPage hasPreviousPage`;
+		const selectionSet = `nodes { ${buildCourseSelection(args.select ?? DEFAULT_LIST_FIELDS$1)} } currentPage totalPages nodesCount hasNextPage hasPreviousPage`;
 		return new QueryBuilder(this.client, {
 			operation: "CourseList",
 			field: "courses",
@@ -348,35 +345,291 @@ var CoursesResource = class {
 				page: args.page,
 				perPage: args.limit
 			},
-			vars: tenantVars(this.client),
+			vars: tenantVars$2(this.client),
 			transform: (raw) => mapCoursePage(raw)
 		}, options);
 	}
 	/**
-	* Get a single course by slug. Returns `null` if not found.
+	* Get a single course by slug.
+	*
+	* Throws `LoopwiseError("GRAPHQL")` when the slug is not found
+	* (Storefront `Queries::Course` raises `service_error("Course-003")`
+	* on a `null: false` field). Wrap with try/catch to render 404 routes:
+	*
 	* @example
-	* const course = await loopwise.courses.get({ slug: 'finance' })
-	* if (!course) return Astro.redirect('/404')
+	* try {
+	*   const course = await loopwise.courses.get({ slug: 'finance' })
+	*   // ...
+	* } catch (e) {
+	*   if (e instanceof LoopwiseError && e.code === 'GRAPHQL') {
+	*     return Astro.redirect('/404')
+	*   }
+	*   throw e
+	* }
 	*/
 	get(args, options = {}) {
-		const sel = args.select ?? DEFAULT_GET_FIELDS;
+		const sel = args.select ?? DEFAULT_GET_FIELDS$2;
 		return new QueryBuilder(this.client, {
 			operation: "CourseGet",
 			field: "course",
 			selectionSet: buildCourseSelection(sel),
 			args: { slug: args.slug },
+			vars: tenantVars$2(this.client),
+			transform: (raw) => mapCourse(raw)
+		}, options);
+	}
+};
+//#endregion
+//#region src/schema/orders.ts
+/** Map SDK Order selection -> schema field selection set. */
+function buildOrderSelection(select) {
+	const parts = ["id"];
+	const sel = select;
+	if (sel.status) parts.push("status");
+	if (sel.total) parts.push("total");
+	if (sel.currency) parts.push("currency");
+	if (sel.createdAt) parts.push("createdAt");
+	if (sel.items && typeof sel.items === "object") {
+		const itemSel = sel.items;
+		const itemParts = ["id"];
+		if (itemSel.name) itemParts.push("name");
+		if (itemSel.quantity) itemParts.push("quantity");
+		if (itemSel.amount) itemParts.push("amount");
+		parts.push(`items { ${itemParts.join(" ")} }`);
+	}
+	return parts.join(" ");
+}
+function mapOrderItem(raw) {
+	const out = { id: raw.id };
+	if (raw.name !== void 0) out.name = raw.name ?? null;
+	if (raw.quantity !== void 0) out.quantity = raw.quantity;
+	if (raw.amount !== void 0) out.amount = raw.amount;
+	return out;
+}
+function mapOrder(raw) {
+	const out = { id: raw.id };
+	if (raw.status !== void 0) out.status = raw.status;
+	if (raw.total !== void 0) out.total = raw.total;
+	if (raw.currency !== void 0) out.currency = raw.currency;
+	if (raw.createdAt !== void 0) out.createdAt = raw.createdAt;
+	if (raw.items !== void 0) out.items = raw.items.map(mapOrderItem);
+	return out;
+}
+//#endregion
+//#region src/resources/orders.ts
+const DEFAULT_GET_FIELDS$1 = {
+	id: true,
+	status: true,
+	total: true,
+	currency: true,
+	createdAt: true,
+	items: {
+		id: true,
+		name: true,
+		quantity: true,
+		amount: true
+	}
+};
+function tenantVars$1(client) {
+	return { subdomain: {
+		type: "String!",
+		value: client.config.tenant ?? ""
+	} };
+}
+var OrdersResource = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	/**
+	* Look up a PII-safe order projection by id (the value the storefront
+	* appends to a merchant's `checkoutSuccessUrl` as `?tradeNo=...`).
+	*
+	* Returns `null`-shaped result via the GraphQL `null` payload when the
+	* id doesn't resolve in the current tenant — does NOT throw. Use the
+	* returned `status` to gate Meta Pixel `Purchase` events:
+	*
+	* @example
+	* const id = new URLSearchParams(location.search).get('tradeNo');
+	* if (!id) return;
+	* const order = await loopwise.orders.get({ id });
+	* if (order?.status === 'PAID') {
+	*   fbq('track', 'Purchase', {
+	*     value: order.total,
+	*     currency: order.currency,
+	*     contents: order.items.map(i => ({
+	*       id: i.id, name: i.name, quantity: i.quantity, item_price: i.amount,
+	*     })),
+	*     content_ids: order.items.map(i => i.id),
+	*     content_type: 'product',
+	*     num_items: order.items.reduce((s, i) => s + i.quantity, 0),
+	*   }, { eventID: order.id });
+	* }
+	*/
+	get(args, options = {}) {
+		const sel = args.select ?? DEFAULT_GET_FIELDS$1;
+		return new QueryBuilder(this.client, {
+			operation: "OrderGet",
+			field: "order",
+			selectionSet: buildOrderSelection(sel),
+			args: { id: args.id },
+			vars: tenantVars$1(this.client),
+			transform: (raw) => raw == null ? null : mapOrder(raw)
+		}, options);
+	}
+};
+//#endregion
+//#region src/schema/posts.ts
+/** Map SDK Post selection -> schema field selection set. */
+function buildPostSelection(select) {
+	const parts = ["id", "slug"];
+	const sel = select;
+	if (sel.title) parts.push("title");
+	if (sel.subtitle) parts.push("subtitle");
+	if (sel.excerpt) parts.push("excerpt");
+	if (sel.body) parts.push("body");
+	if (sel.coverImage) parts.push("coverPhoto");
+	if (sel.publishedAt) parts.push("publishedAt");
+	if (sel.modifiedAt) parts.push("modifiedAt");
+	if (sel.accessType) parts.push("accessType");
+	if (sel.tags) parts.push("tags");
+	if (sel.noindex) parts.push("noindex");
+	if (sel.author && typeof sel.author === "object") {
+		const auth = sel.author;
+		const authParts = ["id"];
+		if (auth.name) authParts.push("name");
+		if (auth.avatar) authParts.push("avatar");
+		parts.push(`author { ${authParts.join(" ")} }`);
+	}
+	return parts.join(" ");
+}
+function mapPost(raw) {
+	const out = {
+		id: raw.id,
+		slug: raw.slug
+	};
+	if (raw.title !== void 0) out.title = raw.title;
+	if (raw.subtitle !== void 0) out.subtitle = raw.subtitle ?? null;
+	if (raw.excerpt !== void 0) out.excerpt = raw.excerpt ?? null;
+	if (raw.body !== void 0) out.body = raw.body;
+	if (raw.coverPhoto !== void 0) out.coverImage = raw.coverPhoto ?? null;
+	if (raw.publishedAt !== void 0) out.publishedAt = raw.publishedAt;
+	if (raw.modifiedAt !== void 0) out.modifiedAt = raw.modifiedAt ?? null;
+	if (raw.accessType !== void 0) out.accessType = raw.accessType;
+	if (raw.tags !== void 0) out.tags = raw.tags ?? null;
+	if (raw.noindex !== void 0) out.noindex = raw.noindex;
+	if (raw.author !== void 0) out.author = raw.author ? mapLecturer(raw.author) : null;
+	return out;
+}
+function mapPostPage(raw) {
+	return {
+		items: raw.nodes.map(mapPost),
+		pageInfo: {
+			page: raw.currentPage,
+			totalPages: raw.totalPages,
+			totalCount: raw.nodesCount,
+			hasNext: raw.hasNextPage,
+			hasPrev: raw.hasPreviousPage
+		}
+	};
+}
+//#endregion
+//#region src/resources/posts.ts
+const DEFAULT_LIST_FIELDS = {
+	id: true,
+	slug: true,
+	title: true,
+	excerpt: true,
+	coverImage: true,
+	publishedAt: true
+};
+const DEFAULT_GET_FIELDS = {
+	id: true,
+	slug: true,
+	title: true,
+	subtitle: true,
+	excerpt: true,
+	body: true,
+	coverImage: true,
+	publishedAt: true,
+	modifiedAt: true,
+	accessType: true,
+	author: {
+		id: true,
+		name: true,
+		avatar: true
+	}
+};
+function tenantVars(client) {
+	return { subdomain: {
+		type: "String!",
+		value: client.config.tenant ?? ""
+	} };
+}
+var PostsResource = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	/**
+	* List published posts for the current tenant, ordered by publishedAt desc.
+	* @example
+	* const { items, pageInfo } = await loopwise.posts.list({ limit: 10 })
+	* @example
+	* await loopwise.posts.list({ limit: 10 }, { cache: 60 })
+	*/
+	list(args = {}, options = {}) {
+		const selectionSet = `nodes { ${buildPostSelection(args.select ?? DEFAULT_LIST_FIELDS)} } currentPage totalPages nodesCount hasNextPage hasPreviousPage`;
+		return new QueryBuilder(this.client, {
+			operation: "PostList",
+			field: "posts",
+			selectionSet,
+			args: {
+				page: args.page,
+				perPage: args.limit
+			},
+			vars: tenantVars(this.client),
+			transform: (raw) => mapPostPage(raw)
+		}, options);
+	}
+	/**
+	* Get a single post by slug.
+	*
+	* Throws `LoopwiseError("GRAPHQL")` when the slug is not found
+	* (Storefront `Queries::Post` raises `service_error("Post-000")` on a
+	* `null: false` field). Wrap with try/catch to render 404 routes:
+	*
+	* @example
+	* try {
+	*   const post = await loopwise.posts.get({ slug: 'hello-world' })
+	*   // ...
+	* } catch (e) {
+	*   if (e instanceof LoopwiseError && e.code === 'GRAPHQL') {
+	*     return Astro.redirect('/404')
+	*   }
+	*   throw e
+	* }
+	*/
+	get(args, options = {}) {
+		const sel = args.select ?? DEFAULT_GET_FIELDS;
+		return new QueryBuilder(this.client, {
+			operation: "PostGet",
+			field: "post",
+			selectionSet: buildPostSelection(sel),
+			args: { slug: args.slug },
 			vars: tenantVars(this.client),
-			transform: (raw) => raw == null ? null : mapCourse(raw)
+			transform: (raw) => mapPost(raw)
 		}, options);
 	}
 };
-
 //#endregion
 //#region src/index.ts
 function createClient(config) {
 	const client = new LoopwiseClient(config);
 	return {
 		courses: new CoursesResource(client),
+		orders: new OrdersResource(client),
+		posts: new PostsResource(client),
 		batch(builders, options) {
 			return client.batch(builders, options);
 		},
@@ -385,6 +638,5 @@ function createClient(config) {
 		}
 	};
 }
-
 //#endregion
-export { LoopwiseError, QueryBuilder, createClient };
+export { LoopwiseError, QueryBuilder, createClient };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@loopwise/sdk",
-  "version": "0.1.0-beta.0",
+  "version": "0.1.0-beta.2",
   "description": "Loopwise platform SDK — agent-friendly headless API client",
   "repository": {
     "type": "git",
-    "url": "https://github.com/kaikhq/manekineko.git",
+    "url": "git+https://github.com/kaikhq/manekineko.git",
     "directory": "packages/sdk"
   },
-  "homepage": "https://github.com/kaikhq/manekineko/tree/develop/packages/sdk#readme",
+  "homepage": "https://www.npmjs.com/package/@loopwise/sdk",
   "bugs": {
     "url": "https://github.com/kaikhq/manekineko/issues"
   },
@@ -43,11 +43,13 @@
     "build": "tsdown",
     "dev": "tsdown --watch",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run"
+    "test": "vitest run",
+    "regen:lock": "node scripts/regen-lock.mjs"
   },
   "devDependencies": {
+    "graphql": "16.13.1",
     "tsconfig": "workspace:*",
-    "tsdown": "0.20.3",
+    "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.0"
   },