@webyy/kontrakt 0.0.0-stage → 0.1.0

package/dist/bilde.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Bilder ligger i R2 under nøkler som utledes av innholdet (arkitektur.md 2.6). Repoet lagrer bare
+ * nøkkelen, alt-teksten og målene. Samme fil gir alltid samme nøkkel, og et objekt overskrives aldri.
+ */
+export declare const BILDEFORMATER: {
+    readonly "image/jpeg": "jpg";
+    readonly "image/png": "png";
+    readonly "image/webp": "webp";
+    readonly "image/avif": "avif";
+};
+export type Bildeformat = keyof typeof BILDEFORMATER;
+export declare const BILDENOKKEL: RegExp;
+/** Verdien i et bildefelt, slik den står i innholdsfila. */
+export interface WebyyBildeVerdi {
+    nokkel: string;
+    alt: string;
+    bredde: number;
+    hoyde: number;
+}
+export declare function bildenokkel(sha256: string, format: Bildeformat): string;
+/** Alle bildenøkler i en oppføring, uansett hvor i strukturen de står. */
+export declare function finnBildenokler(data: unknown): string[];

package/dist/bilde.js

@@ -0,0 +1,18 @@
+/**
+ * Bilder ligger i R2 under nøkler som utledes av innholdet (arkitektur.md 2.6). Repoet lagrer bare
+ * nøkkelen, alt-teksten og målene. Samme fil gir alltid samme nøkkel, og et objekt overskrives aldri.
+ */
+export const BILDEFORMATER = { "image/jpeg": "jpg", "image/png": "png", "image/webp": "webp", "image/avif": "avif" };
+export const BILDENOKKEL = /^bilder\/[0-9a-f]{64}\.(jpg|png|webp|avif)$/;
+export function bildenokkel(sha256, format) {
+    return `bilder/${sha256}.${BILDEFORMATER[format]}`;
+}
+/** Alle bildenøkler i en oppføring, uansett hvor i strukturen de står. */
+export function finnBildenokler(data) {
+    if (Array.isArray(data))
+        return data.flatMap(finnBildenokler);
+    if (typeof data !== "object" || data === null)
+        return [];
+    const egne = typeof data.nokkel === "string" && BILDENOKKEL.test(data.nokkel) ? [data.nokkel] : [];
+    return [...new Set([...egne, ...Object.values(data).flatMap(finnBildenokler)])];
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { kjorManifest, MANIFESTFIL } from "./node.js";
+const BRUK = `Bruk: webyy manifest [--sjekk] [--uten-sync]
+
+  manifest      Lager ${MANIFESTFIL} fra webyy.config.ts og Astros innholdsskjema.
+  --sjekk       Skriver ingenting. Feiler hvis ${MANIFESTFIL} er utdatert eller innholdet er ugyldig.
+  --uten-sync   Hopper over «astro sync» (bruk når den nettopp er kjørt).`;
+const [kommando, ...flagg] = process.argv.slice(2);
+const ukjente = flagg.filter((f) => f !== "--sjekk" && f !== "--uten-sync");
+if (kommando !== "manifest" || ukjente.length > 0) {
+    console.error(BRUK);
+    process.exit(2);
+}
+try {
+    const sjekk = flagg.includes("--sjekk");
+    const { manifest, feil } = await kjorManifest(process.cwd(), { sjekk, sync: !flagg.includes("--uten-sync") });
+    const samlinger = Object.keys(manifest.samlinger).join(", ");
+    if (feil.length > 0) {
+        console.error(`webyy: ${feil.length} feil\n${feil.map((f) => `  ${f}`).join("\n")}`);
+        process.exit(1);
+    }
+    console.log(sjekk ? `webyy: ${MANIFESTFIL} er oppdatert og innholdet er gyldig (${samlinger}).` : `webyy: skrev ${MANIFESTFIL} (${samlinger}).`);
+}
+catch (e) {
+    console.error(`webyy: ${e instanceof Error ? e.message : e}`);
+    process.exit(1);
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type { Manifest, ManifestSamling, SamlingKonfig, Skjema, Valideringsfeil, WebyyKonfig, WebyyMerke } from "./typer.js";
+export { defineWebyy, lagManifest, merkSeksjoner, oppforingId, oppforingSti, oppforingUrl, serialiserManifest } from "./manifest.js";
+export { validerInnhold } from "./valider.js";
+export { BILDEFORMATER, BILDENOKKEL, bildenokkel, finnBildenokler, type Bildeformat, type WebyyBildeVerdi } from "./bilde.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { defineWebyy, lagManifest, merkSeksjoner, oppforingId, oppforingSti, oppforingUrl, serialiserManifest } from "./manifest.js";
+export { validerInnhold } from "./valider.js";
+export { BILDEFORMATER, BILDENOKKEL, bildenokkel, finnBildenokler } from "./bilde.js";

package/dist/manifest.d.ts

@@ -0,0 +1,18 @@
+import type { Manifest, ManifestSamling, Skjema, WebyyKonfig } from "./typer.js";
+export declare function defineWebyy(konfig: WebyyKonfig): WebyyKonfig;
+/**
+ * Slår sammen konfigurasjonen med Astros JSON Schema per samling.
+ * `skjemaer` er innholdet i `.astro/collections/<navn>.schema.json`.
+ */
+export declare function lagManifest(konfig: WebyyKonfig, skjemaer: Record<string, Skjema>): Manifest;
+export declare function serialiserManifest(manifest: Manifest): string;
+/**
+ * Merker hver liste der elementene er en discriminated union (oneOf av objekter med en felles
+ * `const`-nøkkel) med `webyy.seksjoner`. Editoren og byggeren kjenner seksjonslister på dette.
+ */
+export declare function merkSeksjoner(node: unknown): unknown;
+/** Repo-stien til en oppføring. Id-en kan ikke inneholde skråstrek eller punktum. */
+export declare function oppforingSti(samling: ManifestSamling, id: string): string;
+/** Id-en til en fil i samlingen, eller undefined hvis stien ikke hører til samlingen. */
+export declare function oppforingId(samling: ManifestSamling, sti: string): string | undefined;
+export declare function oppforingUrl(samling: ManifestSamling, id: string): string | undefined;

package/dist/manifest.js

@@ -0,0 +1,89 @@
+export function defineWebyy(konfig) {
+    return konfig;
+}
+/**
+ * Slår sammen konfigurasjonen med Astros JSON Schema per samling.
+ * `skjemaer` er innholdet i `.astro/collections/<navn>.schema.json`.
+ */
+export function lagManifest(konfig, skjemaer) {
+    kontrollerKonfig(konfig);
+    const samlinger = {};
+    for (const [navn, samling] of Object.entries(konfig.samlinger)) {
+        const skjema = skjemaer[navn];
+        if (!skjema) {
+            throw new Error(`Samlingen «${navn}» finnes ikke i src/content.config.ts (fant: ${Object.keys(skjemaer).join(", ") || "ingen"}).`);
+        }
+        const { $schema: _, ...uten } = skjema;
+        samlinger[navn] = {
+            tittel: samling.tittel,
+            mappe: samling.mappe.replace(/\/+$/, ""),
+            format: "json",
+            ...(samling.url ? { url: samling.url } : {}),
+            skjema: merkSeksjoner(uten),
+        };
+    }
+    return { versjon: 1, samlinger, etiketter: konfig.etiketter ?? {} };
+}
+export function serialiserManifest(manifest) {
+    return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+/**
+ * Merker hver liste der elementene er en discriminated union (oneOf av objekter med en felles
+ * `const`-nøkkel) med `webyy.seksjoner`. Editoren og byggeren kjenner seksjonslister på dette.
+ */
+export function merkSeksjoner(node) {
+    if (Array.isArray(node))
+        return node.map(merkSeksjoner);
+    if (!erObjekt(node))
+        return node;
+    const ut = Object.fromEntries(Object.entries(node).map(([k, v]) => [k, merkSeksjoner(v)]));
+    const items = ut.items;
+    if (ut.type === "array" && erObjekt(items) && Array.isArray(items.oneOf)) {
+        const diskriminator = finnDiskriminator(items.oneOf);
+        if (diskriminator) {
+            ut.webyy = { ...(erObjekt(ut.webyy) ? ut.webyy : {}), seksjoner: { diskriminator } };
+        }
+    }
+    return ut;
+}
+function finnDiskriminator(varianter) {
+    const egenskaper = varianter.map((v) => (erObjekt(v) && erObjekt(v.properties) ? v.properties : undefined));
+    if (egenskaper.some((e) => !e))
+        return undefined;
+    const kandidater = Object.keys(egenskaper[0]).filter((k) => egenskaper.every((e) => erObjekt(e[k]) && typeof e[k].const === "string"));
+    return kandidater.includes("type") ? "type" : kandidater[0];
+}
+/** Repo-stien til en oppføring. Id-en kan ikke inneholde skråstrek eller punktum. */
+export function oppforingSti(samling, id) {
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(id))
+        throw new Error(`Ugyldig id «${id}».`);
+    return `${samling.mappe}/${id}.json`;
+}
+/** Id-en til en fil i samlingen, eller undefined hvis stien ikke hører til samlingen. */
+export function oppforingId(samling, sti) {
+    const treff = sti.startsWith(`${samling.mappe}/`) ? /^([a-z0-9][a-z0-9-]*)\.json$/.exec(sti.slice(samling.mappe.length + 1)) : null;
+    return treff?.[1];
+}
+export function oppforingUrl(samling, id) {
+    if (!samling.url)
+        return undefined;
+    return id === "index" ? "/" : samling.url.replace("[id]", id);
+}
+function kontrollerKonfig(konfig) {
+    if (!erObjekt(konfig) || !erObjekt(konfig.samlinger) || Object.keys(konfig.samlinger).length === 0) {
+        throw new Error("webyy.config.ts må ha minst én samling under «samlinger».");
+    }
+    for (const [navn, s] of Object.entries(konfig.samlinger)) {
+        if (!s.tittel)
+            throw new Error(`Samlingen «${navn}» mangler tittel.`);
+        if (!s.mappe || s.mappe.startsWith("/") || s.mappe.split("/").includes("..")) {
+            throw new Error(`Samlingen «${navn}» må ha «mappe» som relativ sti i repoet.`);
+        }
+        if (s.url !== undefined && (!s.url.startsWith("/") || !s.url.includes("[id]"))) {
+            throw new Error(`«url» i samlingen «${navn}» må starte med / og inneholde [id].`);
+        }
+    }
+}
+function erObjekt(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}

package/dist/node.d.ts

@@ -0,0 +1,15 @@
+import type { Manifest } from "./typer.js";
+export declare const MANIFESTFIL = "webyy.json";
+export interface Resultat {
+    manifest: Manifest;
+    /** Feil som gjør at `--sjekk` feiler. Tom liste betyr at alt er i orden. */
+    feil: string[];
+}
+/**
+ * Lager manifestet for nettstedet i `rot`. Med `sjekk` skrives ingenting; i stedet sammenlignes
+ * manifestet med det som ligger der, og alt eksisterende innhold valideres slik editoren gjør.
+ */
+export declare function kjorManifest(rot: string, valg?: {
+    sjekk?: boolean;
+    sync?: boolean;
+}): Promise<Resultat>;

package/dist/node.js

@@ -0,0 +1,72 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { lagManifest, oppforingId, serialiserManifest } from "./manifest.js";
+import { validerInnhold } from "./valider.js";
+export const MANIFESTFIL = "webyy.json";
+const KONFIGFILER = ["webyy.config.ts", "webyy.config.mjs", "webyy.config.js"];
+/**
+ * Lager manifestet for nettstedet i `rot`. Med `sjekk` skrives ingenting; i stedet sammenlignes
+ * manifestet med det som ligger der, og alt eksisterende innhold valideres slik editoren gjør.
+ */
+export async function kjorManifest(rot, valg = {}) {
+    const konfig = await lesKonfig(rot);
+    if (valg.sync !== false)
+        astroSync(rot);
+    const manifest = lagManifest(konfig, await lesSkjemaer(rot));
+    const tekst = serialiserManifest(manifest);
+    const fil = join(rot, MANIFESTFIL);
+    if (!valg.sjekk) {
+        await writeFile(fil, tekst);
+        return { manifest, feil: [] };
+    }
+    const feil = [];
+    const gammel = existsSync(fil) ? await readFile(fil, "utf8") : undefined;
+    if (gammel !== tekst) {
+        feil.push(`${MANIFESTFIL} er ${gammel === undefined ? "ikke laget" : "utdatert"}. Kjør «npx webyy manifest» og commit fila.`);
+    }
+    for (const [navn, samling] of Object.entries(manifest.samlinger)) {
+        const mappe = join(rot, samling.mappe);
+        if (!existsSync(mappe)) {
+            feil.push(`Mappa ${samling.mappe} for samlingen «${navn}» finnes ikke.`);
+            continue;
+        }
+        for (const filnavn of (await readdir(mappe)).filter((f) => f.endsWith(".json")).sort()) {
+            const sti = `${samling.mappe}/${filnavn}`;
+            if (!oppforingId(samling, sti)) {
+                feil.push(`${sti}: filnavnet må bestå av små bokstaver, tall og bindestrek.`);
+                continue;
+            }
+            const data = JSON.parse(await readFile(join(rot, sti), "utf8"));
+            for (const f of validerInnhold(samling.skjema, data))
+                feil.push(`${sti}${f.sti ? ` ${f.sti}` : ""}: ${f.melding}`);
+        }
+    }
+    return { manifest, feil };
+}
+async function lesKonfig(rot) {
+    const fil = KONFIGFILER.map((f) => join(rot, f)).find(existsSync);
+    if (!fil)
+        throw new Error(`Fant ikke ${KONFIGFILER[0]} i ${rot}.`);
+    const modul = await import(pathToFileURL(fil).href);
+    return modul.default;
+}
+async function lesSkjemaer(rot) {
+    const mappe = join(rot, ".astro", "collections");
+    if (!existsSync(mappe))
+        throw new Error("Fant ikke .astro/collections. Kjør «astro sync» eller dropp --uten-sync.");
+    const skjemaer = {};
+    for (const fil of await readdir(mappe)) {
+        const navn = /^(.+)\.schema\.json$/.exec(fil)?.[1];
+        if (navn)
+            skjemaer[navn] = JSON.parse(await readFile(join(mappe, fil), "utf8"));
+    }
+    return skjemaer;
+}
+function astroSync(rot) {
+    const kjoring = spawnSync("npx", ["--no-install", "astro", "sync"], { cwd: rot, stdio: ["ignore", "ignore", "inherit"] });
+    if (kjoring.status !== 0)
+        throw new Error("«astro sync» feilet. Se feilmeldingen over.");
+}

package/dist/skjema.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+/**
+ * Bildefelt for content collections. Verdien er en referanse til R2, ikke en fil i repoet.
+ * Gjengis med `<WebyyBilde>` og optimaliseres av Astro ved bygg.
+ */
+export declare function webyyBilde(): z.ZodObject<{
+    nokkel: z.ZodString;
+    alt: z.ZodString;
+    bredde: z.ZodNumber;
+    hoyde: z.ZodNumber;
+}, z.core.$strip>;

package/dist/skjema.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { BILDENOKKEL } from "./bilde.js";
+/**
+ * Bildefelt for content collections. Verdien er en referanse til R2, ikke en fil i repoet.
+ * Gjengis med `<WebyyBilde>` og optimaliseres av Astro ved bygg.
+ */
+export function webyyBilde() {
+    return z
+        .object({
+        nokkel: z.string().regex(BILDENOKKEL),
+        alt: z.string().min(1).meta({ title: "Bildetekst for skjermlesere" }),
+        bredde: z.number().int().positive(),
+        hoyde: z.number().int().positive(),
+    })
+        .meta({ webyy: { felt: "bilde" } });
+}

package/dist/typer.d.ts

@@ -0,0 +1,39 @@
+/** JSON Schema (draft 2020-12) slik Astro skriver det, pluss Webyys merker under `webyy`. */
+export type Skjema = {
+    [nokkel: string]: unknown;
+};
+/** En samling er en mappe med én JSON-fil per oppføring; filnavnet uten `.json` er id-en. */
+export interface SamlingKonfig {
+    tittel: string;
+    mappe: string;
+    /** Adressen en oppføring får, med `[id]` som plassholder. Id-en `index` gir `/`. */
+    url?: string;
+}
+export interface WebyyKonfig {
+    /** Nøklene er navnene på samlingene i `src/content.config.ts`. */
+    samlinger: Record<string, SamlingKonfig>;
+    /** Norske visningsnavn for feltnøkler og seksjonstyper, f.eks. `{ lead: "Ingress" }`. */
+    etiketter?: Record<string, string>;
+}
+export interface ManifestSamling extends SamlingKonfig {
+    format: "json";
+    skjema: Skjema;
+}
+export interface Manifest {
+    versjon: 1;
+    samlinger: Record<string, ManifestSamling>;
+    etiketter: Record<string, string>;
+}
+/** Merker utvikleren setter med `.meta({ webyy: … })`, og som genereringen legger til. */
+export interface WebyyMerke {
+    felt?: "flerlinje" | "bilde" | "lenke";
+    /** Settes av genereringen på lister med seksjoner (discriminated union). */
+    seksjoner?: {
+        diskriminator: string;
+    };
+}
+export interface Valideringsfeil {
+    /** JSON Pointer til feltet, f.eks. `/sections/0/title`. Tom streng er hele oppføringen. */
+    sti: string;
+    melding: string;
+}

package/dist/typer.js

@@ -0,0 +1 @@
+export {};

package/dist/valider.d.ts

@@ -0,0 +1,6 @@
+import type { Skjema, Valideringsfeil } from "./typer.js";
+/**
+ * Validerer én oppføring mot samlingens skjema fra manifestet. Brukes likt i nettleseren,
+ * i API-et før commit og i `webyy manifest --sjekk`. Tom liste betyr gyldig.
+ */
+export declare function validerInnhold(skjema: Skjema, data: unknown): Valideringsfeil[];

package/dist/valider.js

@@ -0,0 +1,115 @@
+import { Validator } from "@cfworker/json-schema";
+const validatorer = new WeakMap();
+/** Ord som bare sier at et barn feilet. Barnets egen feil rapporteres for seg. */
+const OMSLUTTENDE = new Set(["properties", "items", "prefixItems", "allOf", "anyOf", "oneOf", "if", "then", "else", "$ref", "dependentSchemas"]);
+/**
+ * Validerer én oppføring mot samlingens skjema fra manifestet. Brukes likt i nettleseren,
+ * i API-et før commit og i `webyy manifest --sjekk`. Tom liste betyr gyldig.
+ */
+export function validerInnhold(skjema, data) {
+    let kompilert = validatorer.get(skjema);
+    if (!kompilert) {
+        const omskrevet = velgSeksjonEtterType(skjema);
+        kompilert = { validator: new Validator(omskrevet, "2020-12", false), skjema: omskrevet };
+        validatorer.set(skjema, kompilert);
+    }
+    const feil = [...kompilert.validator.validate(data).errors]
+        .filter((e) => !OMSLUTTENDE.has(e.keyword))
+        .map((e) => oversett(e, kompilert.skjema));
+    feil.push(...finnHtml(data, ""));
+    const sett = new Set();
+    return feil.filter((f) => !sett.has(f.sti) && sett.add(f.sti));
+}
+/**
+ * En seksjonsliste er `oneOf`, som gir én feil per variant når én seksjon er ugyldig. Her velges
+ * varianten etter diskriminatoren, slik at feilen gjelder feltet som faktisk er galt.
+ */
+function velgSeksjonEtterType(node) {
+    if (Array.isArray(node))
+        return node.map(velgSeksjonEtterType);
+    if (!erObjekt(node))
+        return node;
+    const ut = Object.fromEntries(Object.entries(node).map(([k, v]) => [k, velgSeksjonEtterType(v)]));
+    const merke = erObjekt(ut.webyy) && erObjekt(ut.webyy.seksjoner) ? ut.webyy.seksjoner : undefined;
+    if (merke && erObjekt(ut.items) && Array.isArray(ut.items.oneOf)) {
+        const d = merke.diskriminator;
+        const varianter = ut.items.oneOf;
+        const typer = varianter.map((v) => v.properties[d].const);
+        ut.items = {
+            type: "object",
+            required: [d],
+            properties: { [d]: { enum: typer } },
+            allOf: varianter.map((v, i) => ({ if: { properties: { [d]: { const: typer[i] } } }, then: v })),
+        };
+    }
+    return ut;
+}
+function oversett(e, skjema) {
+    let sti = e.instanceLocation.replace(/^#/, "");
+    const verdi = slaOpp(skjema, e.keywordLocation);
+    switch (e.keyword) {
+        case "required": {
+            const felt = /"([^"]+)"/.exec(e.error)?.[1];
+            if (felt)
+                sti = `${sti}/${felt.replace(/~/g, "~0").replace(/\//g, "~1")}`;
+            return { sti, melding: "Må fylles ut." };
+        }
+        case "type":
+            return { sti, melding: `Feil type, forventet ${TYPER[String(verdi)] ?? verdi}.` };
+        case "enum":
+            return { sti, melding: `Må være en av: ${verdi.join(", ")}.` };
+        case "const":
+            return { sti, melding: `Må være «${verdi}».` };
+        case "minLength":
+            return { sti, melding: verdi === 1 ? "Må fylles ut." : `Må ha minst ${verdi} tegn.` };
+        case "maxLength":
+            return { sti, melding: `Kan ha høyst ${verdi} tegn.` };
+        case "minItems":
+            return { sti, melding: `Må ha minst ${verdi} element.` };
+        case "maxItems":
+            return { sti, melding: `Kan ha høyst ${verdi} element.` };
+        case "minimum":
+        case "exclusiveMinimum":
+            return { sti, melding: `Må være minst ${verdi}.` };
+        case "maximum":
+        case "exclusiveMaximum":
+            return { sti, melding: `Kan være høyst ${verdi}.` };
+        case "format":
+            return { sti, melding: FORMATER[String(verdi)] ?? "Har feil format." };
+        case "pattern":
+            return { sti, melding: "Har feil format." };
+        default:
+            return { sti, melding: e.error };
+    }
+}
+const TYPER = { string: "tekst", number: "tall", integer: "heltall", boolean: "ja/nei", array: "liste", object: "gruppe" };
+const FORMATER = { email: "Må være en gyldig e-postadresse.", uri: "Må være en gyldig adresse (https://…)." };
+/**
+ * Tekst er ren tekst: ingen HTML, og ingen lenker som kjører kode. Dette er et ekstra lag;
+ * Astro escaper fortsatt alt ved gjengivelse.
+ */
+function finnHtml(data, sti) {
+    if (typeof data === "string") {
+        if (/<[a-z/!?]/i.test(data))
+            return [{ sti, melding: "HTML er ikke tillatt i tekst." }];
+        if (/^\s*(javascript|data|vbscript):/i.test(data.replace(/[\u0000-\u001f]/g, "")))
+            return [{ sti, melding: "Lenken er ikke tillatt." }];
+        return [];
+    }
+    if (Array.isArray(data))
+        return data.flatMap((v, i) => finnHtml(v, `${sti}/${i}`));
+    if (erObjekt(data))
+        return Object.entries(data).flatMap(([k, v]) => finnHtml(v, `${sti}/${k.replace(/~/g, "~0").replace(/\//g, "~1")}`));
+    return [];
+}
+function slaOpp(skjema, peker) {
+    return peker
+        .replace(/^#\/?/, "")
+        .split("/")
+        .filter(Boolean)
+        .map((del) => decodeURIComponent(del).replace(/~1/g, "/").replace(/~0/g, "~"))
+        .reduce((node, del) => node?.[del], skjema);
+}
+function erObjekt(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "@webyy/kontrakt",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Kontrakten mellom et Astro-nettsted og Webyy-editoren: webyy.config.ts → webyy.json, og validering av innhold.",
+  "license": "UNLICENSED",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "default": "./dist/node.js"
+    },
+    "./skjema": {
+      "types": "./dist/skjema.d.ts",
+      "default": "./dist/skjema.js"
+    }
+  },
+  "bin": {
+    "webyy": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepare": "npm run build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@cfworker/json-schema": "^4.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^5.0.5",
+    "zod": "^4.6.7"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "zod": "^4.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nettskaperne/webyy.git",
+    "directory": "packages/kontrakt"
+  },
+  "homepage": "https://webyy.dev"
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.