@magicweave/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1561 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CORE_VERSION: () => CORE_VERSION,
+  EnvTokenProvider: () => EnvTokenProvider,
+  MagicweaveClient: () => MagicweaveClient,
+  MagicweaveError: () => MagicweaveError,
+  NotFoundError: () => NotFoundError,
+  PROD_API_BASE: () => PROD_API_BASE,
+  ProjectGraph: () => ProjectGraph,
+  STAGING_API_BASE: () => STAGING_API_BASE,
+  StaticTokenProvider: () => StaticTokenProvider,
+  UnauthorizedError: () => UnauthorizedError,
+  ValidationError: () => ValidationError,
+  buildReferenceGraph: () => buildReferenceGraph,
+  createClient: () => createClient,
+  currencies: () => currencies,
+  decodeJwt: () => decodeJwt,
+  didYouMean: () => didYouMean,
+  environments: () => environments,
+  exportDefinitions: () => exportDefinitions,
+  impactScan: () => impactScan,
+  isExpired: () => isExpired,
+  iterManifestRefs: () => iterManifestRefs,
+  iterSegmentRefs: () => iterSegmentRefs,
+  leaderboards: () => leaderboards,
+  manifests: () => manifests,
+  orgs: () => orgs,
+  projects: () => projects,
+  releases: () => releases,
+  requestLoginOtp: () => requestLoginOtp,
+  resolveBaseUrl: () => resolveBaseUrl,
+  segments: () => segments,
+  spec: () => spec_exports,
+  stats: () => stats,
+  unwrap: () => unwrap,
+  validateSpec: () => validateSpec,
+  verifyLoginOtp: () => verifyLoginOtp,
+  wheels: () => wheels
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_openapi_fetch = __toESM(require("openapi-fetch"), 1);
+var STAGING_API_BASE = "https://console.staging.magicweave.xyz/api";
+var PROD_API_BASE = "https://console.magicweave.xyz/api";
+function resolveBaseUrl(explicit) {
+  return explicit ?? process.env.MW_API_BASE ?? STAGING_API_BASE;
+}
+var MagicweaveError = class extends Error {
+  constructor(message, status, code, detail) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.detail = detail;
+    this.name = "MagicweaveError";
+  }
+  status;
+  code;
+  detail;
+};
+var UnauthorizedError = class extends MagicweaveError {
+  constructor(detail) {
+    super(
+      "Not authenticated or your session expired. Run `mw login`.",
+      401,
+      "unauthorized",
+      detail
+    );
+    this.name = "UnauthorizedError";
+  }
+};
+var NotFoundError = class extends MagicweaveError {
+  constructor(detail) {
+    super("Not found.", 404, "not_found", detail);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends MagicweaveError {
+  constructor(detail) {
+    super(formatValidationDetail(detail), 422, "validation_error", detail);
+    this.name = "ValidationError";
+  }
+};
+function formatValidationDetail(detail) {
+  const list = detail?.detail;
+  if (Array.isArray(list) && list.length) {
+    return list.map((e) => {
+      const field = Array.isArray(e.loc) ? e.loc.filter((p) => p !== "body").join(".") : "";
+      return field ? `${field}: ${e.msg}` : e.msg ?? "invalid";
+    }).join("; ");
+  }
+  if (typeof detail?.detail === "string") {
+    return detail.detail;
+  }
+  return "Request validation failed.";
+}
+function errorFromResponse(response, body) {
+  switch (response.status) {
+    case 401:
+      return new UnauthorizedError(body);
+    case 404:
+      return new NotFoundError(body);
+    case 422:
+      return new ValidationError(body);
+    default: {
+      const msg = body?.detail ?? `Request failed: ${response.status} ${response.statusText}`;
+      return new MagicweaveError(
+        typeof msg === "string" ? msg : `Request failed: ${response.status}`,
+        response.status,
+        "http_error",
+        body
+      );
+    }
+  }
+}
+async function unwrap(promise) {
+  const { data, error, response } = await promise;
+  if (response.ok) return data;
+  throw errorFromResponse(response, error ?? data);
+}
+var MagicweaveClient = class {
+  raw;
+  baseUrl;
+  constructor(opts = {}) {
+    this.baseUrl = resolveBaseUrl(opts.baseUrl);
+    const tokenProvider = opts.tokenProvider;
+    const auth = {
+      async onRequest({ request }) {
+        const token = tokenProvider ? await tokenProvider.getToken() : null;
+        if (token) request.headers.set("Authorization", `Bearer ${token}`);
+        return request;
+      }
+    };
+    this.raw = (0, import_openapi_fetch.default)({
+      baseUrl: this.baseUrl,
+      fetch: opts.fetch
+    });
+    this.raw.use(auth);
+  }
+};
+function createClient(opts = {}) {
+  return new MagicweaveClient(opts);
+}
+
+// src/auth.ts
+async function requestLoginOtp(baseUrl, email, opts = {}) {
+  const f = opts.fetch ?? globalThis.fetch;
+  const res = await f(`${baseUrl}/auth/login-email/`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email })
+  });
+  if (!res.ok) {
+    throw new MagicweaveError(
+      `Could not send a login code to ${email} (HTTP ${res.status}).`,
+      res.status,
+      "otp_request_failed"
+    );
+  }
+}
+async function verifyLoginOtp(baseUrl, email, otp, opts = {}) {
+  const f = opts.fetch ?? globalThis.fetch;
+  const res = await f(`${baseUrl}/auth/verify-email-otp/`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email, otp })
+  });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok || !body.access_token || !body.refresh_token) {
+    throw new MagicweaveError(
+      body.detail ?? "That code was not accepted. Check it and try again.",
+      res.status,
+      "otp_verify_failed",
+      body
+    );
+  }
+  return { access_token: body.access_token, refresh_token: body.refresh_token };
+}
+function decodeJwt(token) {
+  const part = token.split(".")[1];
+  if (!part) return null;
+  try {
+    return JSON.parse(Buffer.from(part, "base64url").toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+function isExpired(token, skewSeconds = 30) {
+  const exp = decodeJwt(token)?.exp;
+  if (!exp) return true;
+  return exp * 1e3 <= Date.now() + skewSeconds * 1e3;
+}
+var StaticTokenProvider = class {
+  constructor(token) {
+    this.token = token;
+  }
+  token;
+  getToken() {
+    return this.token;
+  }
+};
+var EnvTokenProvider = class {
+  getToken() {
+    return process.env.MW_ACCESS_TOKEN ?? null;
+  }
+};
+
+// src/resources/orgs.ts
+function orgs(client) {
+  return {
+    list: () => unwrap(client.raw.GET("/org/")),
+    create: (name) => unwrap(client.raw.POST("/org/", { body: { name } })),
+    remove: (orgId) => unwrap(client.raw.DELETE("/org/{org_id}/", { params: { path: { org_id: orgId } } }))
+  };
+}
+
+// src/resources/projects.ts
+function projects(client) {
+  return {
+    list: (orgId) => unwrap(client.raw.GET("/project/{org_id}", { params: { path: { org_id: orgId } } })),
+    create: (orgId, name) => unwrap(
+      client.raw.POST("/project/{org_id}", {
+        params: { path: { org_id: orgId } },
+        body: { name }
+      })
+    ),
+    remove: (orgId, projectId) => unwrap(
+      client.raw.DELETE("/project/{org_id}/{project_id}/", {
+        params: { path: { org_id: orgId, project_id: projectId } }
+      })
+    ),
+    enableNetwork: (orgId, projectId) => unwrap(
+      client.raw.POST("/project/{org_id}/{project_id}/enable-network", {
+        params: { path: { org_id: orgId, project_id: projectId } }
+      })
+    )
+  };
+}
+
+// src/resources/environments.ts
+function environments(client) {
+  const base = (orgId, projectId) => ({
+    path: { org_id: orgId, project_id: projectId }
+  });
+  const withEnv = (orgId, projectId, environmentId) => ({
+    path: { org_id: orgId, project_id: projectId, environment_id: environmentId }
+  });
+  return {
+    list: (orgId, projectId) => unwrap(
+      client.raw.GET("/project/{org_id}/{project_id}/environments/", {
+        params: base(orgId, projectId)
+      })
+    ),
+    create: (orgId, projectId, name) => unwrap(
+      client.raw.POST("/project/{org_id}/{project_id}/environments/", {
+        params: base(orgId, projectId),
+        body: { name }
+      })
+    ),
+    remove: (orgId, projectId, environmentId) => unwrap(
+      client.raw.DELETE("/project/{org_id}/{project_id}/environments/{environment_id}", {
+        params: withEnv(orgId, projectId, environmentId)
+      })
+    ),
+    rotateSecret: (orgId, projectId, environmentId) => unwrap(
+      client.raw.POST(
+        "/project/{org_id}/{project_id}/environments/{environment_id}/rotate-secret",
+        {
+          params: withEnv(orgId, projectId, environmentId)
+        }
+      )
+    ),
+    rotatePreviewSecret: (orgId, projectId, environmentId) => unwrap(
+      client.raw.POST(
+        "/project/{org_id}/{project_id}/environments/{environment_id}/rotate-preview-secret",
+        { params: withEnv(orgId, projectId, environmentId) }
+      )
+    )
+  };
+}
+
+// src/resources/releases.ts
+function releases(client) {
+  const rel = (orgId, projectId, releaseId) => ({
+    path: { org_id: orgId, project_id: projectId, release_id: releaseId }
+  });
+  return {
+    list: (orgId, projectId, environmentId) => unwrap(
+      client.raw.GET("/project/{org_id}/{project_id}/environments/{environment_id}/releases/", {
+        params: { path: { org_id: orgId, project_id: projectId, environment_id: environmentId } }
+      })
+    ),
+    create: (orgId, projectId, environmentId, body = { release_notes: "" }) => unwrap(
+      client.raw.POST("/project/{org_id}/{project_id}/environments/{environment_id}/releases/", {
+        params: { path: { org_id: orgId, project_id: projectId, environment_id: environmentId } },
+        body
+      })
+    ),
+    update: (orgId, projectId, releaseId, body) => unwrap(
+      client.raw.PATCH("/project/{org_id}/{project_id}/releases/{release_id}", {
+        params: rel(orgId, projectId, releaseId),
+        body
+      })
+    ),
+    remove: (orgId, projectId, releaseId) => unwrap(
+      client.raw.DELETE("/project/{org_id}/{project_id}/releases/{release_id}", {
+        params: rel(orgId, projectId, releaseId)
+      })
+    ),
+    pushItem: (orgId, projectId, releaseId, body) => unwrap(
+      client.raw.POST("/project/{org_id}/{project_id}/releases/{release_id}/items/", {
+        params: rel(orgId, projectId, releaseId),
+        body
+      })
+    ),
+    removeItem: (orgId, projectId, releaseId, itemId) => unwrap(
+      client.raw.DELETE("/project/{org_id}/{project_id}/releases/{release_id}/items/{item_id}", {
+        params: {
+          path: { org_id: orgId, project_id: projectId, release_id: releaseId, item_id: itemId }
+        }
+      })
+    ),
+    lock: (orgId, projectId, releaseId) => unwrap(
+      client.raw.POST("/project/{org_id}/{project_id}/releases/{release_id}/lock", {
+        params: rel(orgId, projectId, releaseId)
+      })
+    ),
+    activate: (orgId, projectId, releaseId) => unwrap(
+      client.raw.POST("/project/{org_id}/{project_id}/releases/{release_id}/activate", {
+        params: rel(orgId, projectId, releaseId)
+      })
+    ),
+    deactivate: (orgId, projectId, releaseId) => unwrap(
+      client.raw.POST("/project/{org_id}/{project_id}/releases/{release_id}/deactivate", {
+        params: rel(orgId, projectId, releaseId)
+      })
+    ),
+    move: (orgId, projectId, releaseId, targetEnvironmentId, note = "") => unwrap(
+      client.raw.POST("/project/{org_id}/{project_id}/releases/{release_id}/move", {
+        params: rel(orgId, projectId, releaseId),
+        body: { target_environment_id: targetEnvironmentId, note }
+      })
+    ),
+    copy: (orgId, projectId, releaseId, targetEnvironmentId, note = "") => unwrap(
+      client.raw.POST("/project/{org_id}/{project_id}/releases/{release_id}/copy", {
+        params: rel(orgId, projectId, releaseId),
+        body: { target_environment_id: targetEnvironmentId, note }
+      })
+    )
+  };
+}
+
+// src/resources/currencies.ts
+function currencies(client) {
+  const proj = (orgId, projectId) => ({
+    path: { org_id: orgId, project_id: projectId }
+  });
+  const one = (orgId, projectId, definitionId) => ({
+    path: { org_id: orgId, project_id: projectId, definition_id: definitionId }
+  });
+  return {
+    list: (orgId, projectId) => unwrap(
+      client.raw.GET("/currency-definitions/{org_id}/{project_id}/", {
+        params: proj(orgId, projectId)
+      })
+    ),
+    overview: (orgId, projectId) => unwrap(
+      client.raw.GET("/currency-definitions/{org_id}/{project_id}/overview/", {
+        params: proj(orgId, projectId)
+      })
+    ),
+    get: (orgId, projectId, definitionId) => unwrap(
+      client.raw.GET("/currency-definitions/{org_id}/{project_id}/{definition_id}/", {
+        params: one(orgId, projectId, definitionId)
+      })
+    ),
+    create: (orgId, projectId, body) => unwrap(
+      client.raw.POST("/currency-definitions/{org_id}/{project_id}/", {
+        params: proj(orgId, projectId),
+        body
+      })
+    ),
+    update: (orgId, projectId, definitionId, body) => unwrap(
+      client.raw.PATCH("/currency-definitions/{org_id}/{project_id}/{definition_id}/", {
+        params: one(orgId, projectId, definitionId),
+        body
+      })
+    ),
+    remove: (orgId, projectId, definitionId) => unwrap(
+      client.raw.DELETE("/currency-definitions/{org_id}/{project_id}/{definition_id}/", {
+        params: one(orgId, projectId, definitionId)
+      })
+    )
+  };
+}
+
+// src/resources/stats.ts
+function stats(client) {
+  const proj = (orgId, projectId) => ({
+    path: { org_id: orgId, project_id: projectId }
+  });
+  const one = (orgId, projectId, definitionId) => ({
+    path: { org_id: orgId, project_id: projectId, definition_id: definitionId }
+  });
+  return {
+    list: (orgId, projectId) => unwrap(
+      client.raw.GET("/stat-definitions/{org_id}/{project_id}/", {
+        params: proj(orgId, projectId)
+      })
+    ),
+    overview: (orgId, projectId) => unwrap(
+      client.raw.GET("/stat-definitions/{org_id}/{project_id}/overview/", {
+        params: proj(orgId, projectId)
+      })
+    ),
+    get: (orgId, projectId, definitionId) => unwrap(
+      client.raw.GET("/stat-definitions/{org_id}/{project_id}/{definition_id}/", {
+        params: one(orgId, projectId, definitionId)
+      })
+    ),
+    create: (orgId, projectId, body) => unwrap(
+      client.raw.POST("/stat-definitions/{org_id}/{project_id}/", {
+        params: proj(orgId, projectId),
+        body
+      })
+    ),
+    update: (orgId, projectId, definitionId, body) => unwrap(
+      client.raw.PATCH("/stat-definitions/{org_id}/{project_id}/{definition_id}/", {
+        params: one(orgId, projectId, definitionId),
+        body
+      })
+    ),
+    remove: (orgId, projectId, definitionId) => unwrap(
+      client.raw.DELETE("/stat-definitions/{org_id}/{project_id}/{definition_id}/", {
+        params: one(orgId, projectId, definitionId)
+      })
+    )
+  };
+}
+
+// src/resources/manifests.ts
+function manifests(client) {
+  const proj = (orgId, projectId) => ({
+    path: { org_id: orgId, project_id: projectId }
+  });
+  const one = (orgId, projectId, manifestId) => ({
+    path: { org_id: orgId, project_id: projectId, manifest_id: manifestId }
+  });
+  return {
+    list: (orgId, projectId) => unwrap(
+      client.raw.GET("/game-manifests/{org_id}/{project_id}/", {
+        params: proj(orgId, projectId)
+      })
+    ),
+    overview: (orgId, projectId) => unwrap(
+      client.raw.GET("/game-manifests/{org_id}/{project_id}/overview/", {
+        params: proj(orgId, projectId)
+      })
+    ),
+    get: (orgId, projectId, manifestId) => unwrap(
+      client.raw.GET("/game-manifests/{org_id}/{project_id}/{manifest_id}/", {
+        params: one(orgId, projectId, manifestId)
+      })
+    ),
+    create: (orgId, projectId, body) => unwrap(
+      client.raw.POST("/game-manifests/{org_id}/{project_id}/", {
+        params: proj(orgId, projectId),
+        body
+      })
+    ),
+    update: (orgId, projectId, manifestId, body) => unwrap(
+      client.raw.PATCH("/game-manifests/{org_id}/{project_id}/{manifest_id}/", {
+        params: one(orgId, projectId, manifestId),
+        body
+      })
+    ),
+    remove: (orgId, projectId, manifestId) => unwrap(
+      client.raw.DELETE("/game-manifests/{org_id}/{project_id}/{manifest_id}/", {
+        params: one(orgId, projectId, manifestId)
+      })
+    )
+  };
+}
+
+// src/resources/leaderboards.ts
+function leaderboards(client) {
+  const proj = (orgId, projectId) => ({
+    path: { org_id: orgId, project_id: projectId }
+  });
+  const one = (orgId, projectId, leaderboardId) => ({
+    path: { org_id: orgId, project_id: projectId, leaderboard_id: leaderboardId }
+  });
+  return {
+    list: (orgId, projectId) => unwrap(
+      client.raw.GET("/leaderboards/{org_id}/{project_id}/", { params: proj(orgId, projectId) })
+    ),
+    overview: (orgId, projectId) => unwrap(
+      client.raw.GET("/leaderboards/{org_id}/{project_id}/overview/", {
+        params: proj(orgId, projectId)
+      })
+    ),
+    get: (orgId, projectId, leaderboardId) => unwrap(
+      client.raw.GET("/leaderboards/{org_id}/{project_id}/{leaderboard_id}/", {
+        params: one(orgId, projectId, leaderboardId)
+      })
+    ),
+    create: (orgId, projectId, body) => unwrap(
+      client.raw.POST("/leaderboards/{org_id}/{project_id}/", {
+        params: proj(orgId, projectId),
+        body
+      })
+    ),
+    update: (orgId, projectId, leaderboardId, body) => unwrap(
+      client.raw.PATCH("/leaderboards/{org_id}/{project_id}/{leaderboard_id}/", {
+        params: one(orgId, projectId, leaderboardId),
+        body
+      })
+    ),
+    remove: (orgId, projectId, leaderboardId) => unwrap(
+      client.raw.DELETE("/leaderboards/{org_id}/{project_id}/{leaderboard_id}/", {
+        params: one(orgId, projectId, leaderboardId)
+      })
+    ),
+    /** Irreversible: archive scores and reset the board. Confirm-gate in the CLI. */
+    processReset: (orgId, projectId, leaderboardId) => unwrap(
+      client.raw.POST("/leaderboards/{org_id}/{project_id}/{leaderboard_id}/process-reset/", {
+        params: one(orgId, projectId, leaderboardId)
+      })
+    )
+  };
+}
+
+// src/resources/segments.ts
+function segments(client) {
+  const proj = (orgId, projectId) => ({
+    path: { org_id: orgId, project_id: projectId }
+  });
+  const one = (orgId, projectId, segmentId) => ({
+    path: { org_id: orgId, project_id: projectId, segment_id: segmentId }
+  });
+  return {
+    list: (orgId, projectId) => unwrap(
+      client.raw.GET("/spin-wheel/{org_id}/{project_id}/segments/", {
+        params: proj(orgId, projectId)
+      })
+    ),
+    catalog: (orgId, projectId) => unwrap(
+      client.raw.GET("/spin-wheel/{org_id}/{project_id}/segments/catalog/", {
+        params: proj(orgId, projectId)
+      })
+    ),
+    get: (orgId, projectId, segmentId) => unwrap(
+      client.raw.GET("/spin-wheel/{org_id}/{project_id}/segments/{segment_id}/", {
+        params: one(orgId, projectId, segmentId)
+      })
+    ),
+    create: (orgId, projectId, body) => unwrap(
+      client.raw.POST("/spin-wheel/{org_id}/{project_id}/segments/", {
+        params: proj(orgId, projectId),
+        body
+      })
+    ),
+    update: (orgId, projectId, segmentId, body) => unwrap(
+      client.raw.PATCH("/spin-wheel/{org_id}/{project_id}/segments/{segment_id}/", {
+        params: one(orgId, projectId, segmentId),
+        body
+      })
+    ),
+    remove: (orgId, projectId, segmentId) => unwrap(
+      client.raw.DELETE("/spin-wheel/{org_id}/{project_id}/segments/{segment_id}/", {
+        params: one(orgId, projectId, segmentId)
+      })
+    )
+  };
+}
+
+// src/resources/wheels.ts
+function wheels(client) {
+  const proj = (orgId, projectId) => ({
+    path: { org_id: orgId, project_id: projectId }
+  });
+  const one = (orgId, projectId, wheelConfigId) => ({
+    path: { org_id: orgId, project_id: projectId, wheel_config_id: wheelConfigId }
+  });
+  return {
+    list: (orgId, projectId) => unwrap(
+      client.raw.GET("/spin-wheel/{org_id}/{project_id}/wheels/", {
+        params: proj(orgId, projectId)
+      })
+    ),
+    overview: (orgId, projectId) => unwrap(
+      client.raw.GET("/spin-wheel/{org_id}/{project_id}/wheels/overview/", {
+        params: proj(orgId, projectId)
+      })
+    ),
+    create: (orgId, projectId, body) => unwrap(
+      client.raw.POST("/spin-wheel/{org_id}/{project_id}/wheels/", {
+        params: proj(orgId, projectId),
+        body
+      })
+    ),
+    update: (orgId, projectId, wheelConfigId, body) => unwrap(
+      client.raw.PATCH("/spin-wheel/{org_id}/{project_id}/wheels/{wheel_config_id}/", {
+        params: one(orgId, projectId, wheelConfigId),
+        body
+      })
+    ),
+    remove: (orgId, projectId, wheelConfigId) => unwrap(
+      client.raw.DELETE("/spin-wheel/{org_id}/{project_id}/wheels/{wheel_config_id}/", {
+        params: one(orgId, projectId, wheelConfigId)
+      })
+    )
+  };
+}
+
+// src/schemas/spec.ts
+var spec_exports = {};
+__export(spec_exports, {
+  Condition: () => Condition,
+  ConditionSet: () => ConditionSet,
+  CurrencySpec: () => CurrencySpec,
+  EconomySpec: () => EconomySpec,
+  EntryRequirement: () => EntryRequirement,
+  Formula: () => Formula,
+  LeaderboardSpec: () => LeaderboardSpec,
+  ManifestSpec: () => ManifestSpec,
+  Outcome: () => Outcome,
+  Reward: () => Reward,
+  SegmentSpec: () => SegmentSpec,
+  StatSpec: () => StatSpec,
+  Step: () => Step,
+  WheelSegmentLink: () => WheelSegmentLink,
+  WheelSpec: () => WheelSpec
+});
+var import_zod = require("zod");
+var CurrencySpec = import_zod.z.object({
+  key: import_zod.z.string(),
+  name: import_zod.z.string(),
+  symbol: import_zod.z.string().default(""),
+  initial_balance: import_zod.z.number().int().default(0),
+  max_balance: import_zod.z.number().int().nullable().default(null),
+  usable_as_reward: import_zod.z.boolean().default(true),
+  usable_in_conditions: import_zod.z.boolean().default(true)
+});
+var StatSpec = import_zod.z.object({
+  key: import_zod.z.string(),
+  name: import_zod.z.string(),
+  stat_type: import_zod.z.string(),
+  // integer | float | boolean
+  default_value: import_zod.z.union([import_zod.z.number(), import_zod.z.boolean()]),
+  min_value: import_zod.z.number().nullable().default(null),
+  max_value: import_zod.z.number().nullable().default(null),
+  usable_in_conditions: import_zod.z.boolean().default(true),
+  usable_as_reward: import_zod.z.boolean().default(true)
+});
+var Formula = import_zod.z.object({
+  formula: import_zod.z.string().nullish(),
+  max: import_zod.z.number().nullish()
+});
+var Outcome = import_zod.z.object({
+  reward_type: import_zod.z.string().nullish(),
+  // fixed | variable
+  reward_target: import_zod.z.string().nullish(),
+  // currency | stat | gem
+  currency_key: import_zod.z.string().nullish(),
+  stat_key: import_zod.z.string().nullish(),
+  operation: import_zod.z.string().nullish(),
+  // add | subtract | set | multiply
+  value: import_zod.z.number().nullish(),
+  formula: Formula.nullish()
+});
+var Condition = import_zod.z.object({
+  payload_key: import_zod.z.string().nullish(),
+  operator: import_zod.z.string().nullish(),
+  // eq | neq | gt | gte | lt | lte
+  expected_value: import_zod.z.union([import_zod.z.number(), import_zod.z.boolean(), import_zod.z.string()]).nullish()
+});
+var ConditionSet = import_zod.z.object({
+  conditions: import_zod.z.array(Condition).default([]),
+  outcomes: import_zod.z.array(Outcome).default([])
+});
+var Step = import_zod.z.object({
+  key: import_zod.z.string().nullish(),
+  // optional so the validator, not Zod, reports "missing key"
+  name: import_zod.z.string().default(""),
+  is_entry: import_zod.z.boolean().default(false),
+  is_terminal: import_zod.z.boolean().default(false),
+  next_step_keys: import_zod.z.array(import_zod.z.string()).default([]),
+  condition_sets: import_zod.z.array(ConditionSet).default([])
+});
+var EntryRequirement = import_zod.z.object({
+  requirement_type: import_zod.z.string().nullish(),
+  // entry_cost | eligibility
+  value_source: import_zod.z.string().nullish(),
+  // currency | stat
+  currency_key: import_zod.z.string().nullish(),
+  stat_key: import_zod.z.string().nullish(),
+  operator: import_zod.z.string().nullish(),
+  // gte | lte | eq (eligibility)
+  threshold_value: import_zod.z.union([import_zod.z.number(), import_zod.z.boolean()]).nullish(),
+  cost_amount: import_zod.z.number().int().nullish()
+  // REQUIRED by the admin API for entry_cost
+});
+var ManifestSpec = import_zod.z.object({
+  slug: import_zod.z.string(),
+  name: import_zod.z.string(),
+  entry_requirements: import_zod.z.array(EntryRequirement).default([]),
+  steps: import_zod.z.array(Step)
+});
+var LeaderboardSpec = import_zod.z.object({
+  slug: import_zod.z.string(),
+  name: import_zod.z.string(),
+  stat_key: import_zod.z.string(),
+  // authored by key; resolved to stat_id at create time
+  sort_order: import_zod.z.string().default("desc"),
+  leaderboard_type: import_zod.z.string().default("relative"),
+  reset_type: import_zod.z.string().nullable().default(null),
+  soft_reset_percentage: import_zod.z.number().nullish()
+});
+var Reward = import_zod.z.object({
+  reward_type: import_zod.z.string().nullish(),
+  // currency | stat | gem
+  currency_key: import_zod.z.string().nullish(),
+  stat_key: import_zod.z.string().nullish(),
+  amount: import_zod.z.number().int().nullish()
+});
+var SegmentSpec = import_zod.z.object({
+  label: import_zod.z.string(),
+  reward: Reward,
+  probability: import_zod.z.number().int(),
+  can_override: import_zod.z.boolean().default(false)
+});
+var WheelSegmentLink = import_zod.z.object({
+  segment_ref: import_zod.z.string(),
+  // label of a segment defined in this spec
+  probability_override: import_zod.z.number().int().nullish()
+});
+var WheelSpec = import_zod.z.object({
+  key_slug: import_zod.z.string(),
+  name: import_zod.z.string(),
+  daily_free_spins: import_zod.z.number().int().default(1),
+  allow_paid_spins: import_zod.z.boolean().default(false),
+  paid_spin_currency_key: import_zod.z.string().default(""),
+  paid_spin_currency_amount: import_zod.z.number().int().nullish(),
+  segments: import_zod.z.array(WheelSegmentLink).default([])
+});
+var EconomySpec = import_zod.z.object({
+  currencies: import_zod.z.array(CurrencySpec).default([]),
+  stats: import_zod.z.array(StatSpec).default([]),
+  manifests: import_zod.z.array(ManifestSpec).default([]),
+  leaderboards: import_zod.z.array(LeaderboardSpec).default([]),
+  segments: import_zod.z.array(SegmentSpec).default([]),
+  wheels: import_zod.z.array(WheelSpec).default([])
+});
+
+// src/smart/export.ts
+async function exportDefinitions(client, orgId, projectId) {
+  const [currencyList, statList, manifestList, leaderboardList, segmentList, wheelList] = await Promise.all([
+    currencies(client).list(orgId, projectId),
+    stats(client).list(orgId, projectId),
+    manifests(client).list(orgId, projectId),
+    leaderboards(client).list(orgId, projectId),
+    segments(client).list(orgId, projectId),
+    wheels(client).list(orgId, projectId)
+  ]);
+  return {
+    org_id: orgId,
+    project_id: projectId,
+    currencies: currencyList,
+    stats: statList,
+    manifests: manifestList,
+    leaderboards: leaderboardList,
+    segments: segmentList,
+    wheels: wheelList
+  };
+}
+
+// src/smart/refgraph.ts
+function didYouMean(needle, candidates) {
+  let best = null;
+  let bestRatio = 0;
+  for (const c of candidates) {
+    const r = similarity(needle, c);
+    if (r > bestRatio) {
+      bestRatio = r;
+      best = c;
+    }
+  }
+  return bestRatio >= 0.6 ? best : null;
+}
+function similarity(a, b) {
+  if (a === b) return 1;
+  if (!a.length || !b.length) return 0;
+  return 2 * lcsLength(a, b) / (a.length + b.length);
+}
+function lcsLength(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const row = new Array(n + 1).fill(0);
+  for (let i = 1; i <= m; i++) {
+    let prevDiag = 0;
+    for (let j = 1; j <= n; j++) {
+      const tmp = row[j];
+      row[j] = a[i - 1] === b[j - 1] ? prevDiag + 1 : Math.max(row[j], row[j - 1]);
+      prevDiag = tmp;
+    }
+  }
+  return row[n];
+}
+function str(v) {
+  return typeof v === "string" && v ? v : void 0;
+}
+function* iterManifestRefs(manifest) {
+  for (const req of manifest.entry_requirements ?? []) {
+    if (typeof req !== "object" || req === null) continue;
+    const ck = str(req.currency_key);
+    if (ck) yield ["currency", ck, "entry requirement"];
+    const sk = str(req.stat_key);
+    if (sk) yield ["stat", sk, "entry requirement"];
+  }
+  for (const step of manifest.steps ?? []) {
+    if (typeof step !== "object" || step === null) continue;
+    const skey = str(step.key) ?? "?";
+    for (const cs of step.condition_sets ?? []) {
+      if (typeof cs !== "object" || cs === null) continue;
+      for (const out of cs.outcomes ?? []) {
+        if (typeof out !== "object" || out === null) continue;
+        const target = out.reward_target;
+        if (target === "currency") {
+          const ck = str(out.currency_key);
+          if (ck) yield ["currency", ck, `outcome in step '${skey}'`];
+        } else if (target === "stat") {
+          const sk = str(out.stat_key);
+          if (sk) yield ["stat", sk, `outcome in step '${skey}'`];
+        }
+      }
+    }
+  }
+}
+function* iterSegmentRefs(segment) {
+  const reward = segment.reward ?? {};
+  if (reward.reward_type === "currency") {
+    const ck = str(reward.currency_key);
+    if (ck) yield ["currency", ck, "segment reward"];
+  } else if (reward.reward_type === "stat") {
+    const sk = str(reward.stat_key);
+    if (sk) yield ["stat", sk, "segment reward"];
+  }
+}
+function wheelViews(wheel) {
+  const eff = wheel.effective ?? {};
+  const cfg = wheel.wheel_config ?? {};
+  if (Object.keys(eff).length === 0 && Object.keys(cfg).length === 0) return [wheel, wheel];
+  return [eff, cfg];
+}
+var ProjectGraph = class {
+  constructor(currencies2, stats2, manifests2, leaderboards2, segments2, wheels2) {
+    this.currencies = currencies2;
+    this.stats = stats2;
+    this.manifests = manifests2;
+    this.leaderboards = leaderboards2;
+    this.segments = segments2;
+    this.wheels = wheels2;
+  }
+  currencies;
+  stats;
+  manifests;
+  leaderboards;
+  segments;
+  wheels;
+  currencyKeys() {
+    return this.currencies.map((c) => str(c.key)).filter((k) => !!k);
+  }
+  statKeys() {
+    return this.stats.map((s) => str(s.key)).filter((k) => !!k);
+  }
+  segmentIds() {
+    return this.segments.map((s) => s.id).filter((v) => typeof v === "number");
+  }
+  statIdForKey(key) {
+    for (const s of this.stats) if (s.key === key) return s.id ?? null;
+    return null;
+  }
+  /** Inbound references (blast radius) to a currency/stat (by key) or segment (by id). */
+  referencesTo(kind, ref) {
+    if (kind === "segment") return this.refsToSegment(Number(ref));
+    return this.refsToDefinition(kind, String(ref));
+  }
+  refsToDefinition(targetKind, key) {
+    const found = [];
+    for (const m of this.manifests) {
+      for (const [tk, refKey, locus] of iterManifestRefs(m)) {
+        if (tk === targetKind && refKey === key) {
+          found.push({
+            referencingKind: "manifest",
+            id: m.id ?? null,
+            name: str(m.slug) ?? "?",
+            locus
+          });
+        }
+      }
+    }
+    for (const seg of this.segments) {
+      for (const [tk, refKey] of iterSegmentRefs(seg)) {
+        if (tk === targetKind && refKey === key) {
+          found.push({
+            referencingKind: "segment",
+            id: seg.id ?? null,
+            name: str(seg.label) ?? "?",
+            locus: "segment reward"
+          });
+        }
+      }
+    }
+    if (targetKind === "currency") {
+      for (const w of this.wheels) {
+        const [eff, cfg] = wheelViews(w);
+        const paid = str(cfg.paid_spin_currency_key) ?? str(eff.paid_spin_currency_key);
+        if (paid === key) {
+          found.push({
+            referencingKind: "wheel",
+            id: cfg.id ?? null,
+            name: str(cfg.key_slug) ?? str(eff.key_slug) ?? "?",
+            locus: "paid-spin currency"
+          });
+        }
+      }
+    }
+    if (targetKind === "stat") {
+      const statId = this.statIdForKey(key);
+      if (statId !== null) {
+        for (const lb of this.leaderboards) {
+          if (lb.stat_id === statId) {
+            found.push({
+              referencingKind: "leaderboard",
+              id: lb.id ?? null,
+              name: str(lb.slug) ?? "?",
+              locus: "ranked stat"
+            });
+          }
+        }
+      }
+    }
+    return found;
+  }
+  refsToSegment(segmentId) {
+    const found = [];
+    for (const w of this.wheels) {
+      const [eff, cfg] = wheelViews(w);
+      const links = eff.segments ?? cfg.segments ?? [];
+      if (links.some((l) => l.segment_id === segmentId)) {
+        found.push({
+          referencingKind: "wheel",
+          id: cfg.id ?? null,
+          name: str(cfg.key_slug) ?? str(eff.key_slug) ?? "?",
+          locus: "wheel segment link"
+        });
+      }
+    }
+    return found;
+  }
+};
+async function buildReferenceGraph(client, orgId, projectId) {
+  const path = { org_id: orgId, project_id: projectId };
+  const pick = (obj, key) => {
+    const arr = obj?.[key];
+    return Array.isArray(arr) ? arr : [];
+  };
+  const [currencies2, stats2, manifests2, leaderboards2, segments2, wheels2] = await Promise.all([
+    unwrap(client.raw.GET("/currency-definitions/{org_id}/{project_id}/", { params: { path } })),
+    unwrap(client.raw.GET("/stat-definitions/{org_id}/{project_id}/", { params: { path } })),
+    unwrap(client.raw.GET("/game-manifests/{org_id}/{project_id}/", { params: { path } })),
+    unwrap(client.raw.GET("/leaderboards/{org_id}/{project_id}/", { params: { path } })),
+    unwrap(client.raw.GET("/spin-wheel/{org_id}/{project_id}/segments/", { params: { path } })),
+    unwrap(client.raw.GET("/spin-wheel/{org_id}/{project_id}/wheels/", { params: { path } }))
+  ]);
+  return new ProjectGraph(
+    pick(currencies2, "currency_definitions"),
+    pick(stats2, "stat_definitions"),
+    pick(manifests2, "game_manifests"),
+    pick(leaderboards2, "leaderboards"),
+    pick(segments2, "segments"),
+    pick(wheels2, "wheels")
+  );
+}
+
+// src/smart/validate.ts
+var STAT_TYPES = ["integer", "float", "boolean"];
+var SORT_ORDERS = ["desc", "asc"];
+var LEADERBOARD_TYPES = ["relative", "absolute"];
+var RESET_TYPES = ["soft", "hard"];
+var REWARD_TYPES = ["currency", "stat", "gem"];
+var REQUIREMENT_TYPES = ["entry_cost", "eligibility"];
+var VALUE_SOURCES = ["currency", "stat"];
+var OUTCOME_REWARD_TYPES = ["fixed", "variable"];
+var REWARD_TARGETS = ["currency", "stat", "gem"];
+var OPERATIONS = ["add", "subtract", "set", "multiply"];
+var OPERATORS = ["eq", "neq", "gt", "gte", "lt", "lte"];
+var EXPR_IN_VALUE = /\s[-+*/]\s/;
+var FORMULA_TOKEN = /[A-Za-z_][A-Za-z0-9_]*/g;
+var FORMULA_NOISE = /* @__PURE__ */ new Set([
+  "max",
+  "min",
+  "abs",
+  "round",
+  "floor",
+  "ceil",
+  "sqrt",
+  "pow",
+  "if",
+  "else",
+  "and",
+  "or",
+  "not",
+  "true",
+  "false"
+]);
+function validateSpec(input) {
+  const parsed = EconomySpec.safeParse(input);
+  if (!parsed.success) {
+    const violations = parsed.error.issues.map((issue) => ({
+      path: issue.path.join("."),
+      message: issue.message,
+      severity: "error",
+      rule: "schema"
+    }));
+    return report(violations);
+  }
+  return report(validateEconomy(parsed.data));
+}
+function report(violations) {
+  const errors = violations.filter((v) => v.severity === "error").length;
+  const warnings = violations.length - errors;
+  return { ok: errors === 0, violations, summary: { errors, warnings } };
+}
+function validateEconomy(spec) {
+  const out = [];
+  const currencyKeys = new Set(spec.currencies.map((c) => c.key));
+  const statKeys = new Set(spec.stats.map((s) => s.key));
+  const segmentLabels = new Set(spec.segments.map((s) => s.label));
+  const bad = (path, message, severity = "error", rule) => out.push({ path, message, severity, rule });
+  const refOk = (kind, key, path) => {
+    const pool = kind === "currency" ? currencyKeys : statKeys;
+    if (!pool.has(key)) {
+      const hint = didYouMean(key, [...pool].sort());
+      bad(
+        path,
+        `references unknown ${kind} '${key}'.${hint ? ` Did you mean '${hint}'?` : ""}`,
+        "error",
+        "unknown-ref"
+      );
+    }
+  };
+  for (const [poolName, items] of [
+    ["currencies", spec.currencies],
+    ["stats", spec.stats]
+  ]) {
+    const seen = /* @__PURE__ */ new Set();
+    items.forEach((item, i) => {
+      if (seen.has(item.key))
+        bad(`${poolName}[${i}].key`, `duplicate key '${item.key}'.`, "error", "duplicate-key");
+      seen.add(item.key);
+    });
+  }
+  spec.stats.forEach((s, i) => {
+    if (!STAT_TYPES.includes(s.stat_type)) {
+      bad(
+        `stats[${i}].stat_type`,
+        `must be one of ${STAT_TYPES.join(", ")}.`,
+        "error",
+        "stat-type"
+      );
+    }
+  });
+  spec.manifests.forEach((m, i) => {
+    const stepsErr = validateSteps(m);
+    if (stepsErr) bad(`manifests[${i}].steps`, stepsErr, "error", "steps-shape");
+    for (const [tk, key, locus] of iterManifestRefs(m)) {
+      refOk(tk, key, `manifests[${i}] (${locus})`);
+    }
+    validateManifestInternals(bad, i, m);
+    validateEntryRequirements(bad, i, m);
+    lintReachability(bad, i, m);
+    lintFormulaKeys(bad, i, m);
+  });
+  spec.leaderboards.forEach((lb, i) => {
+    const lbErr = validateLeaderboardFields(lb);
+    if (lbErr) bad(`leaderboards[${i}]`, lbErr, "error", "leaderboard-fields");
+    if (!statKeys.has(lb.stat_key)) {
+      const hint = didYouMean(lb.stat_key, [...statKeys].sort());
+      bad(
+        `leaderboards[${i}].stat_key`,
+        `unknown stat '${lb.stat_key}'.${hint ? ` Did you mean '${hint}'?` : ""}`,
+        "error",
+        "unknown-ref"
+      );
+    }
+  });
+  spec.segments.forEach((seg, i) => {
+    const rErr = validateReward(seg.reward);
+    if (rErr) bad(`segments[${i}].reward`, rErr, "error", "reward-shape");
+    for (const [tk, key] of iterSegmentRefs({ reward: seg.reward })) {
+      refOk(tk, key, `segments[${i}].reward`);
+    }
+    if (seg.reward.reward_type === "gem") {
+      bad(
+        `segments[${i}].reward.reward_type`,
+        "gem rewards are only allowed on network catalog segments \u2014 project segments may reward currency only. Link network gem segments into the wheel at authoring time (get_segment_catalog).",
+        "error",
+        "gem-project-segment"
+      );
+    }
+  });
+  spec.wheels.forEach((w, i) => validateWheelSpec(out, i, w, spec, currencyKeys, segmentLabels));
+  lintPhantomStats(bad, spec);
+  lintOrphanCurrencies(bad, spec);
+  return out;
+}
+function validateSteps(m) {
+  const steps = m.steps ?? [];
+  if (steps.length === 0) return "manifest has no steps.";
+  const keys = steps.map((s) => s.key).filter((k) => !!k);
+  if (keys.length !== steps.length) return "every step must have a key.";
+  if (new Set(keys).size !== keys.length) return "step keys must be unique.";
+  const entries = steps.filter((s) => s.is_entry);
+  if (entries.length !== 1) return `exactly one step must be is_entry (found ${entries.length}).`;
+  if (!steps.some((s) => s.is_terminal)) return "at least one step must be is_terminal.";
+  const keySet = new Set(keys);
+  for (const s of steps) {
+    for (const nk of s.next_step_keys ?? []) {
+      if (!keySet.has(nk)) return `step '${s.key}' points to unknown next step '${nk}'.`;
+    }
+  }
+  return null;
+}
+function validateLeaderboardFields(lb) {
+  if (!SORT_ORDERS.includes(lb.sort_order))
+    return `sort_order must be one of ${SORT_ORDERS.join(", ")}.`;
+  if (!LEADERBOARD_TYPES.includes(lb.leaderboard_type))
+    return `leaderboard_type must be one of ${LEADERBOARD_TYPES.join(", ")}.`;
+  if (lb.reset_type != null && !RESET_TYPES.includes(lb.reset_type))
+    return `reset_type must be one of ${RESET_TYPES.join(", ")} or null.`;
+  if (lb.reset_type === "soft") {
+    const p = lb.soft_reset_percentage;
+    if (p == null || p <= 0 || p > 100)
+      return "soft reset requires soft_reset_percentage in (0, 100].";
+  }
+  return null;
+}
+function validateReward(reward) {
+  if (!reward.reward_type) return "reward is missing reward_type (currency | stat | gem).";
+  if (!REWARD_TYPES.includes(reward.reward_type))
+    return `reward_type must be one of ${REWARD_TYPES.join(", ")}.`;
+  if (reward.reward_type === "currency" && !reward.currency_key)
+    return "currency reward must set currency_key.";
+  if (reward.reward_type === "stat" && !reward.stat_key) return "stat reward must set stat_key.";
+  if (reward.amount == null || reward.amount < 1) return "reward amount must be an integer >= 1.";
+  return null;
+}
+function validateEntryRequirements(bad, i, m) {
+  m.entry_requirements.forEach((req, j) => {
+    const base = `manifests[${i}].entry_requirements[${j}]`;
+    if (!req.requirement_type || !REQUIREMENT_TYPES.includes(req.requirement_type)) {
+      bad(
+        `${base}.requirement_type`,
+        `must be one of ${REQUIREMENT_TYPES.join(", ")} (got ${JSON.stringify(req.requirement_type)}).`,
+        "error",
+        "entry-requirement"
+      );
+    }
+    if (!req.value_source || !VALUE_SOURCES.includes(req.value_source)) {
+      bad(
+        `${base}.value_source`,
+        `is required and must be one of ${VALUE_SOURCES.join(", ")}.`,
+        "error",
+        "entry-requirement"
+      );
+    }
+    if (req.requirement_type === "entry_cost" && (req.cost_amount == null || req.cost_amount < 1)) {
+      bad(
+        `${base}.cost_amount`,
+        "cost_amount (integer >= 1) is required for entry_cost.",
+        "error",
+        "entry-requirement"
+      );
+    }
+  });
+}
+function validateManifestInternals(bad, i, m) {
+  m.steps.forEach((step, j) => {
+    step.condition_sets.forEach((cs, k) => {
+      const baseCs = `manifests[${i}].steps[${j}].condition_sets[${k}]`;
+      cs.conditions.forEach((cond, c) => {
+        if (cond.operator != null && !OPERATORS.includes(cond.operator)) {
+          bad(
+            `${baseCs}.conditions[${c}].operator`,
+            `must be one of ${OPERATORS.join(", ")}.`,
+            "error",
+            "condition-operator"
+          );
+        }
+        if (typeof cond.expected_value === "string" && EXPR_IN_VALUE.test(cond.expected_value)) {
+          bad(
+            `${baseCs}.conditions[${c}].expected_value`,
+            `'${cond.expected_value}' looks like an expression \u2014 expected_value must be a literal; compute the value client-side and send the result in the record payload.`,
+            "warning",
+            "expected-value-literal"
+          );
+        }
+      });
+      cs.outcomes.forEach((oc, o) => {
+        const base = `${baseCs}.outcomes[${o}]`;
+        if (!oc.reward_type)
+          bad(base, "outcome is missing reward_type (fixed | variable).", "error", "outcome-enum");
+        else if (!OUTCOME_REWARD_TYPES.includes(oc.reward_type))
+          bad(
+            `${base}.reward_type`,
+            `must be one of ${OUTCOME_REWARD_TYPES.join(", ")}.`,
+            "error",
+            "outcome-enum"
+          );
+        if (!oc.reward_target)
+          bad(
+            base,
+            "outcome is missing reward_target (currency | stat | gem).",
+            "error",
+            "outcome-enum"
+          );
+        else if (!REWARD_TARGETS.includes(oc.reward_target))
+          bad(
+            `${base}.reward_target`,
+            `must be one of ${REWARD_TARGETS.join(", ")}.`,
+            "error",
+            "outcome-enum"
+          );
+        if (oc.operation != null && !OPERATIONS.includes(oc.operation))
+          bad(
+            `${base}.operation`,
+            `must be one of ${OPERATIONS.join(", ")}.`,
+            "error",
+            "outcome-enum"
+          );
+        const hasFormula = oc.formula != null && !!oc.formula.formula;
+        if (oc.reward_type === "fixed") {
+          if (oc.value == null) bad(base, "fixed outcome must set value.", "error", "pairing");
+          if (hasFormula)
+            bad(
+              base,
+              "fixed outcome must not carry a formula \u2014 use reward_type 'variable' to evaluate a formula.",
+              "error",
+              "pairing"
+            );
+        } else if (oc.reward_type === "variable") {
+          if (!hasFormula)
+            bad(base, "variable outcome must set formula.formula.", "error", "pairing");
+          if (oc.value != null)
+            bad(
+              base,
+              "variable outcome must not set value \u2014 use reward_type 'fixed' to award a fixed value.",
+              "error",
+              "pairing"
+            );
+        }
+        if (oc.reward_target === "gem" && oc.reward_type === "variable" && oc.formula != null && oc.formula.max == null) {
+          bad(
+            `${base}.formula.max`,
+            "uncapped variable gem award \u2014 set formula.max (gems are the network-wide premium wallet).",
+            "warning",
+            "uncapped-gem"
+          );
+        }
+      });
+    });
+  });
+}
+function validateWheelSpec(out, i, wheel, spec, currencyKeys, segmentLabels) {
+  const probByLabel = new Map(spec.segments.map((s) => [s.label, s.probability]));
+  let total = 0;
+  wheel.segments.forEach((link, j) => {
+    if (!segmentLabels.has(link.segment_ref)) {
+      const hint = didYouMean(link.segment_ref, [...segmentLabels].sort());
+      out.push({
+        path: `wheels[${i}].segments[${j}].segment_ref`,
+        message: `unknown segment '${link.segment_ref}'.${hint ? ` Did you mean '${hint}'?` : ""}`,
+        severity: "error",
+        rule: "segment-ref"
+      });
+      return;
+    }
+    total += link.probability_override ?? probByLabel.get(link.segment_ref) ?? 0;
+  });
+  if (wheel.segments.length && total !== 100) {
+    out.push({
+      path: `wheels[${i}].segments`,
+      message: `effective probabilities total ${total}, must be exactly 100.`,
+      severity: "error",
+      rule: "probability-total"
+    });
+  }
+  if (wheel.allow_paid_spins) {
+    if (!currencyKeys.has(wheel.paid_spin_currency_key)) {
+      const hint = didYouMean(wheel.paid_spin_currency_key, [...currencyKeys].sort());
+      out.push({
+        path: `wheels[${i}].paid_spin_currency_key`,
+        message: `unknown currency '${wheel.paid_spin_currency_key}'.${hint ? ` Did you mean '${hint}'?` : ""}`,
+        severity: "error",
+        rule: "unknown-ref"
+      });
+    }
+    if (wheel.paid_spin_currency_amount == null || wheel.paid_spin_currency_amount < 1) {
+      out.push({
+        path: `wheels[${i}].paid_spin_currency_amount`,
+        message: "must be an integer >= 1 when allow_paid_spins is true.",
+        severity: "error",
+        rule: "paid-spin"
+      });
+    }
+    const rewardByLabel = new Map(spec.segments.map((s) => [s.label, s.reward]));
+    const amt = wheel.paid_spin_currency_amount;
+    if (currencyKeys.has(wheel.paid_spin_currency_key) && amt && amt >= 1 && wheel.segments.length) {
+      let ev = 0;
+      for (const link of wheel.segments) {
+        const reward = rewardByLabel.get(link.segment_ref);
+        if (!reward || reward.reward_type !== "currency" || !reward.amount) continue;
+        if (reward.currency_key !== wheel.paid_spin_currency_key) continue;
+        const prob = link.probability_override ?? probByLabel.get(link.segment_ref) ?? 0;
+        ev += prob / 100 * reward.amount;
+      }
+      if (ev >= amt) {
+        out.push({
+          path: `wheels[${i}].paid_spin_currency_amount`,
+          message: `money printer: expected payout per paid spin is ${ev.toFixed(1)} '${wheel.paid_spin_currency_key}' but a spin costs ${amt} \u2014 raise the cost or lower the payouts.`,
+          severity: "error",
+          rule: "money-printer"
+        });
+      }
+    }
+  }
+}
+function payloadKeyCounts(m) {
+  const counts = /* @__PURE__ */ new Map();
+  const inc = (k) => counts.set(k, (counts.get(k) ?? 0) + 1);
+  for (const step of m.steps) {
+    for (const cs of step.condition_sets) {
+      for (const cond of cs.conditions) if (cond.payload_key) inc(cond.payload_key);
+      for (const oc of cs.outcomes) {
+        if (oc.formula?.formula) {
+          for (const tok of oc.formula.formula.match(FORMULA_TOKEN) ?? []) {
+            if (!FORMULA_NOISE.has(tok.toLowerCase())) inc(tok);
+          }
+        }
+      }
+    }
+  }
+  return counts;
+}
+function lintReachability(bad, i, m) {
+  const stepsByKey = new Map(m.steps.filter((s) => s.key).map((s) => [s.key, s]));
+  const entries = m.steps.filter((s) => s.is_entry && s.key).map((s) => s.key);
+  if (entries.length !== 1) return;
+  const seen = /* @__PURE__ */ new Set([entries[0]]);
+  const frontier = [entries[0]];
+  while (frontier.length) {
+    const step = stepsByKey.get(frontier.pop());
+    for (const nk of step?.next_step_keys ?? []) {
+      if (stepsByKey.has(nk) && !seen.has(nk)) {
+        seen.add(nk);
+        frontier.push(nk);
+      }
+    }
+  }
+  m.steps.forEach((s, j) => {
+    if (s.key && !seen.has(s.key)) {
+      bad(
+        `manifests[${i}].steps[${j}]`,
+        `step '${s.key}' is unreachable from the entry step.`,
+        "warning",
+        "unreachable-step"
+      );
+    }
+  });
+}
+function lintFormulaKeys(bad, i, m) {
+  const counts = payloadKeyCounts(m);
+  for (const [key, n] of counts) {
+    if (n !== 1) continue;
+    const others = [...counts.keys()].filter((k) => k !== key);
+    const match = didYouMean(key, others);
+    if (match && similarityCloseEnough(key, match)) {
+      bad(
+        `manifests[${i}]`,
+        `payload key '${key}' is used once \u2014 did you mean '${match}'?`,
+        "warning",
+        "payload-typo"
+      );
+    }
+  }
+}
+function similarityCloseEnough(a, b) {
+  const maxLen = Math.max(a.length, b.length) || 1;
+  let same = 0;
+  const bl = [...b];
+  for (const ch of a) {
+    const idx = bl.indexOf(ch);
+    if (idx !== -1) {
+      same++;
+      bl.splice(idx, 1);
+    }
+  }
+  return 2 * same / (a.length + b.length) >= 0.85 && a !== b && Math.abs(a.length - b.length) <= maxLen;
+}
+function lintPhantomStats(bad, spec) {
+  const written = /* @__PURE__ */ new Set();
+  for (const m of spec.manifests)
+    for (const s of m.steps)
+      for (const cs of s.condition_sets)
+        for (const oc of cs.outcomes) if (oc.stat_key) written.add(oc.stat_key);
+  const ranked = new Set(spec.leaderboards.map((lb) => lb.stat_key));
+  const rewarded = new Set(
+    spec.segments.map((s) => s.reward.stat_key).filter((k) => !!k)
+  );
+  const payloadKeys = /* @__PURE__ */ new Set();
+  for (const m of spec.manifests) for (const k of payloadKeyCounts(m).keys()) payloadKeys.add(k);
+  const referenced = /* @__PURE__ */ new Set([...written, ...ranked, ...rewarded]);
+  spec.stats.forEach((st, i) => {
+    if (!referenced.has(st.key) && payloadKeys.has(st.key)) {
+      bad(
+        `stats[${i}]`,
+        `'${st.key}' looks like a runtime payload key, not a stat \u2014 no outcome writes it and no leaderboard ranks it. Payload keys are read from the record payload and need no definition.`,
+        "warning",
+        "phantom-stat"
+      );
+    }
+  });
+}
+function lintOrphanCurrencies(bad, spec) {
+  const sources = /* @__PURE__ */ new Set();
+  const sinks = /* @__PURE__ */ new Set();
+  for (const m of spec.manifests) {
+    for (const req of m.entry_requirements) if (req.currency_key) sinks.add(req.currency_key);
+    for (const s of m.steps)
+      for (const cs of s.condition_sets)
+        for (const oc of cs.outcomes)
+          if (oc.reward_target === "currency" && oc.currency_key)
+            (oc.operation === "subtract" ? sinks : sources).add(oc.currency_key);
+  }
+  for (const seg of spec.segments)
+    if (seg.reward.reward_type === "currency" && seg.reward.currency_key)
+      sources.add(seg.reward.currency_key);
+  for (const w of spec.wheels)
+    if (w.allow_paid_spins && w.paid_spin_currency_key) sinks.add(w.paid_spin_currency_key);
+  spec.currencies.forEach((c, i) => {
+    if (!sources.has(c.key))
+      bad(
+        `currencies[${i}]`,
+        `'${c.key}' has no source \u2014 nothing awards it.`,
+        "warning",
+        "orphan-currency"
+      );
+    if (!sinks.has(c.key))
+      bad(
+        `currencies[${i}]`,
+        `'${c.key}' has no sink \u2014 add an entry cost, a subtract outcome, or paid wheel spins.`,
+        "warning",
+        "orphan-currency"
+      );
+  });
+}
+async function impactScan(client, orgId, projectId, kind, ref) {
+  const graph = await buildReferenceGraph(client, orgId, projectId);
+  const exists = kind === "currency" ? graph.currencyKeys().includes(String(ref)) : kind === "stat" ? graph.statKeys().includes(String(ref)) : graph.segmentIds().includes(Number(ref));
+  const refs = graph.referencesTo(kind, ref);
+  const byKind = {};
+  for (const r of refs) byKind[r.referencingKind] = (byKind[r.referencingKind] ?? 0) + 1;
+  return {
+    target: { kind, ref },
+    exists,
+    referenceCount: refs.length,
+    byKind,
+    references: refs.map((r) => ({
+      kind: r.referencingKind,
+      id: r.id,
+      name: r.name,
+      locus: r.locus
+    })),
+    breaking: refs.length > 0
+  };
+}
+
+// src/index.ts
+var CORE_VERSION = "0.0.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CORE_VERSION,
+  EnvTokenProvider,
+  MagicweaveClient,
+  MagicweaveError,
+  NotFoundError,
+  PROD_API_BASE,
+  ProjectGraph,
+  STAGING_API_BASE,
+  StaticTokenProvider,
+  UnauthorizedError,
+  ValidationError,
+  buildReferenceGraph,
+  createClient,
+  currencies,
+  decodeJwt,
+  didYouMean,
+  environments,
+  exportDefinitions,
+  impactScan,
+  isExpired,
+  iterManifestRefs,
+  iterSegmentRefs,
+  leaderboards,
+  manifests,
+  orgs,
+  projects,
+  releases,
+  requestLoginOtp,
+  resolveBaseUrl,
+  segments,
+  spec,
+  stats,
+  unwrap,
+  validateSpec,
+  verifyLoginOtp,
+  wheels
+});
+//# sourceMappingURL=index.cjs.map