export function visitorOpensSite(page: Page) {
  const session = page.session ?? newSession();
  widget.mount(page.root, { session });
  return session;
}

const snap = (from: Pin, to: Pin) => {
  if (fits(from, to)) return seal(from, to);
  if (bridgeable(from, to)) return amberSeam(from, to);
  return bounce(to, 28);
};

export function visitorOpensSite(page: Page) {
  const session = page.session ?? newSession();
  widget.mount(page.root, { session });
  return session;
}

const snap = (from: Pin, to: Pin) => {
  if (fits(from, to)) return seal(from, to);
  if (bridgeable(from, to)) return amberSeam(from, to);
  return bounce(to, 28);
};

export function visitorOpensSite(page: Page) {
  const session = page.session ?? newSession();
  widget.mount(page.root, { session });
  return session;
}

const snap = (from: Pin, to: Pin) => {
  if (fits(from, to)) return seal(from, to);
  if (bridgeable(from, to)) return amberSeam(from, to);
  return bounce(to, 28);
};

export function visitorOpensSite(page: Page) {
  const session = page.session ?? newSession();
  widget.mount(page.root, { session });
  return session;
}

const snap = (from: Pin, to: Pin) => {
  if (fits(from, to)) return seal(from, to);
  if (bridgeable(from, to)) return amberSeam(from, to);
  return bounce(to, 28);
};

export function visitorOpensSite(page: Page) {
  const session = page.session ?? newSession();
  widget.mount(page.root, { session });
  return session;
}

const snap = (from: Pin, to: Pin) => {
  if (fits(from, to)) return seal(from, to);
  if (bridgeable(from, to)) return amberSeam(from, to);
  return bounce(to, 28);
};

export function visitorOpensSite(page: Page) {
  const session = page.session ?? newSession();
  widget.mount(page.root, { session });
  return session;
}

const snap = (from: Pin, to: Pin) => {
  if (fits(from, to)) return seal(from, to);
  if (bridgeable(from, to)) return amberSeam(from, to);
  return bounce(to, 28);
};

export function visitorOpensSite(page: Page) {
  const session = page.session ?? newSession();
  widget.mount(page.root, { session });
  return session;
}

const snap = (from: Pin, to: Pin) => {
  if (fits(from, to)) return seal(from, to);
  if (bridgeable(from, to)) return amberSeam(from, to);
  return bounce(to, 28);
};

export function visitorOpensSite(page: Page) {
  const session = page.session ?? newSession();
  widget.mount(page.root, { session });
  return session;
}

const snap = (from: Pin, to: Pin) => {
  if (fits(from, to)) return seal(from, to);
  if (bridgeable(from, to)) return amberSeam(from, to);
  return bounce(to, 28);
};

export function visitorOpensSite(page: Page) {
  const session = page.session ?? newSession();
  widget.mount(page.root, { session });
  return session;
}

const snap = (from: Pin, to: Pin) => {
  if (fits(from, to)) return seal(from, to);
  if (bridgeable(from, to)) return amberSeam(from, to);
  return bounce(to, 28);
};

export function visitorOpensSite(page: Page) {
  const session = page.session ?? newSession();
  widget.mount(page.root, { session });
  return session;
}

const snap = (from: Pin, to: Pin) => {
  if (fits(from, to)) return seal(from, to);
  if (bridgeable(from, to)) return amberSeam(from, to);
  return bounce(to, 28);
};

export function visitorOpensSite(page: Page) {
  const session = page.session ?? newSession();
  widget.mount(page.root, { session });
  return session;
}

const snap = (from: Pin, to: Pin) => {
  if (fits(from, to)) return seal(from, to);
  if (bridgeable(from, to)) return amberSeam(from, to);
  return bounce(to, 28);
};

export function visitorOpensSite(page: Page) {
  const session = page.session ?? newSession();
  widget.mount(page.root, { session });
  return session;
}

const snap = (from: Pin, to: Pin) => {
  if (fits(from, to)) return seal(from, to);
  if (bridgeable(from, to)) return amberSeam(from, to);
  return bounce(to, 28);
};

const ChatWidget = ({ session }: Props) => {
  const [turns, setTurns] = useState<Turn[]>([]);
  const send = async (text: string) => {
    const reply = await gemini.reply(session, text);
    setTurns((all) => [...all, reply]);
  };
  return <Panel turns={turns} onSend={send} />;
};

