@aglyn/plugins-ai 1.0.0-beta.143

package/src/lib/jobs/ai-job-page-budget.js

@@ -0,0 +1,60 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { AI_STEP_TIERS } from "../providers/catalog.js";
+import { aiJobStepBudget } from "./ai-job-budget.js";
+/**
+ * The time a page pass needs (AGL-2907, AGL-3036), declared apart from the
+ * page step: the site scaffold builds its pages through that step, and reads
+ * the time a page needs without loading the step it hands them to.
+ */ /** The most one section's answer may run to on any model; slower tiers get less. */ export const AI_JOB_PAGE_SECTION_MAX_TOKENS = 2000;
+/**
+ * The ceiling a section's answer asks on the tier the page step is served
+ * from (AGL-2907): fifteen elements at `AI_JOB_PAGE_REAL_TOKENS_PER_ELEMENT`
+ * (AGL-3042), the size every golden section and a two-person introduction fit
+ * (`ai-job-page-evals.spec.ts`) and a Free page's credits are counted at
+ * (`ai-job-free-page.spec.ts`). A faster tier asks more in the same time, up
+ * to `AI_JOB_PAGE_SECTION_MAX_TOKENS`, and a slower one less.
+ *
+ * A Free page fits its wall at this ceiling with little to spare, so the
+ * ceiling does not move to make a section fit: a few tokens past it, the Free
+ * page that builds its layout first leaves no more of the wall than its
+ * largest pass spends, which is the room a re-asked section needs
+ * (`ai-job-free-page.spec.ts` finds the largest ceiling that holds, and
+ * `docs/AI_JOBS.md` quotes it). The sections a Free plan may ask for are
+ * counted at this ceiling too (AGL-3070). A section that runs past it is asked for
+ * smaller instead (AGL-3042), and on a workspace that keeps no reusable
+ * components a repeated item is written once, which is what lets a Free
+ * section of cards with real copy fit at all (AGL-3053).
+ */ export const AI_JOB_PAGE_SECTION_TOKENS = 1050;
+/**
+ * A section pass's time (AGL-3036): its two inventory-lookup rounds, its
+ * answer and its re-ask at `AI_JOB_PAGE_SECTION_TOKENS` on the served tier,
+ * with the step's reads and writes, at the rates `ai-job-budget.ts` assumes.
+ */ export const AI_JOB_PAGE_STEP_BUDGET = aiJobStepBudget({
+    tier: AI_STEP_TIERS['job.page'],
+    maxTokens: AI_JOB_PAGE_SECTION_TOKENS,
+    cap: AI_JOB_PAGE_SECTION_MAX_TOKENS
+});
+/**
+ * The least time one section pass needs before it starts. Registered with the
+ * step, so neither the beat nor an inline door starts a pass that its budget
+ * would cut off. A spec holds it inside the beat's own budget.
+ */ export const AI_JOB_PAGE_STEP_MINIMUM_MS = AI_JOB_PAGE_STEP_BUDGET.minimumMs;
+/** The ceiling a section's answer asks on this model: the most whose worst case fits a pass. */ export function aiJobPageSectionMaxTokens(model) {
+    return AI_JOB_PAGE_STEP_BUDGET.maxTokens(model);
+}
+
+//# sourceMappingURL=ai-job-page-budget.js.map

