dineway 0.1.30 → 0.1.31

package/README.md

@@ -1,287 +1,454 @@
-# Dineway
+# Dineway — Build Your Restaurant Website with AI
 
-The Agentic Website builder for restaurants and local businesses. Dineway combines structured content modeling with the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) to create intelligent, AI-powered sites that don't just display information — they understand your menus, manage your reputation, execute marketing, and act on behalf of the restaurant owner.
+Dineway is the **Agentic Website builder** for restaurants and local businesses. You don't need to write code. Just tell an AI agent your restaurant name and city, and it builds a professional website — with menus, blog, reviews, gallery, and local SEO — automatically.
 
-The core thesis: A restaurant's website should not be a brochure. It should be an employee — they understand it, act on it, and improve autonomously.
+> **How it works:** You paste this guide into an AI agent (Codex, Claude, OpenClaw, or similar). The agent reads it, installs the tools, and builds your site end-to-end. You review, approve, and publish.
 
-## Overview
+---
 
-Dineway is an [Astro](https://astro.build) integration that gives your site a full content engine, admin panel, built-in MCP server, and plugin system. It runs on Node.js with SQLite/libSQL (or PostgreSQL), deploys anywhere with a single command, and stores all schema in the database — not in code.
+## What You Get
 
-### Architecture
+| Feature | Description |
+| --- | --- |
+| 🍽️ **Restaurant Website** | A polished, mobile-first site built from your real business data — hours, location, reviews, photos |
+| 📝 **Blog & News** | Articles derived from real customer reviews and restaurant updates |
+| 🍕 **Menu Display** | Structured menu with items, prices, descriptions, and photos |
+| ⭐ **Reviews Showcase** | Curated real reviews that highlight your restaurant's character |
+| 🖼️ **Photo Gallery** | A CMS-managed gallery with your best images |
+| 🔍 **Local SEO** | JSON-LD structured data, meta tags, and local business schema — all automatic |
+| 🛠️ **Admin Panel** | A visual dashboard to edit content, manage media, and publish changes |
+| 🤖 **AI-Powered** | 50+ MCP tools let AI agents manage content, menus, and marketing on your behalf |
 
-```
-┌──────────────────────────────────────────────────────────────────┐
-│                       Your Restaurant Site                       │
-│                                                                  │
-│   Astro Framework (Live Collections · Sessions · Middleware)     │
-│                                                                  │
-│  ┌────────────┐  ┌────────────┐  ┌────────────┐  ┌───────────┐  │
-│  │  Content   │  │   Admin    │  │    MCP     │  │  Plugins  │  │
-│  │  Engine    │  │   Panel    │  │   Server   │  │           │  │
-│  └────────────┘  └────────────┘  └────────────┘  └───────────┘  │
-│  ┌────────────┐  ┌────────────┐  ┌────────────┐  ┌───────────┐  │
-│  │ Site       │  │  Entity    │  │   HITL     │  │   CLI     │  │
-│  │ Context    │  │ Resolution │  │  Reviews   │  │           │  │
-│  └────────────┘  └────────────┘  └────────────┘  └───────────┘  │
-│                                                                  │
-│  Data Layer: SQLite / libSQL / PostgreSQL ←→ Local / S3 Storage  │
-└──────────────────────────────────────────────────────────────────┘
-```
+---
 
-### Core Capabilities
+## Before You Start
 
-| Category                | What It Does                                                                                                 |
-| ----------------------- | ------------------------------------------------------------------------------------------------------------ |
-| **MCP Server**          | 50+ tools for AI agents to interact with content, schema, media, search, taxonomies, menus, and site context |
-| **Site Context Engine** | Versioned operational knowledge (brand voice, seasonal strategy, policies) — agents consult before acting    |
-| **Content Engine**      | Structured collections with typed fields, revisions, drafts, scheduled publishing, and full-text search      |
-| **Entity Resolution**   | Natural-language references ("the spring lamb special") resolve to exact content items                       |
-| **Human-in-the-Loop**   | Review requests ensure AI-generated changes get human approval before going live                             |
-| **Admin Panel**         | Visual schema builder, rich text editor (TipTap/Portable Text), media library, menu builder                  |
-| **Plugin System**       | Lifecycle hooks, KV storage, settings, admin pages, dashboard widgets, custom block types                    |
-| **CLI**                 | Programmatic site management for content, schema, media, deployment — designed for both humans and AI agents |
+### What You Need
 
-## Installation
+1. **Node.js 22 or later** — [download here](https://nodejs.org/)
+2. **An AI agent environment** — any of these:
+   - [OpenAI Codex](https://openai.com/codex)
+   - [Claude Code](https://claude.ai)
+   - [OpenClaw](https://openclaw.dev)
+   - Any agent that supports skill packs
+3. **Your restaurant info** — name and city (that's it!)
 
-```shell
-npm create dineway@latest
-```
+### Check Node.js
 
-Or add to an existing Astro project:
+Open a terminal and run:
 
-```shell
-npm install dineway
+```bash
+node --version
+# Should print v22.x.x or higher
 ```
 
-## Agent Skills
+If you don't have Node.js, download it from [nodejs.org](https://nodejs.org/) and install it first.
 
-Dineway also publishes an agent skill pack for designing, building, and publishing AI-ready restaurant sites. The skills guide agents through place-data enrichment, restaurant information architecture, visual design, Dineway CMS schema and seed content, media upload, local SEO, and deployment.
+---
 
-Install the skill pack with `npx skills`:
+## Step 1 — Install Dineway Skills
+
+Dineway Skills are instruction packs that teach your AI agent how to build restaurant websites. Install them with one command:
 
 ```bash
 npx skills add https://github.com/dineway/dineway-skills
 ```
 
-For a full restaurant build, invoke the restaurant-site skill with a restaurant name and city:
+This installs the following skills into your project:
 
-```text
-Use building-restaurant-site to build an AI-ready Dineway restaurant site for "Restaurant Name" in "City, Country".
-```
+| Skill | What It Does |
+| --- | --- |
+| `building-restaurant-site` | End-to-end restaurant site creation from real place data |
+| `building-dineway-site` | General Dineway site building patterns |
+| `dineway-cli` | CLI commands for managing content, schema, media, and deployment |
+| `enrich-place-details` | Fetches your restaurant's real data (hours, reviews, photos, location) |
+| `frontend-design` | Creates distinctive, production-grade visual design |
+| `brainstorming` | Explores design and architecture options before building |
 
-For an existing Dineway project, use the CLI skill to manage schema, content, media, generated types, and deployment:
+---
 
-```text
-Use dineway-cli to seed content, generate types, upload media, and deploy this Dineway site.
-```
+## Step 2 — Create Your Restaurant Site
+
+### Option A: Tell the Agent (Recommended)
 
-## CLI
+Paste this into your AI agent's input:
 
-The Dineway CLI (`dineway`) manages projects and instances. Commands fall into three categories:
+```text
+Use building-restaurant-site to build an AI-ready Dineway restaurant site for "YOUR RESTAURANT NAME" in "YOUR CITY, COUNTRY".
+```
 
-- **Local commands** — work directly on local project files or a SQLite file, no running server needed: `init`, `dev`, `seed`, `export-seed`, `auth secret`, `secrets generate`, `secrets fingerprint`
-- **Deployment commands** — orchestrate platform CLIs or generate provider files: `deploy`
-- **Remote commands** — talk to a running Dineway instance via HTTP: `types`, `login`, `logout`, `whoami`, `content`, `schema`, `media`, `search`, `taxonomy`, `menu`
+Replace with your real restaurant name and city. Examples:
 
-### Authentication
+```text
+Use building-restaurant-site to build an AI-ready Dineway restaurant site for "Peace Harmony" in "Sydney, Australia".
+```
 
-Remote commands resolve auth automatically in this order:
+```text
+Use building-restaurant-site to build an AI-ready Dineway restaurant site for "La Maison Rouge" in "Paris, France".
+```
 
-1. `--token` flag
-2. `DINEWAY_TOKEN` env var
-3. Stored credentials from `dineway login`
-4. Dev bypass (localhost only — no token needed)
+The agent will automatically:
 
-For local dev servers, just run the command — auth is handled automatically. For remote instances, run `dineway login --url https://my-site.example.com` first.
+1. Search for your restaurant and fetch real business data (hours, reviews, photos, location)
+2. Download and curate the best photos
+3. Design an information architecture with Blog, News, Menu, Reviews, and Gallery
+4. Build a polished Astro website with local SEO and JSON-LD
+5. Create the Dineway CMS schema and seed content
+6. Start a local dev server for you to preview
 
-## Quick Start
+### Option B: Manual Project Creation
 
-### Create and Run
+If you prefer to start with a blank project and build it yourself:
 
 ```bash
-# Create a new Dineway site
+# Create a new Dineway project
 npm create dineway@latest my-restaurant
+
+# Enter the project directory
 cd my-restaurant
+
+# Install dependencies
 npm install
 
-# Start the dev server (runs migrations automatically)
+# Start the dev server
 npx dineway dev
-
-# Open the admin panel at http://localhost:4321/_dineway/admin
-# Complete the Setup Wizard to create your first admin account
 ```
 
-### Seed a Site
+The dev server starts at `http://localhost:4321`. The admin panel is at `http://localhost:4321/_dineway/admin`.
+
+---
+
+## Step 3 — Preview Your Site
+
+Once the agent finishes building (or you've started the dev server manually), open your browser:
+
+- **Your site:** `http://localhost:4321`
+- **Admin panel:** `http://localhost:4321/_dineway/admin`
+
+On your first visit to the admin panel, the Setup Wizard runs automatically — it creates the database and prompts you to create your admin account.
+
+### Create Your Admin Account
 
-Apply a seed file to bootstrap collections, menus, taxonomies, and content:
+1. Open `http://localhost:4321/_dineway/admin`
+2. The Setup Wizard appears on first visit
+3. Enter your email and display name
+4. Register a passkey (fingerprint, Face ID, or security key)
+5. You're now the site administrator
+
+> **Tip:** In dev mode, you can skip passkey setup by visiting:
+> `http://localhost:4321/_dineway/api/setup/dev-bypass?redirect=/_dineway/admin`
+
+---
+
+## Step 4 — Manage Content with Dineway CLI
+
+The Dineway CLI is your command-line tool for managing everything about your site. The AI agent uses it automatically, but you can also use it directly.
+
+### Seed Your Site with Content
+
+If you have a seed file (the agent creates one automatically):
 
 ```bash
-npx dineway seed .dineway/seed.json
+npx dineway seed seed/seed.json
 ```
 
-Export the current database as a reusable seed:
+### Manage Menu Items
 
 ```bash
-npx dineway export-seed > seed.json
-npx dineway export-seed --with-content > seed-with-content.json
+# List all menu items
+npx dineway content list menu-items
+
+# Add a new menu item
+npx dineway content create menu-items --data '{
+  "title": "Grilled Salmon",
+  "description": "Atlantic salmon with seasonal vegetables",
+  "price": 28.50
+}'
+
+# Update a menu item (use the ID from a prior list/get)
+npx dineway content get menu-items grilled-salmon
+npx dineway content update menu-items 01ABC123 --rev MToyMDI2... --data '{"price": 32.00}'
 ```
 
-### Manage Content via CLI
-
-The CLI is designed for both humans and AI agents. Create and update auto-publish by default for immediate read-after-write consistency.
+### Manage Blog Posts
 
 ```bash
-# List content
+# List posts
 npx dineway content list posts
-npx dineway content list posts --status published --limit 10
 
-# Get a single item (Portable Text fields converted to markdown)
-npx dineway content get posts my-post-slug
+# Create a new blog post
+npx dineway content create posts --data '{
+  "title": "Spring Menu Now Available",
+  "content": "# Fresh Flavors for the Season\n\nWe are excited to announce our new spring menu..."
+}'
+```
 
-# Create content (auto-publishes by default)
-npx dineway content create posts --data '{"title": "Spring Menu", "content": "# New Dishes"}'
-npx dineway content create posts --file post.json --slug spring-menu
+### Upload Photos
 
-# Update content (requires --rev from a prior get)
-npx dineway content update posts 01ABC123 --rev MToyMDI2... --data '{"title": "Updated"}'
+```bash
+# Upload a dish photo
+npx dineway media upload ./dish-photo.jpg --alt "Grilled salmon plate" --caption "Our signature dish"
 
-# Lifecycle
-npx dineway content publish posts 01ABC123
-npx dineway content unpublish posts 01ABC123
-npx dineway content schedule posts 01ABC123 --at 2026-03-01T09:00:00Z
+# List all media
+npx dineway media list
 ```
 
-### Manage Schema
+### Manage Schema (Collections & Fields)
 
 ```bash
-# List collections
+# List all collections
 npx dineway schema list
 
-# Create a collection
-npx dineway schema create menu-items --label "Menu Items"
+# Add a field to menu items
+npx dineway schema add-field menu-items calories --type integer --label "Calories"
 
-# Add fields
-npx dineway schema add-field menu-items price --type number --required
-npx dineway schema add-field menu-items description --type text --label "Description"
-npx dineway schema add-field menu-items photo --type image
+# Create a new collection
+npx dineway schema create specials --label "Daily Specials"
 ```
 
-Field types: `string`, `text`, `number`, `integer`, `boolean`, `datetime`, `image`, `reference`, `portableText`, `json`.
+### Search Content
+
+```bash
+npx dineway search "salmon" --collection menu-items
+```
 
-### Media, Search, Taxonomies, and Menus
+### Generate TypeScript Types
 
 ```bash
-# Upload media
-npx dineway media upload ./dish-photo.jpg --alt "Grilled lamb" --caption "Spring special"
+npx dineway types
+```
 
-# Search content
-npx dineway search "lamb" --collection menu-items --limit 5
+> **For agents:** All CLI commands support `--json` for machine-readable output. It's auto-enabled when stdout is piped:
+> ```bash
+> npx dineway content list posts --json | jq '.items[].slug'
+> ```
 
-# Manage taxonomies
-npx dineway taxonomy list
-npx dineway taxonomy add-term categories --name "Seasonal" --slug seasonal
+---
 
-# View menus
-npx dineway menu list
-npx dineway menu get primary
-```
+## Step 5 — Deploy Your Site
 
-### Generate TypeScript Types
+When you're happy with your site, deploy it live with one command.
+
+### Deploy to Forgeway (Recommended)
+
+Forgeway is Dineway's first-party hosting platform. It's the simplest way to go live:
 
 ```bash
-npx dineway types
+npx dineway deploy forgeway
 ```
 
-Writes `.dineway/types.ts` and `.dineway/schema.json` for full type safety in your Astro pages.
+What happens:
+
+1. You verify your email address (Dineway account)
+2. The site is built and deployed
+3. You receive a **one-time setup link** to create your admin account on the live site
+4. `DINEWAY_SITE_URL` and `DINEWAY_TOKEN` are saved to your project `.env` automatically
+5. Follow-up CLI commands (like `npx dineway whoami`) work automatically
 
-### Deploy
+> **Important:** Open the setup link in your browser immediately. It lets you register a passkey for your admin account on the live site.
 
-One-command deployment to any Node.js host:
+If you lose the setup link, regenerate it:
 
 ```bash
-npx dineway@latest deploy            # default deploy to dineway platform (no setup required)
-npx dineway@latest deploy railway    # generates railway.json, runs railway up
-npx dineway@latest deploy docker     # generates Dockerfile + .dockerignore
-npx dineway@latest deploy fly        # generates Fly config, runs fly deploy
-npx dineway@latest deploy gcp        # experimental: gcloud run deploy
+npx dineway auth setup-link
 ```
 
-### JSON Output
+### Deploy to Other Platforms
+
+```bash
+npx dineway deploy railway    # Railway — generates config and deploys
+npx dineway deploy docker     # Docker — generates Dockerfile
+npx dineway deploy fly        # Fly.io — generates config and deploys
+npx dineway deploy gcp        # Google Cloud Run (experimental)
+```
 
-All CLI commands support `--json` for machine-readable output. Auto-enabled when stdout is piped:
+### After Deployment
+
+Once deployed, manage your live site remotely:
 
 ```bash
-npx dineway content list posts --json | jq '.items[].slug'
-ID=$(npx dineway content create posts --data '{"title":"Hello"}' --json | jq -r '.id')
+# Log in to your live site
+npx dineway login --url https://your-site.example.com
+
+# Check who you're logged in as
+npx dineway whoami
+
+# Manage content remotely
+npx dineway content list posts --url https://your-site.example.com
 ```
 
-## Astro Configuration
-
-```typescript
-// astro.config.mjs
-import { defineConfig } from "astro/config";
-import dineway, { local } from "dineway/astro";
-import { sqlite } from "dineway/db";
-
-export default defineConfig({
-	integrations: [
-		dineway({
-			database: sqlite({ url: "file:./data.db" }),
-			storage: local({
-				directory: "./uploads",
-				baseUrl: "/_dineway/api/media/file",
-			}),
-		}),
-	],
-});
+---
+
+## Step 6 — Ongoing Management with AI
+
+After your site is live, continue using your AI agent for ongoing tasks:
+
+```text
+Use dineway-cli to create a new blog post about our weekend brunch special.
 ```
 
-```typescript
-// src/live.config.ts
-import { defineLiveCollection } from "astro:content";
-import { dinewayLoader } from "dineway/runtime";
+```text
+Use dineway-cli to update the menu with new summer dishes.
+```
 
-export const collections = {
-	_dineway: defineLiveCollection({ loader: dinewayLoader() }),
-};
+```text
+Use dineway-cli to upload these new restaurant photos and add them to the gallery.
 ```
 
-## Querying Content in Astro Pages
+The agent reads the `dineway-cli` skill and translates your natural-language requests into CLI commands automatically.
+
+---
+
+## Quick Reference
+
+### CLI Command Categories
 
-Use Dineway's query functions in your Astro components:
+| Category | Commands | Needs Server? |
+| --- | --- | --- |
+| **Setup** | `init`, `dev`, `seed`, `export-seed` | No |
+| **Deploy** | `deploy forgeway/railway/docker/fly/gcp` | No |
+| **Auth** | `login`, `logout`, `whoami`, `auth setup-link`, `auth secret` | Yes (remote) |
+| **Content** | `content list/get/create/update/delete/publish/unpublish/schedule` | Yes |
+| **Schema** | `schema list/get/create/delete/add-field/remove-field` | Yes |
+| **Media** | `media list/get/upload/delete` | Yes |
+| **Search** | `search` | Yes |
+| **Taxonomy** | `taxonomy list/terms/add-term` | Yes |
+| **Menu** | `menu list/get` | Yes |
+| **Types** | `types` | Yes |
 
-```typescript
-import {
-	getDinewayCollection,
-	getDinewayEntry,
-	getSiteSettings,
-	getMenu,
-	getTaxonomyTerms,
-	getWidgetArea,
-	search,
-} from "dineway";
+### Field Types for Schema
 
-// Content
-const { entries } = await getDinewayCollection("posts");
-const { entry } = await getDinewayEntry("posts", "hello-world");
+When adding fields to collections, use these types:
 
-// Site settings
-const settings = await getSiteSettings();
+| Type | Use For |
+| --- | --- |
+| `string` | Short text (titles, names) |
+| `text` | Long plain text |
+| `number` | Decimal numbers (prices) |
+| `integer` | Whole numbers (counts, calories) |
+| `boolean` | Yes/No flags |
+| `datetime` | Dates and times |
+| `image` | Photos and images |
+| `reference` | Link to another content item |
+| `portableText` | Rich text with formatting |
+| `json` | Structured data |
 
-// Navigation
-const menu = await getMenu("primary");
+### Authentication Flow
 
-// Taxonomies
-const categories = await getTaxonomyTerms("categories");
+The CLI resolves authentication automatically:
 
-// Widgets
-const sidebar = await getWidgetArea("sidebar");
+1. `--token` flag (highest priority)
+2. `DINEWAY_TOKEN` from shell environment or `.env` file
+3. Stored credentials from `dineway login`
+4. Dev bypass — localhost only, no auth needed
+
+For local development, just run commands — auth is handled automatically.
+
+---
+
+## Common Questions
+
+### How do I access the admin panel?
+
+Visit `http://localhost:4321/_dineway/admin` (local) or `https://your-site.example.com/_dineway/admin` (deployed). You need an admin account — create one through the Setup Wizard on first visit.
+
+### How do I reset my admin account?
 
-// Search
-const results = await search("hello world", { collections: ["posts"] });
+Generate a new one-time setup link:
+
+```bash
+npx dineway auth setup-link
 ```
 
+Open the link in your browser to register a new passkey.
+
+### Can I edit the site design after it's built?
+
+Yes. The site is a standard [Astro](https://astro.build) project. You (or your AI agent) can modify the HTML, CSS, and components in the `src/` directory. Content managed by Dineway CMS is edited through the admin panel or CLI.
+
+### What data does the agent use to build my site?
+
+The agent fetches publicly available business data: your restaurant name, address, hours, reviews, photos, and menu information. It does not access private accounts or require credentials.
+
+### Can I use Dineway for non-restaurant businesses?
+
+Yes. While optimized for restaurants, Dineway's content engine, admin panel, and plugin system work for any local business. Use the `building-dineway-site` skill instead of `building-restaurant-site`.
+
+---
+
+## Agent Automation Reference
+
+> This section is for AI agents that read this README to automate site creation. Human readers can skip this.
+
+### Automated Restaurant Site Build
+
+```text
+STEP 1: Install skills
+  RUN: npx skills add https://github.com/dineway/dineway-skills
+
+STEP 2: Build the site
+  INVOKE SKILL: building-restaurant-site
+  INPUTS: restaurant name, city/country
+  The skill internally invokes:
+    - enrich-place-details (fetch real place data)
+    - brainstorming (design decisions)
+    - frontend-design (visual implementation)
+    - building-dineway-site (CMS integration)
+    - dineway-cli (content seeding, media upload)
+
+STEP 3: Validate
+  RUN: npx dineway dev
+  VERIFY: Site loads at http://localhost:4321
+  VERIFY: Admin panel loads at http://localhost:4321/_dineway/admin
+  VERIFY: Blog, News, Menu, Reviews, Gallery pages exist and render
+
+STEP 4: Deploy
+  RUN: npx dineway deploy forgeway
+  CAPTURE: Setup link from output
+  PRESENT: Setup link to user for admin account creation
+```
+
+### Automated Content Management
+
+```text
+# List content in a collection
+RUN: npx dineway content list {collection} --json
+
+# Create content (auto-publishes)
+RUN: npx dineway content create {collection} --data '{...}' --json
+
+# Update content (requires --rev from a prior get)
+RUN: npx dineway content get {collection} {id} --json
+# Extract _rev from response
+RUN: npx dineway content update {collection} {id} --rev {_rev} --data '{...}' --json
+
+# Upload media
+RUN: npx dineway media upload {filepath} --alt "{description}" --json
+
+# Deploy changes
+RUN: npx dineway deploy forgeway
+```
+
+### Key Files in a Dineway Project
+
+```
+my-restaurant/
+├── astro.config.mjs          # Astro + Dineway configuration
+├── src/
+│   ├── live.config.ts         # Dineway content loader (boilerplate)
+│   ├── pages/                 # Site pages (server-rendered)
+│   ├── layouts/               # Layout components
+│   └── components/            # Reusable UI components
+├── seed/
+│   └── seed.json              # Schema + demo content seed file
+├── .dineway/
+│   ├── types.ts               # Generated TypeScript types
+│   └── schema.json            # Generated schema
+└── package.json
+```
+
+---
+
 ## Documentation
 
-Full documentation, guides, and API reference: [docs](https://docs.dineway.ai)
+Full documentation, guides, and API reference: [docs.dineway.ai](https://docs.dineway.ai)

package/dist/api/route-utils.d.mts

@@ -1,11 +1,11 @@
-import { $n as isParseError, Qn as ParseResult, Zn as OptionsRepository, er as parseBody, ir as handleError, nr as apiError, rr as apiSuccess, t as DinewayConfig, tr as parseQuery } from "../runtime-CJasRKJB.mjs";
+import { $n as isParseError, Qn as ParseResult, Zn as OptionsRepository, er as parseBody, ir as handleError, nr as apiError, rr as apiSuccess, t as DinewayConfig, tr as parseQuery } from "../runtime-CP8eY2L-.mjs";
 import { t as Database } from "../types-B1NksXAb.mjs";
 import { at as StorageCollectionConfig, it as StorageCollection } from "../types-BIM7jwxr.mjs";
 import "../types-BgE6gMFI.mjs";
 import "../runner-pAnQS6iI.mjs";
 import "../index-2tBfB_8X.mjs";
 import "../index-CpbixmRL.mjs";
-import "../bylines-CGwQCHdG.mjs";
+import "../bylines-r8fYBu9F.mjs";
 import "../types-BBETcziA.mjs";
 import "../validate-BzUCAU2a.mjs";
 import { Kysely } from "kysely";

package/dist/api/route-utils.mjs

@@ -12,7 +12,7 @@ import { i as parseQuery, n as parseBody, t as isParseError } from "../parse-D7T
 import "../ssrf-KAIQS48_.mjs";
 import "../cron-D7FDsRu-.mjs";
 import { n as getPublicOrigin } from "../public-url-BL2r8dmQ.mjs";
-import { t as finalizeSetup } from "../setup-complete-DXCcwkth.mjs";
+import { t as finalizeSetup } from "../setup-complete-C2ztsNhJ.mjs";
 
 //#region src/api/auth-storage.ts
 /**