@empty-sekai/sekai-custom-profile-sdk 0.3.0

package/src/cache/sessionImageResourceCache.ts

@@ -0,0 +1,186 @@
+export type DecodedImageValue<T> = { value: T; bytes: number };
+
+export type ImageResourceLease<T> = {
+  value: T;
+  release(): void;
+};
+
+type CacheEntry<T> = {
+  value: T;
+  bytes: number;
+  refs: number;
+  touched: number;
+};
+
+type InflightEntry<T> = {
+  promise: Promise<CacheEntry<T>>;
+  controller: AbortController;
+  waiters: number;
+  settled: boolean;
+};
+
+export class SessionImageResourceCache<T> {
+  private readonly budget: { softBytes: number; hardBytes: number; dispose?: (value: T) => void };
+  private readonly entries = new Map<string, CacheEntry<T>>();
+  private readonly inflight = new Map<string, InflightEntry<T>>();
+  private clock = 0;
+  private totalBytes = 0;
+  private loads = 0;
+  private hits = 0;
+  private evictions = 0;
+
+  constructor(budget: { softBytes: number; hardBytes: number; dispose?: (value: T) => void }) {
+    if (!Number.isFinite(budget.softBytes) || !Number.isFinite(budget.hardBytes)
+      || budget.softBytes < 0 || budget.hardBytes <= 0 || budget.softBytes > budget.hardBytes) {
+      throw new Error("invalid image cache byte budget");
+    }
+    this.budget = budget;
+  }
+
+  async acquire(
+    key: string,
+    loader: (signal: AbortSignal) => Promise<DecodedImageValue<T>>,
+    signal: AbortSignal = new AbortController().signal,
+  ): Promise<ImageResourceLease<T>> {
+    if (signal.aborted) throw abortReason(signal);
+    const cached = this.entries.get(key);
+    if (cached) {
+      this.hits += 1;
+      cached.refs += 1;
+      cached.touched = ++this.clock;
+      return this.lease(cached);
+    }
+    let pending = this.inflight.get(key);
+    if (pending) {
+      this.hits += 1;
+    } else {
+      this.loads += 1;
+      const controller = new AbortController();
+      const created: InflightEntry<T> = {
+        controller,
+        waiters: 0,
+        settled: false,
+        promise: undefined as unknown as Promise<CacheEntry<T>>,
+      };
+      created.promise = Promise.resolve().then(() => this.load(key, () => loader(controller.signal), created));
+      pending = created;
+      this.inflight.set(key, pending);
+      void pending.promise.finally(() => {
+        pending!.settled = true;
+        if (this.inflight.get(key) === pending) this.inflight.delete(key);
+      }).catch(() => undefined);
+    }
+    pending.waiters += 1;
+    try {
+      const entry = await awaitWithAbort(pending.promise, signal);
+      entry.refs += 1;
+      entry.touched = ++this.clock;
+      return this.lease(entry);
+    } finally {
+      pending.waiters = Math.max(0, pending.waiters - 1);
+      if (pending.waiters === 0 && !pending.settled) {
+        if (this.inflight.get(key) === pending) this.inflight.delete(key);
+        pending.controller.abort(new DOMException("No resource waiters remain", "AbortError"));
+      }
+      this.trimSoft();
+    }
+  }
+
+  stats(): { entries: number; bytes: number; pinned: number; loads: number; hits: number; evictions: number } {
+    return {
+      entries: this.entries.size,
+      bytes: this.totalBytes,
+      pinned: [...this.entries.values()].filter((entry) => entry.refs > 0).length,
+      loads: this.loads,
+      hits: this.hits,
+      evictions: this.evictions,
+    };
+  }
+
+  keys(): string[] {
+    return [...this.entries.entries()]
+      .sort(([, left], [, right]) => left.touched - right.touched)
+      .map(([key]) => key);
+  }
+
+  clear(): void {
+    for (const [key, entry] of this.entries) {
+      if (entry.refs === 0) this.remove(key, entry);
+    }
+  }
+
+  private async load(
+    key: string,
+    loader: () => Promise<DecodedImageValue<T>>,
+    owner: InflightEntry<T>,
+  ): Promise<CacheEntry<T>> {
+    const decoded = await loader();
+    if (this.inflight.get(key) !== owner) {
+      this.budget.dispose?.(decoded.value);
+      throw abortReason(owner.controller.signal);
+    }
+    if (!Number.isFinite(decoded.bytes) || !Number.isInteger(decoded.bytes) || decoded.bytes < 0) {
+      throw new Error(`invalid decoded image byte size ${decoded.bytes}`);
+    }
+    if (decoded.bytes > this.budget.hardBytes) {
+      throw new Error(`decoded image exceeds hard byte budget: ${decoded.bytes} > ${this.budget.hardBytes}`);
+    }
+    this.evictUntil(this.budget.hardBytes - decoded.bytes);
+    if (this.totalBytes + decoded.bytes > this.budget.hardBytes) {
+      throw new Error(`decoded image cache hard byte budget is pinned`);
+    }
+    const entry: CacheEntry<T> = { value: decoded.value, bytes: decoded.bytes, refs: 0, touched: ++this.clock };
+    this.entries.set(key, entry);
+    this.totalBytes += decoded.bytes;
+    return entry;
+  }
+
+  private lease(entry: CacheEntry<T>): ImageResourceLease<T> {
+    let released = false;
+    return {
+      value: entry.value,
+      release: () => {
+        if (released) return;
+        released = true;
+        entry.refs = Math.max(0, entry.refs - 1);
+        entry.touched = ++this.clock;
+        this.trimSoft();
+      },
+    };
+  }
+
+  private trimSoft(): void {
+    this.evictUntil(this.budget.softBytes);
+  }
+
+  private evictUntil(targetBytes: number): void {
+    if (this.totalBytes <= targetBytes) return;
+    const candidates = [...this.entries.entries()]
+      .filter(([, entry]) => entry.refs === 0)
+      .sort(([, left], [, right]) => left.touched - right.touched);
+    for (const [key, entry] of candidates) {
+      if (this.totalBytes <= targetBytes) break;
+      this.remove(key, entry);
+    }
+  }
+
+  private remove(key: string, entry: CacheEntry<T>): void {
+    if (!this.entries.delete(key)) return;
+    this.totalBytes -= entry.bytes;
+    this.evictions += 1;
+    this.budget.dispose?.(entry.value);
+  }
+}
+
+function awaitWithAbort<T>(promise: Promise<T>, signal: AbortSignal): Promise<T> {
+  if (signal.aborted) return Promise.reject(abortReason(signal));
+  return new Promise<T>((resolve, reject) => {
+    const abort = () => reject(abortReason(signal));
+    signal.addEventListener("abort", abort, { once: true });
+    void promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+  });
+}
+
+function abortReason(signal: AbortSignal): unknown {
+  return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+}

