@thinair/factory 0.1.170 → 0.1.177

package/cli/evaluate.ts

@@ -26,12 +26,8 @@ export const EvaluateInput = Schema.Struct({
 });
 export type EvaluateInput = typeof EvaluateInput.Type;
 
-const EvaluateNotice = Schema.Struct({ node: Schema.NullOr(NodeId), at: Schema.NullOr(SourceAt), message: Schema.String });
-
 export const EvaluateOutput = Schema.Struct({
   program: Schema.NullOr(Program),
-  /** Notes that hold nothing: a retired constructor the code still calls runs as its replacement. */
-  notices: Schema.Array(EvaluateNotice),
   problems: Schema.Array(Schema.Struct({
     /** `evaluate`: the code threw while it loaded. `value`: the encoder's checks. */
     step: Schema.Literals(["evaluate", "value"]),
@@ -77,13 +73,12 @@ const evaluate = Effect.fn("factory.evaluate")(function* (inputPath: string) {
           hash: (text) => createHash("sha256").update(text).digest("hex"),
           files: input.files,
         });
-        return { program: encoded.program, notices: encoded.notices, problems: encoded.problems.map((problem) => ({ step: "value" as const, ...problem })) };
+        return { program: encoded.program, problems: encoded.problems.map((problem) => ({ step: "value" as const, ...problem })) };
       },
       catch: (error) => error,
     })),
     Effect.catch((error) => Effect.succeed<EvaluateOutput>({
       program: null,
-      notices: [],
       problems: [{ step: "evaluate", node: null, at: throwAt(error, input.tree), message: `The factory's code threw while it loaded: ${error instanceof Error ? error.message : String(error)}` }],
     })),
   );

package/cli/load.ts

@@ -6,7 +6,7 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { Context, Effect, Layer, Result, Schema } from "effect";
-import { holds, LOAD_VERSION, LoadJson, LoadPost, type Finding, type Load } from "../domain/load";
+import { LOAD_VERSION, LoadJson, LoadPost, type Finding, type Load } from "../domain/load";
 import { appShapeProblems, AUTHORING_MODULES, folderKey, IGNORED_FOLDERS, isLoadedPath, memberFiles } from "../domain/system-elements/app-shape";
 import { FrameworkVersion, holesOf, type Node, type Program } from "../domain/system-elements/program";
 import { EvaluateOutputJson, type EvaluateInput } from "./evaluate";
@@ -272,7 +272,6 @@ const evaluate = Effect.fn("factory.load.evaluate")(function* (input: Omit<Evalu
     program: output.program,
     findings: [
       ...output.problems.map((problem) => finding(problem.step, problem.message, { node: problem.node, file: problem.at?.file ?? null, line: problem.at?.line ?? null })),
-      ...output.notices.map((notice) => ({ ...finding("value", notice.message, { node: notice.node, file: notice.at?.file ?? null, line: notice.at?.line ?? null }), notice: true as const })),
     ],
   };
 });
@@ -357,7 +356,7 @@ export const loadFactory = Effect.fn("factory.load")(function* (input: Readonly<
 
   const load: Load = yield* timed(steps, "encode", Effect.sync((): Load => {
     const all = findings.map(pinned(program));
-    return { version: LOAD_VERSION, framework, key: snapshot.key, state: all.some(holds) ? "held" : "ready", program, holes: program === null ? [] : holesOf(program), findings: all, cached: false, steps };
+    return { version: LOAD_VERSION, framework, key: snapshot.key, state: all.length > 0 ? "held" : "ready", program, holes: program === null ? [] : holesOf(program), findings: all, cached: false, steps };
   }));
   const encoded = yield* Schema.encodeEffect(LoadJson)(load).pipe(Effect.mapError((error) => new FactoryLoadFailed({ message: `The load does not encode: ${error.message}` })));
   yield* Effect.tryPromise({ try: () => mkdir(path.dirname(cacheFile), { recursive: true }).then(() => writeFile(cacheFile, JSON.stringify(encoded))), catch: failed("Could not write the load cache.") });

package/domain/load.ts

@@ -22,12 +22,7 @@ export const Finding = Schema.Struct({
   file: Schema.NullOr(Schema.String),
   line: Schema.NullOr(Schema.Int),
   message: Schema.String,
-  /** A note that holds nothing: the code still runs as written (a retired constructor runs as its replacement). */
-  notice: Schema.optionalKey(Schema.Literal(true)),
 });
-
-/** Whether a finding holds the load: every finding but a notice does. */
-export const holds = (finding: Readonly<{ notice?: true | undefined }>) => finding.notice !== true;
 export type Finding = typeof Finding.Type;
 
 /** `ready` runs (live) or draws (preview). `held` keeps the last good revision: its findings say why. */

package/domain/system-elements/node.ts

@@ -158,8 +158,6 @@ export interface Encoder {
   readonly ref: <T extends NodeTag>(to: T, value: Slot<T>) => Ref<T>;
   /** A problem with this node's settings, pinned to it. */
   readonly problem: (message: string) => void;
-  /** A note on this node that holds nothing, pinned to it: its code still runs as written. */
-  readonly notice: (message: string) => void;
 }
 
 /** The rows a floor reads, by the node each belongs to. The records name their nodes by id. */

package/domain/system-elements/pool.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { AUTHORED, authoredHead, head, type Authored, type Encoder, type LiveRows } from "./node";
+import { AUTHORED, authoredHead, head, type Authored, type LiveRows } from "./node";
 
 /*
  * A pool names a provider and an optional narrowing, nothing else.
@@ -13,19 +13,11 @@ import { AUTHORED, authoredHead, head, type Authored, type Encoder, type LiveRow
  */
 
 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 const Provider = Schema.Literals(PROVIDERS);
 export type Provider = typeof Provider.Type;
-export type AuthoredProvider = (typeof PROVIDERS)[number];
-export type RetiredProvider = (typeof RETIRED_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";
+/** Whether a pool names the owner's fleet. */
+export const isFleet = (provider: Provider) => provider === "fleet";
 
 export const Os = Schema.Literals(["mac", "linux", "windows"]);
 export type Os = typeof Os.Type;
@@ -39,37 +31,21 @@ 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 AuthoredProvider = AuthoredProvider> extends Authored<"Pool", string> {
+export interface AuthoredPool<P extends Provider = Provider> extends Authored<"Pool", string> {
   readonly provider: P;
   readonly os: ReadonlyArray<Os>;
   readonly arch: ReadonlyArray<Arch>;
-  /** The retired constructor that made it, when one did: it runs as the fleet, and the load says so. */
-  readonly retired?: RetiredProvider;
 }
 
 type Narrow = Readonly<{ os?: ReadonlyArray<Os>; arch?: ReadonlyArray<Arch> }>;
 
-const made = <const P extends AuthoredProvider>(provider: P, narrow: Narrow | undefined): AuthoredPool<P> => ({
+const made = <const P extends Provider>(provider: P, narrow: Narrow | undefined): AuthoredPool<P> => ({
   [AUTHORED]: authoredHead("Pool", provider, false),
   provider,
   os: narrow?.os ?? [],
   arch: narrow?.arch ?? [],
 });
 
-/**
- * A retired constructor, kept so code written before one fleet still loads and its passes still run: it makes the
- * fleet with the same narrowing, under its own name (`pool:macs`), so its node and every Ref to it stay as they were.
- */
-const retired = (name: RetiredProvider) => (narrow?: Narrow): AuthoredPool<"fleet"> => ({
-  [AUTHORED]: authoredHead("Pool", name, false),
-  provider: "fleet",
-  os: narrow?.os ?? [],
-  arch: narrow?.arch ?? [],
-  retired: name,
-});
-
-const RETIRED_CALL: Readonly<Record<RetiredProvider, string>> = { macs: "pool.macs()", "thinair-cloud": "pool.thinairCloud()", namespace: "pool.namespace()" };
-
 /** The pools a factory can name. Each is named after its provider: `pool:fleet`. */
 export const pool = {
   /**
@@ -81,19 +57,9 @@ export const pool = {
   fleet: (narrow?: Narrow) => made("fleet", narrow),
   /** GitHub Actions runners, dispatched with the Agents App. */
   githubActions: (narrow?: Narrow) => made("github-actions", narrow),
-  /** @deprecated The fleet: use `pool.fleet()`. It makes the fleet with this narrowing, and the load says so. */
-  macs: retired("macs"),
-  /** @deprecated The fleet, which Thinair Cloud joins once the owner names the factory's Cloud Organization: use `pool.fleet()`. */
-  thinairCloud: retired("thinair-cloud"),
-  /** @deprecated Never had a filling: use `pool.fleet()`. It makes the fleet with this narrowing, and the load says so. */
-  namespace: retired("namespace"),
 };
 
-export const make = (authored: AuthoredPool, encoder: Encoder) => {
-  if (authored.retired !== undefined)
-    encoder.notice(`${RETIRED_CALL[authored.retired]} is pool.fleet() now: it runs as the fleet with the same narrowing. Rename it to pool.fleet().`);
-  return { provider: authored.provider, os: [...authored.os], arch: [...authored.arch] };
-};
+export const make = (authored: AuthoredPool) => ({ provider: authored.provider, os: [...authored.os], arch: [...authored.arch] });
 
 /** The machines placement can use now, from their own facts. */
 export const live = (node: Node, rows: LiveRows) => {

package/domain/system-elements/registry.ts

@@ -67,7 +67,7 @@ export type EncodeOptions = Readonly<{
   files: Readonly<Record<string, FileFacts>>;
 }>;
 
-export type Encoded = Readonly<{ program: Program | null; problems: ReadonlyArray<EncodeProblem>; notices: ReadonlyArray<EncodeProblem> }>;
+export type Encoded = Readonly<{ program: Program | null; problems: ReadonlyArray<EncodeProblem> }>;
 
 /** JSON with keys sorted at every level: two values are the same when this is. */
 const canonicalJson = (value: unknown): string => JSON.stringify(value, (_key, item: unknown) =>
@@ -80,7 +80,6 @@ type Draft = Readonly<{ node: Readonly<Record<string, unknown>> & { readonly at:
 /** Encode a factory's root, as `factory.ts` exports it, into its Program. */
 export const encodeFactory = (root: unknown, options: EncodeOptions): Encoded => {
   const problems: EncodeProblem[] = [];
-  const notices: EncodeProblem[] = [];
   const drafts = new Map<NodeId, Draft>();
   const encodedValues = new Map<object, NodeId>();
   const visiting = new Set<object>();
@@ -118,7 +117,6 @@ export const encodeFactory = (root: unknown, options: EncodeOptions): Encoded =>
     const encoder: Encoder = {
       ref: (tag, slot) => encode(tag, slot, { node: id, at }),
       problem: (message) => problems.push({ node: id, at, message }),
-      notice: (message) => notices.push({ node: id, at, message }),
     };
     const settings = (definitions[made.tag] as Definition<Tag>).make(value as never, encoder);
     visiting.delete(value);
@@ -134,10 +132,10 @@ export const encodeFactory = (root: unknown, options: EncodeOptions): Encoded =>
 
   if (!isAuthored(root) || headOf(root).tag !== "Factory") {
     problems.push({ node: null, at: { file: "factory.ts", line: 1 }, message: "factory.ts's default export is the factory: export default defineFactory({ ... })." });
-    return { program: null, problems, notices };
+    return { program: null, problems };
   }
   encode("Factory", root, null);
-  if (broken) return { program: null, problems, notices };
+  if (broken) return { program: null, problems };
 
   // A node's digest covers its content and, when it holds code, the import closure of its file,
   // stopping at files that make other nodes: those nodes have digests of their own.
@@ -167,9 +165,9 @@ export const encodeFactory = (root: unknown, options: EncodeOptions): Encoded =>
   const decoded = Schema.decodeUnknownResult(Program)({ version: LANGUAGE_VERSION, framework: options.framework, root: ROOT_ID, nodes });
   if (Result.isFailure(decoded)) {
     problems.push({ node: null, at: null, message: `The program does not decode: ${decoded.failure.message}` });
-    return { program: null, problems, notices };
+    return { program: null, problems };
   }
   for (const problem of graphProblems(decoded.success))
     problems.push({ node: problem.node, at: (decoded.success.nodes[problem.node] as Node | undefined)?.at ?? null, message: problem.message });
-  return { program: decoded.success, problems, notices };
+  return { program: decoded.success, problems };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thinair/factory",
-  "version": "0.1.170",
+  "version": "0.1.177",
   "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",