@stella-studio/ck 1.0.0

package/.claude/skills/shader/references/glsl-procedural-textures-clouds-marble-wood-terrain.md

@@ -0,0 +1,144 @@
+# Procedural Textures
+
+Practical texture recipes using fBm and noise. See `glsl-fbm-fractional-brownian-motion-turbulence-octaves.md` for core functions.
+
+## Clouds
+
+```glsl
+vec3 clouds(vec2 st, float time) {
+    float n = fbm(st * 3.0 + vec2(time * 0.1, 0.0));
+    n = smoothstep(0.4, 0.6, n);
+    return mix(vec3(0.4, 0.6, 0.9), vec3(1.0), n);
+}
+```
+
+## Marble
+
+```glsl
+float marble(vec2 st) {
+    float n = fbm(st * 4.0);
+    return sin(st.x * 10.0 + n * 20.0) * 0.5 + 0.5;
+}
+
+vec3 marbleColor(vec2 st) {
+    float v = marble(st);
+    vec3 white = vec3(0.95);
+    vec3 gray = vec3(0.3);
+    return mix(gray, white, v);
+}
+```
+
+## Wood Grain
+
+```glsl
+float wood(vec2 st) {
+    float n = fbm(st * 2.0);
+    float grain = sin((st.x + n * 0.5) * 50.0) * 0.5 + 0.5;
+    return mix(0.3, 0.6, grain);
+}
+
+vec3 woodColor(vec2 st) {
+    float v = wood(st);
+    vec3 light = vec3(0.76, 0.60, 0.42);
+    vec3 dark = vec3(0.44, 0.30, 0.18);
+    return mix(dark, light, v);
+}
+```
+
+## Terrain Height
+
+```glsl
+float terrain(vec2 st) {
+    float h = fbm(st * 2.0);
+    h += ridged(st * 4.0) * 0.5;
+    return h;
+}
+
+vec3 terrainColor(vec2 st) {
+    float h = terrain(st);
+    vec3 water = vec3(0.1, 0.3, 0.5);
+    vec3 sand = vec3(0.76, 0.70, 0.50);
+    vec3 grass = vec3(0.2, 0.5, 0.2);
+    vec3 rock = vec3(0.5, 0.5, 0.5);
+    vec3 snow = vec3(1.0);
+
+    if (h < 0.3) return mix(water, sand, h / 0.3);
+    if (h < 0.5) return mix(sand, grass, (h - 0.3) / 0.2);
+    if (h < 0.7) return mix(grass, rock, (h - 0.5) / 0.2);
+    return mix(rock, snow, (h - 0.7) / 0.3);
+}
+```
+
+## Fire / Smoke
+
+```glsl
+vec3 fire(vec2 st, float time) {
+    vec2 q = st;
+    q.y -= time * 0.5;  // Rise
+
+    float n = turbulence(q * 3.0);
+    n *= smoothstep(1.0, 0.0, st.y);  // Fade at top
+
+    vec3 col = mix(vec3(1.0, 0.0, 0.0), vec3(1.0, 1.0, 0.0), n);
+    return col * n;
+}
+
+vec3 smoke(vec2 st, float time) {
+    vec2 q = st;
+    q.y -= time * 0.2;
+
+    float n = fbm(q * 4.0);
+    n *= smoothstep(1.0, 0.0, st.y);
+
+    return vec3(0.3 + n * 0.3) * n;
+}
+```
+
+## Water Caustics
+
+```glsl
+float caustics(vec2 st, float time) {
+    vec2 p = st * 8.0;
+    float c = 0.0;
+    for (int i = 0; i < 3; i++) {
+        float t = time * (0.5 + float(i) * 0.1);
+        c += abs(sin(p.x + sin(p.y + t)) * sin(p.y + sin(p.x + t * 1.3)));
+        p *= 1.5;
+    }
+    return c / 3.0;
+}
+```
+
+## Lava
+
+```glsl
+vec3 lava(vec2 st, float time) {
+    float n = warpedFbm(st + vec2(time * 0.05));
+    vec3 cold = vec3(0.1, 0.0, 0.0);
+    vec3 hot = vec3(1.0, 0.3, 0.0);
+    vec3 bright = vec3(1.0, 0.9, 0.3);
+    return mix(cold, mix(hot, bright, n), smoothstep(0.3, 0.7, n));
+}
+```
+
+## Grass/Fur
+
+```glsl
+float grass(vec2 st) {
+    float n = fbm(st * 20.0);
+    float blade = smoothstep(0.3, 0.5, n);
+    return blade * (0.8 + fbm(st * 5.0) * 0.2);
+}
+```
+
+## Stone/Rock
+
+```glsl
+vec3 stone(vec2 st) {
+    float n1 = fbm(st * 4.0);
+    float n2 = fbm(st * 8.0 + 5.0) * 0.5;
+    float crack = smoothstep(0.48, 0.52, n1);
+    vec3 base = vec3(0.5 + n2 * 0.2);
+    return mix(base * 0.7, base, crack);
+}
+```

