@skinhub/viewer 0.1.1

package/dist/types.js

@@ -0,0 +1,106 @@
+/**
+ * *** `@skinhub/viewer` - THE PUBLIC PROP CONTRACT. ***
+ *
+ * ═════════════════════════════════════════════════════════════════════════════════════════════
+ * *** WHAT THIS PACKAGE IS, AND THE ONE SENTENCE THAT DECIDES EVERY QUESTION BELOW. ***
+ *
+ * The renderer is a page on our origin (`/frame`). This package renders an `<iframe>` at it and
+ * speaks its message protocol. Owner, 2026-08-15: *"the package is just a lightweight helper that
+ * translates the postMessages thing to actual props and state that the user can control."*
+ *
+ * *** SO THERE IS NO `three` HERE AND THERE NEVER WILL BE. *** The design rule is *"there is no raw
+ * npm renderer, ever."* An integrator installing this installs React bindings and a URL builder. The
+ * whole of the 3D - the models, the shaders, the compositing, the 19.7 GB asset export - stays on our
+ * side of the frame, which is what makes the logo enforceable and what removes every peer-dependency
+ * question about three.js at once.
+ *
+ * ═════════════════════════════════════════════════════════════════════════════════════════════
+ * *** THE RULE THIS FILE IS WRITTEN UNDER: nothing here may require knowing how SkinHub is built. ***
+ *
+ * Every name is either a word the CS2 economy already uses (`paintIndex`, `float`, `seed`,
+ * `defindex`, `statTrak`) or a word any 3D component uses (`view`, `camera`, `quality`, `bloom`).
+ * Nothing is named after a route, a store, a shader parameter or a file in our tree. A prop that only
+ * makes sense once you have read our source is a bug in this file.
+ *
+ * *** AND ONE COROLLARY WORTH STATING, because it is the difference between a wrapper and a leak: ***
+ * this file does NOT re-export `/frame`'s own vocabulary. The wire says `weaponType` and
+ * `PlacementSlots` in the game's field names (`sticker_id`, `offset_x`); an integrator says `weapon`
+ * and `{ id, offsetX }`. `item.ts` is the only place the two meet, and it is not exported for the
+ * public surface's sake - it is exported because a marketplace holding an inspect link needs the
+ * bridge in its own server code too.
+ */
+import { LINK } from './link.js';
+/**
+ * *** WHICH ITEM FIELDS UPDATE IN PLACE, WRITTEN DOWN AS A VALUE. ***
+ *
+ * The owner's requirement, verbatim: changing `float`, `seed`, `statTrak`, `nameTag`, the stickers or
+ * the charm *"must NOT reload the viewer - that's a must to make it feel just like in our website."*
+ * Changing the weapon or the paint kit *"shows nothing until the model has loaded, behind the loading
+ * card"*.
+ *
+ * This list is the FIRST half. It is here, as a value, because {@link SkinViewerProps.loading} is
+ * raised off its complement - see `SkinViewer.tsx`'s `isIdentityChange` - and because a contract an
+ * integrator relies on should be readable without opening the renderer.
+ */
+export const CHEAP_FIELDS = ['float', 'seed', 'statTrak', 'nameTag', 'stickers', 'charm'];
+/* ═════════════════════════════════════════════════════════════════════════════════════════════
+ * SETTINGS
+ *
+ * *** FOUR GROUPS, EACH SHALLOW-MERGED OVER OUR DEFAULTS. *** decided
+ * yes: `settings={{ quality: { bloom: 0 } }}` keeps the camera, the environment and the other four
+ * quality fields. Every default is stated on the field, so a partial object is predictable rather
+ * than something you discover by removing keys until the picture changes.
+ *
+ * *** AND THE MERGE HAPPENS IN THE FRAME, NOT HERE, *** which is the only reason it can be trusted:
+ * `/frame` applies a patch through the same `applyFramePatch` that the URL goes through, so a value
+ * this package has never heard of and a value it sets are written to the same field by the same code.
+ * A second merge on this side would be a second set of defaults free to drift from the real ones.
+ * ═══════════════════════════════════════════════════════════════════════════════════════════ */
+/**
+ * *** THE MAPS, AS A CLOSED UNION. *** The owner asked for this directly: `background` is
+ * *"'transparent' or a real map id, not a free string"*.
+ *
+ * WHAT THAT COSTS, said out loud rather than discovered: this list is a COPY of the app's own, so a
+ * map added to the export after this package was published is not typeable until the package is
+ * upgraded. That is the deliberate trade - the rule is *"no back-compat
+ * boilerplate, upgrade when you need to"* - and the failure is legible either way: the frame reports
+ * an unknown map in its `problems` and keeps the lighting it had.
+ */
+export const MAP_NAMES = [
+    'Ancient',
+    'Anubis',
+    'Baggage',
+    'Cache',
+    'Dust II',
+    'Inferno',
+    'Italy',
+    'Mirage',
+    'Nuke',
+    'Office',
+    'Overpass',
+    'Train',
+    'Vertigo',
+    'Warehouse',
+];
+/*
+ * *** THERE IS NO `capture()`, AND THAT IS A MEASURED DECISION RATHER THAN A MISSING FEATURE. ***
+ *
+ * Asked for as *"yes IF IT IS CHEAP, 100% optional"*. It is not cheap. The renderer's
+ * `<Canvas>` runs with `preserveDrawingBuffer: false`, so a `toDataURL` taken from outside the render
+ * loop returns a blank image; shipping a real one means the renderer draws and reads inside a single
+ * frame, which is a change to a shared file in the app rather than anything this package can do. The
+ * frame's protocol has no `capture` verb for the same reason.
+ *
+ * *** AND NOTE WHAT IT WOULD NOT SOLVE EVEN IF IT WERE FREE: *** thumbnails for a listing grid and
+ * preview images for shared links both need a render that happens without a browser tab open. That is
+ * a server-side product and is explicitly not in scope.
+ */
+/*
+ * *** AND THERE IS NO `apiKey`. NOT NOW, NOT LATER. ***
+ *
+ * Decided: *"No, never. Anyone can copy an embed URL anyway, so a key
+ * buys nothing."* The viewer is free for everyone. It is recorded here, in the type surface, because
+ * the cost of adding one later is a breaking change for every integrator - so the absence has to be a
+ * decision somebody can read, not an omission somebody might fix.
+ */
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,OAAO,EAAE,IAAI,EAAmB,MAAM,WAAW,CAAA;AAsGjD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,CAAU,CAAA;AA8ElG;;;;;;;;;;;;iGAYiG;AAEjG;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACxB,SAAS;IACT,QAAQ;IACR,SAAS;IACT,OAAO;IACP,SAAS;IACT,SAAS;IACT,OAAO;IACP,QAAQ;IACR,MAAM;IACN,QAAQ;IACR,UAAU;IACV,OAAO;IACP,SAAS;IACT,WAAW;CACF,CAAA;AAiYV;;;;;;;;;;;;GAYG;AAEH;;;;;;;GAOG"}

