@thinair/factory 0.1.149 → 0.1.155

package/cli/template.ts

@@ -20,7 +20,7 @@ export default defineFactory({
   repositories: [hole("Repository", "main")],
   rules: [hole("Rule", "intake")],
   stages: [hole("Stage", "change")],
-  fleet: [hole("Pool", "macs")],
+  fleet: [hole("Pool", "fleet")],
   agents: [hole("Agent", "coder")],
 });
 `;

package/domain/system-elements/hole.ts

@@ -2,9 +2,9 @@ import { Schema } from "effect";
 import { AUTHORED, authoredHead, head, NodeTag, type HoleFor, type LiveRows } from "./node";
 
 /*
- * A Hole: a part still to build. `hole("Pool", "macs")` plans a pool where
+ * A Hole: a part still to build. `hole("Pool", "fleet")` plans a pool where
  * one will go; the floor draws it dashed amber, "to build". It keeps the id
- * of the node it stands for (`pool:macs`), so filling it is one change in
+ * of the node it stands for (`pool:fleet`), so filling it is one change in
  * place and every Ref to it still holds. The engine skips holes, and types
  * already stop compose from wanting one.
  */

package/domain/system-elements/pool.ts

@@ -3,17 +3,28 @@ import { AUTHORED, authoredHead, head, type Authored, type LiveRows } from "./no
 
 /*
  * A pool names a provider and an optional narrowing, nothing else.
- * `pool.macs()` means every Mac that granted this factory `work`: host
- * commands. `pool.fleet()` means sealed Linux VMs on the computers that lend
- * to the factory's owner. Room, os,
- * arch, VMs, identities and reserve come only from each machine's facts, so
- * two factories never give placement two truths about one machine. The
- * plane gives pools their meaning: its executors.
+ * `pool.fleet()` means the computers that lend to the factory's owner: a
+ * job that needs macOS runs as a host command on one of the owner's Macs, a
+ * Linux job in a sealed VM on any of them, and in Thinair Cloud too once the
+ * owner names the factory's Cloud Organization. Room, os, arch, VMs,
+ * identities and reserve come only from each computer's facts, so two
+ * factories never give placement two truths about one computer. The plane
+ * gives pools their meaning: its executors.
  */
 
-export const PROVIDERS = ["macs", "fleet", "thinair-cloud", "namespace", "github-actions"] as const;
-export const Provider = Schema.Literals(PROVIDERS);
+export const PROVIDERS = ["fleet", "github-actions"] as const;
+/**
+ * Providers a program stored before one `fleet` took their place may still name (`pool:macs`, `pool:thinair-cloud`,
+ * `pool:namespace`): read so a running factory's program stays readable until its next live load, never authored.
+ * Placement reads `macs` and `thinair-cloud` as `fleet`; `namespace` never had a filling.
+ */
+export const RETIRED_PROVIDERS = ["macs", "thinair-cloud", "namespace"] as const;
+export const Provider = Schema.Literals([...PROVIDERS, ...RETIRED_PROVIDERS]);
 export type Provider = typeof Provider.Type;
+export type AuthoredProvider = (typeof PROVIDERS)[number];
+
+/** Whether a pool names the owner's fleet: `fleet`, or a retired name that meant part of it. */
+export const isFleet = (provider: Provider) => provider === "fleet" || provider === "macs" || provider === "thinair-cloud";
 
 export const Os = Schema.Literals(["mac", "linux", "windows"]);
 export type Os = typeof Os.Type;
@@ -27,7 +38,7 @@ export type Narrowing = typeof Narrowing.Type;
 export const Node = Schema.TaggedStruct("Pool", { ...head, provider: Provider, ...Narrowing.fields });
 export type Node = typeof Node.Type;
 
-export interface AuthoredPool<P extends Provider = Provider> extends Authored<"Pool", P> {
+export interface AuthoredPool<P extends AuthoredProvider = AuthoredProvider> extends Authored<"Pool", P> {
   readonly provider: P;
   readonly os: ReadonlyArray<Os>;
   readonly arch: ReadonlyArray<Arch>;
@@ -35,30 +46,22 @@ export interface AuthoredPool<P extends Provider = Provider> extends Authored<"P
 
 type Narrow = Readonly<{ os?: ReadonlyArray<Os>; arch?: ReadonlyArray<Arch> }>;
 
-const made = <const P extends Provider>(provider: P, narrow: Narrow | undefined): AuthoredPool<P> => ({
+const made = <const P extends AuthoredProvider>(provider: P, narrow: Narrow | undefined): AuthoredPool<P> => ({
   [AUTHORED]: authoredHead("Pool", provider, false),
   provider,
   os: narrow?.os ?? [],
   arch: narrow?.arch ?? [],
 });
 
-/** The pools a factory can name. Each is named after its provider: `pool:macs`. */
+/** The pools a factory can name. Each is named after its provider: `pool:fleet`. */
 export const pool = {
-  /** Every Mac that granted this factory `work`. */
-  macs: (narrow?: Narrow) => made("macs", narrow),
   /**
-   * Sealed Linux VMs on the computers that lend to the factory's owner: a job whose `needs.os` is `["linux"]` runs in
-   * one. `arch` narrows the CPU families its VMs run on; `os` names the guest (only `linux`).
+   * The computers that lend to the factory's owner. A job whose `needs.os` is `["linux"]` runs in a sealed Linux VM; any
+   * other job runs as a host command on one of the owner's Macs. `os` narrows the kinds of computer (`mac`, `linux`,
+   * `windows`), `arch` the CPU families a job's VM runs on (`x64` runs natively on Thinair Cloud's x86_64 hosts). Thinair
+   * Cloud lends too once the owner names the factory's Cloud Organization (`factory.cloud.set`), billed to it.
    */
   fleet: (narrow?: Narrow) => made("fleet", narrow),
-  /**
-   * Sealed Linux VMs in Thinair Cloud, in the Organization the factory's owner names (`factory.cloud.set`; Thinair's
-   * own factories name Thinair Computer Inc) and billed to it. Cloud's placer picks the host; `arch` narrows the CPU
-   * family (`x64` runs natively on Cloud's x86_64 hosts).
-   */
-  thinairCloud: (narrow?: Narrow) => made("thinair-cloud", narrow),
-  /** Namespace instances, with the Profile's key. */
-  namespace: (narrow?: Narrow) => made("namespace", narrow),
   /** GitHub Actions runners, dispatched with the Agents App. */
   githubActions: (narrow?: Narrow) => made("github-actions", narrow),
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thinair/factory",
-  "version": "0.1.149",
+  "version": "0.1.155",
   "description": "The Thinair factory SDK: the language a factory's code is written in, and the loader that checks it.",
   "license": "Apache-2.0",
   "type": "module",