package/.claude/skills/shader/references/glsl-shader-builtin-functions-complete-api-reference.md

@@ -0,0 +1,112 @@
+# GLSL Built-in Functions Reference
+
+Complete reference for GLSL ES 1.0 / WebGL functions.
+
+## Trigonometric Functions
+
+| Function | Description | Range |
+|----------|-------------|-------|
+| `sin(x)` | Sine | [-1, 1] |
+| `cos(x)` | Cosine | [-1, 1] |
+| `tan(x)` | Tangent | unbounded |
+| `asin(x)` | Arc sine | [-PI/2, PI/2] |
+| `acos(x)` | Arc cosine | [0, PI] |
+| `atan(y, x)` | Arc tangent (quadrant-aware) | [-PI, PI] |
+| `atan(y_over_x)` | Arc tangent | [-PI/2, PI/2] |
+
+All accept float, vec2, vec3, vec4. Input in radians.
+
+## Exponential Functions
+
+| Function | Description |
+|----------|-------------|
+| `pow(x, y)` | x raised to power y |
+| `exp(x)` / `exp2(x)` | e^x / 2^x |
+| `log(x)` / `log2(x)` | Natural / Base-2 logarithm |
+| `sqrt(x)` / `inversesqrt(x)` | Square root / 1/sqrt(x) |
+
+## Common Functions
+
+| Function | Description |
+|----------|-------------|
+| `abs(x)` / `sign(x)` | Absolute value / -1, 0, or 1 |
+| `floor(x)` / `ceil(x)` | Round down / up |
+| `fract(x)` | x - floor(x) |
+| `mod(x, y)` | x - y * floor(x/y) |
+| `min(x, y)` / `max(x, y)` | Minimum / Maximum |
+| `clamp(x, min, max)` | Constrain to range |
+| `mix(a, b, t)` | Linear interpolation: a*(1-t) + b*t |
+| `step(edge, x)` | 0.0 if x < edge, else 1.0 |
+| `smoothstep(e0, e1, x)` | Hermite interpolation |
+
+## Geometric Functions
+
+| Function | Description |
+|----------|-------------|
+| `length(v)` / `distance(a, b)` | Magnitude / Distance |
+| `dot(a, b)` / `cross(a, b)` | Dot / Cross product |
+| `normalize(v)` | Unit vector |
+| `reflect(i, n)` / `refract(i, n, eta)` | Reflection / Refraction |
+
+## Vector Relational Functions
+
+`lessThan`, `lessThanEqual`, `greaterThan`, `greaterThanEqual`, `equal`, `notEqual` - Return bvec.
+`any(bvec)`, `all(bvec)`, `not(bvec)` - Boolean operations.
+
+## Texture Functions
+
+| Function | Description |
+|----------|-------------|
+| `texture2D(sampler, coord)` | Sample 2D texture |
+| `textureCube(sampler, coord)` | Sample cube map |
+
+## Constants
+
+```glsl
+#define PI 3.14159265359
+#define TWO_PI 6.28318530718
+#define HALF_PI 1.57079632679
+```
+
+## Type Constructors
+
+```glsl
+vec2(x), vec2(x, y)
+vec3(x), vec3(xy, z), vec3(x, y, z)
+vec4(x), vec4(xyz, w), vec4(xy, zw)
+mat2(a, b, c, d), mat3(...), mat4(...)
+```
+
+## Operators
+
+```glsl
++  -  *  /           // Arithmetic (component-wise)
+<  >  <=  >=  ==  != // Comparison
+&&  ||  !            // Logical
+mat * mat            // Matrix multiply
+mat * vec            // Transform vector
+```
+
+## Qualifiers
+
+```glsl
+attribute  // Vertex input
+uniform    // Constant across draw
+varying    // Interpolated vertex->fragment
+lowp / mediump / highp  // Precision
+in / out / inout / const // Parameters
+```
+
+## Built-in Variables
+
+```glsl
+// Fragment Shader
+vec4 gl_FragCoord;   // Window coordinates
+vec4 gl_FragColor;   // Output color (write only)
+bool gl_FrontFacing; // Front face?
+vec2 gl_PointCoord;  // Point sprite [0,1]
+
+// Vertex Shader
+vec4 gl_Position;    // Clip-space position
+float gl_PointSize;  // Point size
+```

