@omen.dog/sdk 1.0.0 → 1.2.0

package/dist/index.mjs

@@ -1,3 +1,13 @@
+import {
+  ASK_GROWN_UP_STATES,
+  CHILD_LOGIN_STATES,
+  ChildLogin,
+  ENTRY_STATES,
+  deriveInitialState,
+  displayGroup,
+  reduce
+} from "./chunk-7L3ANE2V.mjs";
+
 // src/errors.ts
 var OmenError = class extends Error {
   /** HTTP status code from the API. */
@@ -254,6 +264,27 @@ var ItemsNamespace = class {
       body: { reason }
     });
   }
+  /**
+   * Award a catalog item (open-shop cosmetic or avatar-editor trait) to a user,
+   * paid for from your Sparks pool at the item's list price. Custom items use
+   * `issue()` and are free; catalog items draw the pool down. Re-awarding an item
+   * the user already owns is a no-op (no charge).
+   *
+   * @example
+   * ```ts
+   * await omen.items.awardCatalog({
+   *   userId, catalogType: 'store', catalogItemId: 'theme_lava',
+   * });
+   * ```
+   */
+  async awardCatalog(options) {
+    const { idempotencyKey, ...body } = options;
+    return this.http.request(`/api/v1/apps/${this.appId}/items/award-catalog`, {
+      method: "POST",
+      body,
+      headers: idempotencyKey ? { "Idempotency-Key": idempotencyKey } : void 0
+    });
+  }
 };
 
 // src/namespaces/collections.ts
@@ -476,6 +507,396 @@ function timingSafeEqual(a, b) {
   return result === 0;
 }
 
