anhedral 0.8.5 → 0.8.6

package/dist/platforms/extension.js

@@ -4,23 +4,23 @@ import { writeFile } from '../util.js';
 import { EXTENSION_DEPENDENCIES } from '../dependencies.js';
 import { childPackageName, htmlText, jsString, markdownHeading } from '../render.js';
 export async function scaffoldExtension(root, options) {
-    const { projectName, displayName } = options;
+    const { projectName, displayName, extensionSurface = 'sidepanel' } = options;
     const dir = path.join(root, 'apps/extension');
     writePackageJson(dir, projectName);
     writeFile(path.join(dir, 'tsconfig.json'), JSON.stringify({ extends: './.wxt/tsconfig.json', compilerOptions: { strict: true, jsx: 'react-jsx', paths: { '@/*': ['./src/*'] } } }, null, 2) + '\n');
     writeReactLintConfig(dir);
-    writeWxtConfig(dir, displayName);
+    writeWxtConfig(dir, displayName, extensionSurface);
     writeEnvExample(dir);
     writePostcssConfig(dir);
-    writeTailwindConfig(dir);
     writeShadcnConfig(dir);
-    writeReadme(dir, displayName);
+    writeReadme(dir, displayName, extensionSurface);
     writeCnUtil(dir);
     writeButtonComponent(dir);
-    writeBackground(dir);
-    writeSidepanelEntry(dir);
-    writeSidepanelHtml(dir, displayName);
-    writeSidepanelApp(dir);
+    if (extensionSurface === 'sidepanel')
+        writeBackground(dir);
+    writeSurfaceEntry(dir, extensionSurface);
+    writeSurfaceHtml(dir, displayName, extensionSurface);
+    writeSurfaceApp(dir, extensionSurface);
     writeStyles(dir);
 }
 function writePackageJson(dir, projectName) {
@@ -38,10 +38,10 @@ function writePackageJson(dir, projectName) {
             lint: 'eslint src --max-warnings 0',
         },
         dependencies: EXTENSION_DEPENDENCIES.dependencies,
-        devDependencies: { ...EXTENSION_DEPENDENCIES.devDependencies, '@workspace/eslint-config': 'workspace:*', eslint: '10.0.3' },
+        devDependencies: { ...EXTENSION_DEPENDENCIES.devDependencies, '@workspace/eslint-config': 'workspace:*', eslint: '9.39.5' },
     }, null, 2) + '\n');
 }