package/src/edt.rs

@@ -0,0 +1,97 @@
+//! Two-dimensional Euclidean distance transform (Felzenszwalb and Huttenlocher, 2012).
+//!
+//! Exact O(n) squared Euclidean distance transform, evaluated by columns and rows.
+
+const INF: f32 = 1e20;
+
+fn dt_1d(f: &[f32], d: &mut [f32], v: &mut [usize], z: &mut [f32]) {
+    let n = f.len();
+    if n == 0 {
+        return;
+    }
+    let mut k: usize = 0;
+    v[0] = 0;
+    z[0] = -INF;
+    z[1] = INF;
+    for q in 1..n {
+        let mut s = intersection(f, q, v[k]);
+        while s <= z[k] {
+            k -= 1;
+            s = intersection(f, q, v[k]);
+        }
+        k += 1;
+        v[k] = q;
+        z[k] = s;
+        z[k + 1] = INF;
+    }
+
+    let mut k = 0usize;
+    for q in 0..n {
+        while z[k + 1] < q as f32 {
+            k += 1;
+        }
+        let dq = q as f32 - v[k] as f32;
+        d[q] = dq * dq + f[v[k]];
+    }
+}
+#[inline]
+fn intersection(f: &[f32], q: usize, vk: usize) -> f32 {
+    let fq = f[q];
+    let fv = f[vk];
+    ((fq + (q * q) as f32) - (fv + (vk * vk) as f32)) / (2.0 * q as f32 - 2.0 * vk as f32)
+}
+
+pub fn edt_2d_sq(grid: &mut [f32], width: usize, height: usize) {
+    if width == 0 || height == 0 {
+        return;
+    }
+    let cap = width.max(height);
+    let mut f = vec![0.0f32; cap];
+    let mut d = vec![0.0f32; cap];
+    let mut v = vec![0usize; cap + 1];
+    let mut z = vec![0.0f32; cap + 1];
+
+    for x in 0..width {
+        for y in 0..height {
+            f[y] = grid[y * width + x];
+        }
+        dt_1d(&f[..height], &mut d[..height], &mut v, &mut z);
+        for y in 0..height {
+            grid[y * width + x] = d[y];
+        }
+    }
+
+    for y in 0..height {
+        let row = &mut grid[y * width..y * width + width];
+        f[..width].copy_from_slice(row);
+        dt_1d(&f[..width], &mut d[..width], &mut v, &mut z);
+        row.copy_from_slice(&d[..width]);
+    }
+}
+
+pub fn signed_distance_from_mask(inside: &[bool], width: usize, height: usize) -> Vec<f32> {
+    let n = width * height;
+    let mut outside_field = vec![0.0f32; n];
+    let mut inside_field = vec![0.0f32; n];
+    for i in 0..n {
+        if inside[i] {
+            outside_field[i] = INF;
+        } else {
+            inside_field[i] = INF;
+        }
+    }
+    edt_2d_sq(&mut outside_field, width, height);
+    edt_2d_sq(&mut inside_field, width, height);
+
+    let mut out = vec![0.0f32; n];
+    let cap = ((width * width + height * height) as f32).sqrt();
+    for i in 0..n {
+        let dist = if inside[i] {
+            -outside_field[i].max(0.0).sqrt().min(cap)
+        } else {
+            inside_field[i].max(0.0).sqrt().min(cap)
+        };
+        out[i] = dist;
+    }
+    out
+}