package/.claude/skills/shader/references/glsl-shapes-polygon-star-polar-sdf-combinations.md

@@ -0,0 +1,124 @@
+# Advanced Shapes & SDF Combinations
+
+Polygons, stars, polar shapes, and combining multiple SDFs.
+
+## Regular Polygon (N sides)
+
+```glsl
+float polygonSDF(vec2 st, vec2 center, float radius, int sides) {
+    st -= center;
+    float a = atan(st.y, st.x) + PI;
+    float r = TWO_PI / float(sides);
+    float d = cos(floor(0.5 + a / r) * r - a) * length(st);
+    return d - radius;
+}
+
+// Usage: hexagon
+float hex = polygonSDF(st, vec2(0.5), 0.3, 6);
+```
+
+## Star Shape
+
+```glsl
+float starSDF(vec2 st, vec2 center, float r1, float r2, int points) {
+    st -= center;
+    float a = atan(st.y, st.x);
+    float seg = TWO_PI / float(points);
+    a = mod(a, seg) - seg * 0.5;
+    float r = length(st);
+    float inner = r2 / cos(seg * 0.5);
+    float d = mix(r1, inner, step(0.0, a) * 2.0 - 1.0);
+    return r - d;
+}
+```
+
+## Polar Shapes
+
+```glsl
+// Convert to polar coordinates
+vec2 toPolar(vec2 st) {
+    vec2 pos = st - 0.5;
+    float r = length(pos) * 2.0;
+    float a = atan(pos.y, pos.x);
+    return vec2(r, a);
+}
+
+// Polar flower
+float flowerSDF(vec2 st, int petals, float amplitude) {
+    vec2 polar = toPolar(st);
+    float shape = 0.5 + amplitude * cos(float(petals) * polar.y);
+    return polar.x - shape;
+}
+
+// Gear shape
+float gearSDF(vec2 st, int teeth, float innerR, float outerR) {
+    vec2 polar = toPolar(st);
+    float tooth = step(0.5, fract(polar.y * float(teeth) / TWO_PI));
+    float radius = mix(innerR, outerR, tooth);
+    return polar.x - radius;
+}
+
+// Heart
+float heartSDF(vec2 st) {
+    st -= vec2(0.5, 0.4);
+    st.x *= 0.8;
+    float a = atan(st.x, st.y) / PI;
+    float r = length(st);
+    float h = abs(a);
+    float d = (13.0 * h - 22.0 * h * h + 10.0 * h * h * h) / (6.0 - 5.0 * h);
+    return r - d * 0.3;
+}
+```
+
+## Combining SDFs
+
+```glsl
+// Union (OR) - combine shapes
+float sdfUnion(float d1, float d2) {
+    return min(d1, d2);
+}
+
+// Intersection (AND) - overlap only
+float sdfIntersect(float d1, float d2) {
+    return max(d1, d2);
+}
+
+// Subtraction - cut out
+float sdfSubtract(float d1, float d2) {
+    return max(d1, -d2);
+}
+
+// XOR - either but not both
+float sdfXor(float d1, float d2) {
+    return max(min(d1, d2), -max(d1, d2));
+}
+```
+
+## Smooth Boolean Operations
+
+```glsl
+// Smooth union (blended edges)
+float sdfSmoothUnion(float d1, float d2, float k) {
+    float h = clamp(0.5 + 0.5 * (d2 - d1) / k, 0.0, 1.0);
+    return mix(d2, d1, h) - k * h * (1.0 - h);
+}
+
+// Smooth subtraction
+float sdfSmoothSubtract(float d1, float d2, float k) {
+    float h = clamp(0.5 - 0.5 * (d2 + d1) / k, 0.0, 1.0);
+    return mix(d1, -d2, h) + k * h * (1.0 - h);
+}
+
+// Smooth intersection
+float sdfSmoothIntersect(float d1, float d2, float k) {
+    float h = clamp(0.5 - 0.5 * (d2 - d1) / k, 0.0, 1.0);
+    return mix(d2, d1, h) + k * h * (1.0 - h);
+}
+```
+
+## SDF Modifications
+
+```glsl
+float ring(float d, float thickness) { return abs(d) - thickness; }
+float roundSDF(float d, float r) { return d - r; }
+```

package/.claude/skills/shader/references/glsl-shapes-sdf-circles-rectangles-polar-distance-fields.md