package/dist/useSkinViewer.d.ts

@@ -0,0 +1,3 @@
+import type { SkinViewerHandle } from './types.js';
+export declare const useSkinViewer: () => SkinViewerHandle;
+//# sourceMappingURL=useSkinViewer.d.ts.map

package/dist/useSkinViewer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSkinViewer.d.ts","sourceRoot":"","sources":["../src/useSkinViewer.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAIlD,eAAO,MAAM,aAAa,QAAO,gBAiDhC,CAAA"}

package/dist/useSkinViewer.js

@@ -0,0 +1,66 @@
+'use client';
+/**
+ * *** `useSkinViewer()` - PROPS FOR STATE, A HOOK FOR VERBS. ***
+ *
+ * The owner floated this shape and it is the right one. Everything the viewer SHOWS is a prop, because
+ * that is what React is good at. The two or three things that are not values - "load it again", "what
+ * is it doing right now" - cannot be props without inventing a boolean somebody has to toggle back,
+ * so they are here.
+ *
+ *     const viewer = useSkinViewer()
+ *     <SkinViewer item={item} handle={viewer} loading={<Skeleton />} />
+ *     <button onClick={viewer.reload} disabled={viewer.status === 'connecting'}>Reload</button>
+ *
+ * *** THE HOOK IS OPTIONAL AND THE COMPONENT IS COMPLETE WITHOUT IT. *** `onReady`, `onError` and
+ * `onChange` cover every integration that does not need a verb, and a component that only worked when
+ * a hook was also mounted would be a component with a hidden second half.
+ *
+ * *** `reload` IS STABLE; THE HANDLE OBJECT IS NOT. *** The object is rebuilt when `status`, `error` or
+ * `problems` move, because that is how a React value re-renders the tree that reads it. Put
+ * `viewer.reload` in a dependency array, not `viewer`.
+ */
+import { useMemo, useRef, useState } from 'react';
+import { LINK } from './link.js';
+const INITIAL = { status: 'connecting', error: null, problems: [] };
+export const useSkinViewer = () => {
+    const [snapshot, setSnapshot] = useState(INITIAL);
+    /*
+     * ONE LINK OBJECT FOR THE LIFE OF THE HOOK. `useRef` with a lazy fill rather than `useMemo`, because
+     * a memo is a cache and React is allowed to throw a cache away; this is identity, and the component
+     * writes to it.
+     */
+    const link = useRef(null);
+    if (link.current === null)
+        link.current = {
+            reload: () => { },
+            /*
+             * *** THE EQUALITY BAIL IS LOAD-BEARING, NOT AN OPTIMISATION. *** The component publishes from
+             * an effect that runs on every render; a `setState` that always produced a new object would
+             * re-render this hook's owner, which re-renders the component, which runs the effect, which
+             * publishes again - forever.
+             *
+             * *** AND THE ERROR IS COMPARED BY VALUE, NOT IDENTITY, WHICH IS THE WHOLE REASON THIS IS NOT
+             * A ONE-LINER. *** A subject failure (`no-item`, a link that did not decode) is DERIVED from
+             * this render's props, so it is a fresh object every render even when nothing has changed.
+             * Comparing it by identity is exactly the loop above.
+             *
+             * `problems` is compared by identity on purpose: it is the array the frame sent, and a new one
+             * means a new `hello`.
+             */
+            publish: next => setSnapshot(current => current.status === next.status &&
+                current.problems === next.problems &&
+                current.error?.code === next.error?.code &&
+                current.error?.message === next.error?.message
+                ? current
+                : next),
+        };
+    const reload = useRef(() => link.current?.reload()).current;
+    return useMemo(() => ({
+        reload,
+        status: snapshot.status,
+        error: snapshot.error,
+        problems: snapshot.problems,
+        [LINK]: link.current,
+    }), [reload, snapshot]);
+};
+//# sourceMappingURL=useSkinViewer.js.map