package/src/lib/jobs/ai-job-page-budget.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/ai/src/lib/jobs/ai-job-page-budget.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AI_STEP_TIERS } from '../providers/catalog'\nimport { aiJobStepBudget } from './ai-job-budget'\n\n/**\n * The time a page pass needs (AGL-2907, AGL-3036), declared apart from the\n * page step: the site scaffold builds its pages through that step, and reads\n * the time a page needs without loading the step it hands them to.\n */\n\n/** The most one section's answer may run to on any model; slower tiers get less. */\nexport const AI_JOB_PAGE_SECTION_MAX_TOKENS = 2_000\n\n/**\n * The ceiling a section's answer asks on the tier the page step is served\n * from (AGL-2907): fifteen elements at `AI_JOB_PAGE_REAL_TOKENS_PER_ELEMENT`\n * (AGL-3042), the size every golden section and a two-person introduction fit\n * (`ai-job-page-evals.spec.ts`) and a Free page's credits are counted at\n * (`ai-job-free-page.spec.ts`). A faster tier asks more in the same time, up\n * to `AI_JOB_PAGE_SECTION_MAX_TOKENS`, and a slower one less.\n *\n * A Free page fits its wall at this ceiling with little to spare, so the\n * ceiling does not move to make a section fit: a few tokens past it, the Free\n * page that builds its layout first leaves no more of the wall than its\n * largest pass spends, which is the room a re-asked section needs\n * (`ai-job-free-page.spec.ts` finds the largest ceiling that holds, and\n * `docs/AI_JOBS.md` quotes it). The sections a Free plan may ask for are\n * counted at this ceiling too (AGL-3070). A section that runs past it is asked for\n * smaller instead (AGL-3042), and on a workspace that keeps no reusable\n * components a repeated item is written once, which is what lets a Free\n * section of cards with real copy fit at all (AGL-3053).\n */\nexport const AI_JOB_PAGE_SECTION_TOKENS = 1_050\n\n/**\n * A section pass's time (AGL-3036): its two inventory-lookup rounds, its\n * answer and its re-ask at `AI_JOB_PAGE_SECTION_TOKENS` on the served tier,\n * with the step's reads and writes, at the rates `ai-job-budget.ts` assumes.\n */\nexport const AI_JOB_PAGE_STEP_BUDGET = aiJobStepBudget({\n  tier: AI_STEP_TIERS['job.page'],\n  maxTokens: AI_JOB_PAGE_SECTION_TOKENS,\n  cap: AI_JOB_PAGE_SECTION_MAX_TOKENS,\n})\n\n/**\n * The least time one section pass needs before it starts. Registered with the\n * step, so neither the beat nor an inline door starts a pass that its budget\n * would cut off. A spec holds it inside the beat's own budget.\n */\nexport const AI_JOB_PAGE_STEP_MINIMUM_MS = AI_JOB_PAGE_STEP_BUDGET.minimumMs\n\n/** The ceiling a section's answer asks on this model: the most whose worst case fits a pass. */\nexport function aiJobPageSectionMaxTokens(model: string): number {\n  return AI_JOB_PAGE_STEP_BUDGET.maxTokens(model)\n}\n\n"],"names":["AI_STEP_TIERS","aiJobStepBudget","AI_JOB_PAGE_SECTION_MAX_TOKENS","AI_JOB_PAGE_SECTION_TOKENS","AI_JOB_PAGE_STEP_BUDGET","tier","maxTokens","cap","AI_JOB_PAGE_STEP_MINIMUM_MS","minimumMs","aiJobPageSectionMaxTokens","model"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED,SAASA,aAAa,QAAQ,0BAAsB;AACpD,SAASC,eAAe,QAAQ,qBAAiB;AAEjD;;;;CAIC,GAED,kFAAkF,GAClF,OAAO,MAAMC,iCAAiC,KAAK;AAEnD;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,MAAMC,6BAA6B,KAAK;AAE/C;;;;CAIC,GACD,OAAO,MAAMC,0BAA0BH,gBAAgB;IACrDI,MAAML,aAAa,CAAC,WAAW;IAC/BM,WAAWH;IACXI,KAAKL;AACP,GAAE;AAEF;;;;CAIC,GACD,OAAO,MAAMM,8BAA8BJ,wBAAwBK,SAAS,CAAA;AAE5E,8FAA8F,GAC9F,OAAO,SAASC,0BAA0BC,KAAa;IACrD,OAAOP,wBAAwBE,SAAS,CAACK;AAC3C"}

package/src/lib/jobs/ai-job-page-sections.d.ts