@@ -0,0 +1,106 @@
+# Shapes in GLSL
+
+Drawing shapes using Signed Distance Fields (SDF) and distance calculations.
+
+## Distance Fields Concept
+
+SDF returns distance from any point to shape edge:
+- **Negative**: Inside shape
+- **Zero**: On edge
+- **Positive**: Outside shape
+
+## Circle
+
+```glsl
+// Basic circle
+float circle(vec2 st, vec2 center, float radius) {
+    float d = distance(st, center);
+    return 1.0 - step(radius, d);
+}
+
+// Smooth edge circle
+float circleSDF(vec2 st, vec2 center, float radius) {
+    return length(st - center) - radius;
+}
+
+// Usage
+float d = circleSDF(st, vec2(0.5), 0.3);
+vec3 color = vec3(1.0 - smoothstep(0.0, 0.01, d));
+```
+
+## Rectangle
+
+```glsl
+// Basic rectangle
+float rect(vec2 st, vec2 pos, vec2 size) {
+    vec2 bl = step(pos, st);
+    vec2 tr = step(1.0 - pos - size, 1.0 - st);
+    return bl.x * bl.y * tr.x * tr.y;
+}
+
+// Rectangle SDF
+float rectSDF(vec2 st, vec2 center, vec2 size) {
+    vec2 d = abs(st - center) - size * 0.5;
+    return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+}
+
+// Rounded rectangle SDF
+float roundedRectSDF(vec2 st, vec2 center, vec2 size, float radius) {
+    vec2 d = abs(st - center) - size * 0.5 + radius;
+    return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0) - radius;
+}
+```
+
+## Line
+
+```glsl
+// Line segment SDF
+float lineSDF(vec2 p, vec2 a, vec2 b) {
+    vec2 pa = p - a;
+    vec2 ba = b - a;
+    float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0);
+    return length(pa - ba * h);
+}
+
+// Draw line with thickness
+float line(vec2 st, vec2 a, vec2 b, float thickness) {
+    float d = lineSDF(st, a, b);
+    return 1.0 - smoothstep(0.0, thickness, d);
+}
+```
+
+## Shape Outlines
+
+```glsl
+// Outline only
+float outline(float d, float thickness) {
+    return 1.0 - smoothstep(0.0, thickness, abs(d));
+}
+
+// Fill with outline
+vec3 fillWithOutline(float d, vec3 fill, vec3 stroke, float thick) {
+    float fillMask = 1.0 - smoothstep(0.0, 0.01, d);
+    float edge = 1.0 - smoothstep(0.0, thick, abs(d));
+    return mix(fill * fillMask, stroke, edge * (1.0 - fillMask));
+}
+```
+
+## 2D Transformations
+
+```glsl
+// Rotate point around center
+vec2 rotate(vec2 st, vec2 center, float angle) {
+    st -= center;
+    float c = cos(angle);
+    float s = sin(angle);
+    st = mat2(c, -s, s, c) * st;
+    return st + center;
+}
+
+// Scale from center
+vec2 scale(vec2 st, vec2 center, vec2 s) {
+    return (st - center) / s + center;
+}
+```
+
+See also: `glsl-shapes-polygon-star-polar-sdf-combinations.md`

package/.claude/skills/shader/references/glsl-shaping-functions-step-smoothstep-curves-interpolation.md