package/dist/useSkinViewer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSkinViewer.js","sourceRoot":"","sources":["../src/useSkinViewer.ts"],"names":[],"mappings":"AAAA,YAAY,CAAA;AAEZ;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAEjD,OAAO,EAAE,IAAI,EAAwC,MAAM,WAAW,CAAA;AAGtE,MAAM,OAAO,GAAmB,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAA;AAEnF,MAAM,CAAC,MAAM,aAAa,GAAG,GAAqB,EAAE;IACnD,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,QAAQ,CAAiB,OAAO,CAAC,CAAA;IAEjE;;;;OAIG;IACH,MAAM,IAAI,GAAG,MAAM,CAAoB,IAAI,CAAC,CAAA;IAC5C,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI;QACxB,IAAI,CAAC,OAAO,GAAG;YACd,MAAM,EAAE,GAAG,EAAE,GAAE,CAAC;YAChB;;;;;;;;;;;;;eAaG;YACH,OAAO,EAAE,IAAI,CAAC,EAAE,CACf,WAAW,CAAC,OAAO,CAAC,EAAE,CACrB,OAAO,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM;gBAC9B,OAAO,CAAC,QAAQ,KAAK,IAAI,CAAC,QAAQ;gBAClC,OAAO,CAAC,KAAK,EAAE,IAAI,KAAK,IAAI,CAAC,KAAK,EAAE,IAAI;gBACxC,OAAO,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC,KAAK,EAAE,OAAO;gBAC7C,CAAC,CAAC,OAAO;gBACT,CAAC,CAAC,IAAI,CACP;SACF,CAAA;IAEF,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAA;IAE3D,OAAO,OAAO,CACb,GAAG,EAAE,CAAC,CAAC;QACN,MAAM;QACN,MAAM,EAAE,QAAQ,CAAC,MAAM;QACvB,KAAK,EAAE,QAAQ,CAAC,KAAK;QACrB,QAAQ,EAAE,QAAQ,CAAC,QAAQ;QAC3B,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,OAAqB;KAClC,CAAC,EACF,CAAC,MAAM,EAAE,QAAQ,CAAC,CAClB,CAAA;AACF,CAAC,CAAA"}

package/dist/weapons.d.ts