export const Turn = z.object({
  role: z.enum(['visitor', 'sparc']),
  text: z.string().max(4000),
});

const ChatWidget = ({ session }: Props) => {
  const [turns, setTurns] = useState<Turn[]>([]);
  const send = async (text: string) => {
    const reply = await gemini.reply(session, text);
    setTurns((all) => [...all, reply]);
  };
  return <Panel turns={turns} onSend={send} />;
};

export const Turn = z.object({
  role: z.enum(['visitor', 'sparc']),
  text: z.string().max(4000),
});

const ChatWidget = ({ session }: Props) => {
  const [turns, setTurns] = useState<Turn[]>([]);
  const send = async (text: string) => {
    const reply = await gemini.reply(session, text);
    setTurns((all) => [...all, reply]);
  };
  return <Panel turns={turns} onSend={send} />;
};

export const Turn = z.object({
  role: z.enum(['visitor', 'sparc']),
  text: z.string().max(4000),
});

const ChatWidget = ({ session }: Props) => {
  const [turns, setTurns] = useState<Turn[]>([]);
  const send = async (text: string) => {
    const reply = await gemini.reply(session, text);
    setTurns((all) => [...all, reply]);
  };
  return <Panel turns={turns} onSend={send} />;
};

export const Turn = z.object({
  role: z.enum(['visitor', 'sparc']),
  text: z.string().max(4000),
});

const ChatWidget = ({ session }: Props) => {
  const [turns, setTurns] = useState<Turn[]>([]);
  const send = async (text: string) => {
    const reply = await gemini.reply(session, text);
    setTurns((all) => [...all, reply]);
  };
  return <Panel turns={turns} onSend={send} />;
};

export const Turn = z.object({
  role: z.enum(['visitor', 'sparc']),
  text: z.string().max(4000),
});

const ChatWidget = ({ session }: Props) => {
  const [turns, setTurns] = useState<Turn[]>([]);
  const send = async (text: string) => {
    const reply = await gemini.reply(session, text);
    setTurns((all) => [...all, reply]);
  };
  return <Panel turns={turns} onSend={send} />;
};

export const Turn = z.object({
  role: z.enum(['visitor', 'sparc']),
  text: z.string().max(4000),
});

const ChatWidget = ({ session }: Props) => {
  const [turns, setTurns] = useState<Turn[]>([]);
  const send = async (text: string) => {
    const reply = await gemini.reply(session, text);
    setTurns((all) => [...all, reply]);
  };
  return <Panel turns={turns} onSend={send} />;
};

export const Turn = z.object({
  role: z.enum(['visitor', 'sparc']),
  text: z.string().max(4000),
});

const ChatWidget = ({ session }: Props) => {
  const [turns, setTurns] = useState<Turn[]>([]);
  const send = async (text: string) => {
    const reply = await gemini.reply(session, text);
    setTurns((all) => [...all, reply]);
  };
  return <Panel turns={turns} onSend={send} />;
};

export const Turn = z.object({
  role: z.enum(['visitor', 'sparc']),
  text: z.string().max(4000),
});

const ChatWidget = ({ session }: Props) => {
  const [turns, setTurns] = useState<Turn[]>([]);
  const send = async (text: string) => {
    const reply = await gemini.reply(session, text);
    setTurns((all) => [...all, reply]);
  };
  return <Panel turns={turns} onSend={send} />;
};

export const Turn = z.object({
  role: z.enum(['visitor', 'sparc']),
  text: z.string().max(4000),
});

const ChatWidget = ({ session }: Props) => {
  const [turns, setTurns] = useState<Turn[]>([]);
  const send = async (text: string) => {
    const reply = await gemini.reply(session, text);
    setTurns((all) => [...all, reply]);
  };
  return <Panel turns={turns} onSend={send} />;
};

export const Turn = z.object({
  role: z.enum(['visitor', 'sparc']),
  text: z.string().max(4000),
});

const ChatWidget = ({ session }: Props) => {
  const [turns, setTurns] = useState<Turn[]>([]);
  const send = async (text: string) => {
    const reply = await gemini.reply(session, text);
    setTurns((all) => [...all, reply]);
  };
  return <Panel turns={turns} onSend={send} />;
};

export const Turn = z.object({
  role: z.enum(['visitor', 'sparc']),
  text: z.string().max(4000),
});

