@nyuccl/smile 0.2.0-beta.0

package/dist/runtime/plugins/store-sync.client.js

@@ -0,0 +1,74 @@
+/**
+ * @fileoverview Client-only plugin that handles all persistence sync for the store.
+ *
+ * Pinia SSR hydration replaces useCookie() refs with plain objects, breaking
+ * two-way bindings. This plugin runs on the client after hydration and:
+ *
+ * 1. Prevents Pinia SSR hydration from overwriting client-side state
+ * 2. Patches store.localState from localStorage (restoring Tier 2 data)
+ * 3. Watches store.cookieState → writes changes to document.cookie
+ * 4. Watches store.localState → writes changes to localStorage
+ */
+import { defineNuxtPlugin } from '#imports'
+import { watch } from 'vue'
+import useSmileStore, { initLocalState, initDev, COOKIE_MAX_AGE } from '../stores/smilestore.js'
+import appconfig from '../core/config.js'
+
+export default defineNuxtPlugin((nuxtApp) => {
+  // Prevent Pinia SSR hydration from overwriting our store state.
+  // The server-rendered state has stale/default values; the client
+  // should read from cookies and localStorage instead.
+  delete nuxtApp.payload?.pinia?.smilestore
+
+  const store = useSmileStore()
+  const prefix = `smile_${appconfig.codeName}_`
+
+  // --- 1. Patch localState from localStorage ---
+  const raw = localStorage.getItem(appconfig.localStorageKey)
+  if (raw) {
+    try {
+      const saved = JSON.parse(raw)
+      Object.keys(initLocalState).forEach((key) => {
+        if (key in saved) {
+          store.localState[key] = saved[key]
+        }
+      })
+    }
+    catch (e) {
+      console.warn('[store-sync] Failed to parse localStorage:', e)
+    }
+  }
+
+  // --- 2. Watch cookieState → document.cookie ---
+  watch(
+    () => ({ ...store.cookieState }),
+    (val) => {
+      Object.entries(val).forEach(([key, value]) => {
+        const encoded = encodeURIComponent(JSON.stringify(value))
+        document.cookie = `${prefix}${key}=${encoded}; path=/; max-age=${COOKIE_MAX_AGE}; SameSite=Lax`
+      })
+    },
+    { deep: true },
+  )
+
+  // --- 3. Watch store.dev — reset to defaults if externally cleared to null ---
+  if (appconfig.mode === 'development') {
+    watch(
+      () => store.dev,
+      (val) => {
+        if (val === null || val === undefined) {
+          store.dev = { ...initDev }
+        }
+      },
+    )
+  }
+
+  // --- 4. Watch localState → localStorage ---
+  watch(
+    () => store.localState,
+    (val) => {
+      localStorage.setItem(appconfig.localStorageKey, JSON.stringify(val))
+    },
+    { deep: true },
+  )
+})

package/dist/runtime/plugins/timeline.client.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("nuxt/app").Plugin<{
+    timeline: any;
+}> & import("nuxt/app").ObjectPlugin<{
+    timeline: any;
+}>;
+export default _default;

package/dist/runtime/plugins/timeline.client.js

@@ -0,0 +1,10 @@
+import { defineNuxtPlugin } from '#app'
+import createTimeline from '~/design' // resolves to consumer's design.js
+import useAPI from '../composables/useAPI.js'
+
+// eslint-disable-next-line no-unused-vars
+export default defineNuxtPlugin((_nuxtApp) => {
+  const api = useAPI()
+  const timeline = createTimeline(api)
+  return { provide: { timeline } }
+})

package/dist/runtime/server/api/auth/login.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/auth/login.post.js

@@ -0,0 +1,29 @@
+import { randomUUID } from "node:crypto";
+import { useDB } from "../../utils/db.js";
+import { devSessions } from "../../database/schema.js";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const config = useRuntimeConfig();
+  const devPassword = config.smile?.devPassword;
+  if (!devPassword) {
+    throw createError({ statusCode: 500, statusMessage: "Dev password not configured" });
+  }
+  if (body.password !== devPassword) {
+    throw createError({ statusCode: 401, statusMessage: "Invalid password" });
+  }
+  const db = useDB();
+  const token = randomUUID();
+  const expiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3);
+  await db.insert(devSessions).values({
+    id: token,
+    expiresAt
+  });
+  setCookie(event, "smile_dev_session", token, {
+    httpOnly: true,
+    secure: process.env.NODE_ENV === "production",
+    sameSite: "lax",
+    path: "/",
+    maxAge: 7 * 24 * 60 * 60
+  });
+  return { success: true };
+});

package/dist/runtime/server/api/auth/logout.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/auth/logout.post.js

@@ -0,0 +1,12 @@
+import { eq } from "drizzle-orm";
+import { useDB } from "../../utils/db.js";
+import { devSessions } from "../../database/schema.js";
+export default defineEventHandler(async (event) => {
+  const token = getCookie(event, "smile_dev_session");
+  if (token) {
+    const db = useDB();
+    await db.delete(devSessions).where(eq(devSessions.id, token));
+  }
+  deleteCookie(event, "smile_dev_session", { path: "/" });
+  return { success: true };
+});

