@jtakeit/kit 0.7.2 → 0.9.0

package/lib/catalogue.mjs

@@ -18,7 +18,7 @@
  * Both directions matter and they fail differently. A field declared and never
  * rendered is a control in the admin that edits nothing. A field rendered and
  * never declared is text the owner can see and cannot touch — and it is the
- * silent one, which is why `annotation-lint.mjs` exists at the other end of the
+ * silent one, which is why `jtkit lint` exists at the other end of the
  * pipeline to catch it at build time too.
  *
  *   jtk catalogue                 # emit, then check against dist/
@@ -149,7 +149,7 @@ if (Object.keys(modules).length > 0) catalogue.modules = modules;
  * A site scaffolded as `de-CH` therefore had its labels accepted and its own
  * language refused, with the message "not a language — two letters, or two and
  * a region" printed against a tag that is exactly that. Every regional locale
- * fl-init can produce hit it.
+ * jtk create can produce hit it.
  *
  * The region is *read* in either case and *written* in one. There are sites in
  * repositories spelt `de-ch` — the platform asked for that once — and a checker
@@ -1279,7 +1279,7 @@ const contentProblems = [];
 /*
  * A body with pictures in it needs the two class names that draw them.
  *
- * `figures.mjs` turns a paragraph of images into `.fl-figure` and `.fl-row`,
+ * `figures.mjs` turns a paragraph of images into `.jtk-figure` and `.jtk-row`,
  * and the kit ships styles for both in `src/styles/global.css`. A site that
  * deleted them gets pictures at their natural size in document order, which
  * looks like a broken build and is really a missing stylesheet — so it is said
@@ -1287,7 +1287,7 @@ const contentProblems = [];
  */
 if (pages.some(hasBodyPicture)) {
   const styled = readStyles(join(root, 'src'));
-  for (const name of ['fl-figure', 'fl-row']) {
+  for (const name of ['jtk-figure', 'jtk-row']) {
     if (!styled.includes(name)) {
       contentProblems.push(
         `a post has pictures in its body and nothing styles .${name}. ` +
@@ -1409,7 +1409,7 @@ const disagreements = [];
 
 /*
  * Which fields a page must carry a tap target for: the platform's own rule,
- * `tappable()` in its sitebuild/annotation-lint.mjs, copied (12 October 2026).
+ * `tappable()` in its sitebuild/`jtkit lint`, copied (12 October 2026).
  *
  * This used to ask it of every field but a bool or a `no_tap_target`, which
  * is stricter than the judge in exactly the shapes that are the way a
@@ -1745,14 +1745,14 @@ if (!flag('dist') && !existsSync(join(root, 'astro.config.mjs'))) {
   console.log('not an Astro project: the second build under a path is skipped — build with SITE_URL=https://x.invalid/p/check/ and run again with --dist <dir> to prove the addresses');
 }
 if (!flag('dist') && existsSync(join(root, 'astro.config.mjs'))) {
-  const prefix = '/p/fl-check/';
-  const out = join(root, '.fl-prefix-check');
+  const prefix = '/p/jtk-check/';
+  const out = join(root, '.jtk-prefix-check');
 
   try {
     execFileSync('npx', ['astro', 'build', '--outDir', out], {
       cwd: root,
       stdio: 'pipe',
-      env: { ...process.env, SITE_URL: `https://fl-check.invalid${prefix}`, PUBLIC_INDEXABLE: 'false' },
+      env: { ...process.env, SITE_URL: `https://jtk-check.invalid${prefix}`, PUBLIC_INDEXABLE: 'false' },
     });
 
     const leaks = [];

package/lib/codes.mjs

@@ -9,7 +9,7 @@
  * what the troubleshooting page is tested against. Nothing here is authoritative
  * about anything.
  *
- * It is copied because `fl-catalogue` has to work before there is anything to
+ * It is copied because `jtk catalogue` has to work before there is anything to
  * ask — on a laptop, before a deploy, before a token, on a plane. A local
  * checker that needs the network to name a fault is a local checker nobody runs.
  *
@@ -19,7 +19,7 @@
  * checkout, all so that a list of twenty-one strings can be regenerated on the
  * few days a year it changes.
  *
- * **What keeps it honest is `fl-catalogue --judge`, not anybody remembering.**
+ * **What keeps it honest is `jtk catalogue --judge`, not anybody remembering.**
  * That flag posts the emitted catalogue to the real validator and reports every
  * place the two answers differ — a code the server raised and we did not, or one
  * we raised and it did not. Every client the studio runs through it is one
@@ -163,7 +163,7 @@ export const MEANS = Object.freeze({
  * comparison in `--judge`: their absence from the server's answer is the correct
  * answer rather than a gap.
  */
-export const LOCAL = 'FL_LOCAL';
+export const LOCAL = 'JTK_LOCAL';
 
 /** Whether a finding is one the server can be asked about. */
 export function isPlatformCode(code) {

package/lib/devdiary.mjs

@@ -0,0 +1,199 @@
+/**
+ * The diary on the dev server — so a booking form can be walked on localhost.
+ *
+ * On the platform `/api/availability`, `/api/book` and the rest are the edge's;
+ * on `astro dev` there was nothing there, and every booking form on localhost
+ * said nothing at all: no times, no button that did anything (Schorem, 15
+ * October 2026). A developer judging a page by walking it could not walk the
+ * one thing the page is for.
+ *
+ * This answers the same requests, in the same shape, from the site's own files:
+ * the hours, the zone and the slot length in `jtk/bookings.json`, the services
+ * and the people in `jtk/content` (the collections `jtk/catalogue.json` names
+ * for the bookings module). A booking is kept in memory until the server
+ * stops — so the time it took is taken — and nothing ever leaves the machine.
+ * It is not the platform's diary: no buffers between visits, no resource's own
+ * hours, no rates by the hour of the week. Close enough to walk; `preflight`
+ * with `try_booking` is still the test of the real one.
+ *
+ *   import { devDiary } from '@jtakeit/kit/devdiary';
+ *   server.middlewares.use('/api', devDiary(process.cwd()));
+ */
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const DAYS = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
+
+async function json(path) {
+  try {
+    return JSON.parse(await readFile(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/** Every content file under jtk/content, with its slug. */
+async function entries(root) {
+  const out = [];
+  const walk = async (dir) => {
+    let names = [];
+    try {
+      names = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const one of names) {
+      const full = join(dir, one.name);
+      if (one.isDirectory()) await walk(full);
+      else if (one.name.endsWith('.json')) {
+        const doc = await json(full);
+        if (doc?.collection) out.push({ ...doc, slug: String(doc.path ?? one.name).split('/').filter(Boolean).pop()?.replace(/\.json$/, '') });
+      }
+    }
+  };
+  await walk(join(root, 'jtk', 'content'));
+  return out;
+}
+
+/** Minutes a zone is ahead of UTC on a given day, from the platform's own Intl. */
+function offsetOf(zone, at) {
+  try {
+    const parts = new Intl.DateTimeFormat('en-US', { timeZone: zone, hourCycle: 'h23', year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' }).formatToParts(at);
+    const get = (type) => Number(parts.find((p) => p.type === type)?.value);
+    const local = Date.UTC(get('year'), get('month') - 1, get('day'), get('hour'), get('minute'));
+    return Math.round((local - at.getTime()) / 60000);
+  } catch {
+    return 0;
+  }
+}
+
+/** What the site's files say, read fresh on every request so an edit shows at once. */
+async function read(root) {
+  const catalogue = (await json(join(root, 'jtk', 'catalogue.json'))) ?? {};
+  const roles = catalogue.modules?.bookings ?? {};
+  const settings = (await json(join(root, 'jtk', 'bookings.json')))?.blocks?.[0] ?? {};
+  const all = await entries(root);
+  const servicesOf = all.filter((e) => e.collection === (roles.services ?? 'services'));
+  const peopleOf = all.filter((e) => e.collection === (roles.resources ?? 'masters'));
+  const services = servicesOf.map((e) => {
+    const b = e.blocks?.[0] ?? {};
+    return { slug: e.slug, takes: Number(b.takes) || 0, costs: Number(b.costs) || 0, title: b.title ?? e.slug };
+  });
+  const people = peopleOf.map((e) => ({ slug: e.slug, does: e.blocks?.[0]?.does ?? null }));
+  return { settings, services, people };
+}
+
+const send = (res, status, body) => {
+  res.statusCode = status;
+  res.setHeader('Content-Type', 'application/json');
+  res.setHeader('Cache-Control', 'no-store');
+  res.setHeader('X-Jtk-Dev-Diary', '1');
+  res.end(JSON.stringify(body));
+};
+
+const bodyOf = (req) =>
+  new Promise((done) => {
+    let raw = '';
+    req.on('data', (chunk) => (raw += chunk));
+    req.on('end', () => {
+      try {
+        done(JSON.parse(raw || '{}'));
+      } catch {
+        done({});
+      }
+    });
+  });
+
+/** @param {string} root the site's directory */
+export function devDiary(root) {
+  /** start ISO → slugs of the people taken then */
+  const taken = new Map();
+  let made = 0;
+
+  return async (req, res, next) => {
+    const url = new URL(req.url ?? '/', 'http://localhost');
+    const path = url.pathname.replace(/^\/api/, '') || '/';
+
+    if (path === '/turnstile') return send(res, 200, { sitekey: '' });
+
+    if (path === '/lead' && req.method === 'POST') {
+      const body = await bodyOf(req);
+      console.log(`[dev diary] an enquiry, kept on this machine: ${JSON.stringify(body).slice(0, 200)}`);
+      return send(res, 200, { ok: true, dev: true });
+    }
+
+    if (path === '/availability') {
+      const { settings, services, people } = await read(root);
+      if (!settings.zone || !Array.isArray(settings.hours) || settings.hours.length === 0) {
+        return send(res, 412, {
+          code: 'failed_precondition',
+          message: !settings.zone ? 'nobody has said which timezone this business keeps' : 'nobody has said when this business is open',
+          details: { code: 'JTK_E_DIARY_NOT_READY', means: 'jtk/bookings.json needs `zone` and `hours`.' },
+        });
+      }
+      const asked = (url.searchParams.get('service') ?? '').split(',').concat(url.searchParams.getAll('services')).filter(Boolean);
+      const chosen = services.filter((s) => asked.includes(s.slug));
+      const takes = chosen.reduce((sum, s) => sum + s.takes, 0) || Number(settings.slot_every) || 30;
+      const costs = chosen.reduce((sum, s) => sum + s.costs, 0);
+      const every = Number(settings.slot_every) || 15;
+      const lead = Number(settings.lead) || 0;
+      const zone = settings.zone;
+      const from = new Date(url.searchParams.get('from') ?? Date.now());
+      const to = new Date(url.searchParams.get('to') ?? Date.now() + 86400000);
+      const resource = url.searchParams.get('resource') ?? '';
+      const able = people.filter((p) => (!resource || p.slug === resource) && (!p.does || chosen.every((s) => p.does.includes(s.slug))));
+      const earliest = Date.now() + lead * 60000;
+      const slots = [];
+      // Walk the days in the business's own zone, from its local midnight.
+      for (let day = new Date(from.getTime()); day < to; day = new Date(day.getTime() + 86400000)) {
+        const offset = offsetOf(zone, day);
+        const local = new Date(day.getTime() + offset * 60000);
+        const midnightUtc = Date.UTC(local.getUTCFullYear(), local.getUTCMonth(), local.getUTCDate()) - offset * 60000;
+        const weekday = DAYS[new Date(Date.UTC(local.getUTCFullYear(), local.getUTCMonth(), local.getUTCDate())).getUTCDay()];
+        for (const span of settings.hours.filter((h) => h.day === weekday)) {
+          for (let m = Number(span.opens); m + takes <= Number(span.closes); m += every) {
+            const start = midnightUtc + m * 60000;
+            if (start < earliest || start < from.getTime() || start >= to.getTime()) continue;
+            const iso = new Date(start).toISOString();
+            const busy = taken.get(iso) ?? [];
+            const free = (able.length ? able : [{ slug: '' }]).map((p) => p.slug).filter((s) => !busy.includes(s));
+            slots.push({ start: iso, ends: new Date(start + takes * 60000).toISOString(), free: free.filter(Boolean), costs_minor: costs });
+          }
+        }
+      }
+      return send(res, 200, {
+        zone,
+        slots: slots.filter((s) => s.free.length > 0 || people.length === 0),
+        party_max: 0,
+        quantity_max: 1,
+        scale: settings.scale ?? 'hourly',
+        currency: settings.currency ?? '',
+        services: services.map((s) => ({ slug: s.slug, scale: settings.scale ?? 'hourly', takes: s.takes, fewest: 1, most: 1 })),
+        dev: true,
+      });
+    }
+
+    if (path === '/book' && req.method === 'POST') {
+      const body = await bodyOf(req);
+      const { people, services, settings } = await read(root);
+      const start = body.start ? new Date(body.start).toISOString() : '';
+      if (!start) return send(res, 400, { code: 'invalid_argument', message: 'a booking needs a start' });
+      const busy = taken.get(start) ?? [];
+      const who = body.resource || people.map((p) => p.slug).find((s) => !busy.includes(s)) || '';
+      taken.set(start, [...busy, who]);
+      made += 1;
+      console.log(`[dev diary] booked ${body.service ?? (body.services ?? []).join('+')} at ${start}${who ? ` with ${who}` : ''} for ${body.name ?? 'somebody'} — on this machine only, nothing reached the platform`);
+      // The answer the form draws its last screen from: when, until when, with
+      // whom — without `start` and `ends` it cannot say the time, and says
+      // the booking failed instead.
+      const names = [body.service, ...(Array.isArray(body.services) ? body.services : [])].filter(Boolean);
+      const takes = services.filter((s) => names.includes(s.slug)).reduce((sum, s) => sum + s.takes, 0) || Number(settings.slot_every) || 30;
+      const ends = new Date(new Date(start).getTime() + takes * 60000).toISOString();
+      return send(res, 200, { id: `dev-${made}`, state: 'confirmed', start, ends, amount_minor: 0, currency: settings.currency ?? '', token: `dev-${made}`, manage_path: '', telegram_url: '', resource: who, dev: true });
+    }
+
+    if (path === '/booking/cancel' && req.method === 'POST') return send(res, 200, { ok: true, dev: true });
+
+    return next();
+  };
+}

package/lib/kits.mjs

@@ -16,7 +16,7 @@
  * the settings no zone and no hours. What the kit says to take from the brief
  * is in `kit.ask`, for whoever runs this to do next.
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 
 /** Where the platform is, for a kit asked by its kind. */
@@ -74,7 +74,10 @@ export async function fetchKit(kind, api = process.env.JTK_API_URL || API) {
  * @param {string} [api]
  */
 export async function loadKit(asked, api) {
-  if (existsSync(resolve(asked)) || asked.endsWith('.json')) return readKit(asked);
+  // A file is a file: a folder that happens to share the kind's name — a
+  // project called `salon`, run beside `--kit salon` — is not a kit, and
+  // reading it failed with EISDIR.
+  if (asked.endsWith('.json') || (existsSync(resolve(asked)) && statSync(resolve(asked)).isFile())) return readKit(asked);
   if (/^[a-z][a-z_]*$/.test(asked)) return fetchKit(asked, api);
   throw new Error(`--kit ${asked} is neither a kit's kind nor a file`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jtakeit/kit",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "description": "The framework-free half of a site on jtakeit: the booking form as an element and as markup, for Astro through @jtakeit/astro and for any other generator directly",
   "license": "MIT",
   "type": "module",
@@ -45,6 +45,7 @@
       "default": "./lib/kits.mjs"
     },
     "./catalogue": "./lib/catalogue.mjs",
+    "./devdiary": "./lib/devdiary.mjs",
     "./codes": "./lib/codes.mjs",
     "./elements/booking": {
       "types": "./types/elements-booking.d.ts",