@@ -0,0 +1,141 @@
+# Shaping Functions
+
+Control value interpolation for smooth transitions and effects.
+
+## Core Functions
+
+### step(edge, x)
+Hard threshold - returns 0.0 if x < edge, else 1.0.
+
+```glsl
+float y = step(0.5, st.x);  // Black left, white right
+```
+
+### smoothstep(edge0, edge1, x)
+Smooth Hermite interpolation between edges.
+
+```glsl
+float y = smoothstep(0.2, 0.8, st.x);  // Gradual transition
+```
+
+Internally: `t = clamp((x-edge0)/(edge1-edge0), 0.0, 1.0); return t*t*(3.0-2.0*t);`
+
+### mix(a, b, t)
+Linear interpolation: `a*(1-t) + b*t`
+
+```glsl
+vec3 color = mix(colorA, colorB, st.x);  // Gradient
+```
+
+## Power Functions
+
+```glsl
+float y = pow(st.x, 5.0);     // Exponential curve
+float y = sqrt(st.x);         // Square root
+float y = exp(st.x);          // Natural exponential
+float y = log(st.x);          // Natural logarithm
+```
+
+Exponent controls curve shape:
+- `pow(x, n)` where n > 1: Slow start, fast end
+- `pow(x, n)` where n < 1: Fast start, slow end
+
+## Trigonometric Functions
+
+```glsl
+float y = sin(st.x * PI);           // Wave (0 to 1 to 0)
+float y = cos(st.x * TWO_PI);       // Full cycle
+float y = sin(st.x * 10.0 + u_time); // Animated wave
+```
+
+Normalize sin/cos from [-1,1] to [0,1]:
+```glsl
+float y = sin(x) * 0.5 + 0.5;
+```
+
+## Fractional & Modulo
+
+```glsl
+float y = fract(st.x * 5.0);  // Sawtooth wave (0 to 1 repeating)
+float y = mod(st.x, 0.2);     // Modulo, repeats every 0.2
+float y = floor(st.x * 5.0);  // Integer part (0,1,2,3,4...)
+float y = ceil(st.x * 5.0);   // Round up
+```
+
+## Absolute & Sign
+
+```glsl
+float y = abs(st.x - 0.5);    // V-shape centered at 0.5
+float y = sign(st.x - 0.5);   // -1.0, 0.0, or 1.0
+```
+
+## Clamping
+
+```glsl
+float y = clamp(x, 0.0, 1.0);         // Constrain range
+float y = min(a, b);                   // Smaller value
+float y = max(a, b);                   // Larger value
+```
+
+## Custom Shaping Curves
+
+### Polynomial smoothstep (quintic)
+```glsl
+float smootherStep(float x) {
+    return x * x * x * (x * (x * 6.0 - 15.0) + 10.0);
+}
+```
+
+### Exponential impulse
+```glsl
+float impulse(float k, float x) {
+    float h = k * x;
+    return h * exp(1.0 - h);
+}
+```
+
+### Parabola
+```glsl
+float parabola(float x, float k) {
+    return pow(4.0 * x * (1.0 - x), k);
+}
+```
+
+### Cubic pulse
+```glsl
+float cubicPulse(float c, float w, float x) {
+    x = abs(x - c);
+    if (x > w) return 0.0;
+    x /= w;
+    return 1.0 - x * x * (3.0 - 2.0 * x);
+}
+```
+
+## Combining Functions
+
+Create band with two smoothsteps:
+```glsl
+float y = smoothstep(0.2, 0.4, st.x) - smoothstep(0.6, 0.8, st.x);
+```
+
+Smooth edges on shapes:
+```glsl
+float edge = 0.01;
+float circle = smoothstep(radius + edge, radius - edge, dist);
+```
+
+## Animation Patterns
+
+```glsl
+// Oscillate 0-1
+float t = sin(u_time) * 0.5 + 0.5;
+
+// Sawtooth
+float t = fract(u_time);
+
+// Triangle wave
+float t = abs(fract(u_time) * 2.0 - 1.0);
+
+// Ping-pong
+float t = abs(mod(u_time, 2.0) - 1.0);
+```

package/.claude/skills/shopify/README.md

@@ -0,0 +1,66 @@
+# Shopify API Research Documentation
+
+This directory contains comprehensive research and analysis of various APIs for integration purposes.
+
+## Contents
+
+### Shopify GraphQL Admin API Analysis
+**File:** `shopify-graphql-admin-api-analysis.md`  
+**Date:** 2025-10-25  
+**Status:** Complete  
+**Thoroughness:** Very Thorough
+
+A comprehensive analysis of Shopify's GraphQL Admin API covering:
+- API overview and capabilities
+- Key features and operations
+- Common query and mutation patterns
+- Best practices and optimization strategies
+- Authentication and security considerations
+- Rate limiting and performance optimization
+- Typical use cases and implementation patterns
+- Troubleshooting guide
+- Code examples in multiple languages
+- Resources and further learning
+
+**Key Sections:**
+1. Executive Summary
+2. API Overview
+3. Key Features
+4. Common Operations (Queries & Mutations)
+5. API Structure (Types, Connections, Errors)
+6. Best Practices
+7. Typical Use Cases
+8. API Versions and Deprecation
+9. Tools and SDKs
+10. Security Considerations
+11. Performance Optimization
+12. Common Patterns
+13. Troubleshooting
+14. Resources and Further Learning
+
+**Size:** 1,348 lines, ~26KB
+
+---
+
+## Usage
+
+These documents are intended for:
+- Development planning and architecture decisions
+- Team onboarding and training
+- Integration implementation reference
+- Best practices guidance
+- Troubleshooting support
+
+---
+
+## Maintenance
+
+- Documents should be reviewed quarterly
+- Update when API versions change
+- Add new findings from implementation experience
+- Keep code examples current with latest SDK versions
+
+---
+
+**Last Updated:** 2025-10-25  
+**Maintained By:** Claude Code Engineering Team