@@ -0,0 +1,150 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { NodesMap } from '@aglyn/aglyn/types/nodes';
+import type { AiBuildPlanScreen, AiBuildPlanSection } from '../model/ai-build-plan';
+import type { AiJob, AiJobPlan } from '../model/ai-jobs.types';
+import { type AiSiteInventory } from '../model/ai-site-inventory';
+import type { AiTool } from '../providers/contract';
+import { type AiGenerationCheck } from '../runtime/ai-doctrine';
+import { type AiDoctrineTreeContext } from '../runtime/ai-doctrine-validators';
+import type { AiLoadEstimate } from '../runtime/ai-palette';
+import type { AiSystemBlock } from '../runtime/ai-runtime';
+/**
+ * A page built one section at a time (AGL-2907): what one section pass asks
+ * for, how its answer is held to the building rules as part of the page, and
+ * how it joins the page.
+ *
+ * Pure: no Firestore and no provider, so the page step, its specs and the
+ * evals read one definition of a section.
+ *
+ * ── Held as part of the page ─────────────────────────────────────────────
+ *
+ * A section is checked twice over, by validators the doctrine already has:
+ * the palette validator on the section as the model wrote it, then the
+ * doctrine's whole page check on the page built so far with the section
+ * added. So the page's one main, its one h1 and its heading outline, repeats
+ * across sections, and its weight against the page budget are held on every
+ * pass, not only on the last. The violations name the section's own nodes,
+ * by the ids the model wrote, so a re-ask quotes this section and nothing
+ * else — the page is never sent back.
+ *
+ * ── A repeated item written once (AGL-3053) ──────────────────────────────
+ *
+ * Where the workspace keeps no reusable components, an answer writes a
+ * repeated item once and lists its copies' values, and the check draws the
+ * copies before either validator reads the section (`ai-repeated-items.ts`).
+ * Both then read the section as the page stores it, so the page's rules hold
+ * on every copy exactly as on an item written out in full, and a finding on a
+ * copy names the node the model wrote. Where the workspace keeps components,
+ * an item written once is refused: it places instances.
+ */
+/** The section root id a pass writes, from the job and the plan section's index. */
+export declare function aiPageSectionNodeId(jobId: string, index: number): string;
+/** The strict tool a section arrives through. The node map rides as JSON text, as a page's does. */
+export declare const AI_PAGE_SECTION_TOOL: AiTool;
+/** The page step's own instructions, cached after the doctrine, with the screen palette after them. */
+export declare const AI_JOB_PAGE_INSTRUCTIONS: readonly AiSystemBlock[];
+export interface AiPageSectionPromptInput {
+    job: Pick<AiJob, 'brief' | 'inputs'>;
+    plan: AiJobPlan;
+    screen: AiBuildPlanScreen;
+    index: number;
+    /** The most elements the section may carry at this pass's answer ceiling. */
+    maxElements: number;
+    /**
+     * Whether the workspace keeps reusable components and saved forms
+     * (AGL-3030); `false` asks for the section built inline. Absent is `true`.
+     */
+    reusableComponents?: boolean;
+}
+/** What a section request says where the workspace keeps no reusable components or saved forms. */
+export declare const AI_PAGE_SECTION_INLINE_LINE = "This site keeps no saved forms or reusable components: write a repeated item once, and draw a form as a Form holding its Form Fields.";
+/**
+ * How a repeated item is written once (AGL-3053): the item's subtree once,
+ * with placeholders where its copies differ and their values listed, which
+ * the section check draws into its copies (`ai-repeated-items.ts`). It rides
+ * the request of a section whose plan line shows items on a workspace that
+ * keeps no reusable components, and no other: a section with nothing to repeat
+ * pays nothing for it, the cached prefix every workspace shares says only that
+ * a repeated item is written once, and a workspace that places components is
+ * never shown how.
+ */
+export declare const AI_PAGE_SECTION_REPEAT_LINE = "Write a repeated item once: put {{1}}, {{2}}\u2026 where its copies differ, and give its outermost node \"repeat\", one list of values a copy, in that order, as [[\"Title 1\", \"Text 1\"], [\"Title 2\", \"Text 2\"]].";
+/**
+ * What a pass whose answer ran past its ceiling is told makes a section
+ * smaller (AGL-3042): fewer elements, down to the budget the request gave,
+ * shorter copy, and a repeated item drawn no more than once — placed as an
+ * instance where the workspace keeps reusable components, and written once
+ * where it keeps none (AGL-3053), with the shape spelled out, since a section
+ * whose plan line showed no items was never told it. It rides the re-ask,
+ * never the first request, so a pass that fits sends no byte more.
+ */
+export declare function aiPageSectionSmaller(input: Pick<AiPageSectionPromptInput, 'maxElements' | 'reusableComponents'>): string;
+/** One pass's user turn: the page, the brief, the plan, this section and what is built above it. */
+export declare function aiPageSectionPrompt(input: AiPageSectionPromptInput): string;
+/** A validated section: its nodes keyed as the page stores them, its root under the page root. */
+export interface AiPageSection {
+    rootId: string;
+    nodes: NodesMap;
+    /** The page's weight with the section added, as the doctrine measured it. */
+    load: AiLoadEstimate | null;
+}
+/** A page with nothing on it yet: the document wrapper. */
+export declare function aiEmptyPage(): NodesMap;
+/**
+ * The page with a section in its plan position: after every section with a
+ * lower index and before every one with a higher, the page's other children
+ * — whatever a member placed — kept where they are. A section already on the
+ * page is replaced, never doubled.
+ */
+export declare function aiPageWithSection(page: NodesMap, section: AiPageSection, sectionIds: readonly string[]): NodesMap;
+/**
+ * What a tree generated against this inventory may reference, the brand it is
+ * held to, where the workspace keeps no reusable components or saved forms
+ * (AGL-3030) that the page is built inline, and the sections its plan names,
+ * which a link may take a visitor to (AGL-3097).
+ */
+export declare function aiPageCheckContext(inventory: AiSiteInventory | null, options?: {
+    reusableComponents?: boolean;
+    sections?: readonly string[];
+}): AiDoctrineTreeContext;
+export interface AiPageSectionCheckInput {
+    /** The page as stored so far; an empty page on the first pass. */
+    page: NodesMap;
+    /** Every section root id of the plan, in order. */
+    sectionIds: readonly string[];
+    index: number;
+    context: AiDoctrineTreeContext;
+    /**
+     * The plan line this pass answers for: what it places by inventory id, and
+     * how many items it promised, which the answer is held to (AGL-3024).
+     */
+    section: Pick<AiBuildPlanSection, 'name' | 'uses' | 'items'>;
+    inventory: AiSiteInventory | null;
+}
+/**
+ * The check a section's answer is held to: a repeated item written once drawn
+ * into its copies (AGL-3053), then the palette validator on the section, with
+ * any line it cut at its ceiling refused (AGL-3076), the doctrine's page check
+ * on the page with the section added, and the plan line — every component it
+ * names placed as an instance, every form bound by its id (rule 7), and as
+ * many items as it promised (AGL-3024). Violations
+ * name the section's own nodes by the ids the MODEL wrote, and a copy's nodes
+ * by the item's; one that names only nodes an earlier pass stored belongs to
+ * the page rather than to this answer, and is left to the last pass (AGL-3078).
+ */
+export declare function aiPageSectionCheck(input: AiPageSectionCheckInput): AiGenerationCheck<AiPageSection>;