Location Scout Sorter

Required key.

Add this in your Lovable project under Settings → Secrets before pasting the prompt below.

Paste into a fresh Lovable project. Make sure the key above is set first. read the build strategy →

Build "Location Scout Sorter" as a ONE-SHOT Lovable build (~5 credits, no follow-ups).
Single-page TanStack Start app, one route, cut scope ruthlessly.

THIS PROMPT IS SELF-CONTAINED
Do not assume the participant knows Jev or has read any other page. TypeSafe Jev is a decision model,
not a text generator. It receives `state` plus a map of typed `questions` and returns JSON that code can
use directly. Use Choice to select exactly one defined option, Noul for a yes/no probability from 0 to 1,
and Score for a probability-weighted position across ordered levels. Keep rules, thresholds, arithmetic,
and actions in code. Use a generative model only if the product separately needs prose.

CONCEPT
Paste location notes and rank candidate locations by scene fit, logistical ease, and visual potential using adjustable weights.
Discipline: Filmmaking & Animation (Location scouting).
Jev pattern: Score Ranker (graded ranking) — comparable Jev `score` questions per candidate on 3-4 named dimensions, normalised with score/(levels-1) and combined with user-controlled weights in code.
Why typed decisions: Consistent scores help production teams compare subjective visual appeal with concrete constraints.

ENGINE: TypeSafe Jev (typed decisions, not text)
- Before writing code, ask the participant for `TYPESAFE_API_KEY` with Lovable's secure secret form. Never
  ask them to paste it into chat, never prefix it with `VITE_`, and never expose it to browser code.
- Put the callable server function in `src/lib/jev.functions.ts`; do not import a server-only module from UI code.
- Validate the user's input before the handler and read `process.env['TYPESAFE_API_KEY']` inside the handler.
- From the server, call:
  POST https://api.typesafe.ai/v1/systemone
  Authorization: Bearer <TYPESAFE_API_KEY>, Content-Type: application/json
  body: { "model": "jev-latest", "state": <Scene needs, schedule constraints, location notes, and weights>, "questions": QUESTIONS }
- Ask all questions in ONE request (they run in parallel and cannot see each other).
- Read Choice from `answers[id].choice`, `.probabilities`, and `.confidence`; Score from `.score`,
  `.probabilities`, `.legend`, and `.confidence`; Noul from `.noul` only (it has no separate confidence).

SERVER IMPLEMENTATION (adapt the input name and result mapping to this concept)
```ts
import { createServerFn } from "@tanstack/react-start";
import { z } from "zod";

const Input = z.object({ text: z.string().trim().min(1).max(20000) });

export const decide = createServerFn({ method: "POST" })
  .inputValidator((input: unknown) => Input.parse(input))
  .handler(async ({ data }) => {
    const apiKey = process.env['TYPESAFE_API_KEY'];
    if (!apiKey) return { ok: false as const, status: 500, message: "TYPESAFE_API_KEY is not configured." };

    const requestBody = {
      model: "jev-latest",
      state: { text: data.text },
      questions: QUESTIONS,
    };

    let response: Response | undefined;
    for (let attempt = 0; attempt < 3; attempt += 1) {
      response = await fetch("https://api.typesafe.ai/v1/systemone", {
        method: "POST",
        headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
        body: JSON.stringify(requestBody),
      });
      if (response.ok || (response.status !== 429 && response.status < 500)) break;
      if (attempt < 2) await new Promise((resolve) => setTimeout(resolve, 750 * 2 ** attempt));
    }

    if (!response) return { ok: false as const, status: 503, message: "Jev did not respond." };
    if (!response.ok) {
      const message = (await response.text()).slice(0, 500) || `Jev request failed (${response.status}).`;
      return { ok: false as const, status: response.status, message };
    }
    const result = await response.json();
    return { ok: true as const, answers: result.answers };
  });
```

In the page component, call `decide` with `useServerFn`, preserve the participant's input while loading or
on error, disable duplicate submissions, and render the returned typed values rather than parsing prose.

QUESTIONS (start here, refine wording if needed)
{
  "scene_fit": {
    "type": "score",
    "instructions": "How well does this location match the scene's dramatic and visual needs?",
    "criteria": [
      "Poor match",
      "Limited match",
      "Good match",
      "Ideal match"
    ]
  },
  "logistical_ease": {
    "type": "score",
    "instructions": "How manageable is this location under the stated production logistics?",
    "criteria": [
      "Severe barriers",
      "Significant complications",
      "Manageable with planning",
      "Straightforward access and use"
    ]
  },
  "visual_potential": {
    "type": "score",
    "instructions": "How much useful composition and lighting potential does it offer?",
    "criteria": [
      "Very little",
      "Limited",
      "Strong options",
      "Exceptional variety"
    ]
  }
}

DECISION RULES (in code, not in the model)
- choice/score: if confidence < 0.6 show a "needs review" badge instead of acting.
- noul: >= 0.75 = yes, <= 0.25 = no, otherwise "review".
- score: normalise with score / (levels - 1) before combining with weights.
- Missing or malformed answers go to review. Show safe HTTP status and message in the UI. Retry only 429/5xx,
  at most twice with increasing delay; never retry 400/401/402/403/404 and never invent results.
- If the product needs prose (a summary, a message), use Lovable AI for that text only; Jev makes the decisions.

UI
a ranked list with weight sliders that re-rank instantly without calling Jev again. Include 2 sample inputs as one-click chips so the demo works instantly.
Tailwind + shadcn, editorial look, footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

NO database, NO auth, NO extra pages, NO tests.

BEFORE YOU FINISH
- Run the app and test both sample inputs through the real server function.
- Confirm the browser receives no API key and no fabricated fallback result.
- Confirm Choice/Score confidence and Noul probability drive the stated review rules.
- Confirm loading, success, review, empty-input, and service-error states are readable on mobile.

Reference only if needed: https://docs.typesafe.ai/api and https://docs.typesafe.ai/primitives

Market sizing.

Indicative figures for hackathon pitches — refine with your own research before raising.