initial commit: pollz - polls on atproto

- frontend: vite + typescript SPA for creating/viewing polls
- backend: zig + httpz server with sqlite persistence
- cloudflare pages function for dynamic OG tags on poll links
- jetstream integration for real-time vote/poll sync
- justfile with deploy targets for fly.io and cloudflare pages

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[e-mail]>

.gitignore

···
+node_modules
+dist
+.vite
+.zig-cache
+*.db

backend/Dockerfile

···
+# build stage
+FROM debian:bookworm-slim AS builder
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    curl \
+    xz-utils \
+    && rm -rf /var/lib/apt/lists/*
+
+# install zig 0.15.2
+RUN curl -L https://ziglang.org/download/0.15.2/zig-x86_64-linux-0.15.2.tar.xz | tar -xJ -C /usr/local \
+    && ln -s /usr/local/zig-x86_64-linux-0.15.2/zig /usr/local/bin/zig
+
+WORKDIR /app
+COPY build.zig build.zig.zon ./
+COPY src ./src
+
+RUN zig build -Doptimize=ReleaseSafe
+
+# runtime stage
+FROM debian:bookworm-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/* \
+    # prefer IPv4 over IPv6 for outbound connections (IPv6 times out in Fly.io)
+    && echo 'precedence ::ffff:0:0/96  100' >> /etc/gai.conf
+
+WORKDIR /app
+COPY --from=builder /app/zig-out/bin/pollz .
+
+EXPOSE 3000
+
+CMD ["./pollz"]

backend/build.zig

···
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const websocket = b.dependency("websocket", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const zqlite = b.dependency("zqlite", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const exe = b.addExecutable(.{
+        .name = "pollz",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
+            .target = target,
+            .optimize = optimize,
+            .imports = &.{
+                .{ .name = "websocket", .module = websocket.module("websocket") },
+                .{ .name = "zqlite", .module = zqlite.module("zqlite") },
+            },
+        }),
+    });
+
+    b.installArtifact(exe);
+
+    const run_cmd = b.addRunArtifact(exe);
+    run_cmd.step.dependOn(b.getInstallStep());
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    const run_step = b.step("run", "Run the server");
+    run_step.dependOn(&run_cmd.step);
+}

backend/build.zig.zon

···
+.{
+    .name = .pollz_backend,
+    .version = "0.0.1",
+    .fingerprint = 0x855197507943a911,
+    .minimum_zig_version = "0.15.0",
+    .dependencies = .{
+        .websocket = .{
+            .url = "https://github.com/karlseguin/websocket.zig/archive/refs/heads/master.tar.gz",
+            .hash = "websocket-0.1.0-ZPISdRNzAwAGszh62EpRtoQxu8wb1MSMVI6Ow0o2dmyJ",
+        },
+        .zqlite = .{
+            .url = "git+https://github.com/karlseguin/zqlite.zig?ref=master#e041f81c6b11b7381b6358030d57ca95dcd54d30",
+            .hash = "zqlite-0.0.0-RWLaYzS6mAAAzVSs8HPbmwl4DqH5kXG0Ob87asf1YNGL",
+        },
+    },
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+    },
+}

backend/fly.toml

···
+app = 'pollz-backend'
+primary_region = 'iad'
+
+[build]
+
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_stop_machines = 'stop'
+  auto_start_machines = true
+  min_machines_running = 1
+  processes = ['app']
+
+[[vm]]
+  memory = '256mb'
+  cpu_kind = 'shared'
+  cpus = 1
+
+[mounts]
+  source = 'pollz_data'
+  destination = '/data'

backend/justfile

···
+# pollz backend
+
+# dev server with hot reload
+dev:
+    watchexec -r -w src -- zig build run
+
+# build release binary
+build:
+    zig build -Doptimize=ReleaseSafe
+
+# run release binary
+run: build
+    ./zig-out/bin/pollz
+
+# format code
+fmt:
+    zig fmt src/
+
+# check formatting without modifying
+check:
+    zig fmt --check src/
+
+# clean build artifacts
+clean:
+    rm -rf zig-out .zig-cache pollz.db
+
+# deploy to fly.io
+deploy:
+    fly deploy

backend/src/backfill.zig

···
+const std = @import("std");
+const mem = std.mem;
+const json = std.json;
+const Allocator = mem.Allocator;
+const db = @import("db.zig");
+const jetstream = @import("jetstream.zig");
+
+pub fn run(allocator: Allocator) void {
+    std.debug.print("starting backfill from ufos-api.microcosm.blue...\n", .{});
+
+    backfillCollection(allocator, "tech.waow.poll");
+    backfillCollection(allocator, "tech.waow.vote");
+
+    std.debug.print("backfill complete\n", .{});
+}
+
+fn backfillCollection(allocator: Allocator, collection: []const u8) void {
+    var url_buf: [256]u8 = undefined;
+    const url = std.fmt.bufPrint(&url_buf, "https://ufos-api.microcosm.blue/records?collection={s}", .{collection}) catch return;
+
+    std.debug.print("backfill: fetching {s} from ufos\n", .{collection});
+
+    // make https request
+    var client = std.http.Client{ .allocator = allocator };
+    defer client.deinit();
+
+    const uri = std.Uri.parse(url) catch return;
+
+    var req = client.request(.GET, uri, .{
+        .headers = .{ .accept_encoding = .{ .override = "identity" } },
+    }) catch |err| {
+        std.debug.print("backfill: http request error: {}\n", .{err});
+        return;
+    };
+    defer req.deinit();
+
+    req.sendBodiless() catch |err| {
+        std.debug.print("backfill: http send error: {}\n", .{err});
+        return;
+    };
+
+    var redirect_buf: [8192]u8 = undefined;
+    var response = req.receiveHead(&redirect_buf) catch |err| {
+        std.debug.print("backfill: http receive error: {}\n", .{err});
+        return;
+    };
+
+    if (response.head.status != .ok) {
+        std.debug.print("backfill: http status {}\n", .{response.head.status});
+        return;
+    }
+
+    // read response body
+    var reader = response.reader(&.{});
+    const body = reader.allocRemaining(allocator, std.Io.Limit.limited(65536)) catch |err| {
+        std.debug.print("backfill: http read error: {}\n", .{err});
+        return;
+    };
+    defer allocator.free(body);
+
+    // parse json response - UFOs returns array of {did, collection, rkey, record}
+    const parsed = json.parseFromSlice(json.Value, allocator, body, .{}) catch |err| {
+        std.debug.print("backfill: json parse error: {}\n", .{err});
+        return;
+    };
+    defer parsed.deinit();
+
+    if (parsed.value != .array) return;
+
+    var count: usize = 0;
+    for (parsed.value.array.items) |item| {
+        if (item != .object) continue;
+
+        const did = item.object.get("did") orelse continue;
+        if (did != .string) continue;
+
+        const rkey = item.object.get("rkey") orelse continue;
+        if (rkey != .string) continue;
+
+        const record = item.object.get("record") orelse continue;
+        if (record != .object) continue;
+
+        // construct record uri
+        const record_uri = std.fmt.allocPrint(allocator, "at://{s}/{s}/{s}", .{ did.string, collection, rkey.string }) catch continue;
+        defer allocator.free(record_uri);
+
+        if (mem.eql(u8, collection, "tech.waow.poll")) {
+            jetstream.processPoll(allocator, record_uri, did.string, rkey.string, record.object) catch continue;
+            count += 1;
+        } else if (mem.eql(u8, collection, "tech.waow.vote")) {
+            jetstream.processVote(record_uri, did.string, record.object) catch continue;
+            count += 1;
+        }
+    }
+
+    std.debug.print("backfill: indexed {d} {s} records\n", .{ count, collection });
+}

backend/src/db.zig

···
+const std = @import("std");
+const json = std.json;
+const mem = std.mem;
+const Thread = std.Thread;
+const Allocator = mem.Allocator;
+const zqlite = @import("zqlite");
+
+pub var conn: zqlite.Conn = undefined;
+pub var mutex: Thread.Mutex = .{};
+
+pub fn init(path: [*:0]const u8) !void {
+    std.debug.print("opening database at: {s}\n", .{path});
+    conn = zqlite.open(path, zqlite.OpenFlags.Create | zqlite.OpenFlags.ReadWrite) catch |err| {
+        std.debug.print("failed to open database: {}\n", .{err});
+        return err;
+    };
+    try initSchema();
+}
+
+pub fn close() void {
+    conn.close();
+}
+
+fn initSchema() !void {
+    mutex.lock();
+    defer mutex.unlock();
+
+    conn.execNoArgs(
+        \\CREATE TABLE IF NOT EXISTS polls (
+        \\  uri TEXT PRIMARY KEY,
+        \\  repo TEXT NOT NULL,
+        \\  rkey TEXT NOT NULL,
+        \\  text TEXT NOT NULL,
+        \\  options TEXT NOT NULL,
+        \\  created_at TEXT NOT NULL
+        \\)
+    ) catch |err| {
+        std.debug.print("failed to create polls table: {}\n", .{err});
+        return err;
+    };
+
+    conn.execNoArgs(
+        \\CREATE TABLE IF NOT EXISTS votes (
+        \\  uri TEXT PRIMARY KEY,
+        \\  subject TEXT NOT NULL,
+        \\  option INTEGER NOT NULL,
+        \\  voter TEXT NOT NULL,
+        \\  created_at TEXT,
+        \\  UNIQUE(subject, voter)
+        \\)
+    ) catch |err| {
+        std.debug.print("failed to create votes table: {}\n", .{err});
+        return err;
+    };
+
+    // add created_at column if it doesn't exist (migration for existing DBs)
+    conn.execNoArgs("ALTER TABLE votes ADD COLUMN created_at TEXT") catch {};
+
+    conn.execNoArgs(
+        \\CREATE INDEX IF NOT EXISTS idx_votes_subject ON votes(subject)
+    ) catch |err| {
+        std.debug.print("failed to create index: {}\n", .{err});
+        return err;
+    };
+
+    conn.execNoArgs(
+        \\CREATE INDEX IF NOT EXISTS idx_votes_voter ON votes(subject, voter)
+    ) catch |err| {
+        std.debug.print("failed to create voter index: {}\n", .{err});
+        return err;
+    };
+
+    conn.execNoArgs(
+        \\CREATE TABLE IF NOT EXISTS cursor (
+        \\  id INTEGER PRIMARY KEY CHECK (id = 1),
+        \\  time_us INTEGER NOT NULL
+        \\)
+    ) catch |err| {
+        std.debug.print("failed to create cursor table: {}\n", .{err});
+        return err;
+    };
+
+    std.debug.print("database schema initialized\n", .{});
+}
+
+pub fn getCursor() ?i64 {
+    mutex.lock();
+    defer mutex.unlock();
+
+    const row = conn.row("SELECT time_us FROM cursor WHERE id = 1", .{}) catch return null;
+    if (row == null) return null;
+    defer row.?.deinit();
+    return row.?.int(0);
+}
+
+pub fn saveCursor(time_us: i64) void {
+    mutex.lock();
+    defer mutex.unlock();
+
+    conn.exec("INSERT OR REPLACE INTO cursor (id, time_us) VALUES (1, ?)", .{time_us}) catch |err| {
+        std.debug.print("failed to save cursor: {}\n", .{err});
+    };
+}
+
+pub fn insertPoll(uri: []const u8, did: []const u8, rkey: []const u8, text_json: []const u8, options_json: []const u8, created_at: []const u8) !void {
+    mutex.lock();
+    defer mutex.unlock();
+
+    conn.exec(
+        "INSERT OR IGNORE INTO polls (uri, repo, rkey, text, options, created_at) VALUES (?, ?, ?, ?, ?, ?)",
+        .{ uri, did, rkey, text_json, options_json, created_at },
+    ) catch |err| {
+        std.debug.print("db insert poll error: {}\n", .{err});
+        return err;
+    };
+}
+
+pub fn insertVote(uri: []const u8, subject: []const u8, option: i32, voter: []const u8, created_at: ?[]const u8) !void {
+    mutex.lock();
+    defer mutex.unlock();
+
+    // delete any existing vote by this user on this poll, then insert new one
+    // this enforces one vote per user per poll
+    conn.exec("DELETE FROM votes WHERE subject = ? AND voter = ?", .{ subject, voter }) catch {};
+
+    conn.exec(
+        "INSERT INTO votes (uri, subject, option, voter, created_at) VALUES (?, ?, ?, ?, ?)",
+        .{ uri, subject, option, voter, created_at },
+    ) catch |err| {
+        std.debug.print("db insert vote error: {}\n", .{err});
+        return err;
+    };
+}
+
+pub fn deletePoll(uri: []const u8) void {
+    mutex.lock();
+    defer mutex.unlock();
+
+    conn.exec("DELETE FROM polls WHERE uri = ?", .{uri}) catch |err| {
+        std.debug.print("db delete poll error: {}\n", .{err});
+    };
+    // also delete associated votes
+    conn.exec("DELETE FROM votes WHERE subject = ?", .{uri}) catch |err| {
+        std.debug.print("db delete votes error: {}\n", .{err});
+    };
+}
+
+pub fn deleteVote(uri: []const u8) void {
+    mutex.lock();
+    defer mutex.unlock();
+
+    conn.exec("DELETE FROM votes WHERE uri = ?", .{uri}) catch |err| {
+        std.debug.print("db delete vote error: {}\n", .{err});
+    };
+}

backend/src/http.zig

···
+const std = @import("std");
+const net = std.net;
+const http = std.http;
+const mem = std.mem;
+const json = std.json;
+const db = @import("db.zig");
+
+pub fn handleConnection(conn: net.Server.Connection) void {
+    defer conn.stream.close();
+
+    var read_buffer: [8192]u8 = undefined;
+    var write_buffer: [8192]u8 = undefined;
+
+    var reader = conn.stream.reader(&read_buffer);
+    var writer = conn.stream.writer(&write_buffer);
+
+    var server = http.Server.init(reader.interface(), &writer.interface);
+
+    while (true) {
+        var request = server.receiveHead() catch |err| {
+            // this is expected for idle connections
+            if (err != error.HttpConnectionClosing and err != error.EndOfStream) {
+                std.debug.print("http receive error: {}\n", .{err});
+            }
+            return;
+        };
+        handleRequest(&server, &request) catch |err| {
+            std.debug.print("request error: {}\n", .{err});
+            return;
+        };
+        if (!request.head.keep_alive) return;
+    }
+}
+
+fn handleRequest(server: *http.Server, request: *http.Server.Request) !void {
+    _ = server;
+    const target = request.head.target;
+
+    // cors preflight
+    if (request.head.method == .OPTIONS) {
+        try sendCorsHeaders(request, "");
+        return;
+    }
+
+    if (mem.startsWith(u8, target, "/api/polls")) {
+        if (mem.eql(u8, target, "/api/polls")) {
+            try handleGetPolls(request);
+        } else if (mem.indexOf(u8, target, "/votes")) |votes_idx| {
+            // /api/polls/:uri/votes
+            const uri_encoded = target["/api/polls/".len..votes_idx];
+            try handleGetVotes(request, uri_encoded);
+        } else if (mem.startsWith(u8, target, "/api/polls/")) {
+            const uri_encoded = target["/api/polls/".len..];
+            try handleGetPoll(request, uri_encoded);
+        }
+    } else if (mem.eql(u8, target, "/health")) {
+        try sendJson(request, "{\"status\":\"ok\"}");
+    } else {
+        try sendNotFound(request);
+    }
+}
+
+fn handleGetPolls(request: *http.Server.Request) !void {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const alloc = arena.allocator();
+
+    db.mutex.lock();
+    defer db.mutex.unlock();
+
+    var response: std.ArrayList(u8) = .{};
+    defer response.deinit(alloc);
+
+    try response.appendSlice(alloc, "[");
+
+    var rows = db.conn.rows(
+        "SELECT uri, repo, rkey, text, options, created_at FROM polls ORDER BY created_at DESC",
+        .{},
+    ) catch {
+        try sendJson(request, "[]");
+        return;
+    };
+    defer rows.deinit();
+
+    var first = true;
+    while (rows.next()) |row| {
+        if (!first) try response.appendSlice(alloc, ",");
+        first = false;
+
+        const uri = row.text(0);
+        const repo = row.text(1);
+        const rkey = row.text(2);
+        const text_json = row.text(3);
+        const options_json = row.text(4);
+        const created_at = row.text(5);
+
+        // count votes for this poll
+        const vote_count: i64 = blk: {
+            const vrow = db.conn.row("SELECT COUNT(*) FROM votes WHERE subject = ?", .{uri}) catch break :blk 0;
+            if (vrow) |r| {
+                defer r.deinit();
+                break :blk r.int(0);
+            }
+            break :blk 0;
+        };
+
+        try response.print(alloc,
+            \\{{"uri":"{s}","repo":"{s}","rkey":"{s}","text":{s},"options":{s},"createdAt":"{s}","voteCount":{d}}}
+        , .{ uri, repo, rkey, text_json, options_json, created_at, vote_count });
+    }
+
+    if (rows.err) |err| {
+        std.debug.print("rows error: {}\n", .{err});
+    }
+
+    try response.appendSlice(alloc, "]");
+    try sendJson(request, response.items);
+}
+
+fn handleGetPoll(request: *http.Server.Request, uri_encoded: []const u8) !void {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const alloc = arena.allocator();
+
+    // decode uri
+    const uri_buf = try alloc.dupe(u8, uri_encoded);
+    const uri = std.Uri.percentDecodeInPlace(uri_buf);
+
+    db.mutex.lock();
+    defer db.mutex.unlock();
+
+    const row = db.conn.row("SELECT uri, repo, rkey, text, options, created_at FROM polls WHERE uri = ?", .{uri}) catch {
+        try sendNotFound(request);
+        return;
+    };
+    if (row == null) {
+        try sendNotFound(request);
+        return;
+    }
+    defer row.?.deinit();
+
+    const poll_uri = row.?.text(0);
+    const repo = row.?.text(1);
+    const rkey = row.?.text(2);
+    const text_json = row.?.text(3);
+    const options_json = row.?.text(4);
+    const created_at = row.?.text(5);
+
+    // parse options array to get count
+    const parsed = json.parseFromSlice(json.Value, alloc, options_json, .{}) catch {
+        try sendNotFound(request);
+        return;
+    };
+    defer parsed.deinit();
+
+    if (parsed.value != .array) {
+        try sendNotFound(request);
+        return;
+    }
+
+    const options = parsed.value.array.items;
+
+    // build response
+    var response: std.ArrayList(u8) = .{};
+    defer response.deinit(alloc);
+
+    try response.print(alloc,
+        \\{{"uri":"{s}","repo":"{s}","rkey":"{s}","text":{s},"options":[
+    , .{ poll_uri, repo, rkey, text_json });
+
+    for (options, 0..) |opt, i| {
+        if (i > 0) try response.appendSlice(alloc, ",");
+
+        const count: i64 = blk: {
+            const vrow = db.conn.row("SELECT COUNT(*) FROM votes WHERE subject = ? AND option = ?", .{ poll_uri, @as(i32, @intCast(i)) }) catch break :blk 0;
+            if (vrow) |r| {
+                defer r.deinit();
+                break :blk r.int(0);
+            }
+            break :blk 0;
+        };
+
+        const opt_text = if (opt == .string) opt.string else "";
+        try response.print(alloc,
+            \\{{"text":"{s}","count":{d}}}
+        , .{ opt_text, count });
+    }
+
+    try response.print(alloc,
+        \\],"createdAt":"{s}"}}
+    , .{created_at});
+
+    try sendJson(request, response.items);
+}
+
+fn handleGetVotes(request: *http.Server.Request, uri_encoded: []const u8) !void {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const alloc = arena.allocator();
+
+    // decode uri
+    const uri_buf = try alloc.dupe(u8, uri_encoded);
+    const uri = std.Uri.percentDecodeInPlace(uri_buf);
+
+    db.mutex.lock();
+    defer db.mutex.unlock();
+
+    var response: std.ArrayList(u8) = .{};
+    defer response.deinit(alloc);
+
+    try response.appendSlice(alloc, "[");
+
+    var rows = db.conn.rows(
+        "SELECT voter, option, uri, created_at FROM votes WHERE subject = ?",
+        .{uri},
+    ) catch {
+        try sendJson(request, "[]");
+        return;
+    };
+    defer rows.deinit();
+
+    var first = true;
+    while (rows.next()) |row| {
+        if (!first) try response.appendSlice(alloc, ",");
+        first = false;
+
+        const voter = row.text(0);
+        const option = row.int(1);
+        const vote_uri = row.text(2);
+        const created_at = row.text(3);
+
+        try response.print(alloc,
+            \\{{"voter":"{s}","option":{d},"uri":"{s}","createdAt":"{s}"}}
+        , .{ voter, option, vote_uri, created_at });
+    }
+
+    if (rows.err) |err| {
+        std.debug.print("votes query error: {}\n", .{err});
+    }
+
+    try response.appendSlice(alloc, "]");
+    try sendJson(request, response.items);
+}
+
+fn sendJson(request: *http.Server.Request, body: []const u8) !void {
+    try request.respond(body, .{
+        .status = .ok,
+        .extra_headers = &.{
+            .{ .name = "content-type", .value = "application/json" },
+            .{ .name = "access-control-allow-origin", .value = "*" },
+            .{ .name = "access-control-allow-methods", .value = "GET, OPTIONS" },
+            .{ .name = "access-control-allow-headers", .value = "content-type" },
+        },
+    });
+}
+
+fn sendCorsHeaders(request: *http.Server.Request, body: []const u8) !void {
+    try request.respond(body, .{
+        .status = .no_content,
+        .extra_headers = &.{
+            .{ .name = "access-control-allow-origin", .value = "*" },
+            .{ .name = "access-control-allow-methods", .value = "GET, OPTIONS" },
+            .{ .name = "access-control-allow-headers", .value = "content-type" },
+        },
+    });
+}
+
+fn sendNotFound(request: *http.Server.Request) !void {
+    try request.respond("{\"error\":\"not found\"}", .{
+        .status = .not_found,
+        .extra_headers = &.{
+            .{ .name = "content-type", .value = "application/json" },
+            .{ .name = "access-control-allow-origin", .value = "*" },
+        },
+    });
+}

backend/src/jetstream.zig

···
+const std = @import("std");
+const mem = std.mem;
+const json = std.json;
+const posix = std.posix;
+const Allocator = mem.Allocator;
+const websocket = @import("websocket");
+const db = @import("db.zig");
+
+const POLL_COLLECTION = "tech.waow.poll";
+const VOTE_COLLECTION = "tech.waow.vote";
+
+pub fn consumer(allocator: Allocator) void {
+    while (true) {
+        connect(allocator) catch |err| {
+            std.debug.print("jetstream error: {}, reconnecting in 3s...\n", .{err});
+        };
+        posix.nanosleep(3, 0);
+    }
+}
+
+const Handler = struct {
+    allocator: Allocator,
+    msg_count: usize = 0,
+
+    pub fn serverMessage(self: *Handler, data: []const u8) !void {
+        self.msg_count += 1;
+        if (self.msg_count % 100 == 1) {
+            std.debug.print("jetstream: received {} messages\n", .{self.msg_count});
+        }
+        processMessage(self.allocator, data) catch |err| {
+            std.debug.print("message processing error: {}\n", .{err});
+        };
+    }
+
+    pub fn close(_: *Handler) void {
+        std.debug.print("jetstream connection closed\n", .{});
+    }
+};
+
+fn connect(allocator: Allocator) !void {
+    const host = "jetstream1.us-east.bsky.network";
+
+    var path_buf: [512]u8 = undefined;
+
+    // only use saved cursor if we have one (for resuming after disconnect)
+    // otherwise start from NOW - UFOs handles backfill, Jetstream is for live events only
+    const path = if (db.getCursor()) |cursor|
+        std.fmt.bufPrint(&path_buf, "/subscribe?wantedCollections={s}&wantedCollections={s}&cursor={d}", .{ POLL_COLLECTION, VOTE_COLLECTION, cursor }) catch "/subscribe"
+    else
+        std.fmt.bufPrint(&path_buf, "/subscribe?wantedCollections={s}&wantedCollections={s}", .{ POLL_COLLECTION, VOTE_COLLECTION }) catch "/subscribe";
+
+    std.debug.print("connecting to wss://{s}{s}\n", .{ host, path });
+
+    var client = websocket.Client.init(allocator, .{
+        .host = host,
+        .port = 443,
+        .tls = true,
+    }) catch |err| {
+        std.debug.print("websocket client init failed: {}\n", .{err});
+        return err;
+    };
+    defer client.deinit();
+
+    std.debug.print("tcp+tls connected, starting handshake...\n", .{});
+
+    // add Host header which is required for websocket handshake
+    var host_header_buf: [128]u8 = undefined;
+    const host_header = std.fmt.bufPrint(&host_header_buf, "Host: {s}\r\n", .{host}) catch "Host: jetstream1.us-east.bsky.network\r\n";
+
+    client.handshake(path, .{ .headers = host_header }) catch |err| {
+        std.debug.print("websocket handshake failed: {}\n", .{err});
+        return err;
+    };
+
+    std.debug.print("jetstream connected!\n", .{});
+
+    var handler = Handler{ .allocator = allocator };
+    client.readLoop(&handler) catch |err| {
+        std.debug.print("websocket read loop error: {}\n", .{err});
+        return err;
+    };
+}
+
+fn processMessage(allocator: Allocator, payload: []const u8) !void {
+    // parse jetstream event
+    const parsed = json.parseFromSlice(json.Value, allocator, payload, .{}) catch return;
+    defer parsed.deinit();
+
+    const root = parsed.value.object;
+
+    // save cursor from event timestamp
+    if (root.get("time_us")) |time_us_val| {
+        if (time_us_val == .integer) {
+            db.saveCursor(time_us_val.integer);
+        }
+    }
+
+    const kind = root.get("kind") orelse return;
+    if (kind != .string) return;
+
+    if (!mem.eql(u8, kind.string, "commit")) return;
+
+    const commit = root.get("commit") orelse return;
+    if (commit != .object) return;
+
+    const collection = commit.object.get("collection") orelse return;
+    if (collection != .string) return;
+
+    const operation = commit.object.get("operation") orelse return;
+    if (operation != .string) return;
+
+    const did = root.get("did") orelse return;
+    if (did != .string) return;
+
+    const rkey = commit.object.get("rkey") orelse return;
+    if (rkey != .string) return;
+
+    const uri_str = try std.fmt.allocPrint(allocator, "at://{s}/{s}/{s}", .{ did.string, collection.string, rkey.string });
+    defer allocator.free(uri_str);
+
+    if (mem.eql(u8, operation.string, "create")) {
+        const record = commit.object.get("record") orelse return;
+        if (record != .object) return;
+
+        if (mem.eql(u8, collection.string, POLL_COLLECTION)) {
+            processPoll(allocator, uri_str, did.string, rkey.string, record.object) catch |err| {
+                std.debug.print("poll processing error: {}\n", .{err});
+            };
+        } else if (mem.eql(u8, collection.string, VOTE_COLLECTION)) {
+            processVote(uri_str, did.string, record.object) catch |err| {
+                std.debug.print("vote processing error: {}\n", .{err});
+            };
+        }
+    } else if (mem.eql(u8, operation.string, "delete")) {
+        if (mem.eql(u8, collection.string, POLL_COLLECTION)) {
+            db.deletePoll(uri_str);
+            std.debug.print("deleted poll: {s}\n", .{uri_str});
+        } else if (mem.eql(u8, collection.string, VOTE_COLLECTION)) {
+            db.deleteVote(uri_str);
+            std.debug.print("deleted vote: {s}\n", .{uri_str});
+        }
+    }
+}
+
+pub fn processPoll(allocator: Allocator, uri: []const u8, did: []const u8, rkey: []const u8, record: json.ObjectMap) !void {
+    const text_val = record.get("text") orelse return;
+    if (text_val != .string) return;
+
+    const options_val = record.get("options") orelse return;
+    if (options_val != .array) return;
+
+    const created_at_val = record.get("createdAt") orelse return;
+    if (created_at_val != .string) return;
+
+    // serialize options as json
+    var options_buf: std.ArrayList(u8) = .{};
+    defer options_buf.deinit(allocator);
+    try options_buf.print(allocator, "{f}", .{json.fmt(options_val, .{})});
+
+    // serialize text as json (to escape quotes properly)
+    var text_buf: std.ArrayList(u8) = .{};
+    defer text_buf.deinit(allocator);
+    try text_buf.print(allocator, "{f}", .{json.fmt(text_val, .{})});
+
+    try db.insertPoll(uri, did, rkey, text_buf.items, options_buf.items, created_at_val.string);
+    std.debug.print("indexed poll: {s}\n", .{uri});
+}
+
+pub fn processVote(uri: []const u8, did: []const u8, record: json.ObjectMap) !void {
+    const subject_val = record.get("subject") orelse return;
+    if (subject_val != .string) return;
+
+    const option_val = record.get("option") orelse return;
+    if (option_val != .integer) return;
+
+    const created_at: ?[]const u8 = if (record.get("createdAt")) |v| (if (v == .string) v.string else null) else null;
+
+    try db.insertVote(uri, subject_val.string, @as(i32, @intCast(option_val.integer)), did, created_at);
+    std.debug.print("indexed vote: {s} -> {s}\n", .{ uri, subject_val.string });
+}

backend/src/main.zig

···
+const std = @import("std");
+const net = std.net;
+const Thread = std.Thread;
+const db = @import("db.zig");
+const http_server = @import("http.zig");
+const jetstream = @import("jetstream.zig");
+const backfill = @import("backfill.zig");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // init sqlite - use DATA_PATH env or default to /data/pollz.db
+    const db_path = std.posix.getenv("DATA_PATH") orelse "/data/pollz.db";
+    try db.init(db_path);
+    defer db.close();
+
+    // backfill existing records from known repos at startup
+    backfill.run(allocator);
+
+    // start jetstream consumer in background
+    const jetstream_thread = try Thread.spawn(.{}, jetstream.consumer, .{allocator});
+    defer jetstream_thread.join();
+
+    // start http server (bind to 0.0.0.0 for containerized deployments)
+    const address = try net.Address.parseIp("0.0.0.0", 3000);
+    var server = try address.listen(.{ .reuse_address = true });
+    defer server.deinit();
+
+    std.debug.print("pollz backend listening on http://127.0.0.1:3000\n", .{});
+
+    while (true) {
+        const conn = try server.accept();
+        _ = try Thread.spawn(.{}, http_server.handleConnection, .{conn});
+    }
+}

backend/zignotes.md

···
+# zig 0.15 notes
+
+## breaking changes from 0.14
+
+### `json.stringify` → `json.fmt`
+```zig
+// old: json.stringify(value, .{}, writer);
+// new: use json.fmt formatter
+try buffer.print(allocator, "{f}", .{json.fmt(value, .{})});
+```
+
+### `std.builtin.Mode` → `std.builtin.OptimizeMode`
+the optimization mode enum was renamed
+
+### `std.time.sleep` removed
+use `std.posix.nanosleep(seconds, nanoseconds)` instead
+
+### `std.ArrayList` is now unmanaged by default
+the old `ArrayList` with embedded allocator is now `array_list.AlignedManaged`.
+the new `std.ArrayList(T)` returns an unmanaged struct that:
+- doesn't store the allocator internally
+- requires passing allocator to methods like `appendSlice(alloc, slice)`
+- initializes with `.{}` or `.empty` instead of `.init(allocator)`
+- `deinit(alloc)` takes allocator as argument
+
+```zig
+// old 0.14 style:
+var list = std.ArrayList(u8).init(allocator);
+try list.appendSlice("hello");
+list.deinit();
+
+// new 0.15 style:
+var list: std.ArrayList(u8) = .{};
+try list.appendSlice(allocator, "hello");
+list.deinit(allocator);
+```
+
+### build.zig changes
+- `root_source_file` → `root_module` with `b.createModule(...)`
+- `strip` field removed from `ExecutableOptions`
+- fingerprint field required in `build.zig.zon`
+
+### `std.http.Server` API
+requires `*std.Io.Reader` and `*std.Io.Writer`, not raw `net.Stream`
+
+## net.Stream → http.Server
+
+```zig
+var read_buffer: [8192]u8 = undefined;
+var write_buffer: [8192]u8 = undefined;
+
+var reader = conn.stream.reader(&read_buffer);
+var writer = conn.stream.writer(&write_buffer);
+
+// reader has .interface() method that returns *Io.Reader
+// writer has .interface field that is Io.Writer
+var server = http.Server.init(reader.interface(), &writer.interface);
+```
+
+### http.Server.Request.respond
+the `respond` method is on `Request`, not `Server`:
+```zig
+try request.respond(body, .{
+    .status = .ok,
+    .extra_headers = &.{
+        .{ .name = "content-type", .value = "application/json" },
+    },
+});
+```
+
+### `std.Uri.percentDecode` → `std.Uri.percentDecodeInPlace`
+there's no allocating `percentDecode` anymore. use in-place decoding:
+```zig
+// copy to mutable buffer first, then decode in place
+const uri_buf = try alloc.dupe(u8, uri_encoded);
+const uri = std.Uri.percentDecodeInPlace(uri_buf);
+```
+
+### `std.http.Client` for outgoing requests
+```zig
+var client = std.http.Client{ .allocator = allocator };
+defer client.deinit();
+
+const uri = std.Uri.parse("https://example.com/api") catch return;
+
+// use .headers to control accept-encoding (default is gzip/deflate)
+var req = client.request(.GET, uri, .{
+    .headers = .{ .accept_encoding = .{ .override = "identity" } },
+}) catch return;
+defer req.deinit();
+
+req.sendBodiless() catch return;
+
+var redirect_buf: [8192]u8 = undefined;
+var response = req.receiveHead(&redirect_buf) catch return;
+
+if (response.head.status != .ok) return;
+
+// read response body - use allocRemaining with Limit
+var reader = response.reader(&.{});
+const body = reader.allocRemaining(allocator, std.Io.Limit.limited(65536)) catch return;
+defer allocator.free(body);
+```
+
+## external libraries
+
+### websocket.zig (karlseguin/websocket.zig)
+use for websocket client/server. add to `build.zig.zon`:
+```zig
+.dependencies = .{
+    .websocket = .{
+        .url = "https://github.com/karlseguin/websocket.zig/archive/refs/heads/master.tar.gz",
+        .hash = "websocket-0.1.0-ZPISdRNzAwAGszh62EpRtoQxu8wb1MSMVI6Ow0o2dmyJ",
+    },
+},
+```
+
+client usage:
+```zig
+const websocket = @import("websocket");
+
+var client = try websocket.Client.init(allocator, .{
+    .host = "example.com",
+    .port = 443,
+    .tls = true,
+});
+defer client.deinit();
+
+// Host header is NOT automatically added - must provide it
+client.handshake("/path", .{ .headers = "Host: example.com\r\n" }) catch |err| {
+    // handle error
+};
+
+// handler must have serverMessage(self, data) function
+var handler = MyHandler{};
+try client.readLoop(&handler);
+```

functions/poll/[repo]/[rkey].ts

···
+// Cloudflare Pages Function for dynamic OG tags
+const BACKEND_URL = "https://pollz-backend.fly.dev";
+
+interface Poll {
+  uri: string;
+  repo: string;
+  rkey: string;
+  text: string;
+  options: Array<{ text: string; count: number }>;
+  createdAt: string;
+}
+
+export const onRequest: PagesFunction = async (context) => {
+  const { repo, rkey } = context.params as { repo: string; rkey: string };
+  const userAgent = context.request.headers.get("user-agent") || "";
+
+  // check if this is a bot/crawler requesting the page
+  const isCrawler = /bot|crawler|spider|facebook|twitter|slack|discord|telegram|whatsapp|linkedin|preview/i.test(userAgent);
+
+  if (!isCrawler) {
+    // not a crawler, serve the SPA normally
+    return context.next();
+  }
+
+  // fetch poll data from backend
+  const pollUri = `at://${repo}/tech.waow.poll/${rkey}`;
+  try {
+    const res = await fetch(`${BACKEND_URL}/api/polls/${encodeURIComponent(pollUri)}`);
+    if (!res.ok) {
+      return context.next();
+    }
+
+    const poll: Poll = await res.json();
+    const total = poll.options.reduce((sum, o) => sum + o.count, 0);
+    const optionsText = poll.options.map(o => `${o.text}: ${o.count}`).join(" | ");
+    const description = `${total} vote${total === 1 ? "" : "s"} · ${optionsText}`;
+    const url = `https://pollz.waow.tech/poll/${repo}/${rkey}`;
+
+    // return HTML with proper OG tags for crawlers
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(poll.text)} - pollz</title>
+  <meta name="description" content="${escapeHtml(description)}">
+
+  <!-- Open Graph -->
+  <meta property="og:type" content="website">
+  <meta property="og:title" content="${escapeHtml(poll.text)}">
+  <meta property="og:description" content="${escapeHtml(description)}">
+  <meta property="og:url" content="${url}">
+  <meta property="og:site_name" content="pollz">
+
+  <!-- Twitter -->
+  <meta name="twitter:card" content="summary">
+  <meta name="twitter:title" content="${escapeHtml(poll.text)}">
+  <meta name="twitter:description" content="${escapeHtml(description)}">
+
+  <meta http-equiv="refresh" content="0;url=${url}">
+</head>
+<body>
+  <p>redirecting to <a href="${url}">${escapeHtml(poll.text)}</a>...</p>
+</body>
+</html>`;
+
+    return new Response(html, {
+      headers: { "content-type": "text/html;charset=UTF-8" },
+    });
+  } catch (e) {
+    console.error("failed to fetch poll for OG tags:", e);
+    return context.next();
+  }
+};
+
+function escapeHtml(str: string): string {
+  return str
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}

index.html

···
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>pollz</title>
+  <meta name="description" content="polls on atproto">
+
+  <!-- Open Graph -->
+  <meta property="og:type" content="website">
+  <meta property="og:title" content="pollz">
+  <meta property="og:description" content="polls on atproto">
+  <meta property="og:url" content="https://pollz.waow.tech">
+  <meta property="og:site_name" content="pollz">
+
+  <!-- Twitter -->
+  <meta name="twitter:card" content="summary">
+  <meta name="twitter:title" content="pollz">
+  <meta name="twitter:description" content="polls on atproto">
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: monospace;
+      max-width: 600px;
+      margin: 0 auto;
+      padding: 1rem;
+      background: #0a0a0a;
+      color: #ccc;
+      font-size: 14px;
+      line-height: 1.6;
+    }
+    a { color: #888; text-decoration: none; }
+    a:hover { color: #fff; }
+    header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      padding: 1rem 0;
+      border-bottom: 1px solid #222;
+      margin-bottom: 1rem;
+    }
+    header h1 { font-size: 1rem; font-weight: normal; }
+    input, button, textarea {
+      font-family: monospace;
+      font-size: 14px;
+      padding: 0.5rem;
+      border: 1px solid #333;
+      background: #111;
+      color: #ccc;
+    }
+    input:focus, textarea:focus { outline: 1px solid #444; }
+    button { cursor: pointer; }
+    button:hover { background: #222; }
+    .poll {
+      border-bottom: 1px solid #222;
+      padding: 1rem 0;
+    }
+    .poll-question { color: #fff; margin-bottom: 0.5rem; }
+    .poll-meta { color: #555; font-size: 12px; margin-bottom: 0.5rem; }
+    .option {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      padding: 0.5rem 0;
+      cursor: pointer;
+    }
+    .option:hover { color: #fff; }
+    .option-text { flex: 1; }
+    .option-count { color: #888; font-size: 12px; margin-left: 1rem; }
+    .poll-detail .option {
+      position: relative;
+      padding: 0.75rem;
+      margin: 0.5rem 0;
+      background: #111;
+      border: 1px solid #222;
+    }
+    .poll-detail .option-bar {
+      position: absolute;
+      left: 0;
+      top: 0;
+      height: 100%;
+      background: #1a3a1a;
+      z-index: 0;
+      transition: width 0.3s;
+    }
+    .poll-detail .option-text,
+    .poll-detail .option-count {
+      position: relative;
+      z-index: 1;
+    }
+    .poll-detail .poll-meta {
+      margin-top: 1rem;
+    }
+    .create-form { margin-bottom: 2rem; }
+    .create-form input, .create-form textarea { width: 100%; margin-bottom: 0.5rem; }
+    .hidden { display: none; }
+    #status { color: #666; padding: 0.5rem 0; }
+    .vote-count { cursor: help; border-bottom: 1px dotted #555; }
+    .vote-count:hover { color: #fff; }
+    .voters-tooltip {
+      background: #1a1a1a;
+      border: 1px solid #333;
+      padding: 0.5rem;
+      font-size: 12px;
+      z-index: 1000;
+      max-width: 300px;
+      box-shadow: 0 2px 8px rgba(0,0,0,0.5);
+    }
+    .voter { padding: 0.25rem 0; color: #aaa; word-break: break-all; }
+    .voter-link { color: #6af; font-size: 11px; }
+    .voter-link:hover { color: #8cf; text-decoration: underline; }
+    .vote-time { color: #555; font-size: 10px; }
+    .share-btn {
+      background: none;
+      border: 1px solid #333;
+      color: #888;
+      padding: 0.4rem 0.8rem;
+      font-family: monospace;
+      font-size: 12px;
+      cursor: pointer;
+      border-radius: 4px;
+      transition: all 0.2s;
+    }
+    .share-btn:hover { border-color: #555; color: #ccc; }
+    .share-btn.copied { border-color: #4a4; color: #6c6; }
+    .poll-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: flex-start;
+      gap: 1rem;
+      margin-bottom: 1rem;
+    }
+    .poll-header h2 { margin: 0; flex: 1; }
+  </style>
+</head>
+<body>
+  <header>
+    <h1><a href="/">pollz</a></h1>
+    <nav id="nav"></nav>
+  </header>
+  <main id="app"></main>
+  <p id="status"></p>
+  <script type="module" src="/src/main.ts"></script>
+</body>
+</html>

justfile

···
+# pollz
+mod backend
+
+# show available commands
+default:
+    @just --list
+
+# build frontend
+build:
+    pnpm build
+
+# deploy frontend to cloudflare pages
+deploy-frontend:
+    pnpm build
+    npx wrangler pages deploy dist --project-name=pollz-waow-tech --commit-dirty=true
+
+# deploy backend to fly.io
+deploy-backend:
+    just backend::deploy
+
+# deploy everything
+deploy: deploy-backend deploy-frontend

lexicons/tech/waow/poll.json

···
+{
+  "lexicon": 1,
+  "id": "tech.waow.poll",
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "tid",
+      "description": "a poll",
+      "record": {
+        "type": "object",
+        "required": ["text", "options", "createdAt"],
+        "properties": {
+          "text": {
+            "type": "string",
+            "maxLength": 300
+          },
+          "options": {
+            "type": "array",
+            "minLength": 2,
+            "maxLength": 10,
+            "items": {
+              "type": "string",
+              "maxLength": 100
+            }
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/tech/waow/vote.json

···
+{
+  "lexicon": 1,
+  "id": "tech.waow.vote",
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "any",
+      "description": "a vote on a poll",
+      "record": {
+        "type": "object",
+        "required": ["subject", "option", "createdAt"],
+        "properties": {
+          "subject": {
+            "type": "string",
+            "format": "at-uri"
+          },
+          "option": {
+            "type": "integer",
+            "minimum": 0
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime"
+          }
+        }
+      }
+    }
+  }
+}

package.json

···
+{
+  "name": "pollz",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "vite": "^7.2.7"
+  },
+  "dependencies": {
+    "@atcute/client": "^4.1.1",
+    "@atcute/identity": "^1.1.3",
+    "@atcute/identity-resolver": "^1.2.0",
+    "@atcute/oauth-browser-client": "^2.0.3"
+  }
+}

pnpm-lock.yaml

···
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies:
+      '@atcute/client':
+        specifier: ^4.1.1
+        version: 4.1.1
+      '@atcute/identity':
+        specifier: ^1.1.3
+        version: 1.1.3
+      '@atcute/identity-resolver':
+        specifier: ^1.2.0
+        version: 1.2.0(@atcute/identity@1.1.3)
+      '@atcute/oauth-browser-client':
+        specifier: ^2.0.3
+        version: 2.0.3(@atcute/identity@1.1.3)
+    devDependencies:
+      typescript:
+        specifier: ^5.9.3
+        version: 5.9.3
+      vite:
+        specifier: ^7.2.7
+        version: 7.3.0
+
+packages:
+
+  '@atcute/client@4.1.1':
+    resolution: {integrity: sha512-FROCbTTCeL5u4tO/n72jDEKyKqjdlXMB56Ehve3W/gnnLGCYWvN42sS7tvL1Mgu6sbO3yZwsXKDrmM2No4XpjA==}
+
+  '@atcute/identity-resolver@1.2.0':
+    resolution: {integrity: sha512-5UbSJfdV3JIkF8ksXz7g4nKBWasf2wROvzM66cfvTIWydWFO6/oS1KZd+zo9Eokje5Scf5+jsY9ZfgVARLepXg==}
+    peerDependencies:
+      '@atcute/identity': ^1.0.0
+
+  '@atcute/identity@1.1.3':
+    resolution: {integrity: sha512-oIqPoI8TwWeQxvcLmFEZLdN2XdWcaLVtlm8pNk0E72As9HNzzD9pwKPrLr3rmTLRIoULPPFmq9iFNsTeCIU9ng==}
+
+  '@atcute/lexicons@1.2.5':
+    resolution: {integrity: sha512-9yO9WdgxW8jZ7SbzUycH710z+JmsQ9W9n5S6i6eghYju32kkluFmgBeS47r8e8p2+Dv4DemS7o/3SUGsX9FR5Q==}
+
+  '@atcute/multibase@1.1.6':
+    resolution: {integrity: sha512-HBxuCgYLKPPxETV0Rot4VP9e24vKl8JdzGCZOVsDaOXJgbRZoRIF67Lp0H/OgnJeH/Xpva8Z5ReoTNJE5dn3kg==}
+
+  '@atcute/oauth-browser-client@2.0.3':
+    resolution: {integrity: sha512-rzUjwhjE4LRRKdQnCFQag/zXRZMEAB1hhBoLfnoQuHwWbmDUCL7fzwC3jRhDPp3om8XaYNDj8a/iqRip0wRqoQ==}
+
+  '@atcute/uint8array@1.0.6':
+    resolution: {integrity: sha512-ucfRBQc7BFT8n9eCyGOzDHEMKF/nZwhS2pPao4Xtab1ML3HdFYcX2DM1tadCzas85QTGxHe5urnUAAcNKGRi9A==}
+
+  '@atcute/util-fetch@1.0.4':
+    resolution: {integrity: sha512-sIU9Qk0dE8PLEXSfhy+gIJV+HpiiknMytCI2SqLlqd0vgZUtEKI/EQfP+23LHWvP+CLCzVDOa6cpH045OlmNBg==}
+
+  '@badrap/valita@0.4.6':
+    resolution: {integrity: sha512-4kdqcjyxo/8RQ8ayjms47HCWZIF5981oE5nIenbfThKDxWXtEHKipAOWlflpPJzZx9y/JWYQkp18Awr7VuepFg==}
+    engines: {node: '>= 18'}
+
+  '@esbuild/aix-ppc64@0.27.2':
+    resolution: {integrity: sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/android-arm64@0.27.2':
+    resolution: {integrity: sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm@0.27.2':
+    resolution: {integrity: sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-x64@0.27.2':
+    resolution: {integrity: sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/darwin-arm64@0.27.2':
+    resolution: {integrity: sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.27.2':
+    resolution: {integrity: sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/freebsd-arm64@0.27.2':
+    resolution: {integrity: sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.27.2':
+    resolution: {integrity: sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/linux-arm64@0.27.2':
+    resolution: {integrity: sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.27.2':
+    resolution: {integrity: sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.27.2':
+    resolution: {integrity: sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.27.2':
+    resolution: {integrity: sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.27.2':
+    resolution: {integrity: sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.27.2':
+    resolution: {integrity: sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.27.2':
+    resolution: {integrity: sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.27.2':
+    resolution: {integrity: sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.27.2':
+    resolution: {integrity: sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/netbsd-arm64@0.27.2':
+    resolution: {integrity: sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-x64@0.27.2':
+    resolution: {integrity: sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/openbsd-arm64@0.27.2':
+    resolution: {integrity: sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-x64@0.27.2':
+    resolution: {integrity: sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/openharmony-arm64@0.27.2':
+    resolution: {integrity: sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/sunos-x64@0.27.2':
+    resolution: {integrity: sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/win32-arm64@0.27.2':
+    resolution: {integrity: sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.27.2':
+    resolution: {integrity: sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.27.2':
+    resolution: {integrity: sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
+  '@rollup/rollup-android-arm-eabi@4.53.5':
+    resolution: {integrity: sha512-iDGS/h7D8t7tvZ1t6+WPK04KD0MwzLZrG0se1hzBjSi5fyxlsiggoJHwh18PCFNn7tG43OWb6pdZ6Y+rMlmyNQ==}
+    cpu: [arm]
+    os: [android]
+
+  '@rollup/rollup-android-arm64@4.53.5':
+    resolution: {integrity: sha512-wrSAViWvZHBMMlWk6EJhvg8/rjxzyEhEdgfMMjREHEq11EtJ6IP6yfcCH57YAEca2Oe3FNCE9DSTgU70EIGmVw==}
+    cpu: [arm64]
+    os: [android]
+
+  '@rollup/rollup-darwin-arm64@4.53.5':
+    resolution: {integrity: sha512-S87zZPBmRO6u1YXQLwpveZm4JfPpAa6oHBX7/ghSiGH3rz/KDgAu1rKdGutV+WUI6tKDMbaBJomhnT30Y2t4VQ==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@rollup/rollup-darwin-x64@4.53.5':
+    resolution: {integrity: sha512-YTbnsAaHo6VrAczISxgpTva8EkfQus0VPEVJCEaboHtZRIb6h6j0BNxRBOwnDciFTZLDPW5r+ZBmhL/+YpTZgA==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@rollup/rollup-freebsd-arm64@4.53.5':
+    resolution: {integrity: sha512-1T8eY2J8rKJWzaznV7zedfdhD1BqVs1iqILhmHDq/bqCUZsrMt+j8VCTHhP0vdfbHK3e1IQ7VYx3jlKqwlf+vw==}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@rollup/rollup-freebsd-x64@4.53.5':
+    resolution: {integrity: sha512-sHTiuXyBJApxRn+VFMaw1U+Qsz4kcNlxQ742snICYPrY+DDL8/ZbaC4DVIB7vgZmp3jiDaKA0WpBdP0aqPJoBQ==}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.53.5':
+    resolution: {integrity: sha512-dV3T9MyAf0w8zPVLVBptVlzaXxka6xg1f16VAQmjg+4KMSTWDvhimI/Y6mp8oHwNrmnmVl9XxJ/w/mO4uIQONA==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm-musleabihf@4.53.5':
+    resolution: {integrity: sha512-wIGYC1x/hyjP+KAu9+ewDI+fi5XSNiUi9Bvg6KGAh2TsNMA3tSEs+Sh6jJ/r4BV/bx/CyWu2ue9kDnIdRyafcQ==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm64-gnu@4.53.5':
+    resolution: {integrity: sha512-Y+qVA0D9d0y2FRNiG9oM3Hut/DgODZbU9I8pLLPwAsU0tUKZ49cyV1tzmB/qRbSzGvY8lpgGkJuMyuhH7Ma+Vg==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm64-musl@4.53.5':
+    resolution: {integrity: sha512-juaC4bEgJsyFVfqhtGLz8mbopaWD+WeSOYr5E16y+1of6KQjc0BpwZLuxkClqY1i8sco+MdyoXPNiCkQou09+g==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/rollup-linux-loong64-gnu@4.53.5':
+    resolution: {integrity: sha512-rIEC0hZ17A42iXtHX+EPJVL/CakHo+tT7W0pbzdAGuWOt2jxDFh7A/lRhsNHBcqL4T36+UiAgwO8pbmn3dE8wA==}
+    cpu: [loong64]
+    os: [linux]
+
+  '@rollup/rollup-linux-ppc64-gnu@4.53.5':
+    resolution: {integrity: sha512-T7l409NhUE552RcAOcmJHj3xyZ2h7vMWzcwQI0hvn5tqHh3oSoclf9WgTl+0QqffWFG8MEVZZP1/OBglKZx52Q==}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@rollup/rollup-linux-riscv64-gnu@4.53.5':
+    resolution: {integrity: sha512-7OK5/GhxbnrMcxIFoYfhV/TkknarkYC1hqUw1wU2xUN3TVRLNT5FmBv4KkheSG2xZ6IEbRAhTooTV2+R5Tk0lQ==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/rollup-linux-riscv64-musl@4.53.5':
+    resolution: {integrity: sha512-GwuDBE/PsXaTa76lO5eLJTyr2k8QkPipAyOrs4V/KJufHCZBJ495VCGJol35grx9xryk4V+2zd3Ri+3v7NPh+w==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/rollup-linux-s390x-gnu@4.53.5':
+    resolution: {integrity: sha512-IAE1Ziyr1qNfnmiQLHBURAD+eh/zH1pIeJjeShleII7Vj8kyEm2PF77o+lf3WTHDpNJcu4IXJxNO0Zluro8bOw==}
+    cpu: [s390x]
+    os: [linux]
+
+  '@rollup/rollup-linux-x64-gnu@4.53.5':
+    resolution: {integrity: sha512-Pg6E+oP7GvZ4XwgRJBuSXZjcqpIW3yCBhK4BcsANvb47qMvAbCjR6E+1a/U2WXz1JJxp9/4Dno3/iSJLcm5auw==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/rollup-linux-x64-musl@4.53.5':
+    resolution: {integrity: sha512-txGtluxDKTxaMDzUduGP0wdfng24y1rygUMnmlUJ88fzCCULCLn7oE5kb2+tRB+MWq1QDZT6ObT5RrR8HFRKqg==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/rollup-openharmony-arm64@4.53.5':
+    resolution: {integrity: sha512-3DFiLPnTxiOQV993fMc+KO8zXHTcIjgaInrqlG8zDp1TlhYl6WgrOHuJkJQ6M8zHEcntSJsUp1XFZSY8C1DYbg==}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@rollup/rollup-win32-arm64-msvc@4.53.5':
+    resolution: {integrity: sha512-nggc/wPpNTgjGg75hu+Q/3i32R00Lq1B6N1DO7MCU340MRKL3WZJMjA9U4K4gzy3dkZPXm9E1Nc81FItBVGRlA==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@rollup/rollup-win32-ia32-msvc@4.53.5':
+    resolution: {integrity: sha512-U/54pTbdQpPLBdEzCT6NBCFAfSZMvmjr0twhnD9f4EIvlm9wy3jjQ38yQj1AGznrNO65EWQMgm/QUjuIVrYF9w==}
+    cpu: [ia32]
+    os: [win32]
+
+  '@rollup/rollup-win32-x64-gnu@4.53.5':
+    resolution: {integrity: sha512-2NqKgZSuLH9SXBBV2dWNRCZmocgSOx8OJSdpRaEcRlIfX8YrKxUT6z0F1NpvDVhOsl190UFTRh2F2WDWWCYp3A==}
+    cpu: [x64]
+    os: [win32]
+
+  '@rollup/rollup-win32-x64-msvc@4.53.5':
+    resolution: {integrity: sha512-JRpZUhCfhZ4keB5v0fe02gQJy05GqboPOaxvjugW04RLSYYoB/9t2lx2u/tMs/Na/1NXfY8QYjgRljRpN+MjTQ==}
+    cpu: [x64]
+    os: [win32]
+
+  '@standard-schema/spec@1.1.0':
+    resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
+
+  '@types/estree@1.0.8':
+    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+
+  esbuild@0.27.2:
+    resolution: {integrity: sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  esm-env@1.2.2:
+    resolution: {integrity: sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==}
+
+  fdir@6.5.0:
+    resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
+    engines: {node: '>=12.0.0'}
+    peerDependencies:
+      picomatch: ^3 || ^4
+    peerDependenciesMeta:
+      picomatch:
+        optional: true
+
+  fsevents@2.3.3:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  nanoid@3.3.11:
+    resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  nanoid@5.1.6:
+    resolution: {integrity: sha512-c7+7RQ+dMB5dPwwCp4ee1/iV/q2P6aK1mTZcfr1BTuVlyW9hJYiMPybJCcnBlQtuSmTIWNeazm/zqNoZSSElBg==}
+    engines: {node: ^18 || >=20}
+    hasBin: true
+
+  picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  picomatch@4.0.3:
+    resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
+    engines: {node: '>=12'}
+
+  postcss@8.5.6:
+    resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  rollup@4.53.5:
+    resolution: {integrity: sha512-iTNAbFSlRpcHeeWu73ywU/8KuU/LZmNCSxp6fjQkJBD3ivUb8tpDrXhIxEzA05HlYMEwmtaUnb3RP+YNv162OQ==}
+    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
+    hasBin: true
+
+  source-map-js@1.2.1:
+    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+    engines: {node: '>=0.10.0'}
+
+  tinyglobby@0.2.15:
+    resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==}
+    engines: {node: '>=12.0.0'}
+
+  typescript@5.9.3:
+    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  vite@7.3.0:
+    resolution: {integrity: sha512-dZwN5L1VlUBewiP6H9s2+B3e3Jg96D0vzN+Ry73sOefebhYr9f94wwkMNN/9ouoU8pV1BqA1d1zGk8928cx0rg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^20.19.0 || >=22.12.0
+      jiti: '>=1.21.0'
+      less: ^4.0.0
+      lightningcss: ^1.21.0
+      sass: ^1.70.0
+      sass-embedded: ^1.70.0
+      stylus: '>=0.54.8'
+      sugarss: ^5.0.0
+      terser: ^5.16.0
+      tsx: ^4.8.1
+      yaml: ^2.4.2
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      jiti:
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+      tsx:
+        optional: true
+      yaml:
+        optional: true
+
+snapshots:
+
+  '@atcute/client@4.1.1':
+    dependencies:
+      '@atcute/identity': 1.1.3
+      '@atcute/lexicons': 1.2.5
+
+  '@atcute/identity-resolver@1.2.0(@atcute/identity@1.1.3)':
+    dependencies:
+      '@atcute/identity': 1.1.3
+      '@atcute/lexicons': 1.2.5
+      '@atcute/util-fetch': 1.0.4
+      '@badrap/valita': 0.4.6
+
+  '@atcute/identity@1.1.3':
+    dependencies:
+      '@atcute/lexicons': 1.2.5
+      '@badrap/valita': 0.4.6
+
+  '@atcute/lexicons@1.2.5':
+    dependencies:
+      '@standard-schema/spec': 1.1.0
+      esm-env: 1.2.2
+
+  '@atcute/multibase@1.1.6':
+    dependencies:
+      '@atcute/uint8array': 1.0.6
+
+  '@atcute/oauth-browser-client@2.0.3(@atcute/identity@1.1.3)':
+    dependencies:
+      '@atcute/client': 4.1.1
+      '@atcute/identity-resolver': 1.2.0(@atcute/identity@1.1.3)
+      '@atcute/lexicons': 1.2.5
+      '@atcute/multibase': 1.1.6
+      '@atcute/uint8array': 1.0.6
+      nanoid: 5.1.6
+    transitivePeerDependencies:
+      - '@atcute/identity'
+
+  '@atcute/uint8array@1.0.6': {}
+
+  '@atcute/util-fetch@1.0.4':
+    dependencies:
+      '@badrap/valita': 0.4.6
+
+  '@badrap/valita@0.4.6': {}
+
+  '@esbuild/aix-ppc64@0.27.2':
+    optional: true
+
+  '@esbuild/android-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/android-arm@0.27.2':
+    optional: true
+
+  '@esbuild/android-x64@0.27.2':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/darwin-x64@0.27.2':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.27.2':
+    optional: true
+
+  '@esbuild/linux-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/linux-arm@0.27.2':
+    optional: true
+
+  '@esbuild/linux-ia32@0.27.2':
+    optional: true
+
+  '@esbuild/linux-loong64@0.27.2':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.27.2':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.27.2':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.27.2':
+    optional: true
+
+  '@esbuild/linux-s390x@0.27.2':
+    optional: true
+
+  '@esbuild/linux-x64@0.27.2':
+    optional: true
+
+  '@esbuild/netbsd-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.27.2':
+    optional: true
+
+  '@esbuild/openbsd-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.27.2':
+    optional: true
+
+  '@esbuild/openharmony-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/sunos-x64@0.27.2':
+    optional: true
+
+  '@esbuild/win32-arm64@0.27.2':
+    optional: true
+
+  '@esbuild/win32-ia32@0.27.2':
+    optional: true
+
+  '@esbuild/win32-x64@0.27.2':
+    optional: true
+
+  '@rollup/rollup-android-arm-eabi@4.53.5':
+    optional: true
+
+  '@rollup/rollup-android-arm64@4.53.5':
+    optional: true
+
+  '@rollup/rollup-darwin-arm64@4.53.5':
+    optional: true
+
+  '@rollup/rollup-darwin-x64@4.53.5':
+    optional: true
+
+  '@rollup/rollup-freebsd-arm64@4.53.5':
+    optional: true
+
+  '@rollup/rollup-freebsd-x64@4.53.5':
+    optional: true
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.53.5':
+    optional: true
+
+  '@rollup/rollup-linux-arm-musleabihf@4.53.5':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-gnu@4.53.5':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-musl@4.53.5':
+    optional: true
+
+  '@rollup/rollup-linux-loong64-gnu@4.53.5':
+    optional: true
+
+  '@rollup/rollup-linux-ppc64-gnu@4.53.5':
+    optional: true
+
+  '@rollup/rollup-linux-riscv64-gnu@4.53.5':
+    optional: true
+
+  '@rollup/rollup-linux-riscv64-musl@4.53.5':
+    optional: true
+
+  '@rollup/rollup-linux-s390x-gnu@4.53.5':
+    optional: true
+
+  '@rollup/rollup-linux-x64-gnu@4.53.5':
+    optional: true
+
+  '@rollup/rollup-linux-x64-musl@4.53.5':
+    optional: true
+
+  '@rollup/rollup-openharmony-arm64@4.53.5':
+    optional: true
+
+  '@rollup/rollup-win32-arm64-msvc@4.53.5':
+    optional: true
+
+  '@rollup/rollup-win32-ia32-msvc@4.53.5':
+    optional: true
+
+  '@rollup/rollup-win32-x64-gnu@4.53.5':
+    optional: true
+
+  '@rollup/rollup-win32-x64-msvc@4.53.5':
+    optional: true
+
+  '@standard-schema/spec@1.1.0': {}
+
+  '@types/estree@1.0.8': {}
+
+  esbuild@0.27.2:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.27.2
+      '@esbuild/android-arm': 0.27.2
+      '@esbuild/android-arm64': 0.27.2
+      '@esbuild/android-x64': 0.27.2
+      '@esbuild/darwin-arm64': 0.27.2
+      '@esbuild/darwin-x64': 0.27.2
+      '@esbuild/freebsd-arm64': 0.27.2
+      '@esbuild/freebsd-x64': 0.27.2
+      '@esbuild/linux-arm': 0.27.2
+      '@esbuild/linux-arm64': 0.27.2
+      '@esbuild/linux-ia32': 0.27.2
+      '@esbuild/linux-loong64': 0.27.2
+      '@esbuild/linux-mips64el': 0.27.2
+      '@esbuild/linux-ppc64': 0.27.2
+      '@esbuild/linux-riscv64': 0.27.2
+      '@esbuild/linux-s390x': 0.27.2
+      '@esbuild/linux-x64': 0.27.2
+      '@esbuild/netbsd-arm64': 0.27.2
+      '@esbuild/netbsd-x64': 0.27.2
+      '@esbuild/openbsd-arm64': 0.27.2
+      '@esbuild/openbsd-x64': 0.27.2
+      '@esbuild/openharmony-arm64': 0.27.2
+      '@esbuild/sunos-x64': 0.27.2
+      '@esbuild/win32-arm64': 0.27.2
+      '@esbuild/win32-ia32': 0.27.2
+      '@esbuild/win32-x64': 0.27.2
+
+  esm-env@1.2.2: {}
+
+  fdir@6.5.0(picomatch@4.0.3):
+    optionalDependencies:
+      picomatch: 4.0.3
+
+  fsevents@2.3.3:
+    optional: true
+
+  nanoid@3.3.11: {}
+
+  nanoid@5.1.6: {}
+
+  picocolors@1.1.1: {}
+
+  picomatch@4.0.3: {}
+
+  postcss@8.5.6:
+    dependencies:
+      nanoid: 3.3.11
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
+  rollup@4.53.5:
+    dependencies:
+      '@types/estree': 1.0.8
+    optionalDependencies:
+      '@rollup/rollup-android-arm-eabi': 4.53.5
+      '@rollup/rollup-android-arm64': 4.53.5
+      '@rollup/rollup-darwin-arm64': 4.53.5
+      '@rollup/rollup-darwin-x64': 4.53.5
+      '@rollup/rollup-freebsd-arm64': 4.53.5
+      '@rollup/rollup-freebsd-x64': 4.53.5
+      '@rollup/rollup-linux-arm-gnueabihf': 4.53.5
+      '@rollup/rollup-linux-arm-musleabihf': 4.53.5
+      '@rollup/rollup-linux-arm64-gnu': 4.53.5
+      '@rollup/rollup-linux-arm64-musl': 4.53.5
+      '@rollup/rollup-linux-loong64-gnu': 4.53.5
+      '@rollup/rollup-linux-ppc64-gnu': 4.53.5
+      '@rollup/rollup-linux-riscv64-gnu': 4.53.5
+      '@rollup/rollup-linux-riscv64-musl': 4.53.5
+      '@rollup/rollup-linux-s390x-gnu': 4.53.5
+      '@rollup/rollup-linux-x64-gnu': 4.53.5
+      '@rollup/rollup-linux-x64-musl': 4.53.5
+      '@rollup/rollup-openharmony-arm64': 4.53.5
+      '@rollup/rollup-win32-arm64-msvc': 4.53.5
+      '@rollup/rollup-win32-ia32-msvc': 4.53.5
+      '@rollup/rollup-win32-x64-gnu': 4.53.5
+      '@rollup/rollup-win32-x64-msvc': 4.53.5
+      fsevents: 2.3.3
+
+  source-map-js@1.2.1: {}
+
+  tinyglobby@0.2.15:
+    dependencies:
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
+
+  typescript@5.9.3: {}
+
+  vite@7.3.0:
+    dependencies:
+      esbuild: 0.27.2
+      fdir: 6.5.0(picomatch@4.0.3)
+      picomatch: 4.0.3
+      postcss: 8.5.6
+      rollup: 4.53.5
+      tinyglobby: 0.2.15
+    optionalDependencies:
+      fsevents: 2.3.3

public/_redirects

···
+/*    /index.html   200

public/oauth-client-metadata.json

···
+{
+  "client_id": "https://pollz.waow.tech/oauth-client-metadata.json",
+  "client_name": "pollz",
+  "client_uri": "https://pollz.waow.tech",
+  "redirect_uris": ["https://pollz.waow.tech/"],
+  "grant_types": ["authorization_code", "refresh_token"],
+  "response_types": ["code"],
+  "scope": "atproto repo:tech.waow.poll repo:tech.waow.vote",
+  "token_endpoint_auth_method": "none",
+  "application_type": "web",
+  "dpop_bound_access_tokens": true
+}

src/main.ts

···
+import { Client, simpleFetchHandler } from "@atcute/client";
+import {
+  CompositeDidDocumentResolver,
+  CompositeHandleResolver,
+  DohJsonHandleResolver,
+  PlcDidDocumentResolver,
+  AtprotoWebDidDocumentResolver,
+  WellKnownHandleResolver,
+} from "@atcute/identity-resolver";
+import {
+  configureOAuth,
+  createAuthorizationUrl,
+  defaultIdentityResolver,
+  finalizeAuthorization,
+  getSession,
+  OAuthUserAgent,
+  deleteStoredSession,
+} from "@atcute/oauth-browser-client";
+
+const POLL = "tech.waow.poll";
+const VOTE = "tech.waow.vote";
+
+const didDocumentResolver = new CompositeDidDocumentResolver({
+  methods: {
+    plc: new PlcDidDocumentResolver(),
+    web: new AtprotoWebDidDocumentResolver(),
+  },
+});
+
+const handleResolver = new CompositeHandleResolver({
+  strategy: "dns-first",
+  methods: {
+    dns: new DohJsonHandleResolver({ dohUrl: "https://dns.google/resolve?" }),
+    http: new WellKnownHandleResolver(),
+  },
+});
+
+const BASE_URL = import.meta.env.VITE_BASE_URL || "https://pollz.waow.tech";
+
+configureOAuth({
+  metadata: {
+    client_id: `${BASE_URL}/oauth-client-metadata.json`,
+    redirect_uri: `${BASE_URL}/`,
+  },
+  identityResolver: defaultIdentityResolver({
+    handleResolver,
+    didDocumentResolver,
+  }),
+});
+
+const app = document.getElementById("app")!;
+const nav = document.getElementById("nav")!;
+const status = document.getElementById("status")!;
+
+let agent: OAuthUserAgent | null = null;
+let currentDid: string | null = null;
+let jetstream: WebSocket | null = null;
+
+const setStatus = (msg: string) => (status.textContent = msg);
+
+type Poll = {
+  uri: string;
+  repo: string;
+  rkey: string;
+  text: string;
+  options: string[];
+  createdAt: string;
+  votes: Map<string, number>;
+  voteCount?: number; // from backend, used when votes map is empty
+};
+
+const polls = new Map<string, Poll>();
+
+// jetstream - replay last 24h on connect, then live updates
+const connectJetstream = () => {
+  if (jetstream?.readyState === WebSocket.OPEN) return;
+
+  // cursor is microseconds since epoch - go back 24 hours
+  const cursor = (Date.now() - 24 * 60 * 60 * 1000) * 1000;
+  const url = `wss://jetstream1.us-east.bsky.network/subscribe?wantedCollections=${POLL}&wantedCollections=${VOTE}&cursor=${cursor}`;
+  jetstream = new WebSocket(url);
+
+  jetstream.onmessage = (event) => {
+    const msg = JSON.parse(event.data);
+    if (msg.kind !== "commit") return;
+
+    const { commit } = msg;
+    const uri = `at://${msg.did}/${commit.collection}/${commit.rkey}`;
+
+    if (commit.collection === POLL) {
+      if (commit.operation === "create" && commit.record) {
+        polls.set(uri, {
+          uri,
+          repo: msg.did,
+          rkey: commit.rkey,
+          text: commit.record.text,
+          options: commit.record.options,
+          createdAt: commit.record.createdAt,
+          votes: new Map(),
+        });
+        render();
+      } else if (commit.operation === "delete") {
+        polls.delete(uri);
+        render();
+      }
+    }
+
+    if (commit.collection === VOTE) {
+      if (commit.operation === "create" && commit.record) {
+        const poll = polls.get(commit.record.subject);
+        if (poll && !poll.votes.has(uri)) {
+          poll.votes.set(uri, commit.record.option);
+          render();
+        }
+      } else if (commit.operation === "delete") {
+        // find and remove vote from its poll
+        for (const poll of polls.values()) {
+          if (poll.votes.has(uri)) {
+            poll.votes.delete(uri);
+            render();
+            break;
+          }
+        }
+      }
+    }
+  };
+
+  jetstream.onclose = () => setTimeout(connectJetstream, 3000);
+};
+
+// render
+const render = () => {
+  renderNav();
+
+  const path = location.pathname;
+  const match = path.match(/^\/poll\/([^/]+)\/([^/]+)$/);
+
+  if (match) {
+    renderPoll(match[1], match[2]);
+  } else if (path === "/new") {
+    renderCreate();
+  } else {
+    renderHome();
+  }
+};
+
+const renderNav = () => {
+  if (agent) {
+    nav.innerHTML = `<a href="/">my polls</a> · <a href="/new">new</a> · <a href="#" id="logout">logout</a>`;
+    document.getElementById("logout")!.onclick = async (e) => {
+      e.preventDefault();
+      if (currentDid) {
+        await deleteStoredSession(currentDid as `did:${string}:${string}`);
+        localStorage.removeItem("lastDid");
+      }
+      agent = null;
+      currentDid = null;
+      render();
+    };
+  } else {
+    nav.innerHTML = `<input id="handle" placeholder="handle" style="width:120px"/> <button id="login">login</button>`;
+    document.getElementById("login")!.onclick = async () => {
+      const handle = (document.getElementById("handle") as HTMLInputElement).value.trim();
+      if (!handle) return;
+      setStatus("redirecting...");
+      try {
+        const url = await createAuthorizationUrl({
+          scope: `atproto repo:${POLL} repo:${VOTE}`,
+          target: { type: "account", identifier: handle },
+        });
+        location.assign(url);
+      } catch (e) {
+        setStatus(`error: ${e}`);
+      }
+    };
+  }
+};
+
+const BACKEND_URL = import.meta.env.VITE_BACKEND_URL || "https://pollz-backend.fly.dev";
+
+// fetch user's existing votes from their PDS
+const loadUserVotes = async () => {
+  if (!agent || !currentDid) return;
+
+  try {
+    const rpc = new Client({ handler: agent });
+    const res = await rpc.get("com.atproto.repo.listRecords", {
+      params: { repo: currentDid, collection: VOTE, limit: 100 },
+    });
+
+    if (res.ok) {
+      for (const record of res.data.records) {
+        const val = record.value as { subject?: string; option?: number };
+        if (val.subject && typeof val.option === "number") {
+          const poll = polls.get(val.subject);
+          if (poll) {
+            poll.votes.set(record.uri, val.option);
+          }
+        }
+      }
+    }
+  } catch (e) {
+    console.error("failed to load user votes:", e);
+  }
+};
+
+const renderHome = async () => {
+  app.innerHTML = "<p>loading polls...</p>";
+
+  try {
+    // fetch all polls from backend
+    const res = await fetch(`${BACKEND_URL}/api/polls`);
+    if (!res.ok) throw new Error("failed to fetch polls");
+
+    const backendPolls = await res.json() as Array<{
+      uri: string;
+      repo: string;
+      rkey: string;
+      text: string;
+      options: string[];
+      createdAt: string;
+      voteCount: number;
+    }>;
+
+    // merge into local state
+    for (const p of backendPolls) {
+      const existing = polls.get(p.uri);
+      if (existing) {
+        // update vote count from backend
+        existing.voteCount = p.voteCount;
+      } else {
+        polls.set(p.uri, {
+          uri: p.uri,
+          repo: p.repo,
+          rkey: p.rkey,
+          text: p.text,
+          options: p.options,
+          createdAt: p.createdAt,
+          votes: new Map(),
+          voteCount: p.voteCount,
+        });
+      }
+    }
+
+    // load user's votes now that polls are in memory
+    await loadUserVotes();
+
+    const allPolls = Array.from(polls.values())
+      .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+
+    const newLink = agent ? `<p><a href="/new">+ new poll</a></p>` : `<p>login to create polls</p>`;
+
+    if (allPolls.length === 0) {
+      app.innerHTML = newLink + "<p>no polls yet</p>";
+    } else {
+      app.innerHTML = newLink + allPolls.map(renderPollCard).join("");
+      attachVoteHandlers();
+    }
+  } catch (e) {
+    console.error("renderHome error:", e);
+    app.innerHTML = "<p>failed to load polls</p>";
+  }
+};
+
+const renderPollCard = (p: Poll) => {
+  // always use backend voteCount for total
+  const total = p.voteCount ?? 0;
+
+  const opts = p.options
+    .map((opt, i) => {
+      return `
+        <div class="option" data-vote="${i}" data-poll="${p.uri}">
+          <span class="option-text">${esc(opt)}</span>
+        </div>
+      `;
+    })
+    .join("");
+
+  return `
+    <div class="poll">
+      <a href="/poll/${p.repo}/${p.rkey}" class="poll-question">${esc(p.text)}</a>
+      <div class="poll-meta">${ago(p.createdAt)} · <span class="vote-count" data-poll-uri="${p.uri}">${total} vote${total === 1 ? "" : "s"}</span></div>
+      ${opts}
+    </div>
+  `;
+};
+
+const esc = (s: string) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+const ago = (date: string) => {
+  const seconds = Math.floor((Date.now() - new Date(date).getTime()) / 1000);
+  if (seconds < 60) return "just now";
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 30) return `${days}d ago`;
+  return new Date(date).toLocaleDateString();
+};
+
+const attachVoteHandlers = () => {
+  app.querySelectorAll("[data-vote]").forEach((el) => {
+    el.addEventListener("click", async (e) => {
+      e.preventDefault();
+      const t = e.currentTarget as HTMLElement;
+      await vote(t.dataset.poll!, parseInt(t.dataset.vote!, 10));
+    });
+  });
+
+  // attach hover handlers for vote counts
+  app.querySelectorAll(".vote-count").forEach((el) => {
+    el.addEventListener("mouseenter", showVotersTooltip);
+    el.addEventListener("mouseleave", hideVotersTooltip);
+  });
+};
+
+type Vote = { voter: string; option: number; uri: string; createdAt?: string; handle?: string };
+const votersCache = new Map<string, Vote[]>();
+const handleCache = new Map<string, string>();
+let activeTooltip: HTMLElement | null = null;
+let tooltipTimeout: ReturnType<typeof setTimeout> | null = null;
+
+// resolve DID to handle
+const resolveHandle = async (did: string): Promise<string> => {
+  if (handleCache.has(did)) return handleCache.get(did)!;
+  try {
+    const res = await fetch(`https://public.api.bsky.app/xrpc/app.bsky.actor.getProfile?actor=${did}`);
+    if (res.ok) {
+      const data = await res.json();
+      if (data.handle) {
+        handleCache.set(did, data.handle);
+        return data.handle;
+      }
+    }
+  } catch {}
+  return did; // fallback to DID
+};
+
+const showVotersTooltip = async (e: Event) => {
+  const el = e.target as HTMLElement;
+  const pollUri = el.dataset.pollUri;
+  if (!pollUri) return;
+
+  // clear any pending hide
+  if (tooltipTimeout) {
+    clearTimeout(tooltipTimeout);
+    tooltipTimeout = null;
+  }
+
+  // fetch voters if not cached
+  if (!votersCache.has(pollUri)) {
+    try {
+      const res = await fetch(`${BACKEND_URL}/api/polls/${encodeURIComponent(pollUri)}/votes`);
+      if (res.ok) {
+        votersCache.set(pollUri, await res.json());
+      }
+    } catch (err) {
+      console.error("failed to fetch voters:", err);
+      return;
+    }
+  }
+
+  const voters = votersCache.get(pollUri);
+  if (!voters || voters.length === 0) return;
+
+  // resolve handles for all voters
+  await Promise.all(voters.map(async (v) => {
+    if (!v.handle) {
+      v.handle = await resolveHandle(v.voter);
+    }
+  }));
+
+  // get poll options for display
+  const poll = polls.get(pollUri);
+  const options = poll?.options || [];
+
+  // remove existing tooltip if any
+  if (activeTooltip) activeTooltip.remove();
+
+  // create tooltip
+  const tooltip = document.createElement("div");
+  tooltip.className = "voters-tooltip";
+  tooltip.innerHTML = voters
+    .map((v) => {
+      const optText = options[v.option] || `option ${v.option}`;
+      const profileUrl = `https://bsky.app/profile/${v.voter}`;
+      const displayName = v.handle || v.voter;
+      const timeStr = v.createdAt ? ago(v.createdAt) : "";
+      return `<div class="voter"><a href="${profileUrl}" target="_blank" class="voter-link">@${esc(displayName)}</a> → ${esc(optText)}${timeStr ? ` <span class="vote-time">${timeStr}</span>` : ""}</div>`;
+    })
+    .join("");
+
+  // keep tooltip visible when hovering over it
+  tooltip.addEventListener("mouseenter", () => {
+    if (tooltipTimeout) {
+      clearTimeout(tooltipTimeout);
+      tooltipTimeout = null;
+    }
+  });
+  tooltip.addEventListener("mouseleave", hideVotersTooltip);
+
+  // position tooltip
+  const rect = el.getBoundingClientRect();
+  tooltip.style.position = "fixed";
+  tooltip.style.left = `${rect.left}px`;
+  tooltip.style.top = `${rect.bottom + 4}px`;
+
+  document.body.appendChild(tooltip);
+  activeTooltip = tooltip;
+};
+
+const hideVotersTooltip = () => {
+  // delay hiding so user can move to tooltip
+  tooltipTimeout = setTimeout(() => {
+    if (activeTooltip) {
+      activeTooltip.remove();
+      activeTooltip = null;
+    }
+  }, 150);
+};
+
+const attachShareHandler = () => {
+  const btn = app.querySelector(".share-btn") as HTMLButtonElement;
+  if (!btn) return;
+
+  btn.addEventListener("click", async () => {
+    const url = btn.dataset.url!;
+    try {
+      await navigator.clipboard.writeText(url);
+      btn.textContent = "copied!";
+      btn.classList.add("copied");
+      setTimeout(() => {
+        btn.textContent = "copy link";
+        btn.classList.remove("copied");
+      }, 2000);
+    } catch {
+      // fallback for older browsers
+      const input = document.createElement("input");
+      input.value = url;
+      document.body.appendChild(input);
+      input.select();
+      document.execCommand("copy");
+      document.body.removeChild(input);
+      btn.textContent = "copied!";
+      btn.classList.add("copied");
+      setTimeout(() => {
+        btn.textContent = "copy link";
+        btn.classList.remove("copied");
+      }, 2000);
+    }
+  });
+};
+
+const renderPoll = async (repo: string, rkey: string) => {
+  const uri = `at://${repo}/${POLL}/${rkey}`;
+  app.innerHTML = "<p>loading...</p>";
+
+  try {
+    // fetch poll with vote counts from backend
+    const res = await fetch(`${BACKEND_URL}/api/polls/${encodeURIComponent(uri)}`);
+
+    if (res.ok) {
+      const data = await res.json() as {
+        uri: string;
+        repo: string;
+        rkey: string;
+        text: string;
+        options: Array<{ text: string; count: number }>;
+        createdAt: string;
+      };
+
+      // render poll with vote counts from backend
+      const total = data.options.reduce((sum, o) => sum + o.count, 0);
+      const opts = data.options
+        .map((opt, i) => {
+          const pct = total > 0 ? Math.round((opt.count / total) * 100) : 0;
+          return `
+          <div class="option" data-vote="${i}" data-poll="${uri}">
+            <div class="option-bar" style="width: ${pct}%"></div>
+            <span class="option-text">${esc(opt.text)}</span>
+            <span class="option-count">${opt.count} (${pct}%)</span>
+          </div>`;
+        })
+        .join("");
+
+      const shareUrl = `${window.location.origin}/poll/${repo}/${rkey}`;
+      app.innerHTML = `
+        <p><a href="/">&larr; back</a></p>
+        <div class="poll-detail">
+          <div class="poll-header">
+            <h2 class="poll-question">${esc(data.text)}</h2>
+            <button class="share-btn" data-url="${shareUrl}">copy link</button>
+          </div>
+          ${opts}
+          <div class="poll-meta">${ago(data.createdAt)} · <span class="vote-count" data-poll-uri="${uri}">${total} vote${total === 1 ? "" : "s"}</span></div>
+        </div>`;
+      attachVoteHandlers();
+      attachShareHandler();
+      return;
+    }
+
+    // fallback to direct PDS fetch if backend doesn't have it
+    const didDoc = await didDocumentResolver.resolve(repo as `did:${string}:${string}`);
+    const pds = didDoc?.service?.find((s: { id: string }) => s.id === "#atproto_pds") as { serviceEndpoint?: string } | undefined;
+    const pdsUrl = pds?.serviceEndpoint || "https://bsky.social";
+
+    const pdsClient = new Client({
+      handler: simpleFetchHandler({ service: pdsUrl }),
+    });
+
+    const pdsRes = await pdsClient.get("com.atproto.repo.getRecord", {
+      params: { repo, collection: POLL, rkey },
+    });
+    if (!pdsRes.ok) {
+      app.innerHTML = "<p>not found</p>";
+      return;
+    }
+    const rec = pdsRes.data.value as { text: string; options: string[]; createdAt: string };
+    const poll = { uri: pdsRes.data.uri, repo, rkey, text: rec.text, options: rec.options, createdAt: rec.createdAt, votes: new Map() };
+    polls.set(uri, poll);
+
+    app.innerHTML = `<p><a href="/">&larr; back</a></p>${renderPollCard(poll)}`;
+    attachVoteHandlers();
+  } catch (e) {
+    console.error("renderPoll error:", e);
+    app.innerHTML = "<p>error loading poll</p>";
+  }
+};
+
+const renderCreate = () => {
+  if (!agent) {
+    app.innerHTML = "<p>login to create</p>";
+    return;
+  }
+  app.innerHTML = `
+    <div class="create-form">
+      <input type="text" id="question" placeholder="question" />
+      <textarea id="options" rows="4" placeholder="options (one per line)"></textarea>
+      <button id="create">create</button>
+    </div>
+  `;
+  document.getElementById("create")!.onclick = create;
+};
+
+const create = async () => {
+  if (!agent || !currentDid) return;
+
+  const text = (document.getElementById("question") as HTMLInputElement).value.trim();
+  const options = (document.getElementById("options") as HTMLTextAreaElement).value
+    .split("\n")
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  if (!text || options.length < 2) {
+    setStatus("need question + 2 options");
+    return;
+  }
+
+  setStatus("creating...");
+  const rpc = new Client({ handler: agent });
+  const res = await rpc.post("com.atproto.repo.createRecord", {
+    input: {
+      repo: currentDid,
+      collection: POLL,
+      record: { $type: POLL, text, options, createdAt: new Date().toISOString() },
+    },
+  });
+
+  if (!res.ok) {
+    setStatus(`error: ${res.data.error}`);
+    return;
+  }
+
+  const rkey = res.data.uri.split("/").pop()!;
+  polls.set(res.data.uri, {
+    uri: res.data.uri,
+    repo: currentDid,
+    rkey,
+    text,
+    options,
+    createdAt: new Date().toISOString(),
+    votes: new Map(),
+  });
+
+  setStatus("");
+  history.pushState(null, "", "/");
+  render();
+};
+
+const vote = async (pollUri: string, option: number) => {
+  if (!agent || !currentDid) {
+    setStatus("login to vote");
+    return;
+  }
+
+  setStatus("voting...");
+  const rpc = new Client({ handler: agent });
+
+  // first, find and delete any existing votes on this poll
+  try {
+    const existing = await rpc.get("com.atproto.repo.listRecords", {
+      params: { repo: currentDid, collection: VOTE, limit: 100 },
+    });
+    if (existing.ok) {
+      for (const record of existing.data.records) {
+        const val = record.value as { subject?: string };
+        if (val.subject === pollUri) {
+          const rkey = record.uri.split("/").pop()!;
+          await rpc.post("com.atproto.repo.deleteRecord", {
+            input: { repo: currentDid, collection: VOTE, rkey },
+          });
+        }
+      }
+    }
+  } catch (e) {
+    console.error("error checking existing votes:", e);
+  }
+
+  const res = await rpc.post("com.atproto.repo.createRecord", {
+    input: {
+      repo: currentDid,
+      collection: VOTE,
+      record: { $type: VOTE, subject: pollUri, option, createdAt: new Date().toISOString() },
+    },
+  });
+
+  if (!res.ok) {
+    console.error("vote error:", res.status, res.data);
+    setStatus(`error: ${res.data.error || res.data.message || "unknown"}`);
+    setTimeout(() => setStatus(""), 3000);
+    return;
+  }
+
+  // update local state
+  const poll = polls.get(pollUri);
+  if (poll) {
+    // remove any existing vote from this user
+    for (const [uri, _] of poll.votes) {
+      if (uri.startsWith(`at://${currentDid}/${VOTE}/`)) {
+        poll.votes.delete(uri);
+      }
+    }
+    poll.votes.set(res.data.uri, option);
+  }
+
+  setStatus("");
+  render();
+};
+
+// oauth
+const handleCallback = async () => {
+  const params = new URLSearchParams(location.hash.slice(1));
+  if (!params.has("state")) return false;
+
+  history.replaceState(null, "", "/");
+  setStatus("logging in...");
+
+  try {
+    const { session } = await finalizeAuthorization(params);
+    agent = new OAuthUserAgent(session);
+    currentDid = session.info.sub;
+    localStorage.setItem("lastDid", currentDid);
+    setStatus("");
+    return true;
+  } catch (e) {
+    setStatus(`login failed: ${e}`);
+    return false;
+  }
+};
+
+const restoreSession = async () => {
+  const lastDid = localStorage.getItem("lastDid");
+  if (!lastDid) return;
+
+  try {
+    const session = await getSession(lastDid as `did:${string}:${string}`);
+    agent = new OAuthUserAgent(session);
+    currentDid = session.info.sub;
+  } catch {
+    localStorage.removeItem("lastDid");
+  }
+};
+
+// routing
+window.addEventListener("popstate", render);
+document.addEventListener("click", (e) => {
+  const a = (e.target as HTMLElement).closest("a");
+  if (a?.href.startsWith(location.origin) && !a.href.includes("#")) {
+    e.preventDefault();
+    history.pushState(null, "", a.href);
+    render();
+  }
+});
+
+// init
+(async () => {
+  await handleCallback();
+  await restoreSession();
+  connectJetstream();
+  render();
+})();

tsconfig.json

···
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src"]
+}

vite.config.ts

···
+import { defineConfig } from "vite";
+import metadata from "./public/oauth-client-metadata.json";
+
+const SERVER_PORT = 5173;
+
+export default defineConfig({
+  plugins: [
+    {
+      name: "oauth",
+      config(_conf, { command }) {
+        if (command === "build") {
+          process.env.VITE_OAUTH_CLIENT_ID = metadata.client_id;
+          process.env.VITE_OAUTH_REDIRECT_URL = metadata.redirect_uris[0];
+        } else {
+          // local dev: use http://localhost client ID trick
+          const redirectUri = `http://127.0.0.1:${SERVER_PORT}/`;
+          const clientId =
+            `http://localhost` +
+            `?redirect_uri=${encodeURIComponent(redirectUri)}` +
+            `&scope=${encodeURIComponent(metadata.scope)}`;
+
+          process.env.VITE_OAUTH_CLIENT_ID = clientId;
+          process.env.VITE_OAUTH_REDIRECT_URL = redirectUri;
+        }
+      },
+    },
+  ],
+  server: {
+    host: "127.0.0.1",
+    port: SERVER_PORT,
+    strictPort: true,
+  },
+  build: {
+    target: "esnext",
+  },
+});