@phyzess/pappra 0.0.0-stage → 0.1.0-beta.2

package/dist/schemas/init.d.ts

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+import { type Diagnostic } from './diagnostics.js';
+export declare const INIT_CHOICES_SCHEMA = "pappra/init-choices/1";
+export declare const INIT_PLAN_SCHEMA = "pappra/init-plan/1";
+export declare const initRepositoryChoiceSchema: z.ZodObject<{
+    path: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+    access: z.ZodEnum<{
+        read: "read";
+        write: "write";
+    }>;
+}, z.core.$strict>;
+/**
+ * High-level, UI-independent init selections. Candidate validation IDs refer
+ * to WorkspaceDiscovery.validationCandidates; repository paths refer to
+ * discovered checkout keys.
+ */
+export declare const initChoicesSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/init-choices/1">;
+    name: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodUUID>;
+    repositories: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        id: z.ZodOptional<z.ZodString>;
+        access: z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>;
+    }, z.core.$strict>>;
+    knowledge: z.ZodObject<{
+        sources: z.ZodArray<z.ZodString>;
+        newDocuments: z.ZodString;
+        taskVisibility: z.ZodEnum<{
+            private: "private";
+            shared: "shared";
+        }>;
+    }, z.core.$strict>;
+    code: z.ZodObject<{
+        graph: z.ZodEnum<{
+            codegraph: "codegraph";
+            none: "none";
+        }>;
+        symbols: z.ZodEnum<{
+            auto: "auto";
+            none: "none";
+            serena: "serena";
+        }>;
+        prepare: z.ZodEnum<{
+            manual: "manual";
+            "on-demand": "on-demand";
+        }>;
+    }, z.core.$strict>;
+    validation: z.ZodArray<z.ZodString>;
+    excludes: z.ZodArray<z.ZodString>;
+    hosts: z.ZodArray<z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        pi: "pi";
+    }>>;
+}, z.core.$strict>;
+export declare const plannedFileChangeSchema: z.ZodObject<{
+    path: z.ZodString;
+    operation: z.ZodEnum<{
+        create: "create";
+        merge: "merge";
+        "replace-managed": "replace-managed";
+    }>;
+    expectedBeforeDigest: z.ZodNullable<z.ZodString>;
+    nextDigest: z.ZodString;
+    backupRequired: z.ZodBoolean;
+    owner: z.ZodLiteral<"pappra">;
+}, z.core.$strict>;
+export declare const initExternalActionSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "install-provider": "install-provider";
+        "install-runtime": "install-runtime";
+        "prepare-index": "prepare-index";
+    }>;
+    target: z.ZodString;
+    version: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const initPlanSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/init-plan/1">;
+    planId: z.ZodUUID;
+    workspaceRoot: z.ZodString;
+    discoveredAt: z.ZodISODateTime;
+    configurationDigest: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            create: "create";
+            merge: "merge";
+            "replace-managed": "replace-managed";
+        }>;
+        expectedBeforeDigest: z.ZodNullable<z.ZodString>;
+        nextDigest: z.ZodString;
+        backupRequired: z.ZodBoolean;
+        owner: z.ZodLiteral<"pappra">;
+    }, z.core.$strict>>;
+    externalActions: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "install-provider": "install-provider";
+            "install-runtime": "install-runtime";
+            "prepare-index": "prepare-index";
+        }>;
+        target: z.ZodString;
+        version: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type InitChoices = z.infer<typeof initChoicesSchema>;
+export type InitRepositoryChoice = z.infer<typeof initRepositoryChoiceSchema>;
+export type InitPlan = z.infer<typeof initPlanSchema>;
+export type InitExternalAction = z.infer<typeof initExternalActionSchema>;
+export type PlannedFileChange = z.infer<typeof plannedFileChangeSchema>;
+export type PlannedFileOperation = PlannedFileChange['operation'];
+export interface InitChoicesParseResult {
+    readonly value: InitChoices | null;
+    readonly diagnostics: readonly Diagnostic[];
+}
+/** Decodes external --config input without applying defaults or partial data. */
+export declare function parseInitChoices(value: unknown, source: string): InitChoicesParseResult;