-function writeWxtConfig(dir, displayName) {
+function writeWxtConfig(dir, displayName, surface) {
     const nameLiteral = jsString(displayName);
     const descriptionLiteral = jsString(`${displayName} Chrome Extension`);
     const actionTitleLiteral = jsString(`Open ${displayName}`);
@@ -59,15 +59,14 @@ export default defineConfig({
       description: ${descriptionLiteral},
       version: '0.1.0',
       ...(crxPublicKey ? { key: crxPublicKey } : {}),
-      minimum_chrome_version: '114',
-      permissions: ['activeTab', 'scripting', 'sidePanel'],
+      ${surface === 'sidepanel' ? "minimum_chrome_version: '114'," : ''}
+      permissions: ${surface === 'sidepanel' ? "['activeTab', 'scripting', 'sidePanel']" : "['activeTab', 'scripting']"},
       host_permissions: [],
       action: {
         default_title: ${actionTitleLiteral},
+        ${surface === 'popup' ? "default_popup: 'popup.html'," : ''}
       },
-      side_panel: {
-        default_path: 'sidepanel.html',
-      },
+      ${surface === 'sidepanel' ? "side_panel: { default_path: 'sidepanel.html' }," : ''}
     };
   },
   modules: ['@wxt-dev/module-react'],
@@ -91,8 +90,7 @@ function writeEnvExample(dir) {
 function writePostcssConfig(dir) {
     writeFile(path.join(dir, 'postcss.config.cjs'), `module.exports = {
   plugins: {
-    tailwindcss: {},
-    autoprefixer: {},
+    "@tailwindcss/postcss": {},
   },
 };
 `);
@@ -164,62 +162,10 @@ export const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
 Button.displayName = 'Button';
 `);
 }
-function writeTailwindConfig(dir) {
-    writeFile(path.join(dir, 'tailwind.config.cjs'), `/** @type {import('tailwindcss').Config} */
-module.exports = {
-  content: ['./src/**/*.{ts,tsx,html}'],
-  theme: {
-    extend: {
-      colors: {
-        border: 'hsl(var(--border))',
-        input: 'hsl(var(--input))',
-        ring: 'hsl(var(--ring))',
-        background: 'hsl(var(--background))',
-        foreground: 'hsl(var(--foreground))',
-        primary: {
-          DEFAULT: 'hsl(var(--primary))',
-          foreground: 'hsl(var(--primary-foreground))',
-        },
-        secondary: {
-          DEFAULT: 'hsl(var(--secondary))',
-          foreground: 'hsl(var(--secondary-foreground))',
-        },
-        destructive: {
-          DEFAULT: 'hsl(var(--destructive))',
-          foreground: 'hsl(var(--destructive-foreground))',
-        },
-        muted: {
-          DEFAULT: 'hsl(var(--muted))',
-          foreground: 'hsl(var(--muted-foreground))',
-        },
-        accent: {
-          DEFAULT: 'hsl(var(--accent))',
-          foreground: 'hsl(var(--accent-foreground))',
-        },
-        popover: {
-          DEFAULT: 'hsl(var(--popover))',
-          foreground: 'hsl(var(--popover-foreground))',
-        },
-        card: {
-          DEFAULT: 'hsl(var(--card))',
-          foreground: 'hsl(var(--card-foreground))',
-        },
-      },
-      borderRadius: {
-        lg: 'var(--radius)',
-        md: 'calc(var(--radius) - 2px)',
-        sm: 'calc(var(--radius) - 4px)',
-      },
-    },
-  },
-  plugins: [],
-};
-`);
-}
-function writeReadme(dir, displayName) {
+function writeReadme(dir, displayName, surface) {
     writeFile(path.join(dir, 'README.md'), `# ${markdownHeading(displayName)} Chrome Extension
 
-WXT side-panel extension generated by anhedral.
+WXT ${surface} extension generated by anhedral. Choose the surface for the task; content UI, options pages and background-only behavior require targeted implementation.
 
 ## Development
 
@@ -236,29 +182,25 @@ Run these commands from \`apps/extension\`. Anhedral generates only \`.env.examp
 
 Run \`pnpm build\`, then load \`.output/chrome-mv3\` as an unpacked extension from \`chrome://extensions\`.
 
-The extension uses Chrome's Side Panel API. The browser action opens \`sidepanel.html\`, \`wxt.config.ts\` declares the \`sidePanel\` permission and Chrome 114+ minimum version, and active-page reads use a user-triggered \`activeTab\` + \`scripting\` grant instead of persistent site access.
+${surface === 'sidepanel' ? "The browser action opens the Side Panel API surface (Chrome 114+) with the sidePanel permission." : "The browser action opens popup.html; no sidePanel permission or panel background handler is generated."} Active-page reads use a user-triggered activeTab + scripting grant instead of persistent site access. Remove these permissions and the example read action if the product does not need page inspection.
 `);
 }
 function writeBackground(dir) {
-    writeFile(path.join(dir, 'src/entrypoints/background.ts'), `type ChromeWithSidePanel = typeof chrome & {
-  sidePanel: {
-    setPanelBehavior: (behavior: { openPanelOnActionClick: boolean }) => Promise<void>;
-  };
-};
+    writeFile(path.join(dir, 'src/entrypoints/background.ts'), `import { browser } from 'wxt/browser';
 
 export default defineBackground(() => {
 
   // Open the side panel when the extension icon is clicked.
-  (chrome as ChromeWithSidePanel).sidePanel
+  browser.sidePanel
     .setPanelBehavior({ openPanelOnActionClick: true })
     .catch(() => {});
 });
 `);
 }
-function writeSidepanelEntry(dir) {
-    writeFile(path.join(dir, 'src/entrypoints/sidepanel/main.tsx'), `import * as React from 'react';
+function writeSurfaceEntry(dir, surface) {
+    writeFile(path.join(dir, `src/entrypoints/${surface}/main.tsx`), `import * as React from 'react';
 import { createRoot } from 'react-dom/client';
-import { SidePanelApp } from './app';
+import { ExtensionApp } from './app';
 import '../../styles/main.css';
 
 const container = document.getElementById('root');
@@ -266,14 +208,14 @@ if (container) {
   const root = createRoot(container);
   root.render(
     <React.StrictMode>
-      <SidePanelApp />
+      <ExtensionApp />
     </React.StrictMode>
   );
 }
 `);
 }
-function writeSidepanelHtml(dir, displayName) {
-    writeFile(path.join(dir, 'src/entrypoints/sidepanel/index.html'), `<!DOCTYPE html>
+function writeSurfaceHtml(dir, displayName, surface) {
+    writeFile(path.join(dir, `src/entrypoints/${surface}/index.html`), `<!DOCTYPE html>
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
@@ -287,8 +229,9 @@ function writeSidepanelHtml(dir, displayName) {
 </html>
 `);
 }
-function writeSidepanelApp(dir) {
-    writeFile(path.join(dir, 'src/entrypoints/sidepanel/app.tsx'), `import * as React from 'react';
+function writeSurfaceApp(dir, surface) {
+    writeFile(path.join(dir, `src/entrypoints/${surface}/app.tsx`), `import * as React from 'react';
+import { browser } from 'wxt/browser';
 import { Button } from '../../components/ui/button';
 
 type PageSnapshot = {
@@ -297,17 +240,21 @@ type PageSnapshot = {
 };
 
 async function readPageSnapshot(): Promise<PageSnapshot> {
-  const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  const [tab] = await browser.tabs.query({ active: true, currentWindow: true });
   if (!tab?.id) throw new Error('No active tab is available.');
-  const [{ result }] = await chrome.scripting.executeScript({
+  const [injection] = await browser.scripting.executeScript({
     target: { tabId: tab.id },
     func: () => ({ title: document.title, location: window.location.href }),
   });
+  return requireSnapshot(injection?.result);
+}
+
+function requireSnapshot(result: PageSnapshot | undefined): PageSnapshot {
   if (!result) throw new Error('The active page did not return a snapshot.');
-  return result as PageSnapshot;
+  return result;
 }
 
-export function SidePanelApp() {
+export function ExtensionApp() {
   const [page, setPage] = React.useState<PageSnapshot | null>(null);
   const [pageError, setPageError] = React.useState<string | null>(null);
 
@@ -322,7 +269,7 @@ export function SidePanelApp() {
 
 
   return (
-    <div style={{ padding: 24 }}>
+    <div style={{ padding: 24${surface === 'popup' ? ', minWidth: 320' : ''} }}>
       <h2>Welcome!</h2>
       <Button type="button" onClick={() => void readActivePage()}>Read active page</Button>
       {page ? (
@@ -338,9 +285,32 @@ export function SidePanelApp() {
 `);
 }
 function writeStyles(dir) {
-    writeFile(path.join(dir, 'src/styles/main.css'), `@tailwind base;
-@tailwind components;
-@tailwind utilities;
+    writeFile(path.join(dir, 'src/styles/main.css'), `@import "tailwindcss";
+
+@theme inline {
+  --color-background: hsl(var(--background));
+  --color-foreground: hsl(var(--foreground));
+  --color-card: hsl(var(--card));
+  --color-card-foreground: hsl(var(--card-foreground));
+  --color-popover: hsl(var(--popover));
+  --color-popover-foreground: hsl(var(--popover-foreground));
+  --color-primary: hsl(var(--primary));
+  --color-primary-foreground: hsl(var(--primary-foreground));
+  --color-secondary: hsl(var(--secondary));
+  --color-secondary-foreground: hsl(var(--secondary-foreground));
+  --color-muted: hsl(var(--muted));
+  --color-muted-foreground: hsl(var(--muted-foreground));
+  --color-accent: hsl(var(--accent));
+  --color-accent-foreground: hsl(var(--accent-foreground));
+  --color-destructive: hsl(var(--destructive));
+  --color-destructive-foreground: hsl(var(--destructive-foreground));
+  --color-border: hsl(var(--border));
+  --color-input: hsl(var(--input));
+  --color-ring: hsl(var(--ring));
+  --radius-lg: var(--radius);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-sm: calc(var(--radius) - 4px);
+}
 
 @layer base {
   :root {

package/dist/platforms/mobile.js

@@ -159,7 +159,7 @@ export async function scaffoldMobile(root, options) {
             lint: 'eslint app components lib --max-warnings 0',
         },
         dependencies: { ...MOBILE_APP_DEPENDENCIES.dependencies, ...MOBILE_NATIVEWIND_DEPENDENCIES.dependencies },
-        devDependencies: { ...MOBILE_APP_DEPENDENCIES.devDependencies, '@workspace/eslint-config': 'workspace:*', eslint: '10.0.3' },
+        devDependencies: { ...MOBILE_APP_DEPENDENCIES.devDependencies, '@workspace/eslint-config': 'workspace:*', eslint: '9.39.5' },
     }, null, 2) + '\n');
     writeFile(path.join(dir, 'app.json'), JSON.stringify({
         expo: {

package/dist/pnpm-policy.d.ts

@@ -0,0 +1,6 @@
+/** Preserve unrelated starter YAML while replacing the settings this initializer owns. */
+export declare function setPnpmPolicy(root: string, policy: Record<string, unknown>): void;
+/** Only reads the JSON-compatible values written above, never arbitrary client YAML. */
+export declare function generatedPnpmPolicy(root: string, key: string): Record<string, string>;
+/** Merge reviewed patches without deleting starter-maintained mappings. */
+export declare function mergePnpmPatches(root: string, patches: Record<string, string>): void;

package/dist/pnpm-policy.js

@@ -0,0 +1,61 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { writeFile } from './util.js';
+function policyBlock(key) {
+    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`^(?:${escaped}|"${escaped}"|'${escaped}')[ \\t]*:.*(?:\\r?\\n|$)(?:[ \\t]+[^\\n]*(?:\\n|$)|#[^\\n]*(?:\\n|$)|[ \\t]*\\n)*`, 'gm');
+}
+/** Preserve unrelated starter YAML while replacing the settings this initializer owns. */
+export function setPnpmPolicy(root, policy) {
+    const file = path.join(root, 'pnpm-workspace.yaml');
+    let source = existsSync(file) ? readFileSync(file, 'utf8') : '';
+    for (const [key, value] of Object.entries(policy)) {
+        source = source.replace(policyBlock(key), '');
+        if (value === undefined)
+            continue;
+        source += `${source.endsWith('\n') || !source ? '' : '\n'}${key}: ${JSON.stringify(value)}\n`;
+    }
+    writeFile(file, source);
+}
+/** Only reads the JSON-compatible values written above, never arbitrary client YAML. */
+export function generatedPnpmPolicy(root, key) {
+    const source = readFileSync(path.join(root, 'pnpm-workspace.yaml'), 'utf8');
+    const value = source.match(new RegExp(`^${key}: (.+)$`, 'm'))?.[1];
+    return value ? JSON.parse(value) : {};
+}
+/** Merge reviewed patches without deleting starter-maintained mappings. */
+export function mergePnpmPatches(root, patches) {
+    const file = path.join(root, 'pnpm-workspace.yaml');
+    const source = existsSync(file) ? readFileSync(file, 'utf8') : '';
+    const blocks = [...source.matchAll(policyBlock('patchedDependencies'))];
+    if (blocks.length > 1)
+        throw new Error('Duplicate patchedDependencies configuration');
+    const block = blocks[0]?.[0] ?? '';
+    const existing = patchRows(block, patches);
+    const replacement = 'patchedDependencies:\n' + existing + Object.entries(patches)
+        .map(([key, value]) => `  ${JSON.stringify(key)}: ${JSON.stringify(value)}\n`).join('');
+    const remaining = source.replace(policyBlock('patchedDependencies'), '');
+    writeFile(file, remaining + `${remaining.endsWith('\n') || !remaining ? '' : '\n'}${replacement}`);
+}
+function patchRows(block, patches) {
+    if (!block)
+        return '';
+    const [header, ...rows] = block.split(/\r?\n/);
+    const value = header.slice(header.indexOf(':') + 1).trim();
+    if (value && !value.startsWith('#')) {
+        const object = JSON.parse(value);
+        if (!object || Array.isArray(object) || typeof object !== 'object' ||
+            Object.values(object).some((entry) => typeof entry !== 'string'))
+            throw new Error('Unsupported patchedDependencies mapping');
+        return Object.entries(object).filter(([key]) => !Object.hasOwn(patches, key))
+            .map(([key, entry]) => `  ${JSON.stringify(key)}: ${JSON.stringify(entry)}\n`).join('');
+    }
+    return rows.filter((row) => {
+        if (!row.trim() || row.trimStart().startsWith('#'))
+            return true;
+        const match = row.match(/^  (?:"([^"\\]+)"|'([^']+)'|([^\s:'"]+)):\s*(?:"[^"\\]+"|'[^']+'|[^\s{}[\]&*!|>]+)(?:\s+#.*)?\s*$/);
+        if (!match)
+            throw new Error('Unsupported patchedDependencies mapping');
+        return !Object.hasOwn(patches, match[1] ?? match[2] ?? match[3]);
+    }).filter((row, index, rows) => row || index < rows.length - 1).map((row) => `${row}\n`).join('');
+}

package/dist/progress-view.d.ts

@@ -0,0 +1,57 @@
+import type { evaluateProjectProgress } from "./progress.js";
+export type EnvironmentProgress = ReturnType<typeof evaluateProjectProgress>["environments"][number];
+interface ProgressNode {
+    label?: string;
+    id: string;
+    capability?: string;
+    resourceId?: string;
+    status: "planned" | "building" | "configured" | "verified" | "blocked";
+}
+export interface ProviderObservation {
+    id: string;
+    name: string;
+    status: string;
+}
+export declare function componentResources<T extends ProviderObservation>(node: ProgressNode, resources: readonly T[]): T[];
+export declare function providerAttention(resources: readonly ProviderObservation[]): boolean;
+export declare function componentObservations(progress: EnvironmentProgress | undefined, node: ProgressNode): {
+    stale: boolean;
+    capability: string;
+    milestone: import("./progress.js").Milestone;
+    configurationFingerprint: string;
+    resourceRef?: string;
+    revisionRef?: string;
+    outcome: "passed" | "failed" | "blocked";
+    source: "agent" | "independent";
+    observedAt: string;
+    evidence: string;
+    accountRef?: string;
+}[];
+export declare function latestObservations(observations: EnvironmentProgress["observations"]): {
+    stale: boolean;
+    capability: string;
+    milestone: import("./progress.js").Milestone;
+    configurationFingerprint: string;
+    resourceRef?: string;
+    revisionRef?: string;
+    outcome: "passed" | "failed" | "blocked";
+    source: "agent" | "independent";
+    observedAt: string;
+    evidence: string;
+    accountRef?: string;
+}[];
+export declare function componentState(progress: EnvironmentProgress | undefined, node: ProgressNode, resources?: readonly ProviderObservation[]): "blocked" | "planned" | "building" | "configured" | "verified";
+/** A failed optional route does not block a working alternative for the same scope. */
+export declare function discoveryAttention(discovery: EnvironmentProgress["discovery"]): {
+    stale: boolean;
+    provider: string;
+    route: "plugin" | "api" | "cli" | "browser";
+    check: "installed" | "callable" | "local-working" | "authorized" | "integration-tested";
+    expiresAt: string;
+    outcome: "passed" | "failed" | "blocked";
+    source: "agent" | "independent";
+    observedAt: string;
+    evidence: string;
+    accountRef?: string;
+}[];
+export {};

package/dist/progress-view.js

@@ -0,0 +1,69 @@
+export function componentResources(node, resources) {
+    return resources.filter((resource) => node.resourceId
+        ? resource.id === node.resourceId
+        : resource.id === node.id ||
+            (!!node.label && resource.name === node.label));
+}
+export function providerAttention(resources) {
+    return resources.some((resource) => resource.status === "missing" || resource.status === "error");
+}
+export function componentObservations(progress, node) {
+    return (progress?.observations.filter((item) => (item.capability === (node.capability || node.id) &&
+        (!node.resourceId ||
+            !item.resourceRef ||
+            item.resourceRef === node.resourceId)) ||
+        (!!node.resourceId && item.resourceRef === node.resourceId)) || []);
+}
+export function latestObservations(observations) {
+    const latest = new Map();
+    for (const observation of observations) {
+        const key = JSON.stringify([
+            observation.capability,
+            observation.milestone,
+            observation.source,
+            observation.accountRef,
+            observation.resourceRef,
+        ]);
+        const previous = latest.get(key);
+        if (!previous ||
+            Date.parse(observation.observedAt) >= Date.parse(previous.observedAt))
+            latest.set(key, observation);
+    }
+    return [...latest.values()];
+}
+export function componentState(progress, node, resources = []) {
+    if (providerAttention(componentResources(node, resources)))
+        return "blocked";
+    const observations = latestObservations(componentObservations(progress, node));
+    const current = observations.filter((item) => !item.stale);
+    if (current.some((item) => item.outcome !== "passed"))
+        return "blocked";
+    if (current.some((item) => item.milestone === "tested"))
+        return "verified";
+    if (current.some((item) => ["provisioned", "connected"].includes(item.milestone)))
+        return "configured";
+    if (current.some((item) => item.milestone === "generated"))
+        return "building";
+    if (observations.length)
+        return "planned";
+    return node.status;
+}
+/** A failed optional route does not block a working alternative for the same scope. */
+export function discoveryAttention(discovery) {
+    const level = {
+        installed: 0,
+        callable: 1,
+        "local-working": 1,
+        authorized: 2,
+        "integration-tested": 3,
+    };
+    const current = discovery.filter((item) => !item.stale);
+    return current.filter((item) => item.outcome !== "passed" &&
+        !current.some((other) => other.outcome === "passed" &&
+            other.provider === item.provider &&
+            other.route !== item.route &&
+            (!item.accountRef || other.accountRef === item.accountRef) &&
+            (item.source !== "independent" || other.source === "independent") &&
+            level[other.check] >= level[item.check] &&
+            level[other.check] >= 2));
+}

package/dist/progress.d.ts

@@ -0,0 +1,95 @@
+export declare const PROGRESS_FILE = "anhedral.progress.json";
+export declare const MILESTONES: readonly ["generated", "provisioned", "connected", "tested", "deployed"];
+export type Milestone = typeof MILESTONES[number];
+type Outcome = 'passed' | 'failed' | 'blocked';
+type Source = 'agent' | 'independent';
+interface Evidence {
+    outcome: Outcome;
+    source: Source;
+    observedAt: string;
+    evidence: string;
+    accountRef?: string;
+}
+export interface ProgressObservation extends Evidence {
+    capability: string;
+    milestone: Milestone;
+    configurationFingerprint: string;
+    resourceRef?: string;
+    revisionRef?: string;
+}
+export interface DiscoveryObservation extends Evidence {
+    provider: string;
+    route: 'plugin' | 'api' | 'cli' | 'browser';
+    check: 'installed' | 'callable' | 'local-working' | 'authorized' | 'integration-tested';
+    expiresAt: string;
+}
+export interface ProgressEnvironment {
+    id: string;
+    observations: ProgressObservation[];
+    discovery: DiscoveryObservation[];
+    blockers: string[];
+    nextAction?: string;
+    previewUrl?: string;
+    liveUrl?: string;
+}
+export interface ProjectProgress {
+    schemaVersion: 1;
+    revision: number;
+    updatedAt: string;
+    environments: ProgressEnvironment[];
+}
+export interface ProgressReport {
+    revision: number;
+    environment: string;
+    observations?: ProgressObservation[];
+    discovery?: DiscoveryObservation[];
+    blockers?: string[];
+    nextAction?: string | null;
+    previewUrl?: string | null;
+    liveUrl?: string | null;
+}
+export declare function validateProgressReport(value: unknown): ProgressReport;
+export declare function validateProjectProgress(value: unknown): ProjectProgress;
+export declare function readProjectProgress(root: string): ProjectProgress | null;
+/** Bounded source/configuration digest; secrets, dependencies and generated output are excluded. */
+export declare function projectFingerprint(root: string): string;
+/** Reports are caller assertions. Only actual checking adapters should use source: independent. */
+export declare function reportProjectProgress(root: string, input: ProgressReport): ProjectProgress;
+export declare function evaluateProjectProgress(record: ProjectProgress, fingerprint: string, now?: number): {
+    environments: {
+        observations: {
+            stale: boolean;
+            capability: string;
+            milestone: Milestone;
+            configurationFingerprint: string;
+            resourceRef?: string;
+            revisionRef?: string;
+            outcome: Outcome;
+            source: Source;
+            observedAt: string;
+            evidence: string;
+            accountRef?: string;
+        }[];
+        discovery: {
+            stale: boolean;
+            provider: string;
+            route: "plugin" | "api" | "cli" | "browser";
+            check: "installed" | "callable" | "local-working" | "authorized" | "integration-tested";
+            expiresAt: string;
+            outcome: Outcome;
+            source: Source;
+            observedAt: string;
+            evidence: string;
+            accountRef?: string;
+        }[];
+        id: string;
+        blockers: string[];
+        nextAction?: string;
+        previewUrl?: string;
+        liveUrl?: string;
+    }[];
+    schemaVersion: 1;
+    revision: number;
+    updatedAt: string;
+};
+export {};