const ChatWidget = ({ session }: Props) => {
  const [turns, setTurns] = useState<Turn[]>([]);
  const send = async (text: string) => {
    const reply = await gemini.reply(session, text);
    setTurns((all) => [...all, reply]);
  };
  return <Panel turns={turns} onSend={send} />;
};

export const Turn = z.object({
  role: z.enum(['visitor', 'sparc']),
  text: z.string().max(4000),
});

export async function geminiReply(input: Turn[]) {
  const stream = await client.generate({
    model: routeModel(input),
    contents: input,
  });
  for await (const chunk of stream) yield chunk.text;
}

function hasCycle(graph: Graph): boolean {
  const seen = new Set<string>();
  return graph.nodes.some((node) => walk(node, seen));
}

export async function geminiReply(input: Turn[]) {
  const stream = await client.generate({
    model: routeModel(input),
    contents: input,
  });
  for await (const chunk of stream) yield chunk.text;
}

function hasCycle(graph: Graph): boolean {
  const seen = new Set<string>();
  return graph.nodes.some((node) => walk(node, seen));
}

export async function geminiReply(input: Turn[]) {
  const stream = await client.generate({
    model: routeModel(input),
    contents: input,
  });
  for await (const chunk of stream) yield chunk.text;
}

function hasCycle(graph: Graph): boolean {
  const seen = new Set<string>();
  return graph.nodes.some((node) => walk(node, seen));
}

export async function geminiReply(input: Turn[]) {
  const stream = await client.generate({
    model: routeModel(input),
    contents: input,
  });
  for await (const chunk of stream) yield chunk.text;
}

function hasCycle(graph: Graph): boolean {
  const seen = new Set<string>();
  return graph.nodes.some((node) => walk(node, seen));
}

export async function geminiReply(input: Turn[]) {
  const stream = await client.generate({
    model: routeModel(input),
    contents: input,
  });
  for await (const chunk of stream) yield chunk.text;
}

function hasCycle(graph: Graph): boolean {
  const seen = new Set<string>();
  return graph.nodes.some((node) => walk(node, seen));
}

export async function geminiReply(input: Turn[]) {
  const stream = await client.generate({
    model: routeModel(input),
    contents: input,
  });
  for await (const chunk of stream) yield chunk.text;
}

function hasCycle(graph: Graph): boolean {
  const seen = new Set<string>();
  return graph.nodes.some((node) => walk(node, seen));
}

export async function geminiReply(input: Turn[]) {
  const stream = await client.generate({
    model: routeModel(input),
    contents: input,
  });
  for await (const chunk of stream) yield chunk.text;
}

function hasCycle(graph: Graph): boolean {
  const seen = new Set<string>();
  return graph.nodes.some((node) => walk(node, seen));
}

export async function geminiReply(input: Turn[]) {
  const stream = await client.generate({
    model: routeModel(input),
    contents: input,
  });
  for await (const chunk of stream) yield chunk.text;
}

function hasCycle(graph: Graph): boolean {
  const seen = new Set<string>();
  return graph.nodes.some((node) => walk(node, seen));
}

export async function geminiReply(input: Turn[]) {
  const stream = await client.generate({
    model: routeModel(input),
    contents: input,
  });
  for await (const chunk of stream) yield chunk.text;
}

function hasCycle(graph: Graph): boolean {
  const seen = new Set<string>();
  return graph.nodes.some((node) => walk(node, seen));
}

export async function geminiReply(input: Turn[]) {
  const stream = await client.generate({
    model: routeModel(input),
    contents: input,
  });
  for await (const chunk of stream) yield chunk.text;
}

function hasCycle(graph: Graph): boolean {
  const seen = new Set<string>();
  return graph.nodes.some((node) => walk(node, seen));
}

export async function geminiReply(input: Turn[]) {
  const stream = await client.generate({
    model: routeModel(input),
    contents: input,
  });
  for await (const chunk of stream) yield chunk.text;
}

function hasCycle(graph: Graph): boolean {
  const seen = new Set<string>();
  return graph.nodes.some((node) => walk(node, seen));
}

export async function geminiReply(input: Turn[]) {
  const stream = await client.generate({
    model: routeModel(input),
    contents: input,
  });
  for await (const chunk of stream) yield chunk.text;
}

function hasCycle(graph: Graph): boolean {
  const seen = new Set<string>();
  return graph.nodes.some((node) => walk(node, seen));
}

CREATE TABLE memory (
  session_id TEXT NOT NULL,
  turn INTEGER NOT NULL,
  body TEXT NOT NULL,
  PRIMARY KEY (session_id, turn)
);

