peer-ai-standards 1.0.0-next.0

package/dist/core/testing.js

@@ -0,0 +1,124 @@
+// What's tested, including testing for security, and how tests stay trustworthy.
+export const testing = [
+    {
+        id: "TEST-01",
+        domain: "testing",
+        title: "A bug fix ships with the test that would have caught it",
+        rule: "Every bug fix comes with a test that fails without the fix and passes with it.",
+        why: "A bug fixed without a test comes back, usually during the next refactor.",
+        ask: "Does this bug fix come with a test that would have caught the bug?",
+        stage: "mvp",
+        check: "ai-review",
+        severity: "medium",
+    },
+    {
+        id: "TEST-02",
+        domain: "testing",
+        title: "The main journeys are the acceptance tests",
+        rule: "The main journeys through the product are written as end-to-end tests, and an area isn't done until they pass. A rebuild must pass the old product's journeys.",
+        why: "Unit tests can all pass while the one thing people came to do is broken.",
+        ask: "Do the product's main journeys still pass with this change?",
+        stage: "mvp",
+        check: "auto",
+        severity: "medium",
+    },
+    {
+        id: "TEST-03",
+        domain: "testing",
+        title: "Business rules are tested thoroughly with plain values",
+        rule: "Business rules are tested with plain values, case by case, including the edges, with a name for each case.",
+        why: "Plain rules are cheap to test exhaustively, and the edges are where the bugs are.",
+        ask: "Are the business rules in this change tested case by case, including the edges?",
+        stage: "mvp",
+        check: "auto",
+        severity: "medium",
+    },
+    {
+        id: "TEST-04",
+        domain: "testing",
+        title: "Tests check behaviour, not implementation",
+        rule: "Tests check what the code does, the way a person or caller would see it, not how it does it internally.",
+        why: "Tests tied to the implementation break on every refactor and still miss the behaviour that matters.",
+        ask: "Do the tests in this change check behaviour rather than internal details?",
+        stage: "mvp",
+        check: "ai-review",
+        severity: "low",
+    },
+    {
+        id: "TEST-05",
+        domain: "testing",
+        title: "Tests state what they need",
+        rule: "A test that needs something, such as seeded data, a port or a clock, checks for it and skips with a reason when it's missing, rather than failing for want of it.",
+        why: "A test that fails for the wrong reason teaches people to ignore failing tests.",
+        ask: "Does every test in this change state what it needs?",
+        stage: "mvp",
+        check: "ai-review",
+        severity: "low",
+    },
+    {
+        id: "TEST-06",
+        domain: "testing",
+        title: "Test databases are built by the migrations",
+        rule: "The database a test runs against is built by the same migrations as production.",
+        why: "A test database built any other way passes tests that production would fail.",
+        ask: "Is the test database in this change built by the migrations?",
+        stage: "mvp",
+        check: "auto",
+        severity: "medium",
+    },
+    {
+        id: "TEST-07",
+        domain: "testing",
+        title: "No test depends on another's leftovers",
+        rule: "Every test sets up what it needs and cleans up after itself. None depends on what another test left behind.",
+        why: "Tests that share leftovers pass or fail depending on the order they run in.",
+        ask: "Could any test in this change pass or fail depending on another test?",
+        stage: "mvp",
+        check: "ai-review",
+        severity: "medium",
+    },
+    {
+        id: "TEST-08",
+        domain: "testing",
+        title: "Security-sensitive code has abuse tests",
+        rule: "Code that handles sign-in, permissions, money, uploads or input that reaches a database has tests that attack it: injection attempts, other people's ids, missing, expired or tampered tokens, oversized input and going past rate limits. Each test checks the attack is refused. A fixed vulnerability gets a test that repeats the attack. The tests run against the project's own app, never a live system.",
+        why: "Security holes don't show up in tests that only send what a well-behaved client would send, and a fixed hole with no test can quietly open again.",
+        ask: "Does the security-sensitive code in this change have tests that attack it and check the attack is refused?",
+        stage: "mvp",
+        check: "ai-review",
+        severity: "medium",
+    },
+    {
+        id: "TEST-09",
+        domain: "testing",
+        title: "A check is seen failing before it's trusted",
+        rule: "A new test, lint rule or gate is made to fail once on purpose, to prove it can, before anyone relies on it passing.",
+        why: "A check that can't fail reports the same green as one that passed. A green run proves nothing until you've seen it go red.",
+        ask: "Has each new check in this change been seen to fail?",
+        stage: "mvp",
+        check: "ai-review",
+        severity: "low",
+    },
+    {
+        id: "TEST-10",
+        domain: "testing",
+        title: "A skilled attacker tests the product before launch and every year",
+        rule: "Before the product first reaches production, after big changes to who uses it or how it's reached, and at least once a year, someone skilled who didn't build it tests it as an attacker would: a penetration test, within agreed limits and only against the project's own systems. Every finding is fixed or accepted as a risk by a named person.",
+        why: "Automated tests and scanners find the known kinds of problem. A skilled person finds the ones particular to your product, such as two small flaws that together open a big one.",
+        ask: "When was the last penetration test, and is every finding fixed or accepted?",
+        stage: "production",
+        check: "person",
+        severity: "medium",
+    },
+    {
+        id: "TEST-11",
+        domain: "testing",
+        title: "A parser you write is fuzz-tested",
+        rule: "Code the project writes itself to read files or formats from outside, such as an import, a file format or a message protocol, is fuzz-tested: fed large amounts of random and broken input to check it never crashes, hangs or runs out of memory.",
+        why: "Broken files are a classic way in, and nobody writes by hand the millions of strange inputs a fuzzer tries. Well-known parsing libraries are fuzzed by their makers; your own code isn't.",
+        ask: "Does this change add code that reads an outside format, and is it fuzz-tested?",
+        stage: "production",
+        check: "ai-review",
+        severity: "medium",
+    },
+];