@@ -0,0 +1,109 @@
+/**
+ * WHICH WEAPON, said two ways — and the table that makes them the same question.
+ *
+ * An integrator holds one of two things. Either a row out of `@skinhub/cdn`'s `skins.json`, whose
+ * `weapon.id` is `'weapon_ak47'`, or a decoded inspect link, whose `defindex` is `7`. Both are the
+ * AK-47. `<SkinViewer>` takes either — {@link WeaponId} on the `weapon` prop, or the number on
+ * `defindex` — and this is the only place the two are reconciled.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────────────────────
+ * WHY THIS TABLE IS CHECKED IN AND NOT FETCHED, when the whole premise of `@skinhub/cdn` is that
+ * data derived from the CDN has to be derived at runtime.
+ *
+ * That rule is about data that CHANGES — a new finish, a new sticker capsule, a new agent. This is
+ * not that. A defindex is Valve's item definition index: `weapon_ak47` has been 7 since 2013 and
+ * cannot become anything else without breaking every inventory in the game. The table is 63 rows and
+ * it is derived from the export itself (`data/skins.json`, `weapon.weapon_id` → `weapon.id`,
+ * generated 2026-08-15, verified: 63 distinct defindexes, no defindex mapping to two DIFFERENT
+ * weapons — the 20 knives each carry a second `sfui_wpnhud_*` alias for their vanilla row, which
+ * `getWeaponModelPath` already resolves to the same model).
+ *
+ * The alternative is fetching a 4.4 MB `skins.json` to answer "what is 7", which would make the
+ * inspect-link path — the one the product exists for — cost four megabytes before the first frame.
+ *
+ * WHAT GOING STALE LOOKS LIKE, stated rather than discovered: Valve ships a new weapon, an integrator
+ * passes its defindex, and {@link weaponIdForDefindex} returns `undefined`. `<SkinViewer>` then
+ * reports `unknown-weapon` through `onError` and renders its error state, naming the number it could
+ * not resolve. That is a legible failure with an obvious fix (pass `weapon` instead, or upgrade), not
+ * a blank canvas.
+ */
+/**
+ * Every weapon the viewer can render, as the CS2 econ item id.
+ *
+ * This is `skin.weapon.id` in `@skinhub/cdn`'s `skins.json` rows, verbatim — so
+ * `<SkinViewer weapon={row.weapon.id} paintIndex={…} />` typechecks against a catalogue row with no
+ * conversion. Type it into an editor and autocomplete lists all 71.
+ */
+export declare const WEAPON_IDS: readonly ["weapon_cz75a", "weapon_deagle", "weapon_elite", "weapon_fiveseven", "weapon_glock", "weapon_hkp2000", "weapon_p250", "weapon_revolver", "weapon_tec9", "weapon_usp_silencer", "weapon_bizon", "weapon_mac10", "weapon_mp5sd", "weapon_mp7", "weapon_mp9", "weapon_p90", "weapon_ump45", "weapon_ak47", "weapon_aug", "weapon_famas", "weapon_galilar", "weapon_m4a1", "weapon_m4a1_silencer", "weapon_sg556", "weapon_awp", "weapon_g3sg1", "weapon_scar20", "weapon_ssg08", "weapon_m249", "weapon_mag7", "weapon_negev", "weapon_nova", "weapon_sawedoff", "weapon_xm1014", "weapon_taser", "weapon_bayonet", "weapon_knife_butterfly", "weapon_knife_canis", "weapon_knife_cord", "weapon_knife_css", "weapon_knife_falchion", "weapon_knife_flip", "weapon_knife_gut", "weapon_knife_gypsy_jackknife", "weapon_knife_karambit", "weapon_knife_kukri", "weapon_knife_m9_bayonet", "weapon_knife_outdoor", "weapon_knife_push", "weapon_knife_skeleton", "weapon_knife_stiletto", "weapon_knife_survival_bowie", "weapon_knife_tactical", "weapon_knife_ursus", "weapon_knife_widowmaker", "leather_handwraps", "motorcycle_gloves", "slick_gloves", "specialist_gloves", "sporty_gloves", "studded_bloodhound_gloves", "studded_brokenfang_gloves", "studded_hydra_gloves"];
+export type KnownWeaponId = (typeof WEAPON_IDS)[number];
+/**
+ * `'weapon_ak47'`.
+ *
+ * The `(string & {})` arm is deliberate and is not a widening mistake: it keeps autocomplete listing
+ * the 71 known ids while still ACCEPTING an id this build has never heard of, so a new weapon in a
+ * fresh export renders the day it ships rather than the day the package is upgraded. An unknown id
+ * that the asset export also does not know resolves to no model, which surfaces as `unknown-weapon`.
+ */
+export type WeaponId = KnownWeaponId | (string & {});
+/**
+ * Item definition index → econ item id. See the file header for why this is checked in.
+ *
+ * The 20 knives are listed under their `weapon_*` id rather than the `sfui_wpnhud_*` alias that also
+ * appears on their vanilla row; both resolve to the same GLB.
+ */
+export declare const WEAPON_ID_BY_DEFINDEX: Readonly<Record<number, KnownWeaponId>>;
+/**
+ * ─────────────────────────────────────────────────────────────────────────────────────────────
+ * *** THE HUD ALIASES — the difference between a knife and an empty canvas. ***
+ *
+ * `@skinhub/cdn`'s `skins.json` carries TWO ids for every knife. The painted rows say
+ * `weapon.id === 'weapon_bayonet'`; the ONE vanilla row per knife says
+ * `weapon.id === 'sfui_wpnhud_knifebayonet'` — the HUD string, not the item name. Both share
+ * `weapon.weapon_id === 500`. There are 83 distinct `weapon.id` values across 63 defindexes, and the
+ * 20 extras are exactly this.
+ *
+ * So an integrator doing the most natural thing there is —
+ *
+ *     const row = findSkin(skins, { defindex, paintindex })
+ *     <SkinViewer weaponId={row.weapon.id} … />
+ *
+ * — hands this component a HUD string for all twenty vanilla knives and nothing else.
+ *
+ * *** THE ALIAS IS ACCEPTED AND FOLDED, NOT REJECTED. *** The mapping is 1:1 and unambiguous, the
+ * renderer's own model table already resolves the same twenty strings, and failing on a value the data
+ * package hands you from its documented API would only mean the two packages disagree about what a
+ * Bayonet is called. Folding it here additionally makes {@link defindexForWeaponId} answer for those
+ * rows, so an inspect link built back out of a vanilla knife carries 500 rather than 0.
+ *
+ * An id that is neither a known weapon nor a known alias still fails VISIBLY — `<SkinViewer>` reports
+ * `unknown-weapon` and renders its error state naming the string it could not resolve. Rendering
+ * nothing, silently, is the one outcome this table exists to prevent.
+ *
+ * Deliberately NOT in {@link WEAPON_IDS}: these are accepted, not recommended, and an editor should
+ * not offer `sfui_wpnhud_knifekaram` to somebody typing a weapon id.
+ */
+export declare const WEAPON_ID_ALIASES: Readonly<Record<string, KnownWeaponId>>;
+/**
+ * Fold a HUD alias onto the item id. Everything else passes through untouched, including ids this
+ * build has never heard of — see {@link WeaponId} for why an unknown id is not an error here.
+ */
+export declare const normalizeWeaponId: (weapon: WeaponId) => WeaponId;
+/** True for an id this build can name. `false` is what makes `<SkinViewer>` report `unknown-weapon`. */
+export declare const isKnownWeaponId: (weapon: WeaponId) => boolean;
+/**
+ * `7` → `'weapon_ak47'`, or `undefined` for a defindex this build does not know.
+ *
+ * NEVER RETURNS AN ALIAS — the table is keyed on `weapon_id`, which is the whole reason to build it
+ * that way rather than off the first `weapon.id` a scan happens to hit.
+ */
+export declare const weaponIdForDefindex: (defindex: number) => KnownWeaponId | undefined;
+/**
+ * `'weapon_ak47'` → `7`, or `undefined`.
+ *
+ * The inverse, for building an inspect link back out of what the viewer is showing — see
+ * {@link toPlacement}, exported from the package root. Resolves HUD aliases, so a vanilla Bayonet round-trips to 500 rather than to 0.
+ */
+export declare const defindexForWeaponId: (weapon: WeaponId) => number | undefined;
+/** Gloves take a different renderer and carry no stickers, charm, counter or name plate. */
+export declare const isGloveId: (weapon: WeaponId) => boolean;
+//# sourceMappingURL=weapons.d.ts.map