package/dist/schemas/init.js

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import { createDiagnostic, pointer } from './diagnostics.js';
+import { diagnosticCodes } from './errors.js';
+import { hostSchema } from './machine.js';
+import { workspaceCodeSchema, workspaceKnowledgeSchema } from './workspace.js';
+export const INIT_CHOICES_SCHEMA = 'pappra/init-choices/1';
+export const INIT_PLAN_SCHEMA = 'pappra/init-plan/1';
+const identifierSchema = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+const digestSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+export const initRepositoryChoiceSchema = z.strictObject({
+    /** Discovered repository key: workspace-relative path or external:<id>. */
+    path: z.string().min(1).max(2048),
+    id: identifierSchema.optional(),
+    access: z.enum(['read', 'write']),
+});
+/**
+ * High-level, UI-independent init selections. Candidate validation IDs refer
+ * to WorkspaceDiscovery.validationCandidates; repository paths refer to
+ * discovered checkout keys.
+ */
+export const initChoicesSchema = z.strictObject({
+    schema: z.literal(INIT_CHOICES_SCHEMA),
+    name: z.string().min(1).max(200).optional(),
+    workspaceId: z.uuid().optional(),
+    repositories: z.array(initRepositoryChoiceSchema).max(128),
+    knowledge: workspaceKnowledgeSchema,
+    code: workspaceCodeSchema,
+    validation: z.array(z.string().min(1).max(1024)).max(128),
+    excludes: z.array(z.string().min(1).max(2048)).max(128),
+    hosts: z.array(hostSchema).max(16),
+});
+export const plannedFileChangeSchema = z.strictObject({
+    path: z.string().min(1).max(2048),
+    operation: z.enum(['create', 'merge', 'replace-managed']),
+    expectedBeforeDigest: digestSchema.nullable(),
+    nextDigest: digestSchema,
+    backupRequired: z.boolean(),
+    owner: z.literal('pappra'),
+});
+export const initExternalActionSchema = z.strictObject({
+    kind: z.enum(['install-runtime', 'install-provider', 'prepare-index']),
+    target: z.string().min(1).max(256),
+    version: z.string().min(1).max(256).nullable(),
+});
+export const initPlanSchema = z.strictObject({
+    schema: z.literal(INIT_PLAN_SCHEMA),
+    planId: z.uuid(),
+    workspaceRoot: z.string().min(1).max(4096),
+    discoveredAt: z.iso.datetime({ offset: true }),
+    configurationDigest: digestSchema,
+    files: z.array(plannedFileChangeSchema).max(256),
+    externalActions: z.array(initExternalActionSchema).max(128),
+});
+function issuePointer(path) {
+    return path.length === 0
+        ? null
+        : pointer(...path.map((segment) => String(segment)));
+}
+/** Decodes external --config input without applying defaults or partial data. */
+export function parseInitChoices(value, source) {
+    const parsed = initChoicesSchema.safeParse(value);
+    if (parsed.success)
+        return { value: parsed.data, diagnostics: [] };
+    const diagnostics = [];
+    for (const issue of parsed.error.issues) {
+        if (issue.code === 'unrecognized_keys') {
+            const base = issuePointer(issue.path);
+            for (const key of issue.keys) {
+                diagnostics.push(createDiagnostic({
+                    code: diagnosticCodes.initInvalidInput,
+                    severity: 'error',
+                    message: `Unknown init selection key "${key}".`,
+                    source,
+                    pointer: `${base === null ? '' : base}/${key.replaceAll('~', '~0').replaceAll('/', '~1')}`,
+                    hint: 'Remove the key; init choices do not accept arbitrary extensions.',
+                }));
+            }
+            continue;
+        }
+        diagnostics.push(createDiagnostic({
+            code: diagnosticCodes.initInvalidInput,
+            severity: 'error',
+            message: issue.message,
+            source,
+            pointer: issuePointer(issue.path),
+            hint: 'Use pappra/init-choices/1 fields and values; Pappra does not coerce selections.',
+        }));
+    }
+    return { value: null, diagnostics };
+}

package/dist/schemas/install.d.ts