package/dist/runtime/server/api/auth/session.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/auth/session.get.js

@@ -0,0 +1,15 @@
+import { eq } from "drizzle-orm";
+import { useDB } from "../../utils/db.js";
+import { devSessions } from "../../database/schema.js";
+export default defineEventHandler(async (event) => {
+  const token = getCookie(event, "smile_dev_session");
+  if (!token) {
+    return { authenticated: false };
+  }
+  const db = useDB();
+  const session = await db.select().from(devSessions).where(eq(devSessions.id, token)).get();
+  if (!session || session.expiresAt < /* @__PURE__ */ new Date()) {
+    return { authenticated: false };
+  }
+  return { authenticated: true };
+});

package/dist/runtime/server/api/participants/[id]/private.patch.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/participants/[id]/private.patch.js

@@ -0,0 +1,20 @@
+import { eq } from "drizzle-orm";
+import { useDB } from "../../../utils/db.js";
+import { privateData } from "../../../database/schema.js";
+export default defineEventHandler(async (event) => {
+  const participantId = getRouterParam(event, "id");
+  if (!participantId) {
+    throw createError({ statusCode: 400, statusMessage: "Missing participant id" });
+  }
+  const body = await readBody(event);
+  const db = useDB();
+  const existing = await db.select().from(privateData).where(eq(privateData.participantId, participantId)).get();
+  if (!existing) {
+    throw createError({ statusCode: 404, statusMessage: "Private data not found" });
+  }
+  await db.update(privateData).set({
+    data: body.data,
+    updatedAt: /* @__PURE__ */ new Date()
+  }).where(eq(privateData.participantId, participantId));
+  return { success: true };
+});

package/dist/runtime/server/api/participants/[id]/private.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/participants/[id]/private.post.js

@@ -0,0 +1,21 @@
+import { randomUUID } from "node:crypto";
+import { useDB } from "../../../utils/db.js";
+import { privateData } from "../../../database/schema.js";
+export default defineEventHandler(async (event) => {
+  const participantId = getRouterParam(event, "id");
+  if (!participantId) {
+    throw createError({ statusCode: 400, statusMessage: "Missing participant id" });
+  }
+  const body = await readBody(event);
+  const db = useDB();
+  const id = randomUUID();
+  const now = /* @__PURE__ */ new Date();
+  await db.insert(privateData).values({
+    id,
+    participantId,
+    data: body.data || {},
+    createdAt: now,
+    updatedAt: now
+  });
+  return { id };
+});

package/dist/runtime/server/api/participants/[id].get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/participants/[id].get.js

@@ -0,0 +1,15 @@
+import { eq } from "drizzle-orm";
+import { useDB } from "../../utils/db.js";
+import { participants } from "../../database/schema.js";
+export default defineEventHandler(async (event) => {
+  const id = getRouterParam(event, "id");
+  if (!id) {
+    throw createError({ statusCode: 400, statusMessage: "Missing participant id" });
+  }
+  const db = useDB();
+  const row = await db.select().from(participants).where(eq(participants.id, id)).get();
+  if (!row) {
+    throw createError({ statusCode: 404, statusMessage: "Participant not found" });
+  }
+  return { data: row.data };
+});

package/dist/runtime/server/api/participants/[id].patch.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/participants/[id].patch.js

@@ -0,0 +1,20 @@
+import { eq } from "drizzle-orm";
+import { useDB } from "../../utils/db.js";
+import { participants } from "../../database/schema.js";
+export default defineEventHandler(async (event) => {
+  const id = getRouterParam(event, "id");
+  if (!id) {
+    throw createError({ statusCode: 400, statusMessage: "Missing participant id" });
+  }
+  const body = await readBody(event);
+  const db = useDB();
+  const existing = await db.select().from(participants).where(eq(participants.id, id)).get();
+  if (!existing) {
+    throw createError({ statusCode: 404, statusMessage: "Participant not found" });
+  }
+  await db.update(participants).set({
+    data: body.data,
+    updatedAt: /* @__PURE__ */ new Date()
+  }).where(eq(participants.id, id));
+  return { success: true };
+});

package/dist/runtime/server/api/participants/index.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/participants/index.post.js

@@ -0,0 +1,17 @@
+import { randomUUID } from "node:crypto";
+import { useDB } from "../../utils/db.js";
+import { participants } from "../../database/schema.js";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const db = useDB();
+  const id = randomUUID();
+  const now = /* @__PURE__ */ new Date();
+  await db.insert(participants).values({
+    id,
+    projectRef: body.projectRef || "unknown",
+    data: body.data || {},
+    createdAt: now,
+    updatedAt: now
+  });
+  return { id };
+});

package/dist/runtime/server/api/qr.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/qr.get.js