package/dist/weapons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"weapons.d.ts","sourceRoot":"","sources":["../src/weapons.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,2tCA0Eb,CAAA;AAEV,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAA;AAEvD;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,GAAG,aAAa,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAA;AAEpD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAgEzE,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAqBrE,CAAA;AAID;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI,QAAQ,QAAQ,KAAG,QAA+C,CAAA;AAEpG,wGAAwG;AACxG,eAAO,MAAM,eAAe,GAAI,QAAQ,QAAQ,KAAG,OAA0D,CAAA;AAM7G;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,UAAU,MAAM,KAAG,aAAa,GAAG,SAA4C,CAAA;AAEnH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,QAAQ,KAAG,MAAM,GAAG,SACf,CAAA;AAEjD,4FAA4F;AAC5F,eAAO,MAAM,SAAS,GAAI,QAAQ,QAAQ,KAAG,OAAuE,CAAA"}

package/dist/weapons.js

@@ -0,0 +1,260 @@
+/**
+ * WHICH WEAPON, said two ways — and the table that makes them the same question.
+ *
+ * An integrator holds one of two things. Either a row out of `@skinhub/cdn`'s `skins.json`, whose
+ * `weapon.id` is `'weapon_ak47'`, or a decoded inspect link, whose `defindex` is `7`. Both are the
+ * AK-47. `<SkinViewer>` takes either — {@link WeaponId} on the `weapon` prop, or the number on
+ * `defindex` — and this is the only place the two are reconciled.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────────────────────
+ * WHY THIS TABLE IS CHECKED IN AND NOT FETCHED, when the whole premise of `@skinhub/cdn` is that
+ * data derived from the CDN has to be derived at runtime.
+ *
+ * That rule is about data that CHANGES — a new finish, a new sticker capsule, a new agent. This is
+ * not that. A defindex is Valve's item definition index: `weapon_ak47` has been 7 since 2013 and
+ * cannot become anything else without breaking every inventory in the game. The table is 63 rows and
+ * it is derived from the export itself (`data/skins.json`, `weapon.weapon_id` → `weapon.id`,
+ * generated 2026-08-15, verified: 63 distinct defindexes, no defindex mapping to two DIFFERENT
+ * weapons — the 20 knives each carry a second `sfui_wpnhud_*` alias for their vanilla row, which
+ * `getWeaponModelPath` already resolves to the same model).
+ *
+ * The alternative is fetching a 4.4 MB `skins.json` to answer "what is 7", which would make the
+ * inspect-link path — the one the product exists for — cost four megabytes before the first frame.
+ *
+ * WHAT GOING STALE LOOKS LIKE, stated rather than discovered: Valve ships a new weapon, an integrator
+ * passes its defindex, and {@link weaponIdForDefindex} returns `undefined`. `<SkinViewer>` then
+ * reports `unknown-weapon` through `onError` and renders its error state, naming the number it could
+ * not resolve. That is a legible failure with an obvious fix (pass `weapon` instead, or upgrade), not
+ * a blank canvas.
+ */
+/**
+ * Every weapon the viewer can render, as the CS2 econ item id.
+ *
+ * This is `skin.weapon.id` in `@skinhub/cdn`'s `skins.json` rows, verbatim — so
+ * `<SkinViewer weapon={row.weapon.id} paintIndex={…} />` typechecks against a catalogue row with no
+ * conversion. Type it into an editor and autocomplete lists all 71.
+ */
+export const WEAPON_IDS = [
+    // Pistols
+    'weapon_cz75a',
+    'weapon_deagle',
+    'weapon_elite',
+    'weapon_fiveseven',
+    'weapon_glock',
+    'weapon_hkp2000',
+    'weapon_p250',
+    'weapon_revolver',
+    'weapon_tec9',
+    'weapon_usp_silencer',
+    // SMGs
+    'weapon_bizon',
+    'weapon_mac10',
+    'weapon_mp5sd',
+    'weapon_mp7',
+    'weapon_mp9',
+    'weapon_p90',
+    'weapon_ump45',
+    // Rifles
+    'weapon_ak47',
+    'weapon_aug',
+    'weapon_famas',
+    'weapon_galilar',
+    'weapon_m4a1',
+    'weapon_m4a1_silencer',
+    'weapon_sg556',
+    // Snipers
+    'weapon_awp',
+    'weapon_g3sg1',
+    'weapon_scar20',
+    'weapon_ssg08',
+    // Heavy
+    'weapon_m249',
+    'weapon_mag7',
+    'weapon_negev',
+    'weapon_nova',
+    'weapon_sawedoff',
+    'weapon_xm1014',
+    // Other
+    'weapon_taser',
+    // Knives
+    'weapon_bayonet',
+    'weapon_knife_butterfly',
+    'weapon_knife_canis',
+    'weapon_knife_cord',
+    'weapon_knife_css',
+    'weapon_knife_falchion',
+    'weapon_knife_flip',
+    'weapon_knife_gut',
+    'weapon_knife_gypsy_jackknife',
+    'weapon_knife_karambit',
+    'weapon_knife_kukri',
+    'weapon_knife_m9_bayonet',
+    'weapon_knife_outdoor',
+    'weapon_knife_push',
+    'weapon_knife_skeleton',
+    'weapon_knife_stiletto',
+    'weapon_knife_survival_bowie',
+    'weapon_knife_tactical',
+    'weapon_knife_ursus',
+    'weapon_knife_widowmaker',
+    // Gloves. A pair of gloves is the SUBJECT here — the thing on screen, framed and orbitable.
+    // Putting a pair ON an operator in the `operator`/`firstPerson` views is not supported; see
+    // `SkinViewerProps.operator`.
+    'leather_handwraps',
+    'motorcycle_gloves',
+    'slick_gloves',
+    'specialist_gloves',
+    'sporty_gloves',
+    'studded_bloodhound_gloves',
+    'studded_brokenfang_gloves',
+    'studded_hydra_gloves',
+];
+/**
+ * Item definition index → econ item id. See the file header for why this is checked in.
+ *
+ * The 20 knives are listed under their `weapon_*` id rather than the `sfui_wpnhud_*` alias that also
+ * appears on their vanilla row; both resolve to the same GLB.
+ */
+export const WEAPON_ID_BY_DEFINDEX = {
+    1: 'weapon_deagle',
+    2: 'weapon_elite',
+    3: 'weapon_fiveseven',
+    4: 'weapon_glock',
+    7: 'weapon_ak47',
+    8: 'weapon_aug',
+    9: 'weapon_awp',
+    10: 'weapon_famas',
+    11: 'weapon_g3sg1',
+    13: 'weapon_galilar',
+    14: 'weapon_m249',
+    16: 'weapon_m4a1',
+    17: 'weapon_mac10',
+    19: 'weapon_p90',
+    23: 'weapon_mp5sd',
+    24: 'weapon_ump45',
+    25: 'weapon_xm1014',
+    26: 'weapon_bizon',
+    27: 'weapon_mag7',
+    28: 'weapon_negev',
+    29: 'weapon_sawedoff',
+    30: 'weapon_tec9',
+    31: 'weapon_taser',
+    32: 'weapon_hkp2000',
+    33: 'weapon_mp7',
+    34: 'weapon_mp9',
+    35: 'weapon_nova',
+    36: 'weapon_p250',
+    38: 'weapon_scar20',
+    39: 'weapon_sg556',
+    40: 'weapon_ssg08',
+    60: 'weapon_m4a1_silencer',
+    61: 'weapon_usp_silencer',
+    63: 'weapon_cz75a',
+    64: 'weapon_revolver',
+    500: 'weapon_bayonet',
+    503: 'weapon_knife_css',
+    505: 'weapon_knife_flip',
+    506: 'weapon_knife_gut',
+    507: 'weapon_knife_karambit',
+    508: 'weapon_knife_m9_bayonet',
+    509: 'weapon_knife_tactical',
+    512: 'weapon_knife_falchion',
+    514: 'weapon_knife_survival_bowie',
+    515: 'weapon_knife_butterfly',
+    516: 'weapon_knife_push',
+    517: 'weapon_knife_cord',
+    518: 'weapon_knife_canis',
+    519: 'weapon_knife_ursus',
+    520: 'weapon_knife_gypsy_jackknife',
+    521: 'weapon_knife_outdoor',
+    522: 'weapon_knife_stiletto',
+    523: 'weapon_knife_widowmaker',
+    525: 'weapon_knife_skeleton',
+    526: 'weapon_knife_kukri',
+    4725: 'studded_brokenfang_gloves',
+    5027: 'studded_bloodhound_gloves',
+    5030: 'sporty_gloves',
+    5031: 'slick_gloves',
+    5032: 'leather_handwraps',
+    5033: 'motorcycle_gloves',
+    5034: 'specialist_gloves',
+    5035: 'studded_hydra_gloves',
+};
+/**
+ * ─────────────────────────────────────────────────────────────────────────────────────────────
+ * *** THE HUD ALIASES — the difference between a knife and an empty canvas. ***
+ *
+ * `@skinhub/cdn`'s `skins.json` carries TWO ids for every knife. The painted rows say
+ * `weapon.id === 'weapon_bayonet'`; the ONE vanilla row per knife says
+ * `weapon.id === 'sfui_wpnhud_knifebayonet'` — the HUD string, not the item name. Both share
+ * `weapon.weapon_id === 500`. There are 83 distinct `weapon.id` values across 63 defindexes, and the
+ * 20 extras are exactly this.
+ *
+ * So an integrator doing the most natural thing there is —
+ *
+ *     const row = findSkin(skins, { defindex, paintindex })
+ *     <SkinViewer weaponId={row.weapon.id} … />
+ *
+ * — hands this component a HUD string for all twenty vanilla knives and nothing else.
+ *
+ * *** THE ALIAS IS ACCEPTED AND FOLDED, NOT REJECTED. *** The mapping is 1:1 and unambiguous, the
+ * renderer's own model table already resolves the same twenty strings, and failing on a value the data
+ * package hands you from its documented API would only mean the two packages disagree about what a
+ * Bayonet is called. Folding it here additionally makes {@link defindexForWeaponId} answer for those
+ * rows, so an inspect link built back out of a vanilla knife carries 500 rather than 0.
+ *
+ * An id that is neither a known weapon nor a known alias still fails VISIBLY — `<SkinViewer>` reports
+ * `unknown-weapon` and renders its error state naming the string it could not resolve. Rendering
+ * nothing, silently, is the one outcome this table exists to prevent.
+ *
+ * Deliberately NOT in {@link WEAPON_IDS}: these are accepted, not recommended, and an editor should
+ * not offer `sfui_wpnhud_knifekaram` to somebody typing a weapon id.
+ */
+export const WEAPON_ID_ALIASES = {
+    sfui_wpnhud_knifebayonet: 'weapon_bayonet',
+    sfui_wpnhud_knife_butterfly: 'weapon_knife_butterfly',
+    sfui_wpnhud_knife_canis: 'weapon_knife_canis',
+    sfui_wpnhud_knife_cord: 'weapon_knife_cord',
+    sfui_wpnhud_knifecss: 'weapon_knife_css',
+    sfui_wpnhud_knife_falchion_advanced: 'weapon_knife_falchion',
+    sfui_wpnhud_knifeflip: 'weapon_knife_flip',
+    sfui_wpnhud_knifegut: 'weapon_knife_gut',
+    sfui_wpnhud_knife_gypsy_jackknife: 'weapon_knife_gypsy_jackknife',
+    sfui_wpnhud_knifekaram: 'weapon_knife_karambit',
+    sfui_wpnhud_knife_kukri: 'weapon_knife_kukri',
+    sfui_wpnhud_knifem9: 'weapon_knife_m9_bayonet',
+    sfui_wpnhud_knife_outdoor: 'weapon_knife_outdoor',
+    sfui_wpnhud_knife_push: 'weapon_knife_push',
+    sfui_wpnhud_knife_skeleton: 'weapon_knife_skeleton',
+    sfui_wpnhud_knife_stiletto: 'weapon_knife_stiletto',
+    sfui_wpnhud_knife_survival_bowie: 'weapon_knife_survival_bowie',
+    sfui_wpnhud_knifetactical: 'weapon_knife_tactical',
+    sfui_wpnhud_knife_ursus: 'weapon_knife_ursus',
+    sfui_wpnhud_knife_widowmaker: 'weapon_knife_widowmaker',
+};
+const KNOWN_WEAPON_IDS = new Set(WEAPON_IDS);
+/**
+ * Fold a HUD alias onto the item id. Everything else passes through untouched, including ids this
+ * build has never heard of — see {@link WeaponId} for why an unknown id is not an error here.
+ */
+export const normalizeWeaponId = (weapon) => WEAPON_ID_ALIASES[weapon] ?? weapon;
+/** True for an id this build can name. `false` is what makes `<SkinViewer>` report `unknown-weapon`. */
+export const isKnownWeaponId = (weapon) => KNOWN_WEAPON_IDS.has(normalizeWeaponId(weapon));
+const DEFINDEX_BY_WEAPON_ID = Object.fromEntries(Object.entries(WEAPON_ID_BY_DEFINDEX).map(([defindex, id]) => [id, Number(defindex)]));
+/**
+ * `7` → `'weapon_ak47'`, or `undefined` for a defindex this build does not know.
+ *
+ * NEVER RETURNS AN ALIAS — the table is keyed on `weapon_id`, which is the whole reason to build it
+ * that way rather than off the first `weapon.id` a scan happens to hit.
+ */
+export const weaponIdForDefindex = (defindex) => WEAPON_ID_BY_DEFINDEX[defindex];
+/**
+ * `'weapon_ak47'` → `7`, or `undefined`.
+ *
+ * The inverse, for building an inspect link back out of what the viewer is showing — see
+ * {@link toPlacement}, exported from the package root. Resolves HUD aliases, so a vanilla Bayonet round-trips to 500 rather than to 0.
+ */
+export const defindexForWeaponId = (weapon) => DEFINDEX_BY_WEAPON_ID[normalizeWeaponId(weapon)];
+/** Gloves take a different renderer and carry no stickers, charm, counter or name plate. */
+export const isGloveId = (weapon) => weapon.endsWith('_gloves') || weapon === 'leather_handwraps';
+//# sourceMappingURL=weapons.js.map

