stitchkit 0.59.4 → 0.60.0

package/dist/declaration.d.ts

@@ -0,0 +1,345 @@
+/**
+ * The project declaration — the one machine-readable statement a repository
+ * chooses to make about itself.
+ *
+ * The schema lives in the published framework, not in the repository that fills
+ * it in, because it has readers that must never disagree: the project itself,
+ * the scaffolder that writes the first copy, and whatever binds an artifact
+ * of it into a deployment. A copy on any of those sides is a fork rather than a contract —
+ * it diverges silently and nothing fails — so the declaration ships as one
+ * versioned surface instead.
+ *
+ * The boundary rule the schema exists to hold:
+ *
+ * > A declaration must be complete and meaningful **when no machine exists**. A
+ * > field that cannot be filled in without knowing where the code will run is a
+ * > binding supplied by the deployment, not a declaration made by the
+ * > repository.
+ *
+ * What holds it, stated at its real strength:
+ *
+ * 1. **Structure.** There is nowhere a value MUST go. A command is `executable`
+ *    plus an `args` array — no shell string, no pipe, no redirect — and no part
+ *    may be an absolute path or an assignment in any form, so `--port=8080` and
+ *    `--config=/srv/…` have to be written as separate arguments where the same
+ *    checks reach them. Paths are repository-relative. Bindings are named by
+ *    variable, never valued, and a listener's variables must exist in the env
+ *    contract with the right shapes.
+ * 2. **Hygiene.** Every remaining free string is checked against
+ *    `namesAMachine` — a scheme, a protocol-relative host, an absolute or
+ *    home-relative path, a Windows drive, a `host:port` pair, a bare IPv4
+ *    literal — and a number after a port flag is refused.
+ *
+ * The second is a filter for known shapes, not a proof. A secret written as its
+ * own argument (`--token`, `sk-live-…`) and a hostname written as a plain word
+ * (`db.internal`) are indistinguishable from any other argument, and no schema
+ * makes them distinguishable. This is not a secret scanner and does not claim to
+ * be one: the guarantee is that nothing here REQUIRES a value of the place, so a
+ * complete declaration can be written before any machine exists.
+ *
+ * **Declaring is optional, and that is a contract rather than a gap.** A
+ * project with no declaration is a complete project: nothing else in the
+ * framework imports this module, no build, test or start path looks for a
+ * `project.json`, and the absence of one is never an error or a warning. A
+ * check that demanded a declaration "for convenience" would turn a repository
+ * into something only one tool can bring up — which is a fork, not a
+ * dependency, and is the outcome this whole surface exists to avoid.
+ *
+ * Unknown keys are **refused**, not stripped. A declaration is a contract
+ * between programs that never meet; a key one side does not recognise is a
+ * disagreement, and silently discarding it is how a partially understood
+ * declaration becomes a running, wrong deployment.
+ */
+import { z } from 'zod';
+/**
+ * The declaration format this build understands.
+ *
+ * A reader that does not recognise the version a repository declares refuses
+ * the repository rather than interpreting it partially. Because unknown keys
+ * are refused too, the version is what a reader consults when the *shape*
+ * changed — and every added field is a version bump, not a silent widening.
+ */
+export declare const PROJECT_DECLARATION_SCHEMA_VERSION = 1;
+/** The reason this string names a machine, or `undefined` when it does not. */
+export declare function namesAMachine(value: string): string | undefined;
+/**
+ * Lowercase, hyphen-separated identity. Everything named after the project —
+ * process names, derived resource names — is derived from it, so it is the one
+ * identity field with a machine-checkable shape.
+ */
+export declare const ProjectSlugSchema: z.ZodString;
+/**
+ * Human description keyed by locale tag. Which locales a project speaks is the
+ * project's own business — the framework only insists that it speaks one.
+ *
+ * To fix an exact set, replace this field entirely when composing a stricter
+ * declaration; it is a record, so it has no `extend`.
+ */
+export declare const ProjectDescriptionSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+/** Who the project is. True of the code with no machine in existence. */
+export declare const ProjectIdentitySchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strict>;
+/**
+ * A path inside the source. Repository-relative on purpose: a path is code
+ * only while it is relative to the source — the moment it is absolute, climbs
+ * out, or names a drive, it names a machine.
+ */
+export declare const RepositoryPathSchema: z.ZodString;
+/** The name of a variable a deployment will fill in. A name, never a value. */
+export declare const BindingVariableSchema: z.ZodString;
+/**
+ * How a role is reached over the network.
+ *
+ * Absent means the role has no listener at all — a queue consumer, a bot, a
+ * scheduler. That is a legitimate role, not an incomplete one, so nothing here
+ * is required of it.
+ *
+ * Both bindings are named, never valued: a deployment supplies the port and the
+ * interface under these names. There is deliberately no way to say "the port
+ * arrives as a command-line argument" — a reader would then have to implement
+ * two injection forms forever, and a role that needs an argument builds it from
+ * the variable inside its own process.
+ */
+export declare const ProjectListenerSchema: z.ZodObject<{
+    portVariable: z.ZodString;
+    bindVariable: z.ZodString;
+    readinessPath: z.ZodString;
+}, z.core.$strict>;
+/** The run modes a role declares commands for. */
+export declare const ProjectRunModeSchema: z.ZodEnum<{
+    development: "development";
+    production: "production";
+}>;
+export declare const ProjectCommandSchema: z.ZodObject<{
+    executable: z.ZodString;
+    args: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * A command run under a supervisor, which additionally may not be a launcher.
+ *
+ * The rule applies to ROLES and not to `build`: a build is not signalled, so a
+ * script runner in front of it costs nothing. A supervised role is signalled,
+ * and there the launcher is the defect measured above.
+ */
+export declare const ProjectRoleCommandSchema: z.ZodObject<{
+    executable: z.ZodString;
+    args: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const ProjectRoleSchema: z.ZodObject<{
+    name: z.ZodString;
+    workingDirectory: z.ZodOptional<z.ZodString>;
+    commands: z.ZodRecord<z.ZodEnum<{
+        development: "development";
+        production: "production";
+    }>, z.ZodObject<{
+        executable: z.ZodString;
+        args: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    listener: z.ZodOptional<z.ZodObject<{
+        portVariable: z.ZodString;
+        bindVariable: z.ZodString;
+        readinessPath: z.ZodString;
+    }, z.core.$strict>>;
+    drainFloorMs: z.ZodNumber;
+}, z.core.$strict>;
+/**
+ * Data the build is allowed to read, named and frozen.
+ *
+ * The boundary rule separates two things — code, and the values of a place.
+ * There is a third that is neither: **data read while building**. Pages
+ * prerendered from a database depend on bytes that are not in the source and
+ * are not a binding, and no amount of moving environment variables makes such a
+ * build portable. Left unnamed, the dependency is invisible: the build succeeds
+ * on the machine that happens to have the database, and the artifact silently
+ * stops being a function of the source.
+ *
+ * Declaring an input is what makes it legitimate. `path` points at a frozen
+ * export inside the source, `digest` pins its bytes, and a build that reads
+ * anything else is a build nobody declared. The other two legitimate answers
+ * need no field here at all: render at runtime, or generate the bytes as a
+ * release step on the way to the deployment.
+ */
+export declare const ProjectBuildInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    digest: z.ZodString;
+}, z.core.$strict>;
+export type ProjectBuildInput = z.infer<typeof ProjectBuildInputSchema>;
+/** What building the source produces. More than one path is the normal case. */
+export declare const ProjectBuildSchema: z.ZodObject<{
+    command: z.ZodObject<{
+        executable: z.ZodString;
+        args: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    artifacts: z.ZodArray<z.ZodString>;
+    inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+/** When a requirement has to be there. */
+export declare const ProjectRequirementPhaseSchema: z.ZodEnum<{
+    release: "release";
+    start: "start";
+}>;
+/**
+ * Something the code needs that the code does not provide.
+ *
+ * `phases` says when: `release` is needed once while bringing a deployment to
+ * this source, `start` is needed by every process every time it starts. One
+ * requirement can be both, and saying so once beats naming it twice.
+ */
+export declare const ProjectRequirementSchema: z.ZodObject<{
+    name: z.ZodString;
+    phases: z.ZodArray<z.ZodEnum<{
+        release: "release";
+        start: "start";
+    }>>;
+}, z.core.$strict>;
+/**
+ * What a migration IS, declared as a fact rather than as a command to run.
+ *
+ * The repository says which bytes are migrations; whatever brings a deployment
+ * to this source reads them and decides — exact contents, admission verdict,
+ * whether a preflight can be skipped because nothing touches the database. A
+ * free list of shell commands would take that decision away from the side that
+ * is able to make it, and hand it to the side that cannot see the deployment.
+ *
+ * `engine` is a name, checked like every other free string: a connection string
+ * fits in a name-shaped field otherwise, credentials and all.
+ */
+export declare const ProjectMigrationsSchema: z.ZodObject<{
+    engine: z.ZodString;
+    root: z.ZodString;
+    lockfile: z.ZodString;
+}, z.core.$strict>;
+/** What must happen once, before any role starts, to reach this source. */
+export declare const ProjectReleaseSchema: z.ZodObject<{
+    migrations: z.ZodOptional<z.ZodObject<{
+        engine: z.ZodString;
+        root: z.ZodString;
+        lockfile: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** The value shapes a declaration can describe without naming a value. */
+export declare const ProjectEnvShapeSchema: z.ZodEnum<{
+    boolean: "boolean";
+    enum: "enum";
+    integer: "integer";
+    string: "string";
+    url: "url";
+}>;
+/**
+ * A variable a deployment must supply.
+ *
+ * `members` is required for `enum` and forbidden otherwise: a reader without a
+ * TypeScript runtime learns nothing from "one of an unnamed set", which is the
+ * only thing this list exists to tell it.
+ */
+export declare const ProjectEnvVariableSchema: z.ZodObject<{
+    name: z.ZodString;
+    shape: z.ZodEnum<{
+        boolean: "boolean";
+        enum: "enum";
+        integer: "integer";
+        string: "string";
+        url: "url";
+    }>;
+    required: z.ZodBoolean;
+    members: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+/** The declaration itself. Every field here is true about the code alone. */
+export declare const ProjectDeclarationSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    kind: z.ZodEnum<{
+        application: "application";
+        library: "library";
+    }>;
+    identity: z.ZodObject<{
+        slug: z.ZodString;
+        name: z.ZodString;
+        version: z.ZodString;
+        description: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>;
+    roles: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        workingDirectory: z.ZodOptional<z.ZodString>;
+        commands: z.ZodRecord<z.ZodEnum<{
+            development: "development";
+            production: "production";
+        }>, z.ZodObject<{
+            executable: z.ZodString;
+            args: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        listener: z.ZodOptional<z.ZodObject<{
+            portVariable: z.ZodString;
+            bindVariable: z.ZodString;
+            readinessPath: z.ZodString;
+        }, z.core.$strict>>;
+        drainFloorMs: z.ZodNumber;
+    }, z.core.$strict>>;
+    build: z.ZodOptional<z.ZodObject<{
+        command: z.ZodObject<{
+            executable: z.ZodString;
+            args: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        artifacts: z.ZodArray<z.ZodString>;
+        inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            path: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    requires: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        phases: z.ZodArray<z.ZodEnum<{
+            release: "release";
+            start: "start";
+        }>>;
+    }, z.core.$strict>>;
+    release: z.ZodObject<{
+        migrations: z.ZodOptional<z.ZodObject<{
+            engine: z.ZodString;
+            root: z.ZodString;
+            lockfile: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    env: z.ZodObject<{
+        variables: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            shape: z.ZodEnum<{
+                boolean: "boolean";
+                enum: "enum";
+                integer: "integer";
+                string: "string";
+                url: "url";
+            }>;
+            required: z.ZodBoolean;
+            members: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ProjectDeclaration = z.infer<typeof ProjectDeclarationSchema>;
+export type ProjectRole = z.infer<typeof ProjectRoleSchema>;
+export type ProjectCommand = z.infer<typeof ProjectCommandSchema>;
+export type ProjectRoleCommand = z.infer<typeof ProjectRoleCommandSchema>;
+export type ProjectEnvVariable = z.infer<typeof ProjectEnvVariableSchema>;
+export type ProjectIdentity = z.infer<typeof ProjectIdentitySchema>;
+/**
+ * Parse a declaration, refusing an unknown schema version **before** any field
+ * is read.
+ *
+ * Order matters. The object is strict, so a newer declaration would otherwise
+ * report as a list of unrecognised keys — which reads like a broken file rather
+ * than a version this build is too old to serve. The version check is
+ * fail-closed: an unrecognised version is refused, never assumed compatible.
+ */
+export declare function parseProjectDeclaration(source: unknown): ProjectDeclaration;
+/** The role with this name, or `undefined`. */
+export declare function findProjectRole(declaration: ProjectDeclaration, name: string): ProjectRole | undefined;
+//# sourceMappingURL=declaration.d.ts.map

package/dist/declaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declaration.d.ts","sourceRoot":"","sources":["../src/declaration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;GAOG;AACH,eAAO,MAAM,kCAAkC,IAAI,CAAC;AAoBpD,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAK/D;AAUD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,aAO3B,CAAC;AAEJ;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,uCAQlC,CAAC;AAEJ,yEAAyE;AACzE,eAAO,MAAM,qBAAqB;;;;;kBAOvB,CAAC;AAEZ;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,aAW9B,CAAC;AAEJ,+EAA+E;AAC/E,eAAO,MAAM,qBAAqB,aAEiD,CAAC;AAEpF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB;;;;kBAavB,CAAC;AAEZ,kDAAkD;AAClD,eAAO,MAAM,oBAAoB;;;EAAwC,CAAC;AAoG1E,eAAO,MAAM,oBAAoB;;;kBAKtB,CAAC;AAEZ;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;;;kBAMpC,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;kBA0BnB,CAAC;AAEZ;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB;;;;kBAezB,CAAC;AAEZ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,gFAAgF;AAChF,eAAO,MAAM,kBAAkB;;;;;;;;;;;kBAciD,CAAC;AAEjF,0CAA0C;AAC1C,eAAO,MAAM,6BAA6B;;;EAA+B,CAAC;AAE1E;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;;;;;;kBAK1B,CAAC;AAEZ;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB;;;;kBAMzB,CAAC;AAEZ,2EAA2E;AAC3E,eAAO,MAAM,oBAAoB;;;;;;kBAEtB,CAAC;AAEZ,0EAA0E;AAC1E,eAAO,MAAM,qBAAqB;;;;;;EAA0D,CAAC;AAE7F;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;kBAclC,CAAC;AAEJ,6EAA6E;AAC7E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0DjC,CAAC;AAyCL,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAKpE;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,OAAO,GAAG,kBAAkB,CAU3E;AAED,+CAA+C;AAC/C,wBAAgB,eAAe,CAC7B,WAAW,EAAE,kBAAkB,EAC/B,IAAI,EAAE,MAAM,GACX,WAAW,GAAG,SAAS,CAEzB"}

package/dist/declaration.js

@@ -0,0 +1,183 @@
+// src/declaration.ts
+import { z } from "zod";
+var PROJECT_DECLARATION_SCHEMA_VERSION = 1;
+var MACHINE_PATTERNS = [
+  [/:\/\//, "an absolute address"],
+  [/^\/\//, "a protocol-relative host"],
+  [/^[~]/, "a home-relative path"],
+  [/^[A-Za-z]:[\\/]/, "a Windows drive path"],
+  [/\\/, "a Windows path separator"],
+  [/(?:^|[\s=:])\d{1,3}(?:\.\d{1,3}){3}(?![\d.])/, "an IP address"],
+  [/(?:^|[\s=])[A-Za-z][\w.-]*:\d{2,5}(?![\w.])/, "a host and port"]
+];
+function namesAMachine(value) {
+  for (const [pattern, reason] of MACHINE_PATTERNS) {
+    if (pattern.test(value))
+      return reason;
+  }
+  return;
+}
+function refuseMachineNames(label) {
+  return (schema) => schema.refine((value) => namesAMachine(value) === undefined, {
+    error: (issue) => `${label} names a machine — ${namesAMachine(String(issue.input)) ?? "a value of the deployment"} is supplied by the deployment, not written in the code`
+  });
+}
+var ProjectSlugSchema = z.string().min(1).max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Use lowercase letters, numbers and single hyphens (for example: talk-control)");
+var ProjectDescriptionSchema = z.record(refuseMachineNames("A locale tag")(z.string().min(1)), refuseMachineNames("A description")(z.string().trim().min(1))).refine((value) => Object.keys(value).length > 0, "Describe the project in at least one locale");
+var ProjectIdentitySchema = z.object({
+  slug: ProjectSlugSchema,
+  name: refuseMachineNames("A project name")(z.string().trim().min(1).max(80)),
+  version: z.string().regex(/^\d+\.\d+\.\d+$/, "Use a semantic version such as 0.1.0"),
+  description: ProjectDescriptionSchema
+}).strict();
+var RepositoryPathSchema = z.string().min(1).refine((value) => !value.startsWith("/"), "Use a path relative to the repository root").refine((value) => namesAMachine(value) === undefined, {
+  error: (issue) => `A path may not contain ${namesAMachine(String(issue.input)) ?? "a machine name"}`
+}).refine((value) => !value.split("/").includes(".."), "A path may not climb out of the repository");
+var BindingVariableSchema = z.string().regex(/^[A-Z][A-Z0-9_]*$/, "Name an environment variable, for example API_PORT");
+var ProjectListenerSchema = z.object({
+  portVariable: BindingVariableSchema,
+  bindVariable: BindingVariableSchema,
+  readinessPath: refuseMachineNames("A readiness path")(z.string().startsWith("/", "Readiness is a path, for example /health"))
+}).strict();
+var ProjectRunModeSchema = z.enum(["development", "production"]);
+var PROJECT_SCRIPT_LAUNCHERS = [
+  [/^(?:bun|npm|pnpm|yarn)$/, /^run$/],
+  [/^deno$/, /^task$/],
+  [/^(?:npx|bunx|pnpx)$/, null]
+];
+function launchesAScript(executable, firstArgument) {
+  for (const [runner, verb] of PROJECT_SCRIPT_LAUNCHERS) {
+    if (!runner.test(executable))
+      continue;
+    if (verb === null)
+      return true;
+    if (firstArgument !== undefined && verb.test(firstArgument))
+      return true;
+  }
+  return false;
+}
+var PORT_FLAG = /^(?:-p|-{1,2}(?:port|listen))$/i;
+var CommandPartSchema = refuseMachineNames("A command part")(z.string().min(1)).refine((value) => !value.startsWith("/"), "A command part may not be an absolute path — paths are relative to the source").refine((value) => !/^[^=\s]+=/.test(value), "A command part may not carry an inline value — write the flag and its value as separate arguments, so the value is checked like every other one");
+var CommandArgumentsSchema = z.array(CommandPartSchema).refine((args) => args.every((value, index) => !(/^\d{1,5}$/.test(value) && PORT_FLAG.test(args[index - 1] ?? ""))), "A number after a port flag is a port — name the variable that carries it and let the role read it");
+var ProjectCommandSchema = z.object({
+  executable: CommandPartSchema,
+  args: CommandArgumentsSchema
+}).strict();
+var ProjectRoleCommandSchema = ProjectCommandSchema.refine((value) => !launchesAScript(value.executable, value.args[0]), "Start the role process itself, not a script runner: a launcher between the supervisor and the role duplicates the shutdown signal and forces the drain").refine((value) => !value.args.includes("--filter"), "A workspace filter puts a launcher between the supervisor and the role, and the shutdown signal never reaches it");
+var ProjectRoleSchema = z.object({
+  name: ProjectSlugSchema,
+  workingDirectory: RepositoryPathSchema.optional(),
+  commands: z.record(ProjectRunModeSchema, ProjectRoleCommandSchema),
+  listener: ProjectListenerSchema.optional(),
+  drainFloorMs: z.number().int().nonnegative()
+}).strict();
+var ProjectBuildInputSchema = z.object({
+  name: ProjectSlugSchema,
+  path: RepositoryPathSchema,
+  digest: z.string().regex(/^sha256:[0-9a-f]{64}$/, 'Use a lowercase sha256 digest, as "sha256:<64 hex>"')
+}).strict();
+var ProjectBuildSchema = z.object({
+  command: ProjectCommandSchema,
+  artifacts: z.array(RepositoryPathSchema).min(1),
+  inputs: z.array(ProjectBuildInputSchema).optional()
+}).strict().refine((build) => {
+  const names = (build.inputs ?? []).map((input) => input.name);
+  return new Set(names).size === names.length;
+}, "Two build inputs share a name — a failure could then name either of them");
+var ProjectRequirementPhaseSchema = z.enum(["release", "start"]);
+var ProjectRequirementSchema = z.object({
+  name: ProjectSlugSchema,
+  phases: z.array(ProjectRequirementPhaseSchema).min(1)
+}).strict();
+var ProjectMigrationsSchema = z.object({
+  engine: refuseMachineNames("A migration engine name")(z.string().min(1).max(64)),
+  root: RepositoryPathSchema,
+  lockfile: RepositoryPathSchema
+}).strict();
+var ProjectReleaseSchema = z.object({ migrations: ProjectMigrationsSchema.optional() }).strict();
+var ProjectEnvShapeSchema = z.enum(["string", "integer", "boolean", "url", "enum"]);
+var ProjectEnvVariableSchema = z.object({
+  name: BindingVariableSchema,
+  shape: ProjectEnvShapeSchema,
+  required: z.boolean(),
+  members: z.array(refuseMachineNames("An enum member")(z.string().min(1))).min(1).optional()
+}).strict().refine((value) => value.shape === "enum" === (value.members !== undefined), "An enum variable lists its members; every other shape has none");
+var ProjectDeclarationSchema = z.object({
+  schemaVersion: z.literal(PROJECT_DECLARATION_SCHEMA_VERSION),
+  kind: z.enum(["library", "application"]),
+  identity: ProjectIdentitySchema,
+  roles: z.array(ProjectRoleSchema),
+  build: ProjectBuildSchema.optional(),
+  requires: z.array(ProjectRequirementSchema),
+  release: ProjectReleaseSchema,
+  env: z.object({ variables: z.array(ProjectEnvVariableSchema) }).strict()
+}).strict().refine((value) => value.kind === "application" ? value.roles.length > 0 : value.roles.length === 0, "An application declares at least one role; a library declares none").refine((value) => new Set(value.roles.map((role) => role.name)).size === value.roles.length, "Role names must be unique").refine((value) => new Set(value.requires.map((entry) => entry.name)).size === value.requires.length, "Name each requirement once and list its phases").refine((value) => value.requires.every((entry) => new Set(entry.phases).size === entry.phases.length), "List each phase of a requirement once").refine((value) => new Set(value.env.variables.map((entry) => entry.name)).size === value.env.variables.length, "Declare each environment variable once").refine((value) => listenerBindingProblem(value) === undefined, {
+  error: (issue) => listenerBindingProblem(issue.input) ?? "Listener bindings are inconsistent"
+});
+function isListenerBindingSubject(value) {
+  return typeof value === "object" && value !== null && "roles" in value && "env" in value;
+}
+function listenerBindingProblem(value) {
+  if (!isListenerBindingSubject(value))
+    return;
+  const shapes = new Map(value.env.variables.map((entry) => [entry.name, entry.shape]));
+  for (const role of value.roles) {
+    const listener = role.listener;
+    if (!listener)
+      continue;
+    if (listener.portVariable === listener.bindVariable) {
+      return `Role "${role.name}" points its port and its bind address at the same variable "${listener.portVariable}"`;
+    }
+    const expected = [
+      [listener.portVariable, "integer"],
+      [listener.bindVariable, "string"]
+    ];
+    for (const [name, shape] of expected) {
+      const declared = shapes.get(name);
+      if (declared === undefined) {
+        return `Role "${role.name}" listens on "${name}", which env.variables does not declare — a deployment reading this cannot know it has to supply it`;
+      }
+      if (declared !== shape) {
+        return `Role "${role.name}" listens on "${name}", declared as "${declared}" where a ${shape} is needed`;
+      }
+    }
+  }
+  return;
+}
+var VersionProbeSchema = z.object({ schemaVersion: z.unknown() }).loose();
+function parseProjectDeclaration(source) {
+  const probe = VersionProbeSchema.safeParse(source);
+  const declared = probe.success ? probe.data.schemaVersion : undefined;
+  if (declared !== undefined && declared !== PROJECT_DECLARATION_SCHEMA_VERSION) {
+    throw new Error(`Project declaration schema version ${JSON.stringify(declared)} is not supported — ` + `this build understands version ${PROJECT_DECLARATION_SCHEMA_VERSION}.`);
+  }
+  return ProjectDeclarationSchema.parse(source);
+}
+function findProjectRole(declaration, name) {
+  return declaration.roles.find((role) => role.name === name);
+}
+export {
+  BindingVariableSchema,
+  PROJECT_DECLARATION_SCHEMA_VERSION,
+  ProjectBuildInputSchema,
+  ProjectBuildSchema,
+  ProjectCommandSchema,
+  ProjectDeclarationSchema,
+  ProjectDescriptionSchema,
+  ProjectEnvShapeSchema,
+  ProjectEnvVariableSchema,
+  ProjectIdentitySchema,
+  ProjectListenerSchema,
+  ProjectMigrationsSchema,
+  ProjectReleaseSchema,
+  ProjectRequirementPhaseSchema,
+  ProjectRequirementSchema,
+  ProjectRoleCommandSchema,
+  ProjectRoleSchema,
+  ProjectRunModeSchema,
+  ProjectSlugSchema,
+  RepositoryPathSchema,
+  findProjectRole,
+  namesAMachine,
+  parseProjectDeclaration
+};