@@ -0,0 +1,19 @@
+import QRCode from "qrcode-svg";
+export default defineEventHandler((event) => {
+  const query = getQuery(event);
+  const requestUrl = getRequestURL(event);
+  let targetUrl = query.url || requestUrl.origin;
+  targetUrl = targetUrl.replace(/\/$/, "");
+  const qr = new QRCode({
+    content: targetUrl,
+    padding: 4,
+    width: 256,
+    height: 256,
+    color: "#000000",
+    background: "#ffffff",
+    ecl: "M"
+  });
+  setResponseHeader(event, "Content-Type", "image/svg+xml");
+  setResponseHeader(event, "Cache-Control", "public, max-age=86400");
+  return qr.svg();
+});

package/dist/runtime/server/database/schema.d.ts

@@ -0,0 +1,235 @@
+export declare const participants: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "participants";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "participants";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        projectRef: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "project_ref";
+            tableName: "participants";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        data: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "data";
+            tableName: "participants";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: unknown;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "participants";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "participants";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+export declare const privateData: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "private_data";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "private_data";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        participantId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "participant_id";
+            tableName: "private_data";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        data: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "data";
+            tableName: "private_data";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: unknown;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "private_data";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "private_data";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+export declare const devSessions: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "dev_sessions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "dev_sessions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        expiresAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "expires_at";
+            tableName: "dev_sessions";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;

package/dist/runtime/server/database/schema.js

@@ -0,0 +1,19 @@
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+export const participants = sqliteTable("participants", {
+  id: text("id").primaryKey(),
+  projectRef: text("project_ref").notNull(),
+  data: text("data", { mode: "json" }).notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+});
+export const privateData = sqliteTable("private_data", {
+  id: text("id").primaryKey(),
+  participantId: text("participant_id").notNull().references(() => participants.id),
+  data: text("data", { mode: "json" }).notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+});
+export const devSessions = sqliteTable("dev_sessions", {
+  id: text("id").primaryKey(),
+  expiresAt: integer("expires_at", { mode: "timestamp" }).notNull()
+});

package/dist/runtime/server/middleware/dev-auth.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/middleware/dev-auth.js

@@ -0,0 +1,32 @@
+import { eq } from "drizzle-orm";
+import { useDB } from "../utils/db.js";
+import { devSessions } from "../database/schema.js";
+export default defineEventHandler(async (event) => {
+  const path = getRequestURL(event).pathname;
+  const gated = path.startsWith("/dev/") || path === "/dev" || path.startsWith("/presentation/") || path === "/presentation" || path === "/info";
+  if (!gated) {
+    return;
+  }
+  if (path.startsWith("/api/auth")) {
+    return;
+  }
+  if (path === "/dev-login") {
+    return;
+  }
+  const config = useRuntimeConfig();
+  if (!config.smile?.devPassword) {
+    return;
+  }
+  if (import.meta.dev) {
+    return;
+  }
+  const token = getCookie(event, "smile_dev_session");
+  if (!token) {
+    return sendRedirect(event, "/dev-login");
+  }
+  const db = useDB();
+  const session = await db.select().from(devSessions).where(eq(devSessions.id, token)).get();
+  if (!session || session.expiresAt < /* @__PURE__ */ new Date()) {
+    return sendRedirect(event, "/dev-login");
+  }
+});

package/dist/runtime/server/plugins/migrate.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/plugins/migrate.js

@@ -0,0 +1,30 @@
+import { useDB } from "../utils/db.js";
+import { sql } from "drizzle-orm";
+export default defineNitroPlugin(async () => {
+  const db = useDB();
+  await db.run(sql`
+    CREATE TABLE IF NOT EXISTS participants (
+      id TEXT PRIMARY KEY,
+      project_ref TEXT NOT NULL,
+      data TEXT NOT NULL DEFAULT '{}',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  await db.run(sql`
+    CREATE TABLE IF NOT EXISTS private_data (
+      id TEXT PRIMARY KEY,
+      participant_id TEXT NOT NULL REFERENCES participants(id),
+      data TEXT NOT NULL DEFAULT '{}',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  await db.run(sql`
+    CREATE TABLE IF NOT EXISTS dev_sessions (
+      id TEXT PRIMARY KEY,
+      expires_at INTEGER NOT NULL
+    )
+  `);
+  console.log("[SMILE] Database tables initialized");
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

package/dist/runtime/server/utils/db.d.ts

@@ -0,0 +1,3 @@
+export declare function useDB(): import("drizzle-orm/libsql").LibSQLDatabase<Record<string, unknown>> & {
+    $client: import("@libsql/client").Client;
+};

package/dist/runtime/server/utils/db.js

@@ -0,0 +1,21 @@
+import { drizzle } from "drizzle-orm/libsql";
+import { createClient } from "@libsql/client";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import * as schema from "../database/schema.js";
+let _db = null;
+export function useDB() {
+  if (!_db) {
+    const url = process.env.TURSO_DATABASE_URL || "file:.data/experiment.db";
+    if (url.startsWith("file:")) {
+      const filePath = url.slice(5);
+      mkdirSync(dirname(filePath), { recursive: true });
+    }
+    const client = createClient({
+      url,
+      authToken: process.env.TURSO_AUTH_TOKEN
+    });
+    _db = drizzle(client, { schema });
+  }
+  return _db;
+}