pgkiln 0.84.0 → 0.85.0

package/src/builder/appsheets.ts

@@ -22,6 +22,7 @@ import { preview } from './dataload.ts';
 import { finishGeneratedApp, createApp, createAppError, type CheckedApp } from './newapp.ts';
 import { groupColumn } from './appfromfile.ts';
 import { region, type Body } from './ui.ts';
+import { scopedTx as tx } from './i18n.ts';
 
 // Create → From a file with several sheets or tables (APEX: Create App from a
 // File, several sheets). An Excel workbook with several sheets, or a JSON
@@ -66,7 +67,7 @@ export async function parseBook(filename: string, data: Buffer, { headers = true
     try {
       book = await readXlsxFile<string>(data, { parseNumber: (s) => s, trim: true });
     } catch (e) {
-      throw new LoadError(`This is not a readable Excel (.xlsx) file: ${(e as Error).message}`);
+      throw new LoadError(tx('ash.bad_xlsx', { error: (e as Error).message }));
     }
     const sheets: NamedSheet[] = [];
     let total = 0;
@@ -77,16 +78,16 @@ export async function parseBook(filename: string, data: Buffer, { headers = true
       try {
         sheet = tableSheet('xlsx', rows, headers);
       } catch (e) {
-        if (e instanceof LoadError) throw new LoadError(`Sheet ${s.sheet}: ${e.message}`);
+        if (e instanceof LoadError) throw new LoadError(tx('ash.sheet_error', { sheet: s.sheet, error: e.message }));
         throw e;
       }
       if (!sheet.rows.length) continue;
       total += sheet.rows.length;
       sheets.push({ ...sheet, name: s.sheet });
     }
-    if (sheets.length > MAX_SHEETS) throw new LoadError(`The workbook has ${sheets.length} sheets with rows; at most ${MAX_SHEETS} become tables at once.`);
-    if (total > MAX_ROWS) throw new LoadError(`The workbook has ${total} rows; at most ${MAX_ROWS} can be loaded at once.`);
-    if (!sheets.length) throw new LoadError('The file has column names but no rows.');
+    if (sheets.length > MAX_SHEETS) throw new LoadError(tx('ash.too_many_sheets', { n: sheets.length, max: MAX_SHEETS }));
+    if (total > MAX_ROWS) throw new LoadError(tx('ash.too_many_rows_wb', { n: total, max: MAX_ROWS }));
+    if (!sheets.length) throw new LoadError(tx('ash.the_file_has_column_names'));
     return sheets;
   }
   if (/\.json$/i.test(filename) || /^\s*\{/.test(data.subarray(0, 64).toString('utf8').replace(/^/, ''))) {
@@ -101,9 +102,9 @@ export async function parseBook(filename: string, data: Buffer, { headers = true
         ([, v]) => Array.isArray(v) && v.length && v.every((r) => r && typeof r === 'object' && !Array.isArray(r)),
       ) as [string, unknown[]][];
       if (arrays.length > 1) {
-        if (arrays.length > MAX_SHEETS) throw new LoadError(`The JSON has ${arrays.length} arrays; at most ${MAX_SHEETS} become tables at once.`);
+        if (arrays.length > MAX_SHEETS) throw new LoadError(tx('ash.too_many_arrays', { n: arrays.length, max: MAX_SHEETS }));
         const total = arrays.reduce((n, [, v]) => n + v.length, 0);
-        if (total > MAX_ROWS) throw new LoadError(`The file has ${total} rows; at most ${MAX_ROWS} can be loaded at once.`);
+        if (total > MAX_ROWS) throw new LoadError(tx('ash.too_many_rows', { n: total, max: MAX_ROWS }));
         return arrays.map(([name, v]) => ({ ...parseJson(JSON.stringify(v)), name }));
       }
     }
@@ -235,18 +236,18 @@ export function fkChecked(f: ForeignKey, b: Body | null) {
 /** CREATE TABLE for a planned table: an integer key column becomes an identity primary key; another key is unique and not null next to a new identity id. */
 export function plannedTableSql(schema: string, p: TablePlan) {
   const valid = /^[a-z_][a-z0-9_]{0,62}$/;
-  const where = `Sheet ${p.sheet.name}`;
-  if (!valid.test(p.table)) throw new LoadError(`${where}: the table name must be lower-case (letters, digits and _) without a schema; the table goes into the application's schema.`);
-  if (!p.cols.length) throw new LoadError(`${where}: give at least one column a name.`);
+  const where = tx('ash.sheet', { name: p.sheet.name });
+  if (!valid.test(p.table)) throw new LoadError(tx('ash.bad_table_name', { where }));
+  if (!p.cols.length) throw new LoadError(tx('ash.no_columns', { where }));
   for (const c of p.cols) {
-    if (!valid.test(c.name)) throw new LoadError(`${where}: "${c.name}" is not a valid column name.`);
-    if (!COLUMN_TYPES.includes(c.type)) throw new LoadError(`${where}: unknown column type ${c.type}.`);
+    if (!valid.test(c.name)) throw new LoadError(tx('ash.bad_column', { where, col: c.name }));
+    if (!COLUMN_TYPES.includes(c.type)) throw new LoadError(tx('ash.bad_type', { where, type: c.type }));
   }
-  if (new Set(p.cols.map((c) => c.name)).size !== p.cols.length) throw new LoadError(`${where}: column names must be unique.`);
+  if (new Set(p.cols.map((c) => c.name)).size !== p.cols.length) throw new LoadError(tx('ash.dup_columns', { where }));
   const ident = pg.escapeIdentifier;
   const defs: string[] = [];
   if (!identityKey(p)) {
-    if (p.cols.some((c) => c.name === 'id')) throw new LoadError(`${where}: "id" is the name of the new key column; rename the file column or choose it as the primary key.`);
+    if (p.cols.some((c) => c.name === 'id')) throw new LoadError(tx('ash.id_taken', { where }));
     defs.push('id bigint generated by default as identity primary key');
   }
   for (const c of p.cols) {
@@ -366,9 +367,9 @@ export async function addDashboard(c: Client, alias: string, tables: string[], p
 export async function buildAppFromSheets(checked: CheckedApp, sheets: NamedSheet[], b: Body): Promise<BuiltBook> {
   const v = (name: string) => String(b[name] ?? '');
   const plans = planFrom(sheets, v).filter((p) => p.on);
-  if (!plans.length) throw new LoadError('Choose at least one sheet.');
+  if (!plans.length) throw new LoadError(tx('ash.choose_at_least_one_sheet'));
   const ddl = plans.map((p) => plannedTableSql(checked.schema, p));
-  if (new Set(plans.map((p) => p.table)).size !== plans.length) throw new LoadError('Each sheet needs a table name of its own.');
+  if (new Set(plans.map((p) => p.table)).size !== plans.length) throw new LoadError(tx('ash.each_sheet_needs_a_table'));
   // only proposed foreign keys can be chosen (recomputed from the posted names and types)
   const fks = proposeForeignKeys(plans).filter((f) => v(fkName(f)) === String(f.to));
   const headers = b.h !== '0';
@@ -381,7 +382,7 @@ export async function buildAppFromSheets(checked: CheckedApp, sheets: NamedSheet
     const tables: BuiltBook['tables'] = [];
     for (const [n, p] of plans.entries()) {
       await c.query(ddl[n]).catch((e) => {
-        throw new LoadError((e as { code?: string }).code === '42P07' ? `The table ${checked.schema}.${p.table} already exists: choose another name.` : (e as Error).message);
+        throw new LoadError((e as { code?: string }).code === '42P07' ? tx('ash.table_exists', { table: `${checked.schema}.${p.table}` }) : (e as Error).message);
       });
       const T = (await c.query('select $1::regclass::text as t', [`${pg.escapeIdentifier(checked.schema)}.${pg.escapeIdentifier(p.table)}`])).rows[0].t as string;
       qualified.set(p.k, T);
@@ -413,7 +414,7 @@ export async function buildAppFromSheets(checked: CheckedApp, sheets: NamedSheet
       const ident = pg.escapeIdentifier;
       await c.query(`create index on ${A} (${ident(col)})`);
       await c.query(`alter table ${A} add foreign key (${ident(col)}) references ${B} (${ident(key)})`).catch((e) => {
-        throw new LoadError(`Foreign key ${a.table}.${col} → ${to.table}.${key}: ${(e as { detail?: string }).detail ?? (e as Error).message} Untick it, or fix the data.`);
+        throw new LoadError(tx('ash.fk_failed', { fk: `${a.table}.${col} → ${to.table}.${key}`, error: (e as { detail?: string }).detail ?? (e as Error).message }));
       });
       foreignKeys.push(`${a.table}.${col} → ${to.table}.${key}`);
     }
@@ -432,7 +433,7 @@ export async function buildAppFromSheets(checked: CheckedApp, sheets: NamedSheet
     if (b.chart === 'true') {
       const dash = await addDashboard(c, checked.alias, [...qualified.values()], next);
       if (dash) pages.push(dash);
-      else notes.push('No dashboard: no table has a foreign key or a text, yes/no or date column with a few values that repeat, to count the rows by.');
+      else notes.push(tx('ash.no_dashboard'));
     }
     await finishGeneratedApp(c, app.id, { description: checked.description });
     return { app: { id: app.id, alias: checked.alias, existingAccount: app.existingAccount }, tables, foreignKeys, pages, notes };
@@ -462,22 +463,22 @@ export function sheetsForm(sheets: NamedSheet[], b: Body | null): Raw {
   const sections = sheets.map((sheet, k) => {
     const id = field(k, 'table');
     return region(
-      `Sheet ${sheet.name}`,
-      html`<div class="field">${checkbox(field(k, 'on'), 'true', v(field(k, 'on')) === 'true', `Create a table from this sheet (${sheet.rows.length} row(s), ${sheet.headers.length} column(s))`)}</div>
+      tx('ash.sheet', { name: sheet.name }),
+      html`<div class="field">${checkbox(field(k, 'on'), 'true', v(field(k, 'on')) === 'true', tx('ash.create_from_sheet', { rows: sheet.rows.length, cols: sheet.headers.length }))}</div>
         <div class="form-grid">
-          <div class="field"><label class="label" for="f_${id}">Table name</label><input id="f_${id}" name="${id}" value="${v(id)}"></div>
-          <div class="field"><label class="label" for="f_${field(k, 'key')}">Primary key</label>
-            <select id="f_${field(k, 'key')}" name="${field(k, 'key')}">${[['', '- a new column id (identity) -'], ...sheet.headers.map((h, i): [string, string] => [String(i), h])].map(
+          <div class="field"><label class="label" for="f_${id}">${tx('ash.table_name')}</label><input id="f_${id}" name="${id}" value="${v(id)}"></div>
+          <div class="field"><label class="label" for="f_${field(k, 'key')}">${tx('ash.primary_key')}</label>
+            <select id="f_${field(k, 'key')}" name="${field(k, 'key')}">${[['', tx('ash.a_new_column_id_identity')], ...sheet.headers.map((h, i): [string, string] => [String(i), h])].map(
               ([value, label]) => html`<option value="${value}"${v(field(k, 'key')) === value ? raw(' selected') : ''}>${label}</option>`,
             )}</select>
-            <small class="help">A whole-number key column becomes an identity key; another key column is unique, next to a new id.</small></div>
+            <small class="help">${tx('ash.a_whole_number_key_column')}</small></div>
         </div>
-        <div class="table-wrap"><table class="report ff-cols"><thead><tr><th scope="col">File column</th><th scope="col">Values</th><th scope="col">Column name (empty = skip)</th><th scope="col">Type</th></tr></thead><tbody>
+        <div class="table-wrap"><table class="report ff-cols"><thead><tr><th scope="col">${tx('ash.file_column')}</th><th scope="col">${tx('ash.values')}</th><th scope="col">${tx('ash.col_name_head')}</th><th scope="col">${tx('ash.type')}</th></tr></thead><tbody>
           ${sheet.headers.map((h, i) => {
             const type = v(field(k, `type_${i}`));
             return html`<tr><td>${h}</td><td class="muted small ff-sample">${sample(sheet, i)}</td>
-              <td><input name="${field(k, `name_${i}`)}" value="${v(field(k, `name_${i}`))}" aria-label="Column name for ${h} (${sheet.name})"></td>
-              <td><select name="${field(k, `type_${i}`)}" aria-label="Type of ${h} (${sheet.name})">${COLUMN_TYPES.map((t) => html`<option value="${t}"${t === type ? raw(' selected') : ''}>${t}</option>`)}</select></td></tr>`;
+              <td><input name="${field(k, `name_${i}`)}" value="${v(field(k, `name_${i}`))}" aria-label="${tx('ash.col_name_for', { col: h, sheet: sheet.name })}"></td>
+              <td><select name="${field(k, `type_${i}`)}" aria-label="${tx('ash.type_of', { col: h, sheet: sheet.name })}">${COLUMN_TYPES.map((t) => html`<option value="${t}"${t === type ? raw(' selected') : ''}>${t}</option>`)}</select></td></tr>`;
           })}
         </tbody></table></div>
         <details class="ff-preview"><summary>Preview${sheet.rows.length > 10 ? ' (first 10 rows)' : ''}</summary>${preview(sheet)}</details>`,
@@ -491,11 +492,11 @@ export function sheetsForm(sheets: NamedSheet[], b: Body | null): Raw {
   const fkList = fks.length
     ? html`<ul class="ff-fks">${fks.map(
         (f) => html`<li><input type="hidden" name="fkp_${f.from}_${f.col}" value="${String(f.to)}">${checkbox(fkName(f), String(f.to), fkChecked(f, b), html`${name(f.from, f.col)} → ${keyName(f.to)}`)}
-          ${f.missing ? html`<small class="help">${f.missing} row(s) have a value that ${keyName(f.to)} doesn't have.</small>` : ''}</li>`,
+          ${f.missing ? html`<small class="help">${tx('ash.missing', { n: f.missing, key: keyName(f.to) })}</small>` : ''}</li>`,
       )}</ul>`
-    : html`<p class="muted">No column matches another table's key. A column matches when it is named like the key column (dept_id), or like the other table and its key (department_id, department_code), with the same type.</p>`;
+    : html`<p class="muted">${tx('ash.no_column_matches_another_table')}</p>`;
   return html`${sections.map((x) => html`${x}<div class="u-spacer"></div>`)}
-    ${region('Foreign keys', html`<p class="muted u-mt0">Proposed where a column matches another table's primary key; ticked when every value is found. Forms get a select list for each foreign key.</p>
+    ${region(tx('ash.foreign_keys'), html`<p class="muted u-mt0">${tx('ash.fk_intro')}</p>
       ${fkList}
-      <div class="buttons"><button class="btn" name="action" value="preview">Update the proposals</button></div>`)}`;
+      <div class="buttons"><button class="btn" name="action" value="preview">${tx('ash.update_the_proposals')}</button></div>`)}`;
 }

package/src/builder/appwizard.ts

@@ -7,7 +7,7 @@ import { LoadError } from '../dataload.ts';
 import type { Session } from '../session.ts';
 import { aliasFor, check, ITEM, type Created } from './appfromfile.ts';
 import { addDashboard, parseBook } from './appsheets.ts';
-import { finishGeneratedApp, checkNewApp, createApp, createAppError, featuresFrom, FEATURES, reservedSchema, startFromBoilerplate, DEFAULT_APP_ICON, type CheckedApp, type Features } from './newapp.ts';
+import { finishGeneratedApp, checkNewApp, createApp, createAppError, featuresFrom, featureText, FEATURES, reservedSchema, startFromBoilerplate, DEFAULT_APP_ICON, type CheckedApp, type Features } from './newapp.ts';
 import { currentWorkspace } from './workspaces.ts';
 import { back, BASE, csrf, developer, flash, input, region, select, send, shell, type Body, type Req } from './ui.ts';
 import { iconPicker } from './forms.ts';
@@ -16,6 +16,7 @@ import { BASE_STYLES } from '../runtime/styles.ts';
 import { LANGUAGE_NAMES } from '../i18n.ts';
 import { secretKeyConfigured } from '../secrets.ts';
 import { appPublicKey } from '../push.ts';
+import { scopedTx as tx } from './i18n.ts';
 
 // Two more ways into the create application wizard:
 // - From pasted data (APEX: Create App from a File → Copy and Paste): CSV or
@@ -110,7 +111,7 @@ export interface Plan {
 /** Create the application on existing tables and views (each with its page type) and the features, in one transaction. */
 export async function buildAppFromTables(checked: CheckedApp, plans: Plan[], chart: boolean, features: Partial<Features> = {}): Promise<Created> {
   plans = plans.filter((p) => p.kind);
-  if (plans.length > MAX_TABLES) throw new LoadError(`Choose at most ${MAX_TABLES} tables and views.`);
+  if (plans.length > MAX_TABLES) throw new LoadError(tx('aw.at_most_tables', { n: MAX_TABLES }));
   for (const p of plans) if (!kindsFor(p.rel).includes(p.kind)) throw new LoadError(`${p.rel.relname} can't have the page type ${PAGE_KINDS[p.kind] ?? p.kind}.`);
   return owner.tx(async (c) => {
     const app = await createApp(c, checked).catch((e) => {
@@ -157,9 +158,9 @@ export async function buildAppFromTables(checked: CheckedApp, plans: Plan[], cha
       const skipped: string[] = [];
       const dash = await addDashboard(c, checked.alias, tables, next, skipped);
       if (dash) pages.push(dash);
-      else notes.push('No dashboard: no table has a foreign key, or a text, yes/no or date column whose statistics show a few values that repeat (ANALYZE the tables first).');
+      else notes.push(tx('aw.no_dashboard'));
       if (skipped.length)
-        notes.push(`Not on the dashboard: ${skipped.map((t) => t.replace(/^.*\./, '').replace(/"/g, '')).join(', ')} (row level security: the application's role may see none of the rows).`);
+        notes.push(tx('aw.not_on_dashboard', { tables: skipped.map((t) => t.replace(/^.*\./, '').replace(/"/g, '')).join(', ') }));
     }
     await finishGeneratedApp(c, app.id, { description: checked.description, features, notes });
     return { app: { id: app.id, alias: checked.alias, existingAccount: app.existingAccount }, pages, notes };
@@ -168,28 +169,27 @@ export async function buildAppFromTables(checked: CheckedApp, plans: Plan[], cha
 
 export async function appWizardRoutes(app: FastifyInstance) {
   const page = (s: Session, reply: FastifyReply, title: string, crumb: string, main: Raw) =>
-    send(reply, s, shell(s, title, [['App Builder', BASE], ['Create', `${BASE}/create`], [crumb]], html`<div class="ab-narrow">${main}</div>`));
+    send(reply, s, shell(s, title, [[tx('aw.app_builder'), BASE], [tx('aw.create'), `${BASE}/create`], [crumb]], html`<div class="ab-narrow">${main}</div>`));
 
   // ---------------------------------------------------------------- pasted data
   const pasteForm = (s: Session, b: Body = {}, error?: string) =>
-    html`<h1>Create an application from pasted data</h1>
-      <p class="muted">Paste rows copied from a spreadsheet, or CSV or TSV text: the delimiter (tab, comma, semicolon or |) is detected. Next you check the proposed table and its columns, as for a file.
-        <a href="${BASE}/create/file">Upload a file</a> instead.</p>
-      ${region('Data', html`${error ? html`<div class="alert alert-error" role="alert">${error}</div>` : ''}
+    html`<h1>${tx('aw.create_an_application_from_pasted')}</h1>
+      <p class="muted">${tx.rich('aw.paste_intro', { link: html`<a href="${BASE}/create/file">${tx('aw.upload_a_file')}</a>` })}</p>
+      ${region(tx('aw.data'), html`${error ? html`<div class="alert alert-error" role="alert">${error}</div>` : ''}
         <form method="post" action="${BASE}/create/paste">${csrf(s)}
           <div class="form-grid">
-            ${input('title', 'Name', b.title ?? 'Pasted data', { help: 'Names the application and the table (you can change both in the next step).' })}
-            <div class="field" data-wide><label class="label" for="f_data">Data</label>
+            ${input('title', tx('aw.name'), b.title ?? tx('aw.pasted_data'), { help: tx('aw.names_the_application_and_the') })}
+            <div class="field" data-wide><label class="label" for="f_data">${tx('aw.data')}</label>
               <textarea id="f_data" name="data" class="code" rows="12" required spellcheck="false" placeholder="name,city,joined&#10;Ann,Utrecht,2026-01-05">${b.data ?? ''}</textarea></div>
-            <div class="field"><label class="check"><input type="checkbox" name="headers" value="true"${b.headers === undefined || b.headers === 'true' ? raw(' checked') : ''}> First row contains column names</label></div>
+            <div class="field"><label class="check"><input type="checkbox" name="headers" value="true"${b.headers === undefined || b.headers === 'true' ? raw(' checked') : ''}> ${tx('aw.first_row_contains_column_names')}</label></div>
           </div>
-          <div class="buttons"><a class="btn" href="${BASE}/create">Cancel</a><button class="btn btn-hot">${icon('upload')} Next</button></div>
+          <div class="buttons"><a class="btn" href="${BASE}/create">${tx('aw.cancel')}</a><button class="btn btn-hot">${icon('upload')} ${tx('aw.next')}</button></div>
         </form>`)}`;
 
   app.get(`${BASE}/create/paste`, async (req: Req, reply) => {
     const s = await developer(req, reply);
     if (!s) return;
-    return page(s, reply, 'Create application from pasted data', 'Pasted data', pasteForm(s));
+    return page(s, reply, tx('aw.paste_title'), tx('aw.pasted_data'), pasteForm(s));
   });
 
   app.post(`${BASE}/create/paste`, async (req: Req, reply) => {
@@ -198,19 +198,19 @@ export async function appWizardRoutes(app: FastifyInstance) {
     const b = req.body ?? {};
     const fail = (message: string) => {
       reply.code(422);
-      return page(s, reply, 'Create application from pasted data', 'Pasted data', pasteForm(s, { ...b, headers: b.headers === 'true' ? 'true' : 'false' }, message));
+      return page(s, reply, tx('aw.paste_title'), tx('aw.pasted_data'), pasteForm(s, { ...b, headers: b.headers === 'true' ? 'true' : 'false' }, message));
     };
     const text = typeof b.data === 'string' ? b.data : '';
-    if (!text.trim()) return fail('Paste the data.');
+    if (!text.trim()) return fail(tx('aw.paste_the_data'));
     const data = Buffer.from(text, 'utf8');
-    if (data.length > MAX_PASTE) return fail(`At most ${MAX_PASTE / 1024 / 1024} MB of text can be pasted; upload a file instead.`);
+    if (data.length > MAX_PASTE) return fail(tx('aw.paste_max', { mb: MAX_PASTE / 1024 / 1024 }));
     const filename = pastedName(String(b.title ?? ''));
     const headers = b.headers === 'true';
     try {
       // read as delimited text whatever it looks like
       const sheets = await parseBook(filename, data, { headers });
-      if (sheets[0].format !== 'csv') throw new LoadError('Paste delimited text (CSV or TSV); upload JSON, XML or Excel files with From a file.');
-      if (!sheets[0].rows.length) throw new LoadError('The data has column names but no rows.');
+      if (sheets[0].format !== 'csv') throw new LoadError(tx('aw.paste_delimited_text_csv_or'));
+      if (!sheets[0].rows.length) throw new LoadError(tx('aw.the_data_has_column_names'));
     } catch (e) {
       if (e instanceof LoadError) return fail(e.message);
       throw e;
@@ -253,13 +253,13 @@ export async function appWizardRoutes(app: FastifyInstance) {
     let built: Created;
     let pushKey = false;
     try {
-      if (schema && (reservedSchema(schema) || !(await appSchemas()).includes(schema))) throw new LoadError('Choose one of the schemas in the list.');
+      if (schema && (reservedSchema(schema) || !(await appSchemas()).includes(schema))) throw new LoadError(tx('aw.choose_one_of_the_schemas'));
       const checked = await checkNewApp({ ...b, schema }, currentWorkspace(s)).catch((e) => {
         throw new LoadError((e as Error).message);
       });
       const features = featuresFrom(b, b.features === '1');
       const boilerplate = /^\d{1,9}$/.test(b.boilerplate ?? '') ? Number(b.boilerplate) : null;
-      if (boilerplate && !(await boilerplates(s)).some((x) => x.id === boilerplate)) throw new LoadError('Choose a boilerplate application (an application of type Boilerplate).');
+      if (boilerplate && !(await boilerplates(s)).some((x) => x.id === boilerplate)) throw new LoadError(tx('aw.choose_a_boilerplate_application_an'));
       // the tables of the form: only names of this schema's tables and views count (looked up again, never used as SQL)
       const relations = schema ? await schemaRelations(schema) : [];
       const plans: Plan[] = [];
@@ -272,8 +272,8 @@ export async function appWizardRoutes(app: FastifyInstance) {
         if (kind) plans.push({ rel, kind });
       }
       const askedTables = fromTables || b.tables === '1' || Object.keys(b).some((k) => /^t_\d+$/.test(k));
-      if (askedTables && !plans.length) throw new LoadError('Choose at least one table or view.');
-      if (plans.length && boilerplate) throw new LoadError('A boilerplate application brings its own pages: choose no tables, or no boilerplate.');
+      if (askedTables && !plans.length) throw new LoadError(tx('aw.choose_at_least_one_table'));
+      if (plans.length && boilerplate) throw new LoadError(tx('aw.a_boilerplate_application_brings_its'));
       if (plans.length) built = await buildAppFromTables(checked, plans, b.chart === 'true', features);
       else {
         built = await owner.tx(async (c) => {
@@ -294,9 +294,9 @@ export async function appWizardRoutes(app: FastifyInstance) {
     // the push key of the new application, after the commit
     if (pushKey && secretKeyConfigured()) await appPublicKey(built.app.id).catch(() => undefined);
     // (sprint 73, APEX: straight to the new application's home) the result as a message on its page
-    const pages = built.pages.length ? ` with ${built.pages.length} page(s) besides Home` : '';
-    const account = built.app.existingAccount ? ` The existing account ${String(b.admin_user ?? '').trim()} got the admin role (its password was not changed).` : '';
-    flash(s, `Application ${built.app.alias} created${pages}.${account}${built.notes.length ? ` ${built.notes.join(' ')}` : ''}`);
+    const created = built.pages.length ? tx('aw.created_pages', { alias: built.app.alias, n: built.pages.length }) : tx('aw.created', { alias: built.app.alias });
+    const account = built.app.existingAccount ? ` ${tx('aw.existing_account', { user: String(b.admin_user ?? '').trim() })}` : '';
+    flash(s, `${created}${account}${built.notes.length ? ` ${built.notes.join(' ')}` : ''}`);
     return back(reply, s, `${BASE}/apps/${built.app.id}`);
   };
   app.post(`${BASE}/apps`, (req: Req, reply) => create(req, reply));
@@ -322,8 +322,8 @@ const SOURCES: [string, string, string, string][] = [
 const rlsBadge = (r: Relation) =>
   !r.rls ? ''
   : r.policies > 0
-    ? html` <span class="tag aw-rls" title="Row level security is on (${r.policies} ${r.policies === 1 ? 'policy' : 'policies'}): each user sees only the rows the policies allow">${icon('shield')} RLS · ${r.policies}</span>`
-    : html` <span class="tag tag-error aw-rls" title="Row level security is on without policies: the application's role sees no rows (unless it owns the table or bypasses row level security)">${icon('shield')} RLS, no policies</span>`;
+    ? html` <span class="tag aw-rls" title="${r.policies === 1 ? tx('aw.rls_on_1') : tx('aw.rls_on', { n: r.policies })}">${icon('shield')} RLS · ${r.policies}</span>`
+    : html` <span class="tag tag-error aw-rls" title="${tx('aw.row_level_security_is_on')}">${icon('shield')} ${tx('aw.rls_no_policies')}</span>`;
 
 async function createPage(s: Session, reply: FastifyReply, schema: string, b: Body | null, message: Raw | '' = '') {
   const schemas = await appSchemas();
@@ -335,62 +335,62 @@ async function createPage(s: Session, reply: FastifyReply, schema: string, b: Bo
   // (sprint 73) the name proposed from the schema is selected on first focus, so typing replaces it (app.js data-select-once)
   const suggested = known ? schema.replace(/_/g, ' ').replace(/^./, (x) => x.toUpperCase()) : '';
   const kindOf = (r: Relation, i: number) => (b ? (b[`t_${i}`] === r.relname ? (b[`k_${i}`] === undefined ? defaultKind(r) : String(b[`k_${i}`])) : '') : defaultKind(r));
-  const rows = (r: Relation) => (r.rows === null ? 'not analyzed' : `about ${Number(r.rows).toLocaleString('en')} row(s)`);
+  const rows = (r: Relation) => (r.rows === null ? tx('aw.not_analyzed') : tx('aw.about_rows', { n: Number(r.rows).toLocaleString('en') }));
   const main = html`<div class="ab-narrow create-app">
-    <h1>Create an application</h1>
-    <nav class="create-sources" aria-label="Other ways to start">${SOURCES.map(
-      ([path, ic, label, help]) => html`<a class="create-source" href="${BASE}/${path}">${icon(ic)}<span><b>${label}</b><small class="muted">${help}</small></span></a>`,
+    <h1>${tx('aw.create_an_application')}</h1>
+    <nav class="create-sources" aria-label="${tx('aw.other_ways_to_start')}">${SOURCES.map(
+      ([path, ic, label, help]) => html`<a class="create-source" href="${BASE}/${path}">${icon(ic)}<span><b>${tx.dyn(`aw.src.${path.replace(/^create\//, '')}`, label)}</b><small class="muted">${tx.dyn(`aw.srch.${path.replace(/^create\//, '')}`, help)}</small></span></a>`,
     )}</nav>
     ${message}
-    ${schema && !known && !message ? html`<div class="alert alert-error" role="alert">Choose one of the schemas in the list.</div>` : ''}
-    ${region('Data', html`<form method="get" action="${BASE}/create" class="create-schema">
-      <div class="form-grid">${select('schema', 'Pages on the tables of', schema, [['', '- a new, empty schema (Home only) -'], ...schemas.map((x): [string, string] => [x, x])],
-        'The application\'s parsing schema. Choose a schema to get a page per table and view; a new schema is named after the alias.')}</div>
-      <div class="buttons"><button class="btn">${icon('search')} Show its tables</button></div></form>`)}
+    ${schema && !known && !message ? html`<div class="alert alert-error" role="alert">${tx('aw.choose_one_of_the_schemas')}</div>` : ''}
+    ${region(tx('aw.data'), html`<form method="get" action="${BASE}/create" class="create-schema">
+      <div class="form-grid">${select('schema', tx('aw.pages_on_the_tables_of'), schema, [['', tx('aw.a_new_empty_schema_home')], ...schemas.map((x): [string, string] => [x, x])],
+        tx('aw.schema_help'))}</div>
+      <div class="buttons"><button class="btn">${icon('search')} ${tx('aw.show_its_tables')}</button></div></form>`)}
     <form method="post" action="${BASE}/apps" data-progress="Creating the application and its pages…">${csrf(s)}
       <input type="hidden" name="features" value="1">
       <div id="aw-schema-fields"><input type="hidden" name="schema" value="${known ? schema : ''}">${known ? html`<input type="hidden" name="tables" value="1">` : ''}</div>
-      ${region('Application', html`<div class="form-grid">
-        <div class="field"><label class="label" for="f_name">Name</label>
+      ${region(tx('aw.application'), html`<div class="form-grid">
+        <div class="field"><label class="label" for="f_name">${tx('aw.name')}</label>
           <input id="f_name" name="name" value="${v('name', suggested)}" required data-select-once></div>
-        ${input('description', 'Description', v('description', ''), { placeholder: 'One line for the home and About pages' })}
-        ${iconPicker('f_icon', 'icon', 'Icon', v('icon', DEFAULT_APP_ICON))}
+        ${input('description', tx('aw.description'), v('description', ''), { placeholder: tx('aw.one_line_for_the_home') })}
+        ${iconPicker('f_icon', 'icon', tx('aw.icon'), v('icon', DEFAULT_APP_ICON))}
       </div>`)}
-      ${region('Appearance', html`<div class="form-grid">
-        ${select('base', 'Theme style', v('base', 'iris'), [['iris', 'Iris (light body, dark header and menu)'], ['lavender', 'Lavender (rounded, indigo)'], ['standard', 'Standard (blue, navy header)']])}
-        ${select('nav', 'Navigation', v('nav', 'side'), [['side', 'Side menu'], ['top', 'Top menu']])}
-        ${input('accent', 'Accent colour', v('accent', BASE_STYLES.iris.accent), { type: 'color', help: 'Of the theme style; the default stores nothing.' })}
+      ${region(tx('aw.appearance'), html`<div class="form-grid">
+        ${select('base', tx('aw.theme_style'), v('base', 'iris'), [['iris', tx('aw.iris_light_body_dark_header')], ['lavender', tx('aw.lavender_rounded_indigo')], ['standard', tx('aw.standard_blue_navy_header')]])}
+        ${select('nav', tx('aw.navigation'), v('nav', 'side'), [['side', tx('aw.side_menu')], ['top', tx('aw.top_menu')]])}
+        ${input('accent', tx('aw.accent_colour'), v('accent', BASE_STYLES.iris.accent), { type: 'color', help: tx('aw.of_the_theme_style_the') })}
       </div>`)}
-      ${region('Pages', html`<ul class="aw-pages">
-        <li><span class="aw-page-kind">${icon('home')} Home</span><span class="muted">a hero with the name and icon, and a card per page</span></li>
+      ${region(tx('aw.pages'), html`<ul class="aw-pages">
+        <li><span class="aw-page-kind">${icon('home')} ${tx('aw.home')}</span><span class="muted">${tx('aw.a_hero_with_the_name')}</span></li>
         ${known
           ? relations.length
             ? relations.map((r, i) => html`<li><input type="hidden" name="t_${i}" value="${r.relname}">
                 <label class="aw-page-kind" for="f_k_${i}">${icon(r.kind === 'view' ? 'eye' : 'table')} ${r.label}</label>
-                <select id="f_k_${i}" name="k_${i}">${kindsFor(r).map((k) => html`<option value="${k}"${k === kindOf(r, i) ? raw(' selected') : ''}>${PAGE_KINDS[k]}</option>`)}</select>
-                <small class="muted"><code>${r.relname}</code> · ${r.kind === 'view' ? 'view' : rows(r)}${r.kind === 'table' && !r.pk ? ', no single-column key: no form' : ''}${Number(r.rows ?? 0) > LARGE_TABLE ? ': a paged grid' : ''}</small>${rlsBadge(r)}</li>`)
-            : html`<li class="muted">${schema} has no tables or views.</li>`
-          : html`<li class="muted">Choose a schema under Data for a page per table, or add pages with the page wizards later.</li>`}
+                <select id="f_k_${i}" name="k_${i}">${kindsFor(r).map((k) => html`<option value="${k}"${k === kindOf(r, i) ? raw(' selected') : ''}>${tx.dyn(`aw.k.${k || 'none'}`, PAGE_KINDS[k])}</option>`)}</select>
+                <small class="muted"><code>${r.relname}</code> · ${r.kind === 'view' ? tx('aw.view') : rows(r)}${r.kind === 'table' && !r.pk ? tx('aw.no_key') : ''}${Number(r.rows ?? 0) > LARGE_TABLE ? tx('aw.paged_grid') : ''}</small>${rlsBadge(r)}</li>`)
+            : html`<li class="muted">${tx('aw.no_relations', { schema })}</li>`
+          : html`<li class="muted">${tx('aw.choose_a_schema_under_data')}</li>`}
       </ul>
-      ${known ? check('chart', 'Dashboard: a chart per table with the number of rows per parent row (a foreign key) or per value of a column whose values repeat', b ? b.chart === 'true' : true) : ''}`, '', 'aw-pages')}
-      ${region('Features', html`<div class="aw-features">${FEATURES.map(([k, label, help]) => check(`f_${k}`, label, features[k], help))}</div>`)}
-      ${region('Settings', html`<div class="form-grid">
-        <div class="field"><label class="label" for="f_alias">Alias (URL)</label>
+      ${known ? check('chart', tx('aw.dashboard_a_chart_per_table'), b ? b.chart === 'true' : true) : ''}`, '', 'aw-pages')}
+      ${region(tx('aw.features'), html`<div class="aw-features">${FEATURES.map(([k, label, help]) => { const [l, h] = featureText(k, label, help); return check(`f_${k}`, l, features[k], h); })}</div>`)}
+      ${region(tx('aw.settings'), html`<div class="form-grid">
+        <div class="field"><label class="label" for="f_alias">${tx('aw.alias_url')}</label>
           <input id="f_alias" name="alias" value="${v('alias', known ? await aliasFor(schema) : '')}" required pattern="[a-z][a-z0-9_\-]*" maxlength="50" data-derive-from="f_name"${b && b.alias ? raw(' data-edited') : ''}>
-          <small class="help">lowercase, e.g. inventory → /a/inventory; follows the name until you change it</small></div>
-        ${select('authentication', 'Authentication', v('authentication', 'app_users'), [['app_users', 'App users (login page)'], ['none', 'None (public)']])}
-        ${input('admin_user', 'First user', v('admin_user', ''), { placeholder: 'e.g. your name', help: 'Gets the admin role. An existing account in Users is reused.' })}
-        ${input('admin_password', 'Password', '', { type: 'password', auto: 'new-password', help: 'For a new account; at least 8 characters.' })}
-        ${select('language', 'Language', v('language', 'en'), Object.entries(LANGUAGE_NAMES).map(([code, name]): [string, string] => [code, `${name} (${code})`]))}
+          <small class="help">${tx('aw.lowercase_e_g_inventory_a')}</small></div>
+        ${select('authentication', tx('aw.authentication'), v('authentication', 'app_users'), [['app_users', tx('aw.app_users_login_page')], ['none', tx('aw.none_public')]])}
+        ${input('admin_user', tx('aw.first_user'), v('admin_user', ''), { placeholder: tx('aw.e_g_your_name'), help: tx('aw.gets_the_admin_role_an') })}
+        ${input('admin_password', tx('aw.password'), '', { type: 'password', auto: 'new-password', help: tx('aw.for_a_new_account_at') })}
+        ${select('language', tx('aw.language'), v('language', 'en'), Object.entries(LANGUAGE_NAMES).map(([code, name]): [string, string] => [code, `${name} (${code})`]))}
       </div>`)}
       ${!known && bp.length
-        ? html`<details class="region region-standard aw-advanced"><summary class="region-header"><h2>Advanced</h2></summary><div class="region-body"><div class="form-grid">
-            ${select('boilerplate', 'Start from', v('boilerplate', ''), [['', '- a blank application -'], ...bp.map((x): [string, string] => [String(x.id), `${x.name} (boilerplate)`])],
-              'A boilerplate application\'s pages, shared components and settings are copied; the new application keeps its own name, alias, role and authentication.')}
+        ? html`<details class="region region-standard aw-advanced"><summary class="region-header"><h2>${tx('aw.advanced')}</h2></summary><div class="region-body"><div class="form-grid">
+            ${select('boilerplate', tx('aw.start_from'), v('boilerplate', ''), [['', tx('aw.a_blank_application')], ...bp.map((x): [string, string] => [String(x.id), tx('aw.bp_option', { name: x.name })])],
+              tx('aw.bp_help'))}
           </div></div></details>`
         : ''}
-      <div class="buttons"><a class="btn" href="${BASE}">Cancel</a><button class="btn btn-hot">Create application</button></div>
+      <div class="buttons"><a class="btn" href="${BASE}">${tx('aw.cancel')}</a><button class="btn btn-hot">${tx('aw.create_application')}</button></div>
     </form>
   </div>`;
-  return send(reply, s, shell(s, 'Create application', [['App Builder', BASE], ['Create']], main));
+  return send(reply, s, shell(s, tx('aw.create_application'), [[tx('aw.app_builder'), BASE], [tx('aw.create')]], main));
 }