@@ -0,0 +1,213 @@
+import { z } from 'zod';
+export declare const RUNTIME_MANIFEST_SCHEMA = "pappra/runtime-manifest/1";
+export declare const WORKSPACE_MANIFEST_SCHEMA = "pappra/install-manifest/1";
+export declare const INSTALL_JOURNAL_SCHEMA = "pappra/install-journal/1";
+export declare const LOCK_SCHEMA = "pappra/install-lock/1";
+export declare const fileIdentitySchema: z.ZodObject<{
+    dev: z.ZodNumber;
+    ino: z.ZodNumber;
+}, z.core.$strict>;
+export declare const installLockSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/install-lock/1">;
+    token: z.ZodUUID;
+    operation: z.ZodEnum<{
+        "apply-workspace-files": "apply-workspace-files";
+        "install-runtime": "install-runtime";
+        "remove-runtime": "remove-runtime";
+        "rollback-workspace-files": "rollback-workspace-files";
+        "uninstall-workspace-files": "uninstall-workspace-files";
+        "update-machine-runtime": "update-machine-runtime";
+    }>;
+    target: z.ZodString;
+    pid: z.ZodNumber;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type InstallLock = z.infer<typeof installLockSchema>;
+export declare const runtimeSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"version">;
+    packageName: z.ZodString;
+    version: z.ZodString;
+    ref: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"tarball">;
+    packageName: z.ZodString;
+    version: z.ZodString;
+    path: z.ZodString;
+    digest: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type RuntimeSource = z.infer<typeof runtimeSourceSchema>;
+export declare const runtimeManifestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/runtime-manifest/1">;
+    installId: z.ZodUUID;
+    packageName: z.ZodString;
+    runtimeVersion: z.ZodString;
+    runtimeRoot: z.ZodString;
+    executable: z.ZodString;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"version">;
+        packageName: z.ZodString;
+        version: z.ZodString;
+        ref: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"tarball">;
+        packageName: z.ZodString;
+        version: z.ZodString;
+        path: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    packageDigest: z.ZodString;
+    smoke: z.ZodObject<{
+        argv: z.ZodArray<z.ZodString>;
+        exitCode: z.ZodNumber;
+        stdoutDigest: z.ZodString;
+    }, z.core.$strict>;
+    verifiedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type RuntimeManifest = z.infer<typeof runtimeManifestSchema>;
+export declare const journalStatusSchema: z.ZodEnum<{
+    applied: "applied";
+    applying: "applying";
+    prepared: "prepared";
+    "rollback-required": "rollback-required";
+    "rolled-back": "rolled-back";
+    verified: "verified";
+}>;
+export type JournalStatus = z.infer<typeof journalStatusSchema>;
+export declare const journalStepSchema: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        ok: "ok";
+    }>;
+    at: z.ZodISODateTime;
+    detail: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const journalEntrySchema: z.ZodObject<{
+    path: z.ZodString;
+    status: z.ZodEnum<{
+        created: "created";
+        pending: "pending";
+        removed: "removed";
+        residual: "residual";
+        verified: "verified";
+    }>;
+    digest: z.ZodString;
+    identity: z.ZodNullable<z.ZodObject<{
+        dev: z.ZodNumber;
+        ino: z.ZodNumber;
+    }, z.core.$strict>>;
+    backupRef: z.ZodNullable<z.ZodString>;
+    backupDigest: z.ZodNullable<z.ZodString>;
+    detail: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const installJournalSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/install-journal/1">;
+    installId: z.ZodUUID;
+    operation: z.ZodEnum<{
+        "apply-workspace-files": "apply-workspace-files";
+        "install-runtime": "install-runtime";
+        "remove-runtime": "remove-runtime";
+        "rollback-workspace-files": "rollback-workspace-files";
+        "uninstall-workspace-files": "uninstall-workspace-files";
+        "update-machine-runtime": "update-machine-runtime";
+    }>;
+    target: z.ZodString;
+    workspaceRoot: z.ZodNullable<z.ZodString>;
+    runtimeVersion: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        applied: "applied";
+        applying: "applying";
+        prepared: "prepared";
+        "rollback-required": "rollback-required";
+        "rolled-back": "rolled-back";
+        verified: "verified";
+    }>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    steps: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            ok: "ok";
+        }>;
+        at: z.ZodISODateTime;
+        detail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    entries: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        status: z.ZodEnum<{
+            created: "created";
+            pending: "pending";
+            removed: "removed";
+            residual: "residual";
+            verified: "verified";
+        }>;
+        digest: z.ZodString;
+        identity: z.ZodNullable<z.ZodObject<{
+            dev: z.ZodNumber;
+            ino: z.ZodNumber;
+        }, z.core.$strict>>;
+        backupRef: z.ZodNullable<z.ZodString>;
+        backupDigest: z.ZodNullable<z.ZodString>;
+        detail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    residuals: z.ZodArray<z.ZodString>;
+    manifestRef: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type InstallJournal = z.infer<typeof installJournalSchema>;
+export declare const managedFileEntrySchema: z.ZodObject<{
+    path: z.ZodString;
+    installId: z.ZodUUID;
+    operation: z.ZodEnum<{
+        create: "create";
+        "replace-managed": "replace-managed";
+    }>;
+    beforeDigest: z.ZodNullable<z.ZodString>;
+    afterDigest: z.ZodString;
+    backupRef: z.ZodNullable<z.ZodString>;
+    backupDigest: z.ZodNullable<z.ZodString>;
+    identity: z.ZodObject<{
+        dev: z.ZodNumber;
+        ino: z.ZodNumber;
+    }, z.core.$strict>;
+    owner: z.ZodLiteral<"pappra">;
+    verifiedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type ManagedFileEntry = z.infer<typeof managedFileEntrySchema>;
+export declare const workspaceInstallManifestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/install-manifest/1">;
+    workspaceRoot: z.ZodString;
+    rootIdentity: z.ZodObject<{
+        dev: z.ZodNumber;
+        ino: z.ZodNumber;
+    }, z.core.$strict>;
+    entries: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        installId: z.ZodUUID;
+        operation: z.ZodEnum<{
+            create: "create";
+            "replace-managed": "replace-managed";
+        }>;
+        beforeDigest: z.ZodNullable<z.ZodString>;
+        afterDigest: z.ZodString;
+        backupRef: z.ZodNullable<z.ZodString>;
+        backupDigest: z.ZodNullable<z.ZodString>;
+        identity: z.ZodObject<{
+            dev: z.ZodNumber;
+            ino: z.ZodNumber;
+        }, z.core.$strict>;
+        owner: z.ZodLiteral<"pappra">;
+        verifiedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type WorkspaceInstallManifest = z.infer<typeof workspaceInstallManifestSchema>;
+export declare const runtimePackageManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    bin: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type RuntimePackageManifest = z.infer<typeof runtimePackageManifestSchema>;

package/dist/schemas/install.js

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+export const RUNTIME_MANIFEST_SCHEMA = 'pappra/runtime-manifest/1';
+export const WORKSPACE_MANIFEST_SCHEMA = 'pappra/install-manifest/1';
+export const INSTALL_JOURNAL_SCHEMA = 'pappra/install-journal/1';
+export const LOCK_SCHEMA = 'pappra/install-lock/1';
+const digestSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+const versionSchema = z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[0-9A-Za-z][0-9A-Za-z0-9._+-]*$/);
+const pathSchema = z.string().min(1).max(4096);
+export const fileIdentitySchema = z.strictObject({
+    dev: z.number().int().nonnegative(),
+    ino: z.number().int().nonnegative(),
+});
+export const installLockSchema = z.strictObject({
+    schema: z.literal(LOCK_SCHEMA),
+    token: z.uuid(),
+    operation: z.enum([
+        'install-runtime',
+        'apply-workspace-files',
+        'rollback-workspace-files',
+        'uninstall-workspace-files',
+        'remove-runtime',
+        'update-machine-runtime',
+    ]),
+    target: z.string().min(1).max(4096),
+    pid: z.number().int().positive(),
+    createdAt: z.iso.datetime({ offset: true }),
+});
+export const runtimeSourceSchema = z.discriminatedUnion('kind', [
+    z.strictObject({
+        kind: z.literal('version'),
+        packageName: z.string().min(1).max(256),
+        version: versionSchema,
+        ref: z.string().min(1).max(512),
+    }),
+    z.strictObject({
+        kind: z.literal('tarball'),
+        packageName: z.string().min(1).max(256),
+        version: versionSchema,
+        path: pathSchema,
+        digest: digestSchema,
+    }),
+]);
+export const runtimeManifestSchema = z.strictObject({
+    schema: z.literal(RUNTIME_MANIFEST_SCHEMA),
+    installId: z.uuid(),
+    packageName: z.string().min(1).max(256),
+    runtimeVersion: versionSchema,
+    runtimeRoot: pathSchema,
+    executable: pathSchema,
+    source: runtimeSourceSchema,
+    packageDigest: digestSchema,
+    smoke: z.strictObject({
+        argv: z.array(z.string().max(4096)).max(16),
+        exitCode: z.number().int(),
+        stdoutDigest: digestSchema,
+    }),
+    verifiedAt: z.iso.datetime({ offset: true }),
+});
+export const journalStatusSchema = z.enum([
+    'prepared',
+    'applying',
+    'applied',
+    'verified',
+    'rollback-required',
+    'rolled-back',
+]);
+export const journalStepSchema = z.strictObject({
+    name: z.string().min(1).max(256),
+    status: z.enum(['ok', 'failed']),
+    at: z.iso.datetime({ offset: true }),
+    detail: z.string().max(4096).nullable(),
+});
+export const journalEntrySchema = z.strictObject({
+    path: z.string().min(1).max(2048),
+    status: z.enum(['pending', 'created', 'verified', 'removed', 'residual']),
+    digest: digestSchema,
+    identity: fileIdentitySchema.nullable(),
+    backupRef: z.string().min(1).max(4096).nullable(),
+    backupDigest: digestSchema.nullable(),
+    detail: z.string().max(4096).nullable(),
+});
+export const installJournalSchema = z.strictObject({
+    schema: z.literal(INSTALL_JOURNAL_SCHEMA),
+    installId: z.uuid(),
+    operation: z.enum([
+        'install-runtime',
+        'apply-workspace-files',
+        'rollback-workspace-files',
+        'uninstall-workspace-files',
+        'remove-runtime',
+        'update-machine-runtime',
+    ]),
+    target: z.string().min(1).max(4096),
+    workspaceRoot: pathSchema.nullable(),
+    runtimeVersion: versionSchema.nullable(),
+    status: journalStatusSchema,
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+    steps: z.array(journalStepSchema).max(256),
+    entries: z.array(journalEntrySchema).max(256),
+    residuals: z.array(z.string().min(1).max(2048)).max(256),
+    manifestRef: z.string().max(4096).nullable(),
+});
+export const managedFileEntrySchema = z.strictObject({
+    path: z.string().min(1).max(2048),
+    installId: z.uuid(),
+    operation: z.enum(['create', 'replace-managed']),
+    beforeDigest: digestSchema.nullable(),
+    afterDigest: digestSchema,
+    backupRef: z.string().min(1).max(4096).nullable(),
+    backupDigest: digestSchema.nullable(),
+    identity: fileIdentitySchema,
+    owner: z.literal('pappra'),
+    verifiedAt: z.iso.datetime({ offset: true }),
+});
+export const workspaceInstallManifestSchema = z.strictObject({
+    schema: z.literal(WORKSPACE_MANIFEST_SCHEMA),
+    workspaceRoot: pathSchema,
+    rootIdentity: fileIdentitySchema,
+    entries: z.array(managedFileEntrySchema).max(512),
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+});
+export const runtimePackageManifestSchema = z.object({
+    name: z.string().min(1).max(256),
+    version: versionSchema,
+    bin: z
+        .union([
+        z.string().min(1).max(2048),
+        z.record(z.string().min(1).max(256), z.string().min(1).max(2048)),
+    ])
+        .optional(),
+    dependencies: z.record(z.string(), z.string()).optional(),
+    scripts: z.record(z.string(), z.string()).optional(),
+});