package/dist/domains.d.ts

@@ -0,0 +1,6 @@
+import type { DomainId } from "peer-ai-workflow";
+/** Each domain's name and what it covers, in plain words, for the generated pages. */
+export declare const DOMAIN_INFO: Record<DomainId, {
+    title: string;
+    about: string;
+}>;

package/dist/domains.js

@@ -0,0 +1,53 @@
+/** Each domain's name and what it covers, in plain words, for the generated pages. */
+export const DOMAIN_INFO = {
+    requirements: {
+        title: "Requirements",
+        about: "What the product must do, for whom, and how anyone will know it works.",
+    },
+    architecture: {
+        title: "Architecture",
+        about: "How a system is divided, and which way its parts depend on each other. These hold for any architecture: a modular monolith, microservices, a mobile app or a library. A folder layout is a stack profile's default, never a core rule.",
+    },
+    "system-design": {
+        title: "System design and scalability",
+        about: "How the system behaves under load, concurrency and background work.",
+    },
+    "api-design": { title: "API design", about: "How services and clients agree on what they send each other." },
+    frontend: { title: "Frontend", about: "How screens get, hold and show data." },
+    mobile: { title: "Mobile", about: "What phone apps need beyond the frontend rules." },
+    "design-accessibility": {
+        title: "Design and accessibility",
+        about: "Design tokens, shared components, and making the product work for everyone.",
+    },
+    backend: { title: "Backend", about: "How servers take requests, validate them and report what happened." },
+    data: { title: "Data", about: "Databases, migrations and stored files." },
+    performance: {
+        title: "Performance and caching",
+        about: "Knowing what things cost, and caching only what's safe to cache.",
+    },
+    reliability: { title: "Reliability", about: "Staying up, and failing safely when something underneath fails." },
+    security: { title: "Security", about: "Keeping people's data and the system itself safe from attack." },
+    "privacy-compliance": {
+        title: "Privacy and compliance",
+        about: "Personal data, and the laws and rules a product must follow.",
+    },
+    testing: { title: "Testing", about: "What's tested, and how tests stay trustworthy." },
+    delivery: { title: "Delivery", about: "Dependencies, pipelines, and how changes reach people." },
+    operations: {
+        title: "Infrastructure and operations",
+        about: "Environments, logs, metrics, alerts, and running the system.",
+    },
+    "ai-features": { title: "AI features", about: "Features that use AI models." },
+    "code-quality": {
+        title: "Code quality",
+        about: "What makes code good in any language: naming, size, duplication, errors and types.",
+    },
+    money: {
+        title: "Money",
+        about: "For products with the `money` trait. The project's add-on names its currency's smallest unit.",
+    },
+    "safety-critical": {
+        title: "Safety-critical data",
+        about: "For products with the `safety-critical` trait: data where a wrong value could hurt someone, such as allergens, medical dosage, legal deadlines, or eligibility that affects a person's rights. The project's add-on names what counts.",
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import { type DomainId, type Trait } from "peer-ai-workflow";
+import { type AppliedRule, type Part, type Profile, type ProfileSelection } from "./profile.ts";
+import { type Rule, type RuleInput, type Stage } from "./rule.ts";
+export { DOMAIN_INFO } from "./domains.ts";
+export { PIPELINE_JOBS, checkProfiles, overrideFits, withValue, VALUE, type AppliedRule, type Enforcer, type EnforcerTool, type Example, type Part, type PipelineJob, type Profile, type ProfileInput, type ProfileRule, type ProfileSelection, type Value, } from "./profile.ts";
+export { RuleSchema, SourceSchema, STAGES, traitsNeeded, type Rule, type RuleInput, type Stage } from "./rule.ts";
+/** Checks every rule against the schema and that no id is used twice. */
+export declare function checkRules(inputs: RuleInput[]): {
+    rules: Rule[];
+    problems: string[];
+};
+/** Every core rule, in domain order. */
+export declare const CORE_RULES: readonly Rule[];
+export interface Selection {
+    stage: Stage;
+    traits?: readonly Trait[];
+    domains?: readonly DomainId[];
+}
+/** The rules that apply to a project at its stage, with its traits, optionally in some domains only. */
+export declare function rulesFor({ stage, traits, domains }: Selection): Rule[];
+/** Every stack profile, bases before the profiles that extend them. */
+export declare const PROFILES: readonly Profile[];
+/** The profile with this id, if there is one. */
+export declare const profile: (id: string) => Profile | undefined;
+/** The listed profiles that apply to a part, with the profiles they extend, bases first. */
+export declare const profilesForPart: (listed: readonly string[], part: Part) => Profile[];
+/** The profile rules that apply to a part at the project's stage, with the project's values. */
+export declare const profileRulesFor: (selection: ProfileSelection) => AppliedRule[];
+/** Every profile rule, by id. */
+export declare const PROFILE_RULES: ReadonlyMap<string, Profile["rules"][number]>;

package/dist/index.js

@@ -0,0 +1,118 @@
+import { DOMAIN_IDS, DOMAINS } from "peer-ai-workflow";
+import { aiFeatures } from "./core/ai-features.js";
+import { apiDesign } from "./core/api-design.js";
+import { architecture } from "./core/architecture.js";
+import { backend } from "./core/backend.js";
+import { codeQuality } from "./core/code-quality.js";
+import { data } from "./core/data.js";
+import { delivery } from "./core/delivery.js";
+import { designAccessibility } from "./core/design-accessibility.js";
+import { frontend } from "./core/frontend.js";
+import { mobile } from "./core/mobile.js";
+import { money } from "./core/money.js";
+import { operations } from "./core/operations.js";
+import { performance } from "./core/performance.js";
+import { privacyCompliance } from "./core/privacy-compliance.js";
+import { reliability } from "./core/reliability.js";
+import { requirements } from "./core/requirements.js";
+import { safetyCritical } from "./core/safety-critical.js";
+import { security } from "./core/security.js";
+import { systemDesign } from "./core/system-design.js";
+import { testing } from "./core/testing.js";
+import { applyProfiles, checkProfiles, profilesFor, } from "./profile.js";
+import { express } from "./profiles/express.js";
+import { fastapi } from "./profiles/fastapi.js";
+import { fastify } from "./profiles/fastify.js";
+import { githubActions } from "./profiles/github-actions.js";
+import { nestjs } from "./profiles/nestjs.js";
+import { next } from "./profiles/next.js";
+import { node } from "./profiles/node.js";
+import { python } from "./profiles/python.js";
+import { reactNative } from "./profiles/react-native.js";
+import { react } from "./profiles/react.js";
+import { typescript } from "./profiles/typescript.js";
+import { RuleSchema, STAGES, traitsNeeded } from "./rule.js";
+export { DOMAIN_INFO } from "./domains.js";
+export { PIPELINE_JOBS, checkProfiles, overrideFits, withValue, VALUE, } from "./profile.js";
+export { RuleSchema, SourceSchema, STAGES, traitsNeeded } from "./rule.js";
+const CORE_INPUTS = [
+    ...requirements,
+    ...architecture,
+    ...systemDesign,
+    ...apiDesign,
+    ...frontend,
+    ...mobile,
+    ...designAccessibility,
+    ...backend,
+    ...data,
+    ...performance,
+    ...reliability,
+    ...security,
+    ...privacyCompliance,
+    ...testing,
+    ...delivery,
+    ...operations,
+    ...aiFeatures,
+    ...codeQuality,
+    ...money,
+    ...safetyCritical,
+];
+/** Checks every rule against the schema and that no id is used twice. */
+export function checkRules(inputs) {
+    const rules = [];
+    const problems = [];
+    const seen = new Set();
+    for (const input of inputs) {
+        const result = RuleSchema.safeParse(input);
+        if (!result.success) {
+            for (const issue of result.error.issues)
+                problems.push(`${input.id}: ${issue.path.join(".")}: ${issue.message}`);
+            continue;
+        }
+        if (seen.has(result.data.id))
+            problems.push(`${result.data.id}: the id is used twice`);
+        seen.add(result.data.id);
+        rules.push(result.data);
+    }
+    return { rules, problems };
+}
+const checked = checkRules(CORE_INPUTS);
+if (checked.problems.length > 0) {
+    throw new Error(`Peer AI's standards aren't valid:\n- ${checked.problems.join("\n- ")}`);
+}
+/** Every core rule, in domain order. */
+export const CORE_RULES = [...checked.rules].sort((a, b) => DOMAIN_IDS.indexOf(a.domain) - DOMAIN_IDS.indexOf(b.domain) || a.id.localeCompare(b.id, "en", { numeric: true }));
+/** The rules that apply to a project at its stage, with its traits, optionally in some domains only. */
+export function rulesFor({ stage, traits = [], domains }) {
+    const reached = STAGES.indexOf(stage);
+    return CORE_RULES.filter((rule) => STAGES.indexOf(rule.stage) <= reached &&
+        traitsNeeded(rule).every((trait) => traits.includes(trait)) &&
+        (domains === undefined || domains.includes(rule.domain)));
+}
+const PROFILE_INPUTS = [
+    typescript,
+    node,
+    react,
+    reactNative,
+    next,
+    express,
+    nestjs,
+    fastify,
+    python,
+    fastapi,
+    githubActions,
+];
+const checkedProfiles = checkProfiles(PROFILE_INPUTS, CORE_RULES, Object.values(DOMAINS));
+if (checkedProfiles.problems.length > 0) {
+    throw new Error(`Peer AI's stack profiles aren't valid:\n- ${checkedProfiles.problems.join("\n- ")}`);
+}
+/** Every stack profile, bases before the profiles that extend them. */
+export const PROFILES = checkedProfiles.profiles;
+/** The profile with this id, if there is one. */
+export const profile = (id) => PROFILES.find((candidate) => candidate.id === id);
+/** The listed profiles that apply to a part, with the profiles they extend, bases first. */
+export const profilesForPart = (listed, part) => profilesFor(PROFILES, listed, part);
+/** The profile rules that apply to a part at the project's stage, with the project's values. */
+export const profileRulesFor = (selection) => applyProfiles(PROFILES, selection);
+/** Every profile rule, by id. */
+export const PROFILE_RULES = new Map(PROFILES.flatMap((candidate) => candidate.rules.map((rule) => [rule.id, rule])));

package/dist/profile.d.ts

@@ -0,0 +1,262 @@
+import { type Trait } from "peer-ai-workflow";
+import { z } from "zod";
+import { type Rule, type Stage } from "./rule.ts";
+/** A number or a choice a project may change in standards.overrides. */
+export type Value = number | string;
+/** The jobs of Peer AI's pipeline workflow that check a rule automatically (RFC 0006, section 4). */
+export declare const PIPELINE_JOBS: readonly ["secrets", "dependencies", "workflows", "code"];
+export type PipelineJob = (typeof PIPELINE_JOBS)[number];
+/** Where an option holds this, the tool gets the rule's value: its default, or the project's. */
+export declare const VALUE = "$value";
+export declare const EnforcerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    tool: z.ZodLiteral<"eslint">;
+    rule: z.ZodString;
+    options: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    typed: z.ZodOptional<z.ZodBoolean>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    ignores: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    tool: z.ZodLiteral<"ruff">;
+    rule: z.ZodString;
+    settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strict>, z.ZodObject<{
+    tool: z.ZodLiteral<"github-actions">;
+    job: z.ZodEnum<{
+        code: "code";
+        secrets: "secrets";
+        dependencies: "dependencies";
+        workflows: "workflows";
+    }>;
+    finding: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    tool: z.ZodLiteral<"typescript">;
+    option: z.ZodString;
+    value: z.ZodUnknown;
+}, z.core.$strict>], "tool">;
+export type Enforcer = z.output<typeof EnforcerSchema>;
+export type EnforcerTool = Enforcer["tool"];
+/** Example code: fixed, or written for the rule's value, such as a function one line too long. */
+export type Example = string | ((value: Value) => string);
+export declare const ExamplesSchema: z.ZodObject<{
+    file: z.ZodString;
+    fails: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<(value: Value) => string, (value: Value) => string>]>;
+    passes: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<(value: Value) => string, (value: Value) => string>]>;
+}, z.core.$strict>;
+export declare const ProfileRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    rule: z.ZodString;
+    why: z.ZodString;
+    ask: z.ZodString;
+    stage: z.ZodEnum<{
+        prototype: "prototype";
+        mvp: "mvp";
+        production: "production";
+    }>;
+    check: z.ZodEnum<{
+        auto: "auto";
+        "ai-review": "ai-review";
+        person: "person";
+    }>;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    when: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "ai-features": "ai-features";
+        money: "money";
+        "safety-critical": "safety-critical";
+        "several-audiences": "several-audiences";
+        offline: "offline";
+        "real-time": "real-time";
+        uploads: "uploads";
+    }>>>;
+    sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        ref: z.ZodString;
+        url: z.ZodOptional<z.ZodURL>;
+    }, z.core.$strict>>>;
+    carries: z.ZodString;
+    architectures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    default: z.ZodOptional<z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+        unit: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    enforcer: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        tool: z.ZodLiteral<"eslint">;
+        rule: z.ZodString;
+        options: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        typed: z.ZodOptional<z.ZodBoolean>;
+        files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        ignores: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"ruff">;
+        rule: z.ZodString;
+        settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"github-actions">;
+        job: z.ZodEnum<{
+            code: "code";
+            secrets: "secrets";
+            dependencies: "dependencies";
+            workflows: "workflows";
+        }>;
+        finding: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"typescript">;
+        option: z.ZodString;
+        value: z.ZodUnknown;
+    }, z.core.$strict>], "tool">>;
+    examples: z.ZodOptional<z.ZodObject<{
+        file: z.ZodString;
+        fails: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<(value: Value) => string, (value: Value) => string>]>;
+        passes: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<(value: Value) => string, (value: Value) => string>]>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ProfileRuleInput = z.input<typeof ProfileRuleSchema>;
+export declare const ProfileSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    prefix: z.ZodString;
+    about: z.ZodString;
+    stacks: z.ZodArray<z.ZodString>;
+    extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    rules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        rule: z.ZodString;
+        why: z.ZodString;
+        ask: z.ZodString;
+        stage: z.ZodEnum<{
+            prototype: "prototype";
+            mvp: "mvp";
+            production: "production";
+        }>;
+        check: z.ZodEnum<{
+            auto: "auto";
+            "ai-review": "ai-review";
+            person: "person";
+        }>;
+        severity: z.ZodEnum<{
+            critical: "critical";
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        when: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            "ai-features": "ai-features";
+            money: "money";
+            "safety-critical": "safety-critical";
+            "several-audiences": "several-audiences";
+            offline: "offline";
+            "real-time": "real-time";
+            uploads: "uploads";
+        }>>>;
+        sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            ref: z.ZodString;
+            url: z.ZodOptional<z.ZodURL>;
+        }, z.core.$strict>>>;
+        carries: z.ZodString;
+        architectures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        default: z.ZodOptional<z.ZodObject<{
+            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            unit: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        enforcer: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            tool: z.ZodLiteral<"eslint">;
+            rule: z.ZodString;
+            options: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+            typed: z.ZodOptional<z.ZodBoolean>;
+            files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            ignores: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodObject<{
+            tool: z.ZodLiteral<"ruff">;
+            rule: z.ZodString;
+            settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            tool: z.ZodLiteral<"github-actions">;
+            job: z.ZodEnum<{
+                code: "code";
+                secrets: "secrets";
+                dependencies: "dependencies";
+                workflows: "workflows";
+            }>;
+            finding: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            tool: z.ZodLiteral<"typescript">;
+            option: z.ZodString;
+            value: z.ZodUnknown;
+        }, z.core.$strict>], "tool">>;
+        examples: z.ZodOptional<z.ZodObject<{
+            file: z.ZodString;
+            fails: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<(value: Value) => string, (value: Value) => string>]>;
+            passes: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<(value: Value) => string, (value: Value) => string>]>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ProfileInput = z.input<typeof ProfileSchema>;
+/** A profile rule as the tools use it: with its profile, and the domain of the core rule it carries. */
+export type ProfileRule = z.output<typeof ProfileRuleSchema> & {
+    profile: string;
+    domain: Rule["domain"];
+};
+export interface Profile {
+    id: string;
+    name: string;
+    prefix: string;
+    about: string;
+    stacks: string[];
+    extends: string[];
+    rules: ProfileRule[];
+}
+/**
+ * Checks every profile against the schema and against the core: prefixes and ids used once, each
+ * rule's id starting with its profile's prefix, each carried rule a core rule, and every profile
+ * it extends known, without a loop.
+ */
+export declare function checkProfiles(inputs: ProfileInput[], core: readonly Rule[], corePrefixes: readonly string[]): {
+    profiles: Profile[];
+    problems: string[];
+};
+/** A part of the product, as a profile sees it. */
+export interface Part {
+    /** Stack tags, such as ["typescript", "expo"]. None: every listed profile applies. */
+    stack?: readonly string[];
+    /** The part's architecture label, such as layered. */
+    architecture?: string;
+}
+/**
+ * The listed profiles that apply to a part, with the profiles they extend, bases first. A listed
+ * profile applies when the part's stack has one of its tags, when it names no stacks, or when the
+ * part names no stack. A profile it extends comes only with it, never on its own tag.
+ */
+export declare function profilesFor(all: readonly Profile[], listed: readonly string[], part: Part): Profile[];
+/** A profile rule as it applies to one project: its value set, and {value} filled in. */
+export type AppliedRule = ProfileRule & {
+    value?: Value;
+};
+export interface ProfileSelection extends Part {
+    listed: readonly string[];
+    stage: Stage;
+    traits?: readonly Trait[];
+    /** Values the project changed, by rule id, from standards.overrides. */
+    overrides?: Readonly<Record<string, {
+        value: Value;
+    }>>;
+}
+/** Puts the rule's value in its text, and in its enforcer's options. */
+export declare function withValue(rule: ProfileRule, value: Value | undefined): AppliedRule;
+/**
+ * The profile rules that apply to a part at the project's stage, with its traits and its
+ * architecture, and with the project's values in place of the defaults.
+ */
+export declare function applyProfiles(all: readonly Profile[], selection: ProfileSelection): AppliedRule[];
+/**
+ * Whether a project's value can stand in for the rule's default: a rule with one, and a value of
+ * its type. A default that's a whole number, such as a count of lines, takes only whole numbers of
+ * 0 or more, since the tools refuse anything else.
+ */
+export declare function overrideFits(rule: ProfileRule, value: Value): boolean;