export const remaining = (week: Week) =>
  Math.max(0, 100 - (week.used / week.tank) * 100);

export function refund(event: CapacityEvent) {
  week.used -= event.cost;
}

CREATE TABLE memory (
  session_id TEXT NOT NULL,
  turn INTEGER NOT NULL,
  body TEXT NOT NULL,
  PRIMARY KEY (session_id, turn)
);

export const remaining = (week: Week) =>
  Math.max(0, 100 - (week.used / week.tank) * 100);

export function refund(event: CapacityEvent) {
  week.used -= event.cost;
}

CREATE TABLE memory (
  session_id TEXT NOT NULL,
  turn INTEGER NOT NULL,
  body TEXT NOT NULL,
  PRIMARY KEY (session_id, turn)
);

export const remaining = (week: Week) =>
  Math.max(0, 100 - (week.used / week.tank) * 100);

export function refund(event: CapacityEvent) {
  week.used -= event.cost;
}

CREATE TABLE memory (
  session_id TEXT NOT NULL,
  turn INTEGER NOT NULL,
  body TEXT NOT NULL,
  PRIMARY KEY (session_id, turn)
);

export const remaining = (week: Week) =>
  Math.max(0, 100 - (week.used / week.tank) * 100);

export function refund(event: CapacityEvent) {
  week.used -= event.cost;
}

CREATE TABLE memory (
  session_id TEXT NOT NULL,
  turn INTEGER NOT NULL,
  body TEXT NOT NULL,
  PRIMARY KEY (session_id, turn)
);

export const remaining = (week: Week) =>
  Math.max(0, 100 - (week.used / week.tank) * 100);

export function refund(event: CapacityEvent) {
  week.used -= event.cost;
}

CREATE TABLE memory (
  session_id TEXT NOT NULL,
  turn INTEGER NOT NULL,
  body TEXT NOT NULL,
  PRIMARY KEY (session_id, turn)
);

export const remaining = (week: Week) =>
  Math.max(0, 100 - (week.used / week.tank) * 100);

export function refund(event: CapacityEvent) {
  week.used -= event.cost;
}

CREATE TABLE memory (
  session_id TEXT NOT NULL,
  turn INTEGER NOT NULL,
  body TEXT NOT NULL,
  PRIMARY KEY (session_id, turn)
);

export const remaining = (week: Week) =>
  Math.max(0, 100 - (week.used / week.tank) * 100);

export function refund(event: CapacityEvent) {
  week.used -= event.cost;
}

CREATE TABLE memory (
  session_id TEXT NOT NULL,
  turn INTEGER NOT NULL,
  body TEXT NOT NULL,
  PRIMARY KEY (session_id, turn)
);

export const remaining = (week: Week) =>
  Math.max(0, 100 - (week.used / week.tank) * 100);

export function refund(event: CapacityEvent) {
  week.used -= event.cost;
}

CREATE TABLE memory (
  session_id TEXT NOT NULL,
  turn INTEGER NOT NULL,
  body TEXT NOT NULL,
  PRIMARY KEY (session_id, turn)
);

export const remaining = (week: Week) =>
  Math.max(0, 100 - (week.used / week.tank) * 100);

export function refund(event: CapacityEvent) {
  week.used -= event.cost;
}

CREATE TABLE memory (
  session_id TEXT NOT NULL,
  turn INTEGER NOT NULL,
  body TEXT NOT NULL,
  PRIMARY KEY (session_id, turn)
);

export const remaining = (week: Week) =>
  Math.max(0, 100 - (week.used / week.tank) * 100);

export function refund(event: CapacityEvent) {
  week.used -= event.cost;
}

CREATE TABLE memory (
  session_id TEXT NOT NULL,
  turn INTEGER NOT NULL,
  body TEXT NOT NULL,
  PRIMARY KEY (session_id, turn)
);

export const remaining = (week: Week) =>
  Math.max(0, 100 - (week.used / week.tank) * 100);

export function refund(event: CapacityEvent) {
  week.used -= event.cost;
}

CREATE TABLE memory (
  session_id TEXT NOT NULL,
  turn INTEGER NOT NULL,
  body TEXT NOT NULL,
  PRIMARY KEY (session_id, turn)
);

export const remaining = (week: Week) =>
  Math.max(0, 100 - (week.used / week.tank) * 100);

export function refund(event: CapacityEvent) {
  week.used -= event.cost;
}