package/dist/schemas/machine.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { type Diagnostic } from './diagnostics.js';
+export declare const MACHINE_SCHEMA = "pappra/machine/1";
+export declare const hostSchema: z.ZodEnum<{
+    claude: "claude";
+    codex: "codex";
+    pi: "pi";
+}>;
+export declare const externalRepositoryMappingSchema: z.ZodObject<{
+    id: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strict>;
+export declare const runtimeLocationSchema: z.ZodObject<{
+    version: z.ZodString;
+    executable: z.ZodString;
+    verifiedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const machineConfigSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/machine/1">;
+    workspaceRealpath: z.ZodString;
+    checkoutId: z.ZodUUID;
+    externalRepositories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>>;
+    selectedHosts: z.ZodArray<z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        pi: "pi";
+    }>>;
+    runtime: z.ZodNullable<z.ZodObject<{
+        version: z.ZodString;
+        executable: z.ZodString;
+        verifiedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type MachineConfig = z.infer<typeof machineConfigSchema>;
+export type ExternalRepositoryMapping = z.infer<typeof externalRepositoryMappingSchema>;
+export type RuntimeLocation = z.infer<typeof runtimeLocationSchema>;
+export interface MachineConfigSemanticOptions {
+    readonly configPath: string;
+}
+export declare function validateMachineConfigSemantics(config: MachineConfig, options: MachineConfigSemanticOptions): readonly Diagnostic[];