package/dist/weapons.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"weapons.js","sourceRoot":"","sources":["../src/weapons.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,65 @@
+{
+	"name": "@skinhub/viewer",
+	"version": "0.1.1",
+	"description": "React wrapper for the SkinHub CS2 skin viewer embed — props in, postMessage out. No three.js, no renderer, no asset bundle; React is the only peer.",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"bun": "./src/index.ts",
+			"import": "./dist/index.js"
+		},
+		"./protocol": {
+			"types": "./dist/protocol.d.ts",
+			"bun": "./src/protocol.ts",
+			"import": "./dist/protocol.js"
+		},
+		"./weapons": {
+			"types": "./dist/weapons.d.ts",
+			"bun": "./src/weapons.ts",
+			"import": "./dist/weapons.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"files": ["dist", "src", "README.md", "EMBED.md"],
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/SkinHubgg/skinhub-viewer.git"
+	},
+	"homepage": "https://github.com/SkinHubgg/skinhub-viewer#readme",
+	"bugs": {
+		"url": "https://github.com/SkinHubgg/skinhub-viewer/issues"
+	},
+	"keywords": ["cs2", "csgo", "counter-strike", "skin", "viewer", "inspect-link", "react", "iframe", "embed"],
+	"publishConfig": {
+		"access": "public"
+	},
+	"engines": {
+		"node": ">=18"
+	},
+	"scripts": {
+		"typecheck": "tsc --noEmit",
+		"build": "rm -rf dist && tsc -p tsconfig.build.json",
+		"test": "bun test",
+		"test:live": "SKINHUB_VIEWER_LIVE=1 bun test test/live.test.ts",
+		"test:full": "bun test && bun run test:live",
+		"release": "bash scripts/release.sh",
+		"prepare": "bun run build",
+		"prepublishOnly": "bun run typecheck && bun run build"
+	},
+	"peerDependencies": {
+		"react": ">=18"
+	},
+	"dependencies": {
+		"@skinhub/cdn": ">=0.1.3"
+	},
+	"devDependencies": {
+		"@types/bun": "latest",
+		"@types/react": "^19",
+		"react": "^19",
+		"typescript": "^5"
+	}
+}