package/src/emscripten.ts

@@ -0,0 +1,17 @@
+export type EmscriptenModule = {
+  HEAPU8: Uint8Array;
+  HEAPU32: Uint32Array;
+  _malloc(size: number): number;
+  _free(pointer: number): void;
+  ccall(
+    name: string,
+    returnType: "number" | null,
+    argumentTypes: Array<"number" | "string">,
+    arguments_: Array<number | string>,
+  ): number | null;
+};
+
+export type EmscriptenModuleFactory = (options?: {
+  locateFile?: (path: string) => string;
+  printErr?: (...values: unknown[]) => void;
+}) => Promise<EmscriptenModule>;

package/src/fontProvider.ts

@@ -0,0 +1,127 @@
+export type FontRequest = {
+  region: string;
+  family: string;
+};
+
+export type ProvidedFont = {
+  bytes: ArrayBuffer | Uint8Array;
+};
+
+export type FontContext = {
+  signal: AbortSignal;
+};
+
+/** Resolves a demanded font family through arbitrary caller-owned logic. */
+export interface FontProvider {
+  provide(
+    request: FontRequest,
+    context: FontContext,
+  ): Promise<ProvidedFont | null>;
+}
+
+export type FontProviderManagerOptions = {
+  provider: FontProvider;
+  concurrency?: number;
+};
+
+export type FontProviderStats = {
+  requested: number;
+  unique: number;
+  loaded: number;
+  bytes: number;
+  failures: number;
+  active: number;
+  peakActive: number;
+  resolveMs: number;
+};
+
+export class FontProviderManager {
+  private readonly provider: FontProvider;
+  private readonly concurrency: number;
+  private readonly counters: FontProviderStats = {
+    requested: 0,
+    unique: 0,
+    loaded: 0,
+    bytes: 0,
+    failures: 0,
+    active: 0,
+    peakActive: 0,
+    resolveMs: 0,
+  };
+
+  constructor(options: FontProviderManagerOptions) {
+    if (!options.provider || typeof options.provider.provide !== "function") {
+      throw new Error("font provider is required");
+    }
+    const concurrency = options.concurrency ?? 4;
+    if (!Number.isInteger(concurrency) || concurrency <= 0) {
+      throw new Error("font concurrency must be a positive integer");
+    }
+    this.provider = options.provider;
+    this.concurrency = concurrency;
+  }
+
+  async resolve(
+    requests: readonly FontRequest[],
+    signal: AbortSignal = new AbortController().signal,
+  ): Promise<Map<string, ArrayBuffer>> {
+    const started = performance.now();
+    const unique = [...new Map(requests.map((request) => [
+      `${request.region}\0${request.family}`,
+      request,
+    ] as const)).values()];
+    this.counters.requested += requests.length;
+    this.counters.unique += unique.length;
+    const values = new Map<string, ArrayBuffer>();
+    let cursor = 0;
+    const worker = async () => {
+      while (cursor < unique.length) {
+        if (signal.aborted) throw abortReason(signal);
+        const request = unique[cursor++];
+        this.counters.active += 1;
+        this.counters.peakActive = Math.max(this.counters.peakActive, this.counters.active);
+        let provided: ProvidedFont | null;
+        try {
+          provided = await this.provider.provide(request, { signal });
+        } catch (error) {
+          this.counters.failures += 1;
+          throw error;
+        } finally {
+          this.counters.active -= 1;
+        }
+        const bytes = provided?.bytes;
+        if (!(bytes instanceof ArrayBuffer) && !(bytes instanceof Uint8Array)) {
+          this.counters.failures += 1;
+          throw new Error(`font provider returned no bytes for ${request.region}:${request.family}`);
+        }
+        const snapshot = bytes instanceof ArrayBuffer
+          ? bytes.slice(0)
+          : Uint8Array.from(bytes).buffer;
+        if (snapshot.byteLength === 0) {
+          this.counters.failures += 1;
+          throw new Error(`font provider returned an empty font for ${request.region}:${request.family}`);
+        }
+        this.counters.loaded += 1;
+        this.counters.bytes += snapshot.byteLength;
+        values.set(request.family, snapshot);
+      }
+    };
+    try {
+      await Promise.all(Array.from(
+        { length: Math.min(this.concurrency, unique.length) },
+        worker,
+      ));
+      return values;
+    } finally {
+      this.counters.resolveMs += performance.now() - started;
+    }
+  }
+
+  stats(): FontProviderStats {
+    return { ...this.counters };
+  }
+}
+
+function abortReason(signal: AbortSignal): unknown {
+  return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+}