@chat-de-hp/site 0.3.3 → 0.3.5

package/dist/check.js

@@ -1,5 +1,6 @@
 import { readdir, readFile } from "node:fs/promises";
 import { join, relative, sep } from "node:path";
+import { checkSiteConformanceSources, } from "./check-core.js";
 const SOURCE_DIRECTORY = "src";
 const SEED_PATHS = ["seed/seed.json", "seed.json"];
 const IGNORED_DIRECTORIES = new Set([
@@ -8,536 +9,19 @@ const IGNORED_DIRECTORIES = new Set([
     "dist",
     "node_modules",
 ]);
-/**
- * Reports conformance violations for one site root.
- *
- * The invariant behind the screenshot-editing fast path: a rendered CMS-backed
- * value is annotated, or the build fails. See
- * `plans/019-screenshot-site-editing.md` §7.
- */
 export async function checkSiteConformance(options) {
-    const seed = await loadSeed(options.root);
-    if (seed.fields.size === 0) {
-        return [];
-    }
-    const violations = [];
-    for (const file of await astroFiles(join(options.root, SOURCE_DIRECTORY))) {
-        violations.push(...checkAstroSource({
-            relativePath: toPosix(relative(options.root, file)),
-            seed,
-            source: await readFile(file, "utf-8"),
-        }));
-    }
-    return violations.sort((left, right) => left.file.localeCompare(right.file) ||
-        left.line - right.line ||
-        left.field.localeCompare(right.field));
-}
-function checkAstroSource(input) {
-    const { frontmatter, frontmatterLineOffset, template, templateLineOffset } = splitAstro(input.source);
-    const locals = collectLocals(frontmatter, input.seed);
-    const violations = [];
-    const renderedFields = new Set();
-    violations.push(...findFallbacks({
-        code: frontmatter,
-        lineOffset: frontmatterLineOffset,
-        opaque: locals.opaque,
-        relativePath: input.relativePath,
-        seed: input.seed,
-    }), ...findFallbacks({
-        code: template,
-        lineOffset: templateLineOffset,
-        opaque: locals.opaque,
-        relativePath: input.relativePath,
-        seed: input.seed,
-    }));
-    for (const render of findRenders({ locals, seed: input.seed, template })) {
-        renderedFields.add(`${render.collection}.${render.field}`);
-        if (render.annotated) {
-            continue;
-        }
-        violations.push({
-            field: render.field,
-            file: input.relativePath,
-            line: templateLineOffset + render.line,
-            message: `${render.collection}.${render.field} rendered without {...<entry>.edit.${render.field}}`,
-            rule: "annotations",
-        });
-    }
-    for (const rendered of renderedFields) {
-        if (input.seed.seeded.has(rendered)) {
-            continue;
-        }
-        const [, field = ""] = rendered.split(".");
-        violations.push({
-            field,
-            file: input.relativePath,
-            line: 1,
-            message: `${rendered} rendered but absent from seed`,
-            rule: "seed",
-        });
-    }
-    return violations;
-}
-/**
- * Splits an `.astro` file into its frontmatter and template halves, keeping the
- * template's 1-based line offset so reported lines match the real file.
- */
-function splitAstro(source) {
-    const match = /^(---\r?\n)([\s\S]*?)\r?\n---[^\n]*\r?\n?/u.exec(source);
-    if (!match) {
-        return {
-            frontmatter: "",
-            frontmatterLineOffset: 0,
-            template: source,
-            templateLineOffset: 0,
-        };
-    }
-    const consumed = match[0];
-    return {
-        frontmatter: match[2] ?? "",
-        // The opening `---` line sits above the frontmatter body.
-        frontmatterLineOffset: countLines(match[1] ?? ""),
-        template: source.slice(consumed.length),
-        templateLineOffset: countLines(consumed),
-    };
-}
-function countLines(text) {
-    let lines = 0;
-    for (const character of text) {
-        if (character === "\n") {
-            lines += 1;
-        }
-    }
-    return lines;
-}
-const LEADING_MEMBER_CHAIN = /^\s*[A-Za-z_$][\w$]*((?:\s*\??\.\s*[A-Za-z_$][\w$]*)+)/u;
-const MEMBER_CHAIN_ONLY = /^\s*[A-Za-z_$][\w$]*(?:\s*\??\.\s*[A-Za-z_$][\w$]*)*\s*$/u;
-/**
- * Classifies frontmatter locals. `const eyebrow = info.data.hero_eyebrow`
- * aliases the field it carries. `const seo = getSeoMeta(post, {...})` is
- * opaque: its properties are derived values, so `seo.title` colliding with a
- * field slug is not a CMS read. A local that only *selects by* a field
- * (`items.find((i) => i.is_featured)`) is neither — it carries an entry, not
- * that field's value.
- */
-function collectLocals(frontmatter, seed) {
-    const aliases = new Map();
-    const opaque = new Set();
-    const declaration = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*([^;\n]+)/gu;
-    let match = declaration.exec(frontmatter);
-    while (match !== null) {
-        const name = match[1] ?? "";
-        const initializer = match[2] ?? "";
-        if (!(aliases.has(name) || opaque.has(name))) {
-            const field = leadingChainField(initializer, seed);
-            if (field) {
-                aliases.set(name, field);
-            }
-            else if (!(
-            // `const data = info.data` re-roots an entry, not a derived value.
-            (MEMBER_CHAIN_ONLY.test(initializer) ||
-                // Awaited initializers are entry/settings fetches; their fields count.
-                /\bawait\b/u.test(initializer) ||
-                firstFieldRead(initializer, seed)))) {
-                opaque.add(name);
-            }
-        }
-        match = declaration.exec(frontmatter);
-    }
-    return { aliases, opaque };
-}
-/**
- * The CMS field read by `expression`'s leading member chain —
- * `info.data.hero_title.split("…")` reads `hero_title`, while
- * `items.find((i) => i.hero_title)` reads none: a field inside call arguments
- * selects, it does not flow into the local.
- */
-function leadingChainField(expression, seed) {
-    const chain = LEADING_MEMBER_CHAIN.exec(expression)?.[1] ?? "";
-    return firstFieldRead(chain, seed);
-}
-/**
- * The root identifier of the member chain containing the property at `index`,
- * or null when the chain hangs off something other than a plain identifier
- * (`getEntry(x).title`, `rows[0].name`).
- */
-function chainRootAt(code, index) {
-    let cursor = index - 1;
-    for (;;) {
-        while (cursor >= 0 && /\s/u.test(code[cursor] ?? "")) {
-            cursor -= 1;
-        }
-        if (code[cursor] !== ".") {
-            return null;
-        }
-        cursor -= 1;
-        if (code[cursor] === "?") {
-            cursor -= 1;
-        }
-        while (cursor >= 0 && /\s/u.test(code[cursor] ?? "")) {
-            cursor -= 1;
-        }
-        const end = cursor;
-        while (cursor >= 0 && /[\w$]/u.test(code[cursor] ?? "")) {
-            cursor -= 1;
-        }
-        if (cursor === end) {
-            return null;
-        }
-        const name = code.slice(cursor + 1, end + 1);
-        let before = cursor;
-        while (before >= 0 && /\s/u.test(code[before] ?? "")) {
-            before -= 1;
-        }
-        if (code[before] !== ".") {
-            return name;
-        }
-        cursor = before;
-    }
-}
-/** The first CMS field slug read by a property access in `expression`. */
-function firstFieldRead(expression, seed) {
-    for (const access of propertyAccesses(expression)) {
-        if (seed.fields.has(access.property)) {
-            return access.property;
-        }
-    }
-    return null;
-}
-/** Every `<expr>.<name>` / `<expr>?.<name>` property read in `code`. */
-function propertyAccesses(code) {
-    const accesses = [];
-    const pattern = /\??\.\s*([A-Za-z_$][\w$]*)/gu;
-    let match = pattern.exec(code);
-    while (match !== null) {
-        accesses.push({
-            index: match.index + match[0].length - (match[1]?.length ?? 0),
-            property: match[1] ?? "",
-        });
-        match = pattern.exec(code);
-    }
-    return accesses;
-}
-function findFallbacks(input) {
-    const violations = [];
-    // `<something>.<cms field> ?? <default>` — the default belongs in seed data.
-    const pattern = /\??\.\s*([A-Za-z_$][\w$]*)\s*\?\?/gu;
-    let match = pattern.exec(input.code);
-    while (match !== null) {
-        const field = match[1] ?? "";
-        const collections = input.seed.fields.get(field);
-        const root = chainRootAt(input.code, input.code.indexOf(field, match.index));
-        if (collections?.[0] && !(root && input.opaque.has(root))) {
-            violations.push({
-                field,
-                file: input.relativePath,
-                line: input.lineOffset + lineAt(input.code, match.index),
-                message: `${collections[0].collection}.${field} has a hardcoded ?? fallback; defaults belong in seed data`,
-                rule: "fallbacks",
-            });
-        }
-        match = pattern.exec(input.code);
-    }
-    return violations;
-}
-/**
- * Finds each CMS-backed value rendered by the template and whether an
- * annotation covers it — either on the element it renders in or on an ancestor
- * wrapper, which is how a transformed value stays one target.
- *
- * Guard reads (`{price && …}`) only test the value, so like plain HTML
- * attributes they are not renders; the render a guard protects is checked on
- * its own. A genuinely unannotated render is always reported, even when the
- * same field is annotated elsewhere in the file: each render site has to carry
- * its own annotation for the routing rule to be honest about that element.
- */
-function findRenders(input) {
-    const annotations = findAnnotations(input.template);
-    const renders = [];
-    const seen = new Set();
-    for (const expression of templateExpressions(input.template)) {
-        for (const read of fieldsRenderedBy(expression.code, input)) {
-            const collections = input.seed.fields.get(read.field);
-            const collection = collections?.[0]?.collection;
-            if (!collection || isGuardRead(expression.code, read.index)) {
-                continue;
-            }
-            // Offsets are absolute so an annotation on an ancestor covers the read.
-            const index = expression.index + read.index;
-            const line = lineAt(input.template, index);
-            const key = `${collection}.${read.field}:${line}`;
-            if (seen.has(key)) {
-                continue;
-            }
-            seen.add(key);
-            renders.push({
-                annotated: isAnnotated({ annotations, field: read.field, index }),
-                collection,
-                field: read.field,
-                line,
-            });
-        }
-    }
-    return renders;
-}
-/**
- * Whether the read at `index` only tests its value. True when what follows is a
- * boolean operator or a ternary condition rather than the end of the
- * expression, as in `{price && (…)}` or `{price ? … : …}`.
- *
- * Trailing property access is part of the read being tested, so
- * `{image?.id && (…)}` is a guard on `image` just as `{image && (…)}` is.
- */
-function isGuardRead(code, index) {
-    const rest = code
-        .slice(index)
-        .replace(/^[\w$]+/u, "")
-        .replace(/^(\??\.\s*[\w$]+)*\s*/u, "");
-    return /^(&&|\|\||\?[^.?])/u.test(rest);
-}
-/**
- * CMS fields a rendered expression resolves to, directly or via an alias, each
- * with the offset it is read at.
- */
-function fieldsRenderedBy(code, input) {
-    const reads = [];
-    for (const access of propertyAccesses(code)) {
-        if (!input.seed.fields.has(access.property)) {
-            continue;
-        }
-        const root = chainRootAt(code, access.index);
-        if (root && input.locals.opaque.has(root)) {
-            continue;
-        }
-        reads.push({ field: access.property, index: access.index });
-    }
-    for (const identifier of bareIdentifiers(code)) {
-        const aliased = input.locals.aliases.get(identifier.name);
-        if (aliased) {
-            reads.push({ field: aliased, index: identifier.index });
-        }
-    }
-    return reads;
-}
-/** Identifiers used on their own — not as `.property` and not as a call. */
-function bareIdentifiers(code) {
-    const identifiers = [];
-    const pattern = /(^|[^.\w$?])([A-Za-z_$][\w$]*)\s*(?![\w$(.])/gu;
-    let match = pattern.exec(code);
-    while (match !== null) {
-        identifiers.push({
-            index: match.index + (match[1]?.length ?? 0),
-            name: match[2] ?? "",
-        });
-        match = pattern.exec(code);
-    }
-    return identifiers;
-}
-/**
- * Locates `{...<entry>.edit.<field>}` spreads and the span of the element each
- * one annotates, so a wrapper annotation covers everything it contains.
- */
-function findAnnotations(template) {
-    const annotations = [];
-    const pattern = /\{\s*\.\.\.\s*[\w$?.]*\bedit\??\.\s*([A-Za-z_$][\w$]*)\s*\}/gu;
-    let match = pattern.exec(template);
-    while (match !== null) {
-        const start = template.lastIndexOf("<", match.index);
-        if (start !== -1) {
-            annotations.push({
-                end: elementEnd(template, start),
-                field: match[1] ?? "",
-                start,
-            });
-        }
-        match = pattern.exec(template);
-    }
-    return annotations;
-}
-/**
- * End offset of the element opening at `start`: the matching close tag when the
- * element has one, otherwise the end of its self-closing/void tag.
- */
-function elementEnd(template, start) {
-    const tagMatch = /^<\s*([A-Za-z][\w:.-]*)/u.exec(template.slice(start));
-    const tag = tagMatch?.[1];
-    const openTagEnd = template.indexOf(">", start);
-    if (!tag || openTagEnd === -1) {
-        return template.length;
-    }
-    if (template[openTagEnd - 1] === "/") {
-        return openTagEnd + 1;
-    }
-    const boundary = new RegExp(`<\\s*(/)?${escapeRegExp(tag)}(?=[\\s/>])`, "gu");
-    boundary.lastIndex = openTagEnd + 1;
-    let depth = 1;
-    let match = boundary.exec(template);
-    while (match !== null) {
-        depth += match[1] ? -1 : 1;
-        if (depth === 0) {
-            return match.index + match[0].length;
-        }
-        match = boundary.exec(template);
-    }
-    return template.length;
-}
-function escapeRegExp(value) {
-    return value.replaceAll(/[.*+?^${}()|[\]\\-]/gu, String.raw `\$&`);
-}
-function isAnnotated(input) {
-    return input.annotations.some((annotation) => annotation.field === input.field &&
-        input.index >= annotation.start &&
-        input.index < annotation.end);
+    return checkSiteConformanceSources({
+        files: astroSources(options.root),
+        seed: await readSeedSource(options.root),
+    });
 }
-/**
- * `{...}` expressions in template position, including those nested inside
- * markup an outer expression returns, and those passed as props to a component.
- * Annotation spreads are skipped: only what the page actually renders counts.
- *
- * Nested expressions are visited separately rather than as part of their
- * parent's text, so an identifier is only read where it is genuinely
- * evaluated — an `aria-label` attribute is markup, not a render of `label`.
- *
- * A component prop (`<Image image={data.hero_image} />`) renders its value, so
- * it counts. A plain HTML attribute (`href={mapUrl}`) does not: it carries
- * metadata rather than visible content the customer would screenshot.
- */
-function templateExpressions(template, offset = 0) {
-    const expressions = [];
-    let index = 0;
-    let componentTagDepth = 0;
-    let insideTag = false;
-    while (index < template.length) {
-        const character = template[index];
-        if (character === "<" && /[A-Za-z/]/u.test(template[index + 1] ?? "")) {
-            insideTag = true;
-            // Components are capitalized; lowercase names are HTML elements.
-            componentTagDepth = /^<\s*[A-Z]/u.test(template.slice(index, index + 3))
-                ? 1
-                : 0;
-            index += 1;
-            continue;
-        }
-        if (character === ">" && insideTag) {
-            insideTag = false;
-            componentTagDepth = 0;
-            index += 1;
-            continue;
-        }
-        if (character !== "{") {
-            index += 1;
-            continue;
-        }
-        if (insideTag) {
-            if (componentTagDepth > 0) {
-                const attributeEnd = matchingBrace(template, index);
-                const attributeBody = template.slice(index + 1, attributeEnd);
-                if (!isSpread(attributeBody)) {
-                    expressions.push({
-                        code: attributeBody,
-                        index: offset + index + 1,
-                    });
-                }
-                index = attributeEnd + 1;
-                continue;
-            }
-            index += 1;
-            continue;
-        }
-        const end = matchingBrace(template, index);
-        const body = template.slice(index + 1, end);
-        if (!isSpread(body)) {
-            const bodyStart = offset + index + 1;
-            const markupAt = body.search(/<\s*[A-Za-z]/u);
-            if (markupAt === -1) {
-                expressions.push({ code: body, index: bodyStart });
-            }
-            else {
-                // Everything before the markup is this expression's own code; the
-                // markup is a nested template scanned on its own terms.
-                expressions.push({
-                    code: body.slice(0, markupAt),
-                    index: bodyStart,
-                });
-                expressions.push(...templateExpressions(body.slice(markupAt), bodyStart + markupAt));
-            }
-        }
-        index = end + 1;
-    }
-    return expressions;
-}
-function isSpread(code) {
-    return code.trimStart().startsWith("...");
-}
-function matchingBrace(template, start) {
-    let depth = 0;
-    for (let index = start; index < template.length; index += 1) {
-        const character = template[index];
-        if (character === "{") {
-            depth += 1;
-        }
-        else if (character === "}") {
-            depth -= 1;
-            if (depth === 0) {
-                return index;
-            }
-        }
-    }
-    return template.length;
-}
-function lineAt(code, index) {
-    return countLines(code.slice(0, index)) + 1;
-}
-async function loadSeed(root) {
-    const raw = await readSeedFile(root);
-    const parsed = JSON.parse(raw);
-    const fields = new Map();
-    const seeded = new Set();
-    if (!isRecord(parsed)) {
-        return { fields, seeded };
-    }
-    const collections = Array.isArray(parsed.collections)
-        ? parsed.collections
-        : [];
-    for (const collection of collections) {
-        if (!(isRecord(collection) && typeof collection.slug === "string")) {
-            continue;
-        }
-        const collectionSlug = collection.slug;
-        const collectionFields = Array.isArray(collection.fields)
-            ? collection.fields
-            : [];
-        for (const field of collectionFields) {
-            if (!(isRecord(field) && typeof field.slug === "string")) {
-                continue;
-            }
-            const entries = fields.get(field.slug) ?? [];
-            entries.push({ collection: collectionSlug, slug: field.slug });
-            fields.set(field.slug, entries);
-        }
-    }
-    const content = isRecord(parsed.content) ? parsed.content : {};
-    for (const [collectionSlug, entries] of Object.entries(content)) {
-        if (!Array.isArray(entries)) {
-            continue;
-        }
-        for (const entry of entries) {
-            if (!(isRecord(entry) && isRecord(entry.data))) {
-                continue;
-            }
-            for (const [slug, value] of Object.entries(entry.data)) {
-                if (value !== null && value !== undefined && value !== "") {
-                    seeded.add(`${collectionSlug}.${slug}`);
-                }
-            }
-        }
-    }
-    return { fields, seeded };
-}
-async function readSeedFile(root) {
+async function readSeedSource(root) {
     for (const candidate of SEED_PATHS) {
         try {
-            return await readFile(join(root, candidate), "utf-8");
+            return {
+                file: candidate,
+                source: await readFile(join(root, candidate), "utf-8"),
+            };
         }
         catch {
             // Try the next supported seed location.
@@ -545,6 +29,14 @@ async function readSeedFile(root) {
     }
     throw new Error(`Could not find seed data in ${root}. Expected ${SEED_PATHS.join(" or ")}.`);
 }
+async function* astroSources(root) {
+    for (const file of await astroFiles(join(root, SOURCE_DIRECTORY))) {
+        yield {
+            file: toPosix(relative(root, file)),
+            source: await readFile(file, "utf-8"),
+        };
+    }
+}
 async function astroFiles(directory) {
     let entries;
     try {
@@ -568,9 +60,6 @@ async function astroFiles(directory) {
     }
     return files;
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function toPosix(path) {
     return sep === "/" ? path : path.split(sep).join("/");
 }

package/dist/control-plane.d.ts

@@ -1,10 +1,10 @@
-import { z } from "zod";
+import { type infer as InferSchema } from "zod/mini";
 export declare const SITE_RUNTIME_NAME: "@chat-de-hp/site";
 export declare const SITE_RUNTIME_VERSION: string;
 export declare const SITE_RUNTIME_PROTOCOL_VERSION: 1;
-export declare const siteRuntimeBindingSchema: z.ZodObject<{
-    name: z.ZodString;
-    type: z.ZodEnum<{
+export declare const siteRuntimeBindingSchema: import("zod/mini").ZodMiniObject<{
+    name: import("zod/mini").ZodMiniString<string>;
+    type: import("zod/mini").ZodMiniEnum<{
         d1: "d1";
         images: "images";
         kv_namespace: "kv_namespace";
@@ -12,20 +12,20 @@ export declare const siteRuntimeBindingSchema: z.ZodObject<{
         send_email: "send_email";
         worker_loader: "worker_loader";
     }>;
-}, z.core.$loose>;
-export declare const siteRuntimeManifestSchema: z.ZodObject<{
-    capabilities: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        provider: z.ZodString;
-        schemaVersion: z.ZodNumber;
-    }, z.core.$loose>>;
-    primitives: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        schemaVersion: z.ZodNumber;
-    }, z.core.$loose>>;
-    requiredBindings: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        type: z.ZodEnum<{
+}, import("zod/v4/core").$loose>;
+export declare const siteRuntimeManifestSchema: import("zod/mini").ZodMiniObject<{
+    capabilities: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniObject<{
+        id: import("zod/mini").ZodMiniString<string>;
+        provider: import("zod/mini").ZodMiniString<string>;
+        schemaVersion: import("zod/mini").ZodMiniNumber<number>;
+    }, import("zod/v4/core").$loose>>;
+    primitives: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniObject<{
+        id: import("zod/mini").ZodMiniString<string>;
+        schemaVersion: import("zod/mini").ZodMiniNumber<number>;
+    }, import("zod/v4/core").$loose>>;
+    requiredBindings: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniObject<{
+        name: import("zod/mini").ZodMiniString<string>;
+        type: import("zod/mini").ZodMiniEnum<{
             d1: "d1";
             images: "images";
             kv_namespace: "kv_namespace";
@@ -33,15 +33,15 @@ export declare const siteRuntimeManifestSchema: z.ZodObject<{
             send_email: "send_email";
             worker_loader: "worker_loader";
         }>;
-    }, z.core.$loose>>;
-    runtime: z.ZodObject<{
-        name: z.ZodLiteral<"@chat-de-hp/site">;
-        protocolVersion: z.ZodLiteral<1>;
-        version: z.ZodString;
-    }, z.core.$loose>;
-    schemaVersion: z.ZodLiteral<1>;
-}, z.core.$loose>;
-export type SiteRuntimeBinding = z.infer<typeof siteRuntimeBindingSchema>;
-export type SiteRuntimeManifest = z.infer<typeof siteRuntimeManifestSchema>;
+    }, import("zod/v4/core").$loose>>;
+    runtime: import("zod/mini").ZodMiniObject<{
+        name: import("zod/mini").ZodMiniLiteral<"@chat-de-hp/site">;
+        protocolVersion: import("zod/mini").ZodMiniLiteral<1>;
+        version: import("zod/mini").ZodMiniString<string>;
+    }, import("zod/v4/core").$loose>;
+    schemaVersion: import("zod/mini").ZodMiniLiteral<1>;
+}, import("zod/v4/core").$loose>;
+export type SiteRuntimeBinding = InferSchema<typeof siteRuntimeBindingSchema>;
+export type SiteRuntimeManifest = InferSchema<typeof siteRuntimeManifestSchema>;
 export declare function parseSiteRuntimeManifest(value: unknown): SiteRuntimeManifest;
 //# sourceMappingURL=control-plane.d.ts.map

package/dist/control-plane.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"control-plane.d.ts","sourceRoot":"","sources":["../src/control-plane.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,iBAAiB,EAAG,kBAA2B,CAAC;AAC7D,eAAO,MAAM,oBAAoB,QAAsB,CAAC;AACxD,eAAO,MAAM,6BAA6B,EAAG,CAAU,CAAC;AAExD,eAAO,MAAM,wBAAwB;;;;;;;;;;iBAYrB,CAAC;AAEjB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BtB,CAAC;AAEjB,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,mBAAmB,CAE5E"}
+{"version":3,"file":"control-plane.d.ts","sourceRoot":"","sources":["../src/control-plane.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,KAAK,IAAI,WAAW,EAQ1B,MAAM,UAAU,CAAC;AAIlB,eAAO,MAAM,iBAAiB,EAAG,kBAA2B,CAAC;AAC7D,eAAO,MAAM,oBAAoB,QAAsB,CAAC;AACxD,eAAO,MAAM,6BAA6B,EAAG,CAAU,CAAC;AAExD,eAAO,MAAM,wBAAwB;;;;;;;;;;gCAUnC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAqBpC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC9E,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAEhF,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,mBAAmB,CAQ5E"}