+// src/namespaces/products.ts
+var ProductsNamespace = class {
+  constructor(http, appId) {
+    this.http = http;
+    this.appId = appId;
+  }
+  /**
+   * Create a new product.
+   *
+   * @example
+   * ```ts
+   * const product = await omen.products.create({
+   *   name: 'Premium Sword',
+   *   type: 'one_time',
+   *   priceCents: 499,
+   * });
+   * ```
+   */
+  async create(options) {
+    return this.http.request(`/api/v1/apps/${this.appId}/products`, {
+      method: "POST",
+      body: options
+    });
+  }
+  /**
+   * List all products for this app.
+   *
+   * @param activeOnly - If true, only return active products. Defaults to false.
+   */
+  async list(activeOnly) {
+    return this.http.request(`/api/v1/apps/${this.appId}/products`, {
+      query: activeOnly ? { active: "true" } : void 0
+    });
+  }
+  /**
+   * Update an existing product.
+   *
+   * @param productId - The product ID to update.
+   * @param options - Fields to update.
+   */
+  async update(productId, options) {
+    return this.http.request(`/api/v1/apps/${this.appId}/products`, {
+      method: "PATCH",
+      query: { productId },
+      body: options
+    });
+  }
+  /**
+   * Deactivate a product. Deactivated products cannot be purchased but existing
+   * purchases remain valid.
+   *
+   * @param productId - The product ID to deactivate.
+   */
+  async deactivate(productId) {
+    await this.http.request(`/api/v1/apps/${this.appId}/products`, {
+      method: "DELETE",
+      query: { productId }
+    });
+  }
+};
+
+// src/namespaces/multiplayer.ts
+var MultiplayerNamespace = class {
+  constructor(http, appId) {
+    this.http = http;
+    this.appId = appId;
+  }
+  /**
+   * Get the current multiplayer configuration for this app.
+   */
+  async getConfig() {
+    const res = await this.http.request(
+      `/api/v1/apps/${this.appId}/multiplayer-config`
+    );
+    return res.multiplayerConfig;
+  }
+  /**
+   * Enable or update managed multiplayer configuration.
+   *
+   * @example
+   * ```ts
+   * await omen.multiplayer.updateConfig({
+   *   managed: true,
+   *   maxPlayers: 8,
+   *   voiceEnabled: true,
+   *   teamMode: 'manual',
+   * });
+   * ```
+   */
+  async updateConfig(options) {
+    const res = await this.http.request(
+      `/api/v1/apps/${this.appId}/multiplayer-config`,
+      { method: "PUT", body: options }
+    );
+    return res.multiplayerConfig;
+  }
+  /**
+   * Deploy authoritative room logic (Pro tier required).
+   * The bundle is a JavaScript file that exports room lifecycle hooks.
+   *
+   * @param bundle - The JavaScript source code as a string.
+   */
+  async deployLogic(bundle) {
+    return this.http.request(`/api/v1/apps/${this.appId}/room-logic`, {
+      method: "PUT",
+      body: { bundle }
+    });
+  }
+  /**
+   * List deployed room logic versions.
+   */
+  async listLogicVersions() {
+    const res = await this.http.request(
+      `/api/v1/apps/${this.appId}/room-logic/versions`
+    );
+    return res.versions;
+  }
+  /**
+   * Roll back to a previous room logic version.
+   *
+   * @param version - The version number to roll back to.
+   */
+  async rollbackLogic(version) {
+    return this.http.request(`/api/v1/apps/${this.appId}/room-logic/rollback`, {
+      method: "POST",
+      body: { version }
+    });
+  }
+};
+
+// src/namespaces/notifications.ts
+var NotificationsNamespace = class {
+  constructor(http, appId) {
+    this.http = http;
+    this.appId = appId;
+  }
+  /**
+   * Send a notification to a user.
+   *
+   * @example
+   * ```ts
+   * await omen.notifications.send({
+   *   userId: 'cmm0tzco8...',
+   *   title: 'New high score!',
+   *   body: 'Someone beat your record on Pixel Duel.',
+   *   category: 'app',
+   *   actionUrl: '/creations/pixel-duel',
+   * });
+   * ```
+   */
+  async send(options) {
+    return this.http.request(`/api/v1/apps/${this.appId}/notifications/send`, {
+      method: "POST",
+      body: options
+    });
+  }
+};
+
+// src/namespaces/sparks.ts
+import { createHmac } from "crypto";
+var SparksNamespace = class {
+  constructor(http, appId) {
+    this.http = http;
+    this.appId = appId;
+  }
+  /**
+   * Award Sparks to a single user. Pass `idempotencyKey` to make retries safe.
+   *
+   * @example
+   * ```ts
+   * await omen.sparks.award({
+   *   userId: 'cmm0tzco8...',
+   *   amount: 250,
+   *   reason: 'Beat level 10',
+   *   idempotencyKey: `level10:${userId}`,
+   * });
+   * ```
+   */
+  async award(options) {
+    const { idempotencyKey, ...body } = options;
+    return this.http.request(`/api/v1/apps/${this.appId}/sparks/award`, {
+      method: "POST",
+      body,
+      headers: idempotencyKey ? { "Idempotency-Key": idempotencyKey } : void 0
+    });
+  }
+  /**
+   * Award Sparks to many users in one request (max 100). Best-effort per item:
+   * a single bad/underfunded entry does not fail the rest. Inspect `results`.
+   */
+  async awardBatch(awards) {
+    return this.http.request(`/api/v1/apps/${this.appId}/sparks/award-batch`, {
+      method: "POST",
+      body: { awards }
+    });
+  }
+  /** Current pool status: balance, lifetime stats, and per-app budgets. */
+  async pool() {
+    return this.http.request(`/api/v1/apps/${this.appId}/sparks/pool`);
+  }
+  /**
+   * Mint a short-lived display token for the UI kit, scoped to one user. Sign
+   * with your app's OAuth client SECRET (from the Developer Portal) — never ship
+   * the secret to the browser; call this on your backend and pass the token to
+   * `<omen-sparks-balance token="...">` / `<omen-inventory token="...">`.
+   *
+   * Synchronous (no network). Default TTL 10 min, max 1 hour.
+   *
+   * @example
+   * ```ts
+   * const token = omen.sparks.displayToken({ userId, secret: process.env.OMEN_CLIENT_SECRET! });
+   * ```
+   */
+  displayToken(options) {
+    if (!options.userId || !options.secret) throw new Error("userId and secret are required");
+    const ttl = Math.min(Math.max(1, Math.floor(options.ttlSeconds ?? 600)), 3600);
+    const exp = Math.floor(Date.now() / 1e3) + ttl;
+    const payloadB64 = Buffer.from(JSON.stringify({ a: this.appId, u: options.userId, e: exp })).toString("base64url");
+    const sig = createHmac("sha256", options.secret).update(payloadB64).digest("base64url");
+    return `${payloadB64}.${sig}`;
+  }
+};
+
+// src/namespaces/emails.ts
+var EmailsNamespace = class {
+  constructor(http, appId) {
+    this.http = http;
+    this.appId = appId;
+  }
+  /**
+   * Send one email (up to 10 recipients). No attachments; 256 KB body max.
+   *
+   * @example
+   * ```ts
+   * await omen.emails.send({
+   *   from: 'hello@yourdomain.com',
+   *   fromName: 'My App',
+   *   to: player.email,
+   *   subject: 'Your weekly recap',
+   *   html: '<h1>Nice run!</h1>',
+   * });
+   * ```
+   */
+  async send(options) {
+    return this.http.request(`/api/v1/apps/${this.appId}/emails/send`, {
+      method: "POST",
+      body: options
+    });
+  }
+  /** Recent sends for this app plus the rolling 24h quota. */
+  async log(limit = 50) {
+    return this.http.request(`/api/v1/apps/${this.appId}/emails/log?limit=${limit}`);
+  }
+};
+
+// src/namespaces/avatar.ts
+import { createHmac as createHmac2 } from "crypto";
+var AvatarNamespace = class {
+  constructor(appId, baseUrl) {
+    this.appId = appId;
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * Mint a short-lived WRITE-scoped editor token for one user (backend only —
+   * never expose your client secret to the browser). Pass it to
+   * `<omen-avatar-editor token="...">`.
+   *
+   * @example
+   * ```ts
+   * const token = omen.avatar.editorToken({ userId, secret: process.env.OMEN_CLIENT_SECRET! });
+   * ```
+   */
+  editorToken(options) {
+    if (!options.userId || !options.secret) throw new Error("userId and secret are required");
+    const ttl = Math.min(Math.max(1, Math.floor(options.ttlSeconds ?? 600)), 3600);
+    const exp = Math.floor(Date.now() / 1e3) + ttl;
+    const payloadB64 = Buffer.from(
+      JSON.stringify({ a: this.appId, u: options.userId, e: exp, t: "editor" })
+    ).toString("base64url");
+    const sig = createHmac2("sha256", options.secret).update(payloadB64).digest("base64url");
+    return `${payloadB64}.${sig}`;
+  }
+  /**
+   * Public render URL for a user's shared avatar (SVG; append `&format=png`
+   * where supported). Pass `version` (from the `avatar:saved` event or the
+   * `user.avatar_updated` webhook) to bust caches after an edit.
+   */
+  renderUrl(userId, options) {
+    const v = options?.version ? `&v=${encodeURIComponent(options.version)}` : "";
+    return `${this.baseUrl}/api/v1/avatar/render?userId=${encodeURIComponent(userId)}${v}`;
+  }
+  /**
+   * Enumerate the shared avatar catalog — every trait id, name, rarity and
+   * Sparks list price. Public, no auth. Trait ids (`category/file.svg` paths)
+   * are also public SVGs at `{baseUrl}/avatar/{id}` for previews, and feed
+   * `omen.items.awardCatalog({ catalogType: 'avatar_trait', catalogItemId })`
+   * for pool-funded gifts.
+   *
+   * Pass a user's editor token and each trait's `locked` flag reflects that
+   * user's ownership instead of the anonymous default.
+   */
+  async catalog(options) {
+    const res = await fetch(`${this.baseUrl}/api/v1/avatar/catalog`, {
+      headers: options?.editorToken ? { Authorization: `Bearer ${options.editorToken}` } : void 0
+    });
+    if (!res.ok) throw new Error(`Failed to load avatar catalog (HTTP ${res.status})`);
+    return await res.json();
+  }
+};
+
+// src/namespaces/assets.ts
+var AssetsNamespace = class {
+  constructor(http, appId) {
+    this.http = http;
+    this.appId = appId;
+  }
+  /**
+   * Upload bytes and get back a public, immutable file URL. Accepts a Buffer /
+   * Uint8Array (raw bytes) or a base64 string (raw or a `data:` URL). Supported:
+   * PNG, JPG, SVG, GIF (SVGs are sanitized). Max 10 MB.
+   *
+   * @example
+   * ```ts
+   * const { url } = await omen.assets.upload(pngBuffer, { name: 'Apple', contentType: 'image/png' });
+   * ```
+   */
+  async upload(data, options = {}) {
+    const fileData = typeof data === "string" ? data : Buffer.from(data).toString("base64");
+    const res = await this.http.request(`/api/v1/apps/${this.appId}/assets`, {
+      method: "POST",
+      body: { fileData, ...options }
+    });
+    return res.asset;
+  }
+  /** List the app's assets, newest first. Paginate with `nextCursor`. */
+  async list(options = {}) {
+    return this.http.request(`/api/v1/apps/${this.appId}/assets`, {
+      query: { limit: options.limit, cursor: options.cursor }
+    });
+  }
+  /** Get one asset's metadata. */
+  async get(id) {
+    const res = await this.http.request(`/api/v1/apps/${this.appId}/assets/${id}`);
+    return res.asset;
+  }
+  /** Evict an asset (hard delete — row + bytes). Never purged on a timer; deletion is yours to control. */
+  async delete(id) {
+    return this.http.request(`/api/v1/apps/${this.appId}/assets/${id}`, { method: "DELETE" });
+  }
+};
+
+// src/namespaces/images.ts
+var ImagesNamespace = class {
+  constructor(http, appId) {
+    this.http = http;
+    this.appId = appId;
+  }
+  /**
+   * Generate one image and host it app-owned.
+   *
+   * @example
+   * ```ts
+   * const { asset, cost, poolBalance } = await omen.images.generate({
+   *   prompt: 'a friendly red apple with a smiling face',
+   *   aspectRatio: '4:3',
+   *   style: 'storybook',
+   *   idempotencyKey: `apple:${pageId}`,
+   * });
+   * console.log(asset.url); // embed anywhere
+   * ```
+   *
+   * @example Recurring character across story pages — pass an identity reference:
+   * ```ts
+   * await omen.images.generate({
+   *   prompt: 'the same fox, now jumping over a log',
+   *   aspectRatio: '3:4',
+   *   referenceImages: [{ data: foxPngBase64, tag: 'identity' }],
+   * });
+   * ```
+   */
+  async generate(options) {
+    const { idempotencyKey, ...body } = options;
+    return this.http.request(`/api/v1/apps/${this.appId}/generate/image`, {
+      method: "POST",
+      body,
+      headers: idempotencyKey ? { "Idempotency-Key": idempotencyKey } : void 0
+    });
+  }
+};
+
 // src/index.ts
 var OmenClient = class {
   /** User profiles and friend lists. */
@@ -488,6 +909,22 @@ var OmenClient = class {
   collections;
   /** Webhook endpoint management and signature verification. */
   webhooks;
+  /** In-app products (one-time purchases and subscriptions). */
+  products;
+  /** Managed multiplayer configuration and room logic deployment. */
+  multiplayer;
+  /** Send notifications to app users. */
+  notifications;
+  /** Award Sparks from your prepaid pool + mint UI-kit display tokens. */
+  sparks;
+  /** Send transactional email from your verified domains (Partner Apps). */
+  emails;
+  /** Shared Omen avatar in your app: editor tokens + render URLs (F262). */
+  avatar;
+  /** Host app-owned content art — upload + serve from a public immutable URL (F264). */
+  assets;
+  /** Generate content art billed to your prepaid Sparks pool, hosted app-owned (F264). */
+  images;
   constructor(options) {
     if (!options.token) throw new Error("OmenClient: token is required");
     if (!options.appId) throw new Error("OmenClient: appId is required");
@@ -498,13 +935,28 @@ var OmenClient = class {
     this.items = new ItemsNamespace(http, options.appId);
     this.collections = new CollectionsNamespace(http, options.appId);
     this.webhooks = new WebhooksNamespace(http, options.appId);
+    this.products = new ProductsNamespace(http, options.appId);
+    this.multiplayer = new MultiplayerNamespace(http, options.appId);
+    this.notifications = new NotificationsNamespace(http, options.appId);
+    this.sparks = new SparksNamespace(http, options.appId);
+    this.emails = new EmailsNamespace(http, options.appId);
+    this.avatar = new AvatarNamespace(options.appId, baseUrl);
+    this.assets = new AssetsNamespace(http, options.appId);
+    this.images = new ImagesNamespace(http, options.appId);
   }
 };
 export {
+  ASK_GROWN_UP_STATES,
+  CHILD_LOGIN_STATES,
+  ChildLogin,
+  ENTRY_STATES,
   OmenAuthError,
   OmenClient,
   OmenError,
   OmenNotFoundError,
   OmenRateLimitError,
-  OmenValidationError
+  OmenValidationError,
+  deriveInitialState,
+  displayGroup,
+  reduce
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omen.dog/sdk",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Official server-side TypeScript SDK for the Omen platform",
   "license": "MIT",
   "main": "./dist/index.js",
@@ -12,6 +12,11 @@
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
     },
+    "./child-login": {
+      "types": "./dist/child-login.d.ts",
+      "import": "./dist/child-login.mjs",
+      "require": "./dist/child-login.js"
+    },
     "./creation": {
       "types": "./dist/creation.d.ts"
     }
@@ -23,7 +28,7 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts --clean && cp src/creation.d.ts dist/creation.d.ts",
+    "build": "tsup src/index.ts src/child-login.ts --format cjs,esm --dts --clean && cp src/creation.d.ts dist/creation.d.ts",
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {