@thinair/factory 0.1.175 → 0.1.179

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/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.175",
+  "version": "0.1.179",
   "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",