@feelflow/ffid-sdk 4.2.0 → 5.0.0

package/dist/chunk-CISVLEY5.js

@@ -0,0 +1,1727 @@
+import { z } from 'zod';
+import { createContext, useState, useRef, useCallback, useEffect, useMemo, useContext } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+var FFIDConsentCategoryCodeSchema = z.enum([
+  "necessary",
+  "functional",
+  "analytics",
+  "marketing"
+]);
+var FFIDConsentCategoriesSchema = z.object({
+  necessary: z.literal(true),
+  functional: z.boolean(),
+  analytics: z.boolean(),
+  marketing: z.boolean()
+});
+var FFIDPublicConsentSourceSchema = z.enum([
+  "banner",
+  "preference_center"
+]);
+var FFIDInternalConsentSourceSchema = z.enum([
+  "sdk_default",
+  "api_withdraw",
+  "sync_merge",
+  "persisted_unknown"
+]);
+var FFIDConsentSourceSchema = z.union([
+  FFIDPublicConsentSourceSchema,
+  FFIDInternalConsentSourceSchema
+]);
+var FFIDConsentMergeStrategySchema = z.enum([
+  "db_wins",
+  "device_promoted",
+  "device_promoted_with_drift",
+  "cross_user_insert",
+  "first_insert"
+]);
+var FFIDConsentMergeWarningSchema = z.enum([
+  "shared_device_detected",
+  "local_state_overridden",
+  "drift_detected"
+]);
+var FFIDConsentStateSchema = z.discriminatedUnion("hasDecided", [
+  z.object({
+    hasDecided: z.literal(false),
+    needsRenewal: z.boolean(),
+    categories: FFIDConsentCategoriesSchema,
+    decidedAt: z.null(),
+    cookiePolicyVersion: z.null(),
+    source: z.null()
+  }),
+  z.object({
+    hasDecided: z.literal(true),
+    needsRenewal: z.boolean(),
+    categories: FFIDConsentCategoriesSchema,
+    decidedAt: z.coerce.date(),
+    cookiePolicyVersion: z.string().min(1),
+    source: FFIDConsentSourceSchema
+  })
+]);
+var FFIDConsentUpdateSchema = z.object({
+  functional: z.boolean().optional(),
+  analytics: z.boolean().optional(),
+  marketing: z.boolean().optional()
+});
+var FFIDConsentCategoryMetadataSchema = z.object({
+  code: FFIDConsentCategoryCodeSchema,
+  displayOrder: z.number().int().nonnegative(),
+  isRequired: z.boolean(),
+  label: z.string().min(1),
+  description: z.string().min(1),
+  exampleServices: z.array(z.string())
+});
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var UuidLikeSchema = z.string().regex(UUID_REGEX, "must be a UUID string");
+var FFIDCookiePolicySchema = z.object({
+  id: UuidLikeSchema,
+  version: z.string().min(1),
+  title: z.string().min(1),
+  summary: z.string(),
+  content: z.string(),
+  effectiveDate: z.iso.date(),
+  publishedAt: z.iso.datetime()
+});
+var PostConsentRequestSchema = z.object({
+  categories: z.object({
+    functional: z.boolean(),
+    analytics: z.boolean(),
+    marketing: z.boolean()
+  }).strict(),
+  source: FFIDPublicConsentSourceSchema,
+  cookie_policy_version: z.string().min(1)
+});
+var PostSyncRequestSchema = z.object({
+  local_consent: z.object({
+    necessary: z.literal(true),
+    functional: z.boolean(),
+    analytics: z.boolean(),
+    marketing: z.boolean(),
+    cookie_policy_version: z.string().min(1)
+  }).nullable()
+});
+var ConsentRowWireSchema = z.object({
+  necessary: z.boolean(),
+  functional: z.boolean(),
+  analytics: z.boolean(),
+  marketing: z.boolean(),
+  cookie_policy_version: z.string().min(1),
+  decided_at: z.iso.datetime()
+});
+var ConsentRowWithIdWireSchema = ConsentRowWireSchema.extend({
+  id: UuidLikeSchema
+});
+var WithdrawalRowWireSchema = ConsentRowWithIdWireSchema.extend({
+  is_withdrawal: z.literal(true),
+  supersedes_id: UuidLikeSchema.nullable()
+});
+var GetConsentMeWireSchema = z.object({
+  consent: ConsentRowWireSchema.nullable(),
+  default_state: FFIDConsentCategoriesSchema.optional(),
+  current_policy_version: z.string().min(1),
+  needs_renewal: z.boolean(),
+  /**
+   * Spec §8.1: server signals `degraded: true` when DB read failed and the
+   * response was reconstructed from a cookie-only fallback. SDK consumers
+   * must NOT treat `needs_renewal` as authoritative when degraded.
+   */
+  degraded: z.boolean().optional()
+});
+var PostConsentWireSchema = z.object({
+  consent: ConsentRowWithIdWireSchema
+});
+var PostSyncWireSchema = z.object({
+  consent: ConsentRowWithIdWireSchema,
+  merge_strategy: FFIDConsentMergeStrategySchema,
+  warning: FFIDConsentMergeWarningSchema.nullable()
+});
+var PostWithdrawWireSchema = z.object({
+  consent: WithdrawalRowWireSchema
+});
+var GetCategoriesWireSchema = z.object({
+  categories: z.array(FFIDConsentCategoryMetadataSchema)
+});
+var GetDocumentWireSchema = z.object({
+  document: FFIDCookiePolicySchema
+});
+var DeviceIdSchema = z.string().regex(UUID_REGEX, "must be a UUID string (UUIDv4 or UUIDv7)");
+var ErrorBodyWireSchema = z.object({
+  error: z.string().optional(),
+  retry_after_ms: z.number().nonnegative().optional(),
+  current_version: z.string().optional(),
+  submitted_version: z.string().optional()
+});
+
+// src/consent/errors.ts
+var FFID_CONSENT_ERROR_CODES = [
+  // SDK client (network / response)
+  "cookie_consent_api_unreachable",
+  "cookie_consent_response_invalid",
+  "cookie_consent_rate_limited",
+  // SDK storage
+  "cookie_consent_cookie_write_failed",
+  "cookie_consent_parse_failed",
+  // API surface (mapped from server status codes)
+  "cookie_consent_sync_conflict",
+  "cookie_consent_immutable_violation",
+  "cookie_consent_policy_outdated",
+  "cookie_consent_capture_failed",
+  "cookie_consent_db_write_failed",
+  // SDK-wide (NOT spec §8.2 reserved — mapped from 401/403)
+  "auth_failure"
+];
+var FFIDConsentError = class extends Error {
+  code;
+  httpStatus;
+  /** For rate-limited errors (HTTP 429): seconds suggested by `Retry-After`. */
+  retryAfterSec;
+  cause;
+  constructor(code, message, options) {
+    super(message);
+    this.name = "FFIDConsentError";
+    this.code = code;
+    if (options?.httpStatus !== void 0) this.httpStatus = options.httpStatus;
+    if (options?.retryAfterSec !== void 0) {
+      this.retryAfterSec = options.retryAfterSec;
+    }
+    if (options?.cause !== void 0) this.cause = options.cause;
+  }
+};
+var DEFAULT_CONSENT_ERROR_MESSAGES = {
+  cookie_consent_api_unreachable: "\u901A\u4FE1\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F\u3002\u3082\u3046\u4E00\u5EA6\u304A\u8A66\u3057\u304F\u3060\u3055\u3044",
+  cookie_consent_response_invalid: "\u540C\u610F\u60C5\u5831\u306E\u53D6\u5F97\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3002\u6642\u9593\u3092\u7F6E\u3044\u3066\u518D\u5EA6\u304A\u8A66\u3057\u304F\u3060\u3055\u3044",
+  cookie_consent_rate_limited: "\u30B5\u30FC\u30D3\u30B9\u304C\u6DF7\u96D1\u3057\u3066\u3044\u307E\u3059\u3002\u3057\u3070\u3089\u304F\u7D4C\u3063\u3066\u304B\u3089\u518D\u5EA6\u304A\u8A66\u3057\u304F\u3060\u3055\u3044",
+  cookie_consent_cookie_write_failed: "\u30D6\u30E9\u30A6\u30B6\u306E\u8A2D\u5B9A\u306B\u3088\u308A\u540C\u610F\u60C5\u5831\u3092\u4FDD\u5B58\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u30D7\u30E9\u30A4\u30D9\u30FC\u30C8\u30D6\u30E9\u30A6\u30BA\u3084\u62E1\u5F35\u6A5F\u80FD\u3092\u3054\u78BA\u8A8D\u304F\u3060\u3055\u3044",
+  cookie_consent_parse_failed: "\u4FDD\u5B58\u3055\u308C\u3066\u3044\u305F\u540C\u610F\u60C5\u5831\u304C\u7121\u52B9\u3067\u3057\u305F\u3002\u540C\u610F\u3092\u518D\u53D6\u5F97\u3057\u307E\u3059",
+  cookie_consent_sync_conflict: "\u5225\u306E\u7AEF\u672B\u3067\u540C\u610F\u60C5\u5831\u304C\u66F4\u65B0\u3055\u308C\u3066\u3044\u307E\u3059\u3002\u6700\u65B0\u306E\u8A2D\u5B9A\u306B\u540C\u671F\u3057\u307E\u3057\u305F",
+  cookie_consent_immutable_violation: "\u540C\u610F\u5C65\u6B74\u306F\u66F8\u304D\u63DB\u3048\u3067\u304D\u306A\u3044\u4ED5\u7D44\u307F\u3067\u3059\u3002\u65B0\u3057\u3044\u540C\u610F\u3068\u3057\u3066\u8A18\u9332\u3055\u308C\u307E\u3057\u305F",
+  cookie_consent_policy_outdated: "Cookie \u30DD\u30EA\u30B7\u30FC\u304C\u66F4\u65B0\u3055\u308C\u307E\u3057\u305F\u3002\u6539\u3081\u3066\u540C\u610F\u3092\u304A\u9858\u3044\u3057\u307E\u3059",
+  cookie_consent_capture_failed: "\u540C\u610F\u306E\u4FDD\u5B58\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3002\u3082\u3046\u4E00\u5EA6\u304A\u8A66\u3057\u304F\u3060\u3055\u3044",
+  cookie_consent_db_write_failed: "\u30B5\u30FC\u30D0\u30FC\u5074\u3067\u540C\u610F\u306E\u4FDD\u5B58\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3002\u6642\u9593\u3092\u7F6E\u3044\u3066\u518D\u5EA6\u304A\u8A66\u3057\u304F\u3060\u3055\u3044",
+  auth_failure: "\u8A8D\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F\u3002\u30ED\u30B0\u30A4\u30F3\u3057\u76F4\u3057\u3066\u304B\u3089\u518D\u5EA6\u304A\u8A66\u3057\u304F\u3060\u3055\u3044"
+};
+
+// src/consent/storage/encode.ts
+var COOKIE_VERSION = "v1";
+var ALL_DENIED_EXCEPT_NECESSARY = {
+  necessary: true,
+  functional: false,
+  analytics: false,
+  marketing: false
+};
+var CATEGORY_LETTERS = {
+  n: "necessary",
+  f: "functional",
+  a: "analytics",
+  m: "marketing"
+};
+var ORDERED_LETTERS = ["n", "f", "a", "m"];
+function encodeConsentCookie(cats) {
+  const parts = ORDERED_LETTERS.map((letter) => {
+    const key = CATEGORY_LETTERS[letter];
+    return `${letter}${cats[key] ? "+" : "-"}`;
+  });
+  return `${COOKIE_VERSION}:${parts.join(",")}`;
+}
+function decodeConsentCookie(raw) {
+  if (typeof raw !== "string" || raw.length === 0) {
+    return { ...ALL_DENIED_EXCEPT_NECESSARY };
+  }
+  const colonIdx = raw.indexOf(":");
+  if (colonIdx === -1) {
+    return { ...ALL_DENIED_EXCEPT_NECESSARY };
+  }
+  const version = raw.slice(0, colonIdx);
+  if (version !== COOKIE_VERSION) {
+    return { ...ALL_DENIED_EXCEPT_NECESSARY };
+  }
+  const body = raw.slice(colonIdx + 1);
+  if (body.length === 0) {
+    return { ...ALL_DENIED_EXCEPT_NECESSARY };
+  }
+  const tokens = body.split(",");
+  if (tokens.length !== ORDERED_LETTERS.length) {
+    return { ...ALL_DENIED_EXCEPT_NECESSARY };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const result = {};
+  for (const token of tokens) {
+    if (token.length !== 2) {
+      return { ...ALL_DENIED_EXCEPT_NECESSARY };
+    }
+    const letter = token[0];
+    const value = token[1];
+    if (!CATEGORY_LETTERS[letter] || value !== "+" && value !== "-") {
+      return { ...ALL_DENIED_EXCEPT_NECESSARY };
+    }
+    if (seen.has(letter)) {
+      return { ...ALL_DENIED_EXCEPT_NECESSARY };
+    }
+    seen.add(letter);
+    const key = CATEGORY_LETTERS[letter];
+    result[key] = value === "+";
+  }
+  if (result.necessary !== true) {
+    return { ...ALL_DENIED_EXCEPT_NECESSARY };
+  }
+  return {
+    necessary: true,
+    functional: result.functional ?? false,
+    analytics: result.analytics ?? false,
+    marketing: result.marketing ?? false
+  };
+}
+
+// src/consent/storage/cookie.ts
+var CONSENT_COOKIE_NAME = "ffid_consent";
+var SECONDS_PER_MINUTE = 60;
+var MINUTES_PER_HOUR = 60;
+var HOURS_PER_DAY = 24;
+var DAYS_PER_YEAR = 365;
+var CONSENT_COOKIE_MAX_AGE_SEC = SECONDS_PER_MINUTE * MINUTES_PER_HOUR * HOURS_PER_DAY * DAYS_PER_YEAR;
+var CONSENT_SESSION_STORAGE_KEY = "ffid_consent_state";
+function hasDocument() {
+  return typeof document !== "undefined";
+}
+function defaultSecure() {
+  if (typeof process === "undefined") return true;
+  return process.env?.NODE_ENV === "production";
+}
+function buildCookieAttrs(args) {
+  const attrs = [
+    `${args.name}=${args.value}`,
+    `Max-Age=${args.maxAgeSec}`,
+    `Path=${args.path}`,
+    "SameSite=Lax"
+  ];
+  if (args.domain) attrs.push(`Domain=${args.domain}`);
+  if (args.secure) attrs.push("Secure");
+  return attrs.join("; ");
+}
+function readConsentCookie() {
+  if (!hasDocument()) return { ...ALL_DENIED_EXCEPT_NECESSARY };
+  const raw = document.cookie.split(";").map((c) => c.trim()).find((c) => c.startsWith(`${CONSENT_COOKIE_NAME}=`));
+  if (!raw) return { ...ALL_DENIED_EXCEPT_NECESSARY };
+  const value = raw.slice(CONSENT_COOKIE_NAME.length + 1);
+  return decodeConsentCookie(decodeURIComponent(value));
+}
+function writeConsentCookie(cats, opts = {}) {
+  if (!hasDocument()) return false;
+  const encoded = encodeConsentCookie(cats);
+  const secure = opts.secure ?? defaultSecure();
+  const path = opts.path ?? "/";
+  document.cookie = buildCookieAttrs({
+    name: CONSENT_COOKIE_NAME,
+    value: encodeURIComponent(encoded),
+    maxAgeSec: CONSENT_COOKIE_MAX_AGE_SEC,
+    path,
+    ...opts.domain !== void 0 ? { domain: opts.domain } : {},
+    secure
+  });
+  const verified = readConsentCookie();
+  return verified.necessary === cats.necessary && verified.functional === cats.functional && verified.analytics === cats.analytics && verified.marketing === cats.marketing;
+}
+function deleteConsentCookie(opts = {}) {
+  if (!hasDocument()) return false;
+  const path = opts.path ?? "/";
+  document.cookie = buildCookieAttrs({
+    name: CONSENT_COOKIE_NAME,
+    value: "",
+    maxAgeSec: 0,
+    path,
+    ...opts.domain !== void 0 ? { domain: opts.domain } : {}
+  });
+  return !document.cookie.split(";").map((c) => c.trim()).some((c) => c.startsWith(`${CONSENT_COOKIE_NAME}=`));
+}
+function hasSessionStorage() {
+  if (typeof sessionStorage === "undefined") return false;
+  try {
+    const probe = "__ffid_consent_probe__";
+    sessionStorage.setItem(probe, "1");
+    sessionStorage.removeItem(probe);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readConsentSessionMirror() {
+  if (!hasSessionStorage()) return null;
+  try {
+    const raw = sessionStorage.getItem(CONSENT_SESSION_STORAGE_KEY);
+    if (!raw) return null;
+    return decodeConsentCookie(raw);
+  } catch {
+    return null;
+  }
+}
+function writeConsentSessionMirror(cats) {
+  if (!hasSessionStorage()) return false;
+  try {
+    sessionStorage.setItem(CONSENT_SESSION_STORAGE_KEY, encodeConsentCookie(cats));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function clearConsentSessionMirror() {
+  if (!hasSessionStorage()) return;
+  try {
+    sessionStorage.removeItem(CONSENT_SESSION_STORAGE_KEY);
+  } catch {
+  }
+}
+
+// src/consent/storage/device-id.ts
+var DEVICE_ID_LOCAL_STORAGE_KEY = "ffid_device_id";
+var DEVICE_ID_SESSION_STORAGE_KEY = "ffid_device_id_ephemeral";
+var UUIDV7_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var UUID_ANY_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var TIMESTAMP_BYTES = 6;
+var RANDOM_BYTES = 10;
+var UUID_TOTAL_BYTES = 16;
+var BYTE_MASK = 255;
+var BYTE_SIZE = 256;
+var VERSION_NIBBLE_MASK = 15;
+var VERSION_V7_BITS = 112;
+var VARIANT_BITS_MASK = 63;
+var VARIANT_RFC_BITS = 128;
+var HEX_GROUP_1_END = 8;
+var HEX_GROUP_2_END = 12;
+var HEX_GROUP_3_END = 16;
+var HEX_GROUP_4_END = 20;
+var HEX_GROUP_5_END = 32;
+var HEX_RADIX = 16;
+var HEX_BYTE_PAD = 2;
+var RANDOM_32BIT_MAX = 4294967296;
+var TIMESTAMP_HEX_PAD = 12;
+var HEX_PAD_8 = 8;
+var HEX_TS_GROUP_1 = 8;
+var HEX_TS_GROUP_2 = 12;
+var RAND_SLICE_START = 1;
+var RAND_SLICE_END_3 = 4;
+var RAND_TAIL_TOTAL = 12;
+function generateDeviceId() {
+  if (typeof crypto === "undefined") {
+    return generateUuidV7Fallback();
+  }
+  if (typeof crypto.getRandomValues === "function") {
+    return generateUuidV7Crypto();
+  }
+  if (typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return generateUuidV7Fallback();
+}
+function generateUuidV7Crypto() {
+  const now = Date.now();
+  const tsBytes = new Uint8Array(TIMESTAMP_BYTES);
+  let remaining = now;
+  for (let i = TIMESTAMP_BYTES - 1; i >= 0; i--) {
+    tsBytes[i] = remaining & BYTE_MASK;
+    remaining = Math.floor(remaining / BYTE_SIZE);
+  }
+  const rand = new Uint8Array(RANDOM_BYTES);
+  crypto.getRandomValues(rand);
+  rand[0] = (rand[0] ?? 0) & VERSION_NIBBLE_MASK | VERSION_V7_BITS;
+  rand[2] = (rand[2] ?? 0) & VARIANT_BITS_MASK | VARIANT_RFC_BITS;
+  const all = new Uint8Array(UUID_TOTAL_BYTES);
+  all.set(tsBytes, 0);
+  all.set(rand, TIMESTAMP_BYTES);
+  const hex = Array.from(all, (b) => b.toString(HEX_RADIX).padStart(HEX_BYTE_PAD, "0")).join("");
+  return [
+    hex.slice(0, HEX_GROUP_1_END),
+    hex.slice(HEX_GROUP_1_END, HEX_GROUP_2_END),
+    hex.slice(HEX_GROUP_2_END, HEX_GROUP_3_END),
+    hex.slice(HEX_GROUP_3_END, HEX_GROUP_4_END),
+    hex.slice(HEX_GROUP_4_END, HEX_GROUP_5_END)
+  ].join("-");
+}
+function generateUuidV7Fallback() {
+  const now = Date.now();
+  const r = () => Math.floor(Math.random() * RANDOM_32BIT_MAX).toString(HEX_RADIX).padStart(HEX_PAD_8, "0");
+  const tsHex = now.toString(HEX_RADIX).padStart(TIMESTAMP_HEX_PAD, "0").slice(-TIMESTAMP_HEX_PAD);
+  return [
+    tsHex.slice(0, HEX_TS_GROUP_1),
+    tsHex.slice(HEX_TS_GROUP_1, HEX_TS_GROUP_2),
+    `7${r().slice(RAND_SLICE_START, RAND_SLICE_END_3)}`,
+    `8${r().slice(RAND_SLICE_START, RAND_SLICE_END_3)}`,
+    (r() + r()).slice(0, RAND_TAIL_TOTAL)
+  ].join("-");
+}
+function isValidDeviceId(id) {
+  return UUID_ANY_REGEX.test(id);
+}
+function isUuidV7(id) {
+  return UUIDV7_REGEX.test(id);
+}
+function tryLocalStorage() {
+  if (typeof localStorage === "undefined") return null;
+  try {
+    const probe = "__ffid_device_probe__";
+    localStorage.setItem(probe, "1");
+    localStorage.removeItem(probe);
+    return localStorage;
+  } catch {
+    return null;
+  }
+}
+function trySessionStorage() {
+  if (typeof sessionStorage === "undefined") return null;
+  try {
+    const probe = "__ffid_device_probe__";
+    sessionStorage.setItem(probe, "1");
+    sessionStorage.removeItem(probe);
+    return sessionStorage;
+  } catch {
+    return null;
+  }
+}
+var warnedEphemeralFallback = false;
+function warnEphemeralOnce(reason) {
+  if (warnedEphemeralFallback) return;
+  warnedEphemeralFallback = true;
+  if (typeof console !== "undefined" && typeof console.warn === "function") {
+    console.warn(
+      `[ffid-sdk] device-id falling back to ephemeral storage (${reason}). Each request may use a different device id, which breaks server-side shared_device_detected merge UX.`
+    );
+  }
+}
+function getOrCreateDeviceId() {
+  const local = tryLocalStorage();
+  if (local) {
+    const existing = local.getItem(DEVICE_ID_LOCAL_STORAGE_KEY);
+    if (existing && isValidDeviceId(existing)) return existing;
+    const fresh = generateDeviceId();
+    try {
+      local.setItem(DEVICE_ID_LOCAL_STORAGE_KEY, fresh);
+    } catch {
+      const session2 = trySessionStorage();
+      if (session2) {
+        try {
+          session2.setItem(DEVICE_ID_SESSION_STORAGE_KEY, fresh);
+        } catch {
+        }
+      }
+    }
+    return fresh;
+  }
+  const session = trySessionStorage();
+  if (session) {
+    const existing = session.getItem(DEVICE_ID_SESSION_STORAGE_KEY);
+    if (existing && isValidDeviceId(existing)) return existing;
+    const fresh = generateDeviceId();
+    try {
+      session.setItem(DEVICE_ID_SESSION_STORAGE_KEY, fresh);
+    } catch {
+    }
+    return fresh;
+  }
+  warnEphemeralOnce("no localStorage / sessionStorage available");
+  return generateDeviceId();
+}
+function clearDeviceId() {
+  const local = tryLocalStorage();
+  if (local) {
+    try {
+      local.removeItem(DEVICE_ID_LOCAL_STORAGE_KEY);
+    } catch {
+    }
+  }
+  const session = trySessionStorage();
+  if (session) {
+    try {
+      session.removeItem(DEVICE_ID_SESSION_STORAGE_KEY);
+    } catch {
+    }
+  }
+}
+
+// src/consent/client/mappers.ts
+function categoriesFromWire(row) {
+  return {
+    necessary: true,
+    functional: row.functional,
+    analytics: row.analytics,
+    marketing: row.marketing
+  };
+}
+function decidedStateFromRow(row, source, needsRenewal = false) {
+  return {
+    hasDecided: true,
+    needsRenewal,
+    categories: categoriesFromWire(row),
+    decidedAt: new Date(row.decided_at),
+    cookiePolicyVersion: row.cookie_policy_version,
+    source
+  };
+}
+function mapMeWireToState(wire) {
+  if (!wire.consent) {
+    return {
+      hasDecided: false,
+      needsRenewal: wire.needs_renewal,
+      categories: wire.default_state ?? { ...ALL_DENIED_EXCEPT_NECESSARY },
+      decidedAt: null,
+      cookiePolicyVersion: null,
+      source: null
+    };
+  }
+  return decidedStateFromRow(wire.consent, "persisted_unknown", wire.needs_renewal);
+}
+function mapConsentWireToState(wire, source) {
+  return decidedStateFromRow(wire.consent, source);
+}
+function mapWithdrawWireToState(wire) {
+  return decidedStateFromRow(wire.consent, "api_withdraw");
+}
+function mapSyncWireToResult(wire) {
+  return {
+    state: decidedStateFromRow(wire.consent, "sync_merge"),
+    mergeStrategy: wire.merge_strategy,
+    warning: wire.warning
+  };
+}
+function stateFromLocalCategories(cats) {
+  return {
+    hasDecided: false,
+    needsRenewal: false,
+    categories: cats,
+    decidedAt: null,
+    cookiePolicyVersion: null,
+    source: null
+  };
+}
+
+// src/consent/client/consent-client.ts
+var HTTP_TOO_MANY_REQUESTS = 429;
+var HTTP_UNAUTHORIZED = 401;
+var HTTP_FORBIDDEN = 403;
+var HTTP_BAD_REQUEST = 400;
+var HTTP_NOT_FOUND = 404;
+var HTTP_CONFLICT = 409;
+var HTTP_INTERNAL_SERVER_ERROR = 500;
+var MS_PER_SECOND = 1e3;
+var RETRY_JITTER_RATIO = 0.2;
+var DEFAULT_RETRY_AFTER_SEC = 1;
+function parseRetryAfterHeader(header) {
+  if (!header) return void 0;
+  const asNumber = Number(header);
+  if (Number.isFinite(asNumber) && asNumber >= 0) return asNumber;
+  const ms = Date.parse(header);
+  if (!Number.isFinite(ms)) return void 0;
+  const diffSec = (ms - Date.now()) / MS_PER_SECOND;
+  return diffSec > 0 ? Math.ceil(diffSec) : 0;
+}
+function jitteredDelayMs(baseSec) {
+  const jitter = (Math.random() * 2 - 1) * RETRY_JITTER_RATIO;
+  return Math.max(0, baseSec * MS_PER_SECOND * (1 + jitter));
+}
+function parseErrorBody(json, retryAfterHeader) {
+  const parsed = ErrorBodyWireSchema.safeParse(json);
+  const body = parsed.success ? parsed.data : {};
+  const fromHeader = parseRetryAfterHeader(retryAfterHeader);
+  const fromBody = body.retry_after_ms !== void 0 ? Math.ceil(body.retry_after_ms / MS_PER_SECOND) : void 0;
+  return {
+    serverCode: body.error,
+    retryAfterSec: fromHeader ?? fromBody,
+    body
+  };
+}
+function mapHttpToConsentError(status, parsed, url) {
+  const { serverCode, retryAfterSec, body } = parsed;
+  if (status === HTTP_TOO_MANY_REQUESTS) {
+    return new FFIDConsentError(
+      "cookie_consent_rate_limited",
+      `Rate limit exceeded for ${url}`,
+      {
+        httpStatus: status,
+        ...retryAfterSec !== void 0 ? { retryAfterSec } : {}
+      }
+    );
+  }
+  if (status === HTTP_UNAUTHORIZED || status === HTTP_FORBIDDEN) {
+    return new FFIDConsentError(
+      "auth_failure",
+      `Authentication failed (${serverCode ?? "unauthorized"})`,
+      { httpStatus: status }
+    );
+  }
+  if (status === HTTP_NOT_FOUND) {
+    return new FFIDConsentError(
+      "cookie_consent_api_unreachable",
+      `Consent endpoint not found at ${url} (check baseUrl / API version)`,
+      { httpStatus: status }
+    );
+  }
+  if (status === HTTP_BAD_REQUEST && serverCode === "policy_version_outdated") {
+    return new FFIDConsentError(
+      "cookie_consent_policy_outdated",
+      `Cookie policy version outdated (current=${body.current_version ?? "?"})`,
+      { httpStatus: status }
+    );
+  }
+  if (status === HTTP_CONFLICT) {
+    if (serverCode === "sync_conflict") {
+      return new FFIDConsentError(
+        "cookie_consent_sync_conflict",
+        "Concurrent consent update detected on the server",
+        { httpStatus: status }
+      );
+    }
+    return new FFIDConsentError(
+      "cookie_consent_immutable_violation",
+      "Consent row is immutable; new row will be recorded instead",
+      { httpStatus: status }
+    );
+  }
+  if (status >= HTTP_INTERNAL_SERVER_ERROR) {
+    if (serverCode === "db_write_failed") {
+      return new FFIDConsentError(
+        "cookie_consent_db_write_failed",
+        "Server-side database write failed",
+        { httpStatus: status }
+      );
+    }
+    return new FFIDConsentError(
+      "cookie_consent_capture_failed",
+      `Server error for ${url} (HTTP ${status})`,
+      { httpStatus: status }
+    );
+  }
+  return new FFIDConsentError(
+    "cookie_consent_capture_failed",
+    `Unexpected status ${status} for ${url}`,
+    { httpStatus: status }
+  );
+}
+function createConsentClient(opts) {
+  const baseUrl = opts.baseUrl.replace(/\/+$/, "");
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const defaultLang = opts.defaultLang ?? "ja";
+  const maxAutoRetry429 = opts.maxAutoRetry429 ?? 1;
+  async function buildHeaders(withBearer) {
+    const deviceId = opts.getDeviceId();
+    if (!deviceId) {
+      throw new FFIDConsentError(
+        "auth_failure",
+        "Device ID not initialized (SDK header builder)"
+      );
+    }
+    const headers = {
+      "X-Service-Api-Key": opts.serviceApiKey,
+      "X-FFID-Device-Id": deviceId,
+      "Content-Type": "application/json"
+    };
+    if (withBearer && opts.getAccessToken) {
+      const token = await opts.getAccessToken();
+      if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+    }
+    return headers;
+  }
+  async function performFetch(url, init) {
+    try {
+      const res = await fetchImpl(url, init);
+      return { res };
+    } catch (cause) {
+      return {
+        err: new FFIDConsentError(
+          "cookie_consent_api_unreachable",
+          `Network error reaching ${url}`,
+          { cause }
+        )
+      };
+    }
+  }
+  async function request(reqOpts, parseFn) {
+    const url = `${baseUrl}${reqOpts.path}`;
+    const withBearer = reqOpts.withBearer ?? Boolean(opts.getAccessToken);
+    let headers;
+    try {
+      headers = await buildHeaders(withBearer);
+    } catch (err) {
+      if (err instanceof FFIDConsentError) return { ok: false, error: err };
+      return {
+        ok: false,
+        error: new FFIDConsentError(
+          "cookie_consent_api_unreachable",
+          "Failed to acquire SDK headers (token / device-id)",
+          { cause: err }
+        )
+      };
+    }
+    const init = {
+      method: reqOpts.method,
+      headers,
+      credentials: "include"
+    };
+    if (reqOpts.body !== void 0) init.body = JSON.stringify(reqOpts.body);
+    if (reqOpts.signal) init.signal = reqOpts.signal;
+    let res;
+    for (let attempt = 0; attempt <= maxAutoRetry429; attempt++) {
+      const fetched = await performFetch(url, init);
+      if (fetched.err) return { ok: false, error: fetched.err };
+      res = fetched.res;
+      if (res.status !== HTTP_TOO_MANY_REQUESTS || attempt >= maxAutoRetry429) {
+        break;
+      }
+      const parsedHeader = parseRetryAfterHeader(res.headers.get("Retry-After"));
+      const delaySec = parsedHeader ?? DEFAULT_RETRY_AFTER_SEC;
+      await new Promise((resolve) => {
+        setTimeout(resolve, jitteredDelayMs(delaySec));
+      });
+    }
+    if (!res) {
+      return {
+        ok: false,
+        error: new FFIDConsentError(
+          "cookie_consent_api_unreachable",
+          `Unreachable: fetch loop produced no response for ${url}`
+        )
+      };
+    }
+    if (!res.ok) {
+      let errorJson = {};
+      try {
+        errorJson = await res.json();
+      } catch {
+      }
+      const parsed = parseErrorBody(errorJson, res.headers.get("Retry-After"));
+      return {
+        ok: false,
+        error: mapHttpToConsentError(res.status, parsed, url)
+      };
+    }
+    let json;
+    try {
+      json = await res.json();
+    } catch (err) {
+      return {
+        ok: false,
+        error: new FFIDConsentError(
+          "cookie_consent_response_invalid",
+          `Invalid JSON in response from ${url}`,
+          { cause: err }
+        )
+      };
+    }
+    try {
+      return { ok: true, value: parseFn(json) };
+    } catch (err) {
+      return {
+        ok: false,
+        error: new FFIDConsentError(
+          "cookie_consent_response_invalid",
+          `Response shape mismatch for ${url}`,
+          { cause: err }
+        )
+      };
+    }
+  }
+  return {
+    async getMe(signal) {
+      return request(
+        { method: "GET", path: "/api/v1/ext/consent/me", ...signal ? { signal } : {} },
+        (json) => {
+          const parsed = GetConsentMeWireSchema.parse(json);
+          return mapMeWireToState(parsed);
+        }
+      );
+    },
+    async submit(categories, source, cookiePolicyVersion, signal) {
+      return request(
+        {
+          method: "POST",
+          path: "/api/v1/ext/consent",
+          body: {
+            categories,
+            source,
+            cookie_policy_version: cookiePolicyVersion
+          },
+          ...signal ? { signal } : {}
+        },
+        (json) => {
+          const parsed = PostConsentWireSchema.parse(json);
+          return mapConsentWireToState(parsed, source);
+        }
+      );
+    },
+    async sync(localConsent, signal) {
+      const body = {
+        local_consent: localConsent ? {
+          necessary: true,
+          functional: localConsent.functional,
+          analytics: localConsent.analytics,
+          marketing: localConsent.marketing,
+          cookie_policy_version: localConsent.cookiePolicyVersion
+        } : null
+      };
+      return request(
+        {
+          method: "POST",
+          path: "/api/v1/ext/consent/sync",
+          body,
+          withBearer: true,
+          ...signal ? { signal } : {}
+        },
+        (json) => {
+          const parsed = PostSyncWireSchema.parse(json);
+          return mapSyncWireToResult(parsed);
+        }
+      );
+    },
+    async withdraw(signal) {
+      return request(
+        {
+          method: "POST",
+          path: "/api/v1/ext/consent/withdraw",
+          body: {},
+          ...signal ? { signal } : {}
+        },
+        (json) => {
+          const parsed = PostWithdrawWireSchema.parse(json);
+          return mapWithdrawWireToState(parsed);
+        }
+      );
+    },
+    async getCategories(lang, signal) {
+      const resolvedLang = lang ?? defaultLang;
+      return request(
+        {
+          method: "GET",
+          path: `/api/v1/ext/consent/categories?lang=${resolvedLang}`,
+          ...signal ? { signal } : {}
+        },
+        (json) => {
+          const parsed = GetCategoriesWireSchema.parse(json);
+          return parsed.categories;
+        }
+      );
+    },
+    async getDocument(lang, signal) {
+      const resolvedLang = lang ?? defaultLang;
+      return request(
+        {
+          method: "GET",
+          path: `/api/v1/ext/consent/document?lang=${resolvedLang}`,
+          ...signal ? { signal } : {}
+        },
+        (json) => {
+          const parsed = GetDocumentWireSchema.parse(json);
+          return parsed.document;
+        }
+      );
+    }
+  };
+}
+
+// src/consent/client/gtag-bridge.ts
+var DEFAULT_GTAG_SRC = "https://www.googletagmanager.com/gtag/js";
+function bool(g) {
+  return g ? "granted" : "denied";
+}
+function mapCategoriesToGtagParams(cats) {
+  return {
+    security_storage: "granted",
+    // necessary is always granted
+    functionality_storage: bool(cats.functional),
+    personalization_storage: bool(cats.functional),
+    analytics_storage: bool(cats.analytics),
+    ad_storage: bool(cats.marketing),
+    ad_user_data: bool(cats.marketing),
+    ad_personalization: bool(cats.marketing)
+  };
+}
+function pushDataLayer(win, args) {
+  if (!win) return;
+  win.dataLayer = win.dataLayer ?? [];
+  win.dataLayer.push(args);
+}
+function createGtagBridge(opts = {}) {
+  const win = opts.win ?? (typeof window !== "undefined" ? window : void 0);
+  const gaId = opts.gaMeasurementId ?? null;
+  const scriptSrc = opts.gtagScriptSrc ?? DEFAULT_GTAG_SRC;
+  let gaScriptInjected = false;
+  return {
+    setDefaultConsent() {
+      const denyParams = mapCategoriesToGtagParams({
+        functional: false,
+        analytics: false,
+        marketing: false
+      });
+      pushDataLayer(win, ["consent", "default", denyParams]);
+    },
+    updateConsent(cats) {
+      const params = mapCategoriesToGtagParams(cats);
+      pushDataLayer(win, ["consent", "update", params]);
+    },
+    applyGaInjection(cats) {
+      if (!win || !gaId) return;
+      if (!cats.analytics) return;
+      if (gaScriptInjected) return;
+      const doc = win.document;
+      if (!doc) return;
+      const script = doc.createElement("script");
+      script.async = true;
+      script.src = `${scriptSrc}?id=${encodeURIComponent(gaId)}`;
+      doc.head.appendChild(script);
+      pushDataLayer(win, ["js", /* @__PURE__ */ new Date()]);
+      pushDataLayer(win, ["config", gaId]);
+      gaScriptInjected = true;
+    }
+  };
+}
+var FFID_CONSENT_NOT_DECIDED_STATE = {
+  hasDecided: false,
+  needsRenewal: false,
+  categories: { ...ALL_DENIED_EXCEPT_NECESSARY },
+  decidedAt: null,
+  cookiePolicyVersion: null,
+  source: null
+};
+function defaultAction() {
+  throw new Error(
+    "[ffid-sdk] consent action called outside of <FFIDAnalyticsProvider>"
+  );
+}
+var FALLBACK_VALUE = {
+  state: FFID_CONSENT_NOT_DECIDED_STATE,
+  isLoading: false,
+  error: null,
+  categoryMetadata: null,
+  policy: null,
+  isBannerOpen: false,
+  isPreferencesOpen: false,
+  openBanner: defaultAction,
+  closeBanner: defaultAction,
+  openPreferences: defaultAction,
+  closePreferences: defaultAction,
+  acceptAll: defaultAction,
+  acceptNecessaryOnly: defaultAction,
+  setCategories: defaultAction,
+  withdraw: defaultAction,
+  refresh: defaultAction,
+  syncWithUser: defaultAction
+};
+var FFIDConsentContext = createContext(FALLBACK_VALUE);
+var DEFAULT_MERGE_WARNING_MESSAGES = {
+  local_state_overridden: "\u5225\u306E\u7AEF\u672B\u3067\u4FDD\u5B58\u3055\u308C\u305F Cookie \u540C\u610F\u8A2D\u5B9A\u3067\u66F4\u65B0\u3055\u308C\u307E\u3057\u305F",
+  shared_device_detected: "\u3053\u306E\u7AEF\u672B\u306F\u5225\u306E\u30A2\u30AB\u30A6\u30F3\u30C8\u3067\u3082\u4F7F\u7528\u3055\u308C\u3066\u3044\u307E\u3059\u3002Cookie \u8A2D\u5B9A\u306F\u30A2\u30AB\u30A6\u30F3\u30C8\u3054\u3068\u306B\u4FDD\u5B58\u3055\u308C\u3066\u3044\u307E\u3059",
+  drift_detected: "\u4FDD\u5B58\u3055\u308C\u3066\u3044\u305F\u8A2D\u5B9A\u3068\u7570\u306A\u308B\u9805\u76EE\u304C\u3042\u3063\u305F\u305F\u3081\u3001\u65B0\u3057\u304F\u8A18\u9332\u3055\u308C\u307E\u3057\u305F"
+};
+function applyChanges(base, changes) {
+  return {
+    necessary: true,
+    functional: changes.functional ?? base.functional,
+    analytics: changes.analytics ?? base.analytics,
+    marketing: changes.marketing ?? base.marketing
+  };
+}
+function FFIDAnalyticsProvider({
+  baseUrl,
+  serviceApiKey,
+  getAccessToken,
+  gaMeasurementId,
+  sentryReplay,
+  sentry,
+  onConsentChange,
+  onError,
+  autoShowBanner = true,
+  fetchImpl,
+  children
+}) {
+  const [state, setState] = useState(
+    FFID_CONSENT_NOT_DECIDED_STATE
+  );
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [isBannerOpen, setIsBannerOpen] = useState(false);
+  const [isPreferencesOpen, setIsPreferencesOpen] = useState(false);
+  const [categoryMetadata, setCategoryMetadata] = useState(null);
+  const [policy, setPolicy] = useState(null);
+  const clientRef = useRef(null);
+  const bridgeRef = useRef(null);
+  const deviceIdRef = useRef(null);
+  if (!clientRef.current) {
+    deviceIdRef.current = getOrCreateDeviceId();
+    const clientOpts = {
+      baseUrl,
+      serviceApiKey,
+      getDeviceId: () => deviceIdRef.current ?? ""
+    };
+    if (getAccessToken !== void 0) clientOpts.getAccessToken = getAccessToken;
+    if (fetchImpl !== void 0) clientOpts.fetchImpl = fetchImpl;
+    clientRef.current = createConsentClient(clientOpts);
+  }
+  if (!bridgeRef.current) {
+    bridgeRef.current = createGtagBridge({
+      gaMeasurementId: gaMeasurementId ?? null
+    });
+    bridgeRef.current.setDefaultConsent();
+  }
+  const applyCategoriesSideEffects = useCallback(
+    (cats) => {
+      const bridge = bridgeRef.current;
+      if (bridge) {
+        bridge.updateConsent(cats);
+        bridge.applyGaInjection(cats);
+      }
+      if (sentryReplay) {
+        const sdk = sentry ?? (typeof window !== "undefined" ? window.Sentry : void 0);
+        const replay = sdk?.getReplay?.();
+        if (replay) {
+          try {
+            if (cats.functional) {
+              replay.start();
+            } else {
+              const maybe = replay.stop();
+              if (maybe && typeof maybe.catch === "function") {
+                ;
+                maybe.catch(() => {
+                });
+              }
+            }
+          } catch (err) {
+            if (typeof console !== "undefined") {
+              console.warn("[ffid-sdk] Sentry replay control failed", err);
+            }
+          }
+        }
+      }
+    },
+    [sentry, sentryReplay]
+  );
+  const persistCategories = useCallback(
+    (cats) => {
+      const cookieWritten = writeConsentCookie(cats);
+      const mirrorWritten = writeConsentSessionMirror(cats);
+      if (!cookieWritten) {
+        const writeErr = new FFIDConsentError(
+          "cookie_consent_cookie_write_failed",
+          mirrorWritten ? "\u540C\u610F\u60C5\u5831\u3092 Cookie \u306B\u4FDD\u5B58\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u306E\u307F\u6709\u52B9\u3067\u3059" : DEFAULT_CONSENT_ERROR_MESSAGES.cookie_consent_cookie_write_failed
+        );
+        setError(writeErr);
+        onError?.(writeErr);
+      }
+    },
+    [onError]
+  );
+  const handleResult = useCallback(
+    (result, warning) => {
+      if (!result.ok) {
+        setError(result.error);
+        onError?.(result.error);
+        return;
+      }
+      setError(null);
+      setState(result.value);
+      applyCategoriesSideEffects(result.value.categories);
+      persistCategories(result.value.categories);
+      onConsentChange?.(result.value, warning ?? null);
+    },
+    [applyCategoriesSideEffects, onConsentChange, onError, persistCategories]
+  );
+  useEffect(() => {
+    let cancelled = false;
+    async function bootstrap() {
+      const local = readConsentSessionMirror() ?? readConsentCookie();
+      applyCategoriesSideEffects(local);
+      setState(stateFromLocalCategories(local));
+      const client = clientRef.current;
+      const result = await client.getMe();
+      if (cancelled) return;
+      if (!result.ok) {
+        setError(result.error);
+        onError?.(result.error);
+        setIsLoading(false);
+        return;
+      }
+      setState(result.value);
+      applyCategoriesSideEffects(result.value.categories);
+      writeConsentSessionMirror(result.value.categories);
+      setIsLoading(false);
+      if (!result.value.hasDecided && autoShowBanner) {
+        setIsBannerOpen(true);
+      }
+      if (result.value.needsRenewal && autoShowBanner) {
+        setIsBannerOpen(true);
+      }
+    }
+    void bootstrap();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  const ensurePolicyVersion = useCallback(async () => {
+    if (policy) return { ok: true, version: policy.version };
+    const client = clientRef.current;
+    const result = await client.getDocument();
+    if (!result.ok) {
+      setError(result.error);
+      onError?.(result.error);
+      return { ok: false, error: result.error };
+    }
+    setPolicy(result.value);
+    return { ok: true, version: result.value.version };
+  }, [onError, policy]);
+  const submitFromBanner = useCallback(
+    async (cats) => {
+      const version = await ensurePolicyVersion();
+      if (!version.ok) return { ok: false, error: version.error };
+      const client = clientRef.current;
+      const result = await client.submit(cats, "banner", version.version);
+      if (!result.ok && result.error.code === "cookie_consent_policy_outdated") {
+        setPolicy(null);
+      }
+      handleResult(result);
+      if (result.ok) setIsBannerOpen(false);
+      return result;
+    },
+    [ensurePolicyVersion, handleResult]
+  );
+  const acceptAll = useCallback(
+    () => submitFromBanner({
+      functional: true,
+      analytics: true,
+      marketing: true
+    }),
+    [submitFromBanner]
+  );
+  const acceptNecessaryOnly = useCallback(
+    () => submitFromBanner({
+      functional: false,
+      analytics: false,
+      marketing: false
+    }),
+    [submitFromBanner]
+  );
+  const setCategories = useCallback(
+    async (changes, source = "preference_center") => {
+      const version = await ensurePolicyVersion();
+      if (!version.ok) return { ok: false, error: version.error };
+      const base = state.categories;
+      const next = applyChanges(base, changes);
+      const client = clientRef.current;
+      const result = await client.submit(
+        {
+          functional: next.functional,
+          analytics: next.analytics,
+          marketing: next.marketing
+        },
+        source,
+        version.version
+      );
+      if (!result.ok && result.error.code === "cookie_consent_policy_outdated") {
+        setPolicy(null);
+      }
+      handleResult(result);
+      return result;
+    },
+    [ensurePolicyVersion, handleResult, state.categories]
+  );
+  const withdraw = useCallback(async () => {
+    const client = clientRef.current;
+    const result = await client.withdraw();
+    handleResult(result);
+    return result;
+  }, [handleResult]);
+  const refresh = useCallback(async () => {
+    const client = clientRef.current;
+    setIsLoading(true);
+    const result = await client.getMe();
+    handleResult(result);
+    setIsLoading(false);
+  }, [handleResult]);
+  const syncWithUser = useCallback(async () => {
+    const client = clientRef.current;
+    const localCats = readConsentCookie();
+    const ver = await ensurePolicyVersion();
+    const result = await client.sync(
+      ver.ok ? {
+        necessary: true,
+        functional: localCats.functional,
+        analytics: localCats.analytics,
+        marketing: localCats.marketing,
+        cookiePolicyVersion: ver.version
+      } : null
+    );
+    if (!result.ok) {
+      setError(result.error);
+      onError?.(result.error);
+      return result;
+    }
+    setError(null);
+    setState(result.value.state);
+    applyCategoriesSideEffects(result.value.state.categories);
+    persistCategories(result.value.state.categories);
+    const warning = result.value.warning ? {
+      code: result.value.warning,
+      message: DEFAULT_MERGE_WARNING_MESSAGES[result.value.warning]
+    } : null;
+    onConsentChange?.(result.value.state, warning);
+    return result;
+  }, [
+    applyCategoriesSideEffects,
+    ensurePolicyVersion,
+    onConsentChange,
+    onError,
+    persistCategories
+  ]);
+  const openBanner = useCallback(() => setIsBannerOpen(true), []);
+  const closeBanner = useCallback(() => setIsBannerOpen(false), []);
+  const openPreferences = useCallback(async () => {
+    if (!categoryMetadata) {
+      const client = clientRef.current;
+      const result = await client.getCategories();
+      if (!result.ok) {
+        setError(result.error);
+        onError?.(result.error);
+      } else {
+        setCategoryMetadata(result.value);
+      }
+    }
+    setIsPreferencesOpen(true);
+  }, [categoryMetadata, onError]);
+  const closePreferences = useCallback(() => setIsPreferencesOpen(false), []);
+  const contextValue = useMemo(
+    () => ({
+      state,
+      isLoading,
+      error,
+      categoryMetadata,
+      policy,
+      isBannerOpen,
+      isPreferencesOpen,
+      openBanner,
+      closeBanner,
+      openPreferences,
+      closePreferences,
+      acceptAll,
+      acceptNecessaryOnly,
+      setCategories,
+      withdraw,
+      refresh,
+      syncWithUser
+    }),
+    [
+      acceptAll,
+      acceptNecessaryOnly,
+      categoryMetadata,
+      closeBanner,
+      closePreferences,
+      error,
+      isBannerOpen,
+      isLoading,
+      isPreferencesOpen,
+      openBanner,
+      openPreferences,
+      policy,
+      refresh,
+      setCategories,
+      state,
+      syncWithUser,
+      withdraw
+    ]
+  );
+  return /* @__PURE__ */ jsx(FFIDConsentContext.Provider, { value: contextValue, children });
+}
+function useFFIDConsent() {
+  const ctx = useContext(FFIDConsentContext);
+  return {
+    state: ctx.state,
+    categories: ctx.state.categories,
+    isLoading: ctx.isLoading,
+    error: ctx.error,
+    isBannerOpen: ctx.isBannerOpen,
+    isPreferencesOpen: ctx.isPreferencesOpen,
+    openBanner: ctx.openBanner,
+    closeBanner: ctx.closeBanner,
+    openPreferences: ctx.openPreferences,
+    closePreferences: ctx.closePreferences,
+    acceptAll: ctx.acceptAll,
+    acceptNecessaryOnly: ctx.acceptNecessaryOnly,
+    setCategories: ctx.setCategories,
+    withdraw: ctx.withdraw,
+    refresh: ctx.refresh
+  };
+}
+function useFFIDConsentPreferences() {
+  const ctx = useContext(FFIDConsentContext);
+  return {
+    state: ctx.state,
+    categoryMetadata: ctx.categoryMetadata,
+    policy: ctx.policy,
+    isLoading: ctx.isLoading,
+    save: (changes) => ctx.setCategories(changes, "preference_center"),
+    withdraw: ctx.withdraw
+  };
+}
+var DEFAULT_STYLE = {
+  position: "fixed",
+  bottom: 0,
+  left: 0,
+  right: 0,
+  padding: "16px",
+  backgroundColor: "#fff",
+  borderTop: "1px solid #e5e7eb",
+  boxShadow: "0 -4px 12px rgba(0,0,0,0.08)",
+  zIndex: 9999,
+  display: "flex",
+  flexDirection: "column",
+  gap: "12px"
+};
+var DEFAULT_BUTTON_GROUP_STYLE = {
+  display: "flex",
+  gap: "8px",
+  flexWrap: "wrap"
+};
+var DEFAULT_BUTTON_STYLE = {
+  flex: "1 1 auto",
+  minWidth: "120px",
+  padding: "10px 16px",
+  borderRadius: "6px",
+  border: "1px solid #d1d5db",
+  background: "#f9fafb",
+  cursor: "pointer",
+  fontSize: "14px"
+};
+var DEFAULT_PRIMARY_STYLE = {
+  ...DEFAULT_BUTTON_STYLE,
+  background: "#111827",
+  color: "#fff",
+  border: "1px solid #111827"
+};
+function FFIDCookieBanner({
+  className,
+  classNames,
+  message,
+  acceptAllLabel,
+  necessaryOnlyLabel,
+  preferencesLabel,
+  style
+}) {
+  const {
+    state,
+    isBannerOpen,
+    acceptAll,
+    acceptNecessaryOnly,
+    openPreferences,
+    error
+  } = useFFIDConsent();
+  if (!isBannerOpen && state.hasDecided && !state.needsRenewal) return null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      role: "dialog",
+      "aria-modal": "false",
+      "aria-label": "Cookie \u540C\u610F",
+      className: className ?? classNames?.root,
+      style: style ?? DEFAULT_STYLE,
+      "data-testid": "ffid-cookie-banner",
+      children: [
+        /* @__PURE__ */ jsx("p", { className: classNames?.message, style: { margin: 0, fontSize: "14px" }, children: message ?? "\u5F53\u30B5\u30A4\u30C8\u3067\u306F\u3001\u30B5\u30FC\u30D3\u30B9\u306E\u54C1\u8CEA\u5411\u4E0A\u306E\u305F\u3081 Cookie \u3092\u4F7F\u7528\u3057\u307E\u3059\u3002" }),
+        error ? /* @__PURE__ */ jsx(
+          "p",
+          {
+            role: "alert",
+            style: { margin: 0, color: "#dc2626", fontSize: "13px" },
+            children: error.message
+          }
+        ) : null,
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: classNames?.buttonGroup,
+            style: DEFAULT_BUTTON_GROUP_STYLE,
+            children: [
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  className: classNames?.primaryButton,
+                  style: DEFAULT_PRIMARY_STYLE,
+                  onClick: () => {
+                    void acceptAll();
+                  },
+                  "data-testid": "ffid-cookie-banner-accept-all",
+                  children: acceptAllLabel ?? "\u3059\u3079\u3066\u540C\u610F"
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  className: classNames?.secondaryButton,
+                  style: DEFAULT_BUTTON_STYLE,
+                  onClick: () => {
+                    void acceptNecessaryOnly();
+                  },
+                  "data-testid": "ffid-cookie-banner-necessary-only",
+                  children: necessaryOnlyLabel ?? "\u5FC5\u8981\u306A\u3082\u306E\u3060\u3051"
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  className: classNames?.linkButton,
+                  style: DEFAULT_BUTTON_STYLE,
+                  onClick: () => {
+                    void openPreferences();
+                  },
+                  "data-testid": "ffid-cookie-banner-preferences",
+                  children: preferencesLabel ?? "\u8A73\u7D30\u8A2D\u5B9A"
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+var DEFAULT_BACKDROP_STYLE = {
+  position: "fixed",
+  inset: 0,
+  background: "rgba(0,0,0,0.4)",
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center",
+  zIndex: 1e4
+};
+var DEFAULT_MODAL_STYLE = {
+  width: "min(90vw, 480px)",
+  maxHeight: "85vh",
+  overflow: "auto",
+  background: "#fff",
+  borderRadius: "8px",
+  padding: "20px",
+  boxShadow: "0 8px 32px rgba(0,0,0,0.18)",
+  display: "flex",
+  flexDirection: "column",
+  gap: "16px"
+};
+var ROW_STYLE = {
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "space-between",
+  gap: "12px",
+  padding: "12px 0",
+  borderBottom: "1px solid #f3f4f6"
+};
+function FFIDCookieSettings({
+  className,
+  classNames,
+  open,
+  showWithdrawButton = true
+}) {
+  const { isPreferencesOpen, closePreferences } = useFFIDConsent();
+  const { state, categoryMetadata, save, withdraw } = useFFIDConsentPreferences();
+  const visible = open ?? isPreferencesOpen;
+  const [draft, setDraft] = useState({
+    functional: state.categories.functional,
+    analytics: state.categories.analytics,
+    marketing: state.categories.marketing
+  });
+  useEffect(() => {
+    setDraft({
+      functional: state.categories.functional,
+      analytics: state.categories.analytics,
+      marketing: state.categories.marketing
+    });
+  }, [
+    state.categories.functional,
+    state.categories.analytics,
+    state.categories.marketing
+  ]);
+  const openerRef = useRef(null);
+  useEffect(() => {
+    if (!visible) return;
+    if (typeof document === "undefined") return;
+    openerRef.current = document.activeElement;
+    const onKey = (e) => {
+      if (e.key === "Escape") closePreferences();
+    };
+    document.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("keydown", onKey);
+      openerRef.current?.focus?.();
+    };
+  }, [visible, closePreferences]);
+  if (!visible) return null;
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      role: "presentation",
+      className: classNames?.backdrop,
+      style: DEFAULT_BACKDROP_STYLE,
+      onClick: (e) => {
+        if (e.target === e.currentTarget) closePreferences();
+      },
+      "data-testid": "ffid-cookie-settings-backdrop",
+      children: /* @__PURE__ */ jsxs(
+        "div",
+        {
+          role: "dialog",
+          "aria-modal": "true",
+          "aria-label": "Cookie \u8A2D\u5B9A",
+          className: className ?? classNames?.root,
+          style: DEFAULT_MODAL_STYLE,
+          "data-testid": "ffid-cookie-settings",
+          children: [
+            /* @__PURE__ */ jsx("header", { className: classNames?.header, children: /* @__PURE__ */ jsx("h2", { style: { margin: 0, fontSize: "18px" }, children: "Cookie \u8A2D\u5B9A" }) }),
+            /* @__PURE__ */ jsx("div", { children: (categoryMetadata ?? FALLBACK_CATEGORIES).map((cat) => {
+              const checked = cat.code === "necessary" ? true : draft[cat.code] ?? false;
+              return /* @__PURE__ */ jsxs(
+                "label",
+                {
+                  className: classNames?.categoryRow,
+                  style: ROW_STYLE,
+                  children: [
+                    /* @__PURE__ */ jsxs("div", { style: { flex: 1 }, children: [
+                      /* @__PURE__ */ jsx("div", { style: { fontWeight: 600, fontSize: "14px" }, children: cat.label }),
+                      /* @__PURE__ */ jsx("div", { style: { color: "#6b7280", fontSize: "13px" }, children: cat.description })
+                    ] }),
+                    /* @__PURE__ */ jsx(
+                      "input",
+                      {
+                        type: "checkbox",
+                        checked,
+                        disabled: cat.isRequired,
+                        "aria-disabled": cat.isRequired,
+                        onChange: (e) => {
+                          if (cat.isRequired) return;
+                          setDraft((d) => ({
+                            ...d,
+                            [cat.code]: e.target.checked
+                          }));
+                        },
+                        "data-testid": `ffid-cookie-toggle-${cat.code}`
+                      }
+                    )
+                  ]
+                },
+                cat.code
+              );
+            }) }),
+            /* @__PURE__ */ jsxs(
+              "div",
+              {
+                style: { display: "flex", gap: "8px", justifyContent: "flex-end" },
+                children: [
+                  showWithdrawButton ? /* @__PURE__ */ jsx(
+                    "button",
+                    {
+                      type: "button",
+                      className: classNames?.secondaryButton,
+                      onClick: () => {
+                        void withdraw().then(() => closePreferences());
+                      },
+                      style: {
+                        padding: "10px 16px",
+                        borderRadius: "6px",
+                        border: "1px solid #d1d5db",
+                        background: "#fff",
+                        cursor: "pointer"
+                      },
+                      "data-testid": "ffid-cookie-settings-withdraw",
+                      children: "\u3059\u3079\u3066\u64A4\u56DE"
+                    }
+                  ) : null,
+                  /* @__PURE__ */ jsx(
+                    "button",
+                    {
+                      type: "button",
+                      className: classNames?.primaryButton,
+                      onClick: () => {
+                        void save(draft).then(() => closePreferences());
+                      },
+                      style: {
+                        padding: "10px 16px",
+                        borderRadius: "6px",
+                        border: "1px solid #111827",
+                        background: "#111827",
+                        color: "#fff",
+                        cursor: "pointer"
+                      },
+                      "data-testid": "ffid-cookie-settings-save",
+                      children: "\u5909\u66F4\u3092\u4FDD\u5B58"
+                    }
+                  )
+                ]
+              }
+            )
+          ]
+        }
+      )
+    }
+  );
+}
+var FALLBACK_CATEGORIES = [
+  {
+    code: "necessary",
+    displayOrder: 0,
+    isRequired: true,
+    label: "\u5FC5\u9808",
+    description: "\u30B5\u30FC\u30D3\u30B9\u306E\u52D5\u4F5C\u306B\u4E0D\u53EF\u6B20\u306A Cookie \u3067\u3059\u3002\u7121\u52B9\u306B\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093\u3002",
+    exampleServices: []
+  },
+  {
+    code: "functional",
+    displayOrder: 1,
+    isRequired: false,
+    label: "\u6A5F\u80FD",
+    description: "\u30E6\u30FC\u30B6\u30FC\u4F53\u9A13\u3092\u5411\u4E0A\u3055\u305B\u308B Cookie \u3067\u3059\u3002",
+    exampleServices: []
+  },
+  {
+    code: "analytics",
+    displayOrder: 2,
+    isRequired: false,
+    label: "\u5206\u6790",
+    description: "\u30B5\u30A4\u30C8\u5229\u7528\u72B6\u6CC1\u306E\u8A08\u6E2C\u306B\u4F7F\u7528\u3057\u307E\u3059\u3002",
+    exampleServices: []
+  },
+  {
+    code: "marketing",
+    displayOrder: 3,
+    isRequired: false,
+    label: "\u5E83\u544A",
+    description: "\u95A2\u5FC3\u306B\u5408\u3063\u305F\u5E83\u544A\u914D\u4FE1\u306B\u4F7F\u7528\u3057\u307E\u3059\u3002",
+    exampleServices: []
+  }
+];
+var DEFAULT_LINK_STYLE = {
+  background: "transparent",
+  border: 0,
+  padding: 0,
+  cursor: "pointer",
+  color: "inherit",
+  textDecoration: "underline",
+  font: "inherit"
+};
+function FFIDCookieLink({
+  children,
+  className,
+  style,
+  id
+}) {
+  const { openPreferences } = useFFIDConsent();
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      className,
+      style: style ?? DEFAULT_LINK_STYLE,
+      onClick: () => {
+        void openPreferences();
+      },
+      "data-testid": "ffid-cookie-link",
+      ...id !== void 0 ? { id } : {},
+      children: children ?? "Cookie \u8A2D\u5B9A"
+    }
+  );
+}
+
+export { ALL_DENIED_EXCEPT_NECESSARY, CONSENT_COOKIE_MAX_AGE_SEC, CONSENT_COOKIE_NAME, CONSENT_SESSION_STORAGE_KEY, COOKIE_VERSION, DEFAULT_CONSENT_ERROR_MESSAGES, DEFAULT_MERGE_WARNING_MESSAGES, DEVICE_ID_LOCAL_STORAGE_KEY, DEVICE_ID_SESSION_STORAGE_KEY, DeviceIdSchema, FFIDAnalyticsProvider, FFIDConsentCategoriesSchema, FFIDConsentCategoryCodeSchema, FFIDConsentCategoryMetadataSchema, FFIDConsentContext, FFIDConsentError, FFIDConsentMergeStrategySchema, FFIDConsentMergeWarningSchema, FFIDConsentSourceSchema, FFIDConsentStateSchema, FFIDConsentUpdateSchema, FFIDCookieBanner, FFIDCookieLink, FFIDCookiePolicySchema, FFIDCookieSettings, FFIDInternalConsentSourceSchema, FFIDPublicConsentSourceSchema, FFID_CONSENT_ERROR_CODES, FFID_CONSENT_NOT_DECIDED_STATE, GetCategoriesWireSchema, GetConsentMeWireSchema, GetDocumentWireSchema, PostConsentRequestSchema, PostConsentWireSchema, PostSyncRequestSchema, PostSyncWireSchema, PostWithdrawWireSchema, clearConsentSessionMirror, clearDeviceId, createConsentClient, createGtagBridge, decodeConsentCookie, deleteConsentCookie, encodeConsentCookie, generateDeviceId, getOrCreateDeviceId, isUuidV7, isValidDeviceId, mapCategoriesToGtagParams, mapConsentWireToState, mapMeWireToState, mapSyncWireToResult, mapWithdrawWireToState, readConsentCookie, readConsentSessionMirror, useFFIDConsent, useFFIDConsentPreferences, writeConsentCookie, writeConsentSessionMirror };