@webpresso/agent-kit 0.21.0

package/dist/esm/config/launch/dev-manifest.js

@@ -0,0 +1,196 @@
+export function parseDevManifest(raw) {
+    const input = assertRecord(raw, 'dev manifest');
+    if (input.version !== 1) {
+        throw new Error('dev manifest version must be 1');
+    }
+    const rawServices = assertRecord(input.services, 'services');
+    const serviceIds = Object.keys(rawServices);
+    if (serviceIds.length === 0) {
+        throw new Error('dev manifest must define at least one service');
+    }
+    const services = {};
+    for (const id of serviceIds) {
+        assertIdentifier(id, `services.${id}`);
+        const service = assertRecord(rawServices[id], `services.${id}`);
+        const command = assertString(service.command, `services.${id}.command`);
+        const args = assertStringArray(service.args ?? [], `services.${id}.args`);
+        const dependsOn = assertStringArray(service.dependsOn ?? [], `services.${id}.dependsOn`);
+        const env = service.env === undefined ? undefined : assertStringRecord(service.env, `services.${id}.env`);
+        const cwd = service.cwd === undefined ? undefined : assertString(service.cwd, `services.${id}.cwd`);
+        services[id] = {
+            id,
+            command,
+            args,
+            dependsOn,
+            ...(cwd ? { cwd } : {}),
+            ...(env ? { env } : {}),
+            ...(service.readiness
+                ? { readiness: normalizeReadiness(service.readiness, `services.${id}.readiness`) }
+                : {}),
+            ...(service.restart
+                ? { restart: normalizeRestart(service.restart, `services.${id}.restart`) }
+                : {}),
+        };
+    }
+    for (const [id, service] of Object.entries(services)) {
+        for (const dependency of service.dependsOn) {
+            if (!services[dependency]) {
+                throw new Error(`services.${id}.dependsOn references unknown service "${dependency}"`);
+            }
+        }
+    }
+    const groups = {};
+    const rawGroups = input.groups ?? {};
+    for (const [groupId, rawGroup] of Object.entries(rawGroups)) {
+        assertIdentifier(groupId, `groups.${groupId}`);
+        const group = assertRecord(rawGroup, `groups.${groupId}`);
+        const groupServices = assertStringArray(group.services, `groups.${groupId}.services`);
+        if (groupServices.length === 0) {
+            throw new Error(`groups.${groupId}.services must include at least one service`);
+        }
+        for (const serviceId of groupServices) {
+            if (!services[serviceId]) {
+                throw new Error(`groups.${groupId}.services references unknown service "${serviceId}"`);
+            }
+        }
+        const description = group.description === undefined
+            ? undefined
+            : assertString(group.description, `groups.${groupId}.description`);
+        groups[groupId] = {
+            services: groupServices,
+            ...(description ? { description } : {}),
+        };
+    }
+    const rawDefaults = input.defaults ?? {};
+    const defaults = assertRecord(rawDefaults, 'defaults');
+    const target = defaults.target === undefined ? undefined : assertString(defaults.target, 'defaults.target');
+    if (target && !services[target] && !groups[target]) {
+        throw new Error(`defaults.target references unknown target "${target}"`);
+    }
+    return {
+        version: 1,
+        ...(input.name ? { name: assertString(input.name, 'name') } : {}),
+        services,
+        groups,
+        defaults: target ? { target } : {},
+    };
+}
+export function resolveDevTargets(manifest, target = manifest.defaults.target) {
+    if (!target) {
+        throw new Error('No dev target supplied and defaults.target is not configured');
+    }
+    const roots = manifest.groups[target]?.services ?? (manifest.services[target] ? [target] : undefined);
+    if (!roots) {
+        throw new Error(`Unknown dev target "${target}". Known services: ${Object.keys(manifest.services).join(', ')}. Known groups: ${Object.keys(manifest.groups).join(', ')}.`);
+    }
+    const resolved = [];
+    const visited = new Set();
+    const visiting = new Set();
+    function visit(serviceId, stack) {
+        if (visited.has(serviceId))
+            return;
+        if (visiting.has(serviceId)) {
+            const cycleStart = stack.indexOf(serviceId);
+            const cycle = [...stack.slice(cycleStart), serviceId];
+            throw new Error(`Cyclic dev service dependency detected: ${cycle.join(' -> ')}`);
+        }
+        const service = manifest.services[serviceId];
+        if (!service) {
+            throw new Error(`Unknown dev service "${serviceId}"`);
+        }
+        visiting.add(serviceId);
+        for (const dependency of service.dependsOn) {
+            visit(dependency, [...stack, serviceId]);
+        }
+        visiting.delete(serviceId);
+        visited.add(serviceId);
+        resolved.push(serviceId);
+    }
+    for (const root of roots) {
+        visit(root, []);
+    }
+    return resolved;
+}
+function assertRecord(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${label} must be an object`);
+    }
+    return value;
+}
+function assertString(value, label) {
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw new Error(`${label} must be a non-empty string`);
+    }
+    return value;
+}
+function assertStringArray(value, label) {
+    if (!Array.isArray(value)) {
+        throw new TypeError(`${label} must be an array of strings`);
+    }
+    return value.map((entry, index) => assertString(entry, `${label}[${index}]`));
+}
+function assertStringRecord(value, label) {
+    const record = assertRecord(value, label);
+    const out = {};
+    for (const [key, entry] of Object.entries(record)) {
+        out[key] = assertString(entry, `${label}.${key}`);
+    }
+    return out;
+}
+function assertIdentifier(value, label) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(value)) {
+        throw new Error(`${label} must be a portable identifier`);
+    }
+}
+function normalizeReadiness(value, label) {
+    const readiness = assertRecord(value, label);
+    if (readiness.type === 'http') {
+        return {
+            type: 'http',
+            ...(readiness.path ? { path: assertString(readiness.path, `${label}.path`) } : {}),
+            ...(readiness.url ? { url: assertString(readiness.url, `${label}.url`) } : {}),
+            ...optionalPositiveInt(readiness.timeoutMs, `${label}.timeoutMs`, 'timeoutMs'),
+            ...optionalPositiveInt(readiness.intervalMs, `${label}.intervalMs`, 'intervalMs'),
+        };
+    }
+    if (readiness.type === 'log') {
+        return {
+            type: 'log',
+            pattern: assertString(readiness.pattern, `${label}.pattern`),
+            ...optionalPositiveInt(readiness.timeoutMs, `${label}.timeoutMs`, 'timeoutMs'),
+        };
+    }
+    if (readiness.type === 'manual') {
+        return {
+            type: 'manual',
+            ...(readiness.description
+                ? { description: assertString(readiness.description, `${label}.description`) }
+                : {}),
+        };
+    }
+    throw new Error(`${label}.type must be http, log, or manual`);
+}
+function normalizeRestart(value, label) {
+    const restart = assertRecord(value, label);
+    return {
+        ...(restart.onFailure === undefined
+            ? {}
+            : { onFailure: assertBoolean(restart.onFailure, `${label}.onFailure`) }),
+        ...optionalPositiveInt(restart.maxRestarts, `${label}.maxRestarts`, 'maxRestarts'),
+    };
+}
+function assertBoolean(value, label) {
+    if (typeof value !== 'boolean') {
+        throw new TypeError(`${label} must be a boolean`);
+    }
+    return value;
+}
+function optionalPositiveInt(value, label, key) {
+    if (value === undefined)
+        return {};
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error(`${label} must be a positive integer`);
+    }
+    return { [key]: value };
+}
+//# sourceMappingURL=dev-manifest.js.map

package/dist/esm/config/launch/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Contract-safe `webpresso/launch` public surface.
+ *
+ * This package defines generic, host-agnostic launch primitives. Host
+ * adapters (e.g. the Neon-backed provisioner in `@webpresso/cli-utils`)
+ * consume these contracts; launch-engine itself has no dependency on any
+ * host-specific package and uses no Webpresso app-slug literals.
+ */
+export type { DatabaseUrlSelector, LaunchProfile, LaunchRegistration, ProvisionedDatabaseHandle, } from './contracts.js';
+export { type AssembleEffectiveVarsInput, assembleEffectiveVars } from './launch-profile.js';
+export { type BuildLaunchRegistrationInput, type LaunchRegistrationSpawnContext, type LaunchRegistrationSpawnPlan, buildLaunchRegistration, } from './provision-stack.js';
+export type { DevRestartPolicy, DevServiceRuntimeState, DevServiceRuntimeStatus, DevServiceStartPlan, DevSupervisorAdapter, ServiceReadiness, } from './dev-contracts.js';
+export { type DevManifestGroupInput, type DevManifestInput, type DevManifestServiceInput, type NormalizedDevGroup, type NormalizedDevManifest, type NormalizedDevService, parseDevManifest, resolveDevTargets, } from './dev-manifest.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/config/launch/index.js

@@ -0,0 +1,12 @@
+/**
+ * Contract-safe `webpresso/launch` public surface.
+ *
+ * This package defines generic, host-agnostic launch primitives. Host
+ * adapters (e.g. the Neon-backed provisioner in `@webpresso/cli-utils`)
+ * consume these contracts; launch-engine itself has no dependency on any
+ * host-specific package and uses no Webpresso app-slug literals.
+ */
+export { assembleEffectiveVars } from './launch-profile.js';
+export { buildLaunchRegistration, } from './provision-stack.js';
+export { parseDevManifest, resolveDevTargets, } from './dev-manifest.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/config/launch/launch-profile.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Generic var-assembly for a launch profile.
+ *
+ * Given an optional pre-assembly hook, an optional secret injector, and an
+ * optional provisioned database handle plus URL selector, produce the
+ * effective environment-variable bundle a spawn will use. No wrangler,
+ * vite, or host-specific logic lives here.
+ *
+ * @module webpresso/launch/launch-profile
+ */
+import type { DatabaseUrlSelector, ProvisionedDatabaseHandle } from './contracts.js';
+export interface AssembleEffectiveVarsInput {
+    /** Starting var bundle. Not mutated; copied internally. */
+    vars: Record<string, string>;
+    /** Optional database handle whose URLs are exported to the launch env. */
+    databaseHandle?: ProvisionedDatabaseHandle;
+    /**
+     * Optional selector that maps a handle to runtime/metadata URLs.
+     * Defaults to `{ runtimeDatabaseUrl: handle.primaryConnectionUri }`.
+     */
+    databaseUrlSelector?: DatabaseUrlSelector;
+    /**
+     * Optional pre-assembly hook invoked with the var-copy before any
+     * secrets or DB URLs are injected. Use to install defaults like a
+     * repo-root env var. Must only mutate the target in place.
+     */
+    preAssemble?: (vars: Record<string, string>) => void;
+    /**
+     * Optional secret injector invoked with the var-copy after the
+     * pre-assembly hook but before DB URLs are written. Must only mutate
+     * the target in place; throws propagate unmodified.
+     */
+    secretInjector?: (vars: Record<string, string>) => void;
+}
+/**
+ * Assemble the effective launch environment-variable bundle.
+ *
+ * Order of operations (observable from tests):
+ *   1. copy caller-provided vars (never mutate caller input)
+ *   2. run optional {@link AssembleEffectiveVarsInput.preAssemble} hook
+ *   3. run optional {@link AssembleEffectiveVarsInput.secretInjector}
+ *   4. if a database handle is supplied, run the URL selector and assign
+ *      `DATABASE_URL` (and `HASURA_GRAPHQL_METADATA_DATABASE_URL` when
+ *      returned)
+ */
+export declare function assembleEffectiveVars(input: AssembleEffectiveVarsInput): Record<string, string>;
+//# sourceMappingURL=launch-profile.d.ts.map

package/dist/esm/config/launch/launch-profile.js

@@ -0,0 +1,39 @@
+/**
+ * Generic var-assembly for a launch profile.
+ *
+ * Given an optional pre-assembly hook, an optional secret injector, and an
+ * optional provisioned database handle plus URL selector, produce the
+ * effective environment-variable bundle a spawn will use. No wrangler,
+ * vite, or host-specific logic lives here.
+ *
+ * @module webpresso/launch/launch-profile
+ */
+const defaultDatabaseUrlSelector = (handle) => ({
+    runtimeDatabaseUrl: handle.primaryConnectionUri,
+});
+/**
+ * Assemble the effective launch environment-variable bundle.
+ *
+ * Order of operations (observable from tests):
+ *   1. copy caller-provided vars (never mutate caller input)
+ *   2. run optional {@link AssembleEffectiveVarsInput.preAssemble} hook
+ *   3. run optional {@link AssembleEffectiveVarsInput.secretInjector}
+ *   4. if a database handle is supplied, run the URL selector and assign
+ *      `DATABASE_URL` (and `HASURA_GRAPHQL_METADATA_DATABASE_URL` when
+ *      returned)
+ */
+export function assembleEffectiveVars(input) {
+    const effectiveVars = { ...input.vars };
+    input.preAssemble?.(effectiveVars);
+    input.secretInjector?.(effectiveVars);
+    if (input.databaseHandle) {
+        const selector = input.databaseUrlSelector ?? defaultDatabaseUrlSelector;
+        const selected = selector(input.databaseHandle);
+        effectiveVars.DATABASE_URL = selected.runtimeDatabaseUrl;
+        if (selected.metadataDatabaseUrl) {
+            effectiveVars.HASURA_GRAPHQL_METADATA_DATABASE_URL = selected.metadataDatabaseUrl;
+        }
+    }
+    return effectiveVars;
+}
+//# sourceMappingURL=launch-profile.js.map

package/dist/esm/config/launch/provision-stack.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Generic launch-registration orchestration.
+ *
+ * Host adapters provide:
+ *   - an async port allocator
+ *   - a secret injector
+ *   - a spawn-plan builder that turns a resolved launch context into a
+ *     concrete (command, args, env) triple
+ *
+ * launch-engine orchestrates them into a {@link LaunchRegistration}
+ * without depending on any host-specific package.
+ *
+ * @module webpresso/launch/provision-stack
+ */
+import type { LaunchProfile, LaunchRegistration, ProvisionedDatabaseHandle } from './contracts.js';
+export interface LaunchRegistrationSpawnContext {
+    /** Resolved launch cwd (mirrors `profile.cwd`). */
+    cwd: string;
+    /** The effective vars after injection and DB-url assembly. */
+    effectiveVars: Record<string, string>;
+    /** Allocated ports for this launch. */
+    ports: {
+        api: number;
+        inspector: number;
+    };
+    /** The provisioned database handle threaded through from the profile. */
+    databaseHandle?: ProvisionedDatabaseHandle;
+}
+export interface LaunchRegistrationSpawnPlan {
+    command: string;
+    args: readonly string[];
+    env: NodeJS.ProcessEnv;
+}
+export interface BuildLaunchRegistrationInput {
+    profile: LaunchProfile;
+    /**
+     * Async port allocator. Called exactly once per registration.
+     */
+    allocatePorts: () => Promise<{
+        apiPort: number;
+        inspectorPort: number;
+    }>;
+    /**
+     * Secret injector forwarded to {@link assembleEffectiveVars}. Mutate the
+     * supplied var bundle in place.
+     */
+    secretInjector: (vars: Record<string, string>) => void;
+    /**
+     * Optional pre-assembly hook (e.g. inject a repo-root env var) forwarded
+     * to {@link assembleEffectiveVars}.
+     */
+    preAssemble?: (vars: Record<string, string>) => void;
+    /**
+     * Turn a resolved launch context into a concrete spawn plan. Callers
+     * own host-specific logic here (wrangler/vite args, docker wrappers,
+     * etc.).
+     */
+    buildSpawnPlan: (context: LaunchRegistrationSpawnContext) => LaunchRegistrationSpawnPlan;
+}
+/**
+ * Build a generic launch registration over a host-agnostic profile.
+ */
+export declare function buildLaunchRegistration(input: BuildLaunchRegistrationInput): Promise<LaunchRegistration>;
+//# sourceMappingURL=provision-stack.d.ts.map

package/dist/esm/config/launch/provision-stack.js

@@ -0,0 +1,45 @@
+/**
+ * Generic launch-registration orchestration.
+ *
+ * Host adapters provide:
+ *   - an async port allocator
+ *   - a secret injector
+ *   - a spawn-plan builder that turns a resolved launch context into a
+ *     concrete (command, args, env) triple
+ *
+ * launch-engine orchestrates them into a {@link LaunchRegistration}
+ * without depending on any host-specific package.
+ *
+ * @module webpresso/launch/provision-stack
+ */
+import { assembleEffectiveVars } from './launch-profile.js';
+/**
+ * Build a generic launch registration over a host-agnostic profile.
+ */
+export async function buildLaunchRegistration(input) {
+    const { profile } = input;
+    const effectiveVars = assembleEffectiveVars({
+        vars: profile.vars,
+        databaseHandle: profile.databaseHandle,
+        databaseUrlSelector: profile.databaseUrlSelector,
+        preAssemble: input.preAssemble,
+        secretInjector: input.secretInjector,
+    });
+    const { apiPort, inspectorPort } = await input.allocatePorts();
+    const spawnPlan = input.buildSpawnPlan({
+        cwd: profile.cwd,
+        effectiveVars,
+        ports: { api: apiPort, inspector: inspectorPort },
+        databaseHandle: profile.databaseHandle,
+    });
+    return {
+        command: spawnPlan.command,
+        args: spawnPlan.args,
+        cwd: profile.cwd,
+        env: spawnPlan.env,
+        ports: { api: apiPort, inspector: inspectorPort },
+        logFile: profile.logFile,
+        databaseHandle: profile.databaseHandle,
+    };
+}
+//# sourceMappingURL=provision-stack.js.map

package/dist/esm/config/oxlint/code-safety.d.ts

@@ -0,0 +1,19 @@
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        'as-any-audit': {
+            create(context: any): {
+                TSAsExpression(node: any): void;
+            };
+        };
+        'no-swallowed-errors': {
+            create(context: any): {
+                CatchClause(node: any): void;
+            };
+        };
+    };
+};
+export default plugin;
+//# sourceMappingURL=code-safety.d.ts.map

package/dist/esm/config/oxlint/code-safety.js

@@ -0,0 +1,90 @@
+// @ts-nocheck
+// Webpresso code safety rules — replaces GritQL patterns:
+// - as_any_audit (audit unsafe `as any` casts)
+// - no_swallowed_errors (catch blocks that only console.error)
+const asAnyAudit = {
+    create(context) {
+        return {
+            TSAsExpression(node) {
+                const annotation = node.typeAnnotation;
+                if (annotation.type === 'TSAnyKeyword' ||
+                    (annotation.type === 'TSTypeReference' &&
+                        annotation.typeName?.type === 'Identifier' &&
+                        annotation.typeName.name === 'any')) {
+                    context.report({
+                        node: annotation,
+                        message: 'Unsafe `as any` cast. Use a specific type, `as unknown`, or a type guard instead.',
+                    });
+                }
+            },
+        };
+    },
+};
+const ALLOWED_ACTIONS = new Set(['throw', 'setError', 'toast', 'reportError', 'return']);
+function hasAllowedAction(body) {
+    if (!body || body.type !== 'BlockStatement')
+        return false;
+    for (const stmt of body.body) {
+        if (stmt.type === 'ThrowStatement')
+            return true;
+        if (stmt.type === 'ReturnStatement')
+            return true;
+        if (stmt.type === 'ExpressionStatement' && stmt.expression.type === 'CallExpression') {
+            const callee = stmt.expression.callee;
+            // setError(...), reportError(...)
+            if (callee.type === 'Identifier' && ALLOWED_ACTIONS.has(callee.name))
+                return true;
+            // toast.error(...)
+            if (callee.type === 'MemberExpression' &&
+                callee.object.type === 'Identifier' &&
+                ALLOWED_ACTIONS.has(callee.object.name)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function hasConsoleError(body) {
+    if (!body || body.type !== 'BlockStatement')
+        return false;
+    for (const stmt of body.body) {
+        if (stmt.type === 'ExpressionStatement' &&
+            stmt.expression.type === 'CallExpression' &&
+            stmt.expression.callee.type === 'MemberExpression' &&
+            stmt.expression.callee.object.type === 'Identifier' &&
+            stmt.expression.callee.object.name === 'console' &&
+            stmt.expression.callee.property.type === 'Identifier' &&
+            stmt.expression.callee.property.name === 'error') {
+            return true;
+        }
+    }
+    return false;
+}
+const noSwallowedErrors = {
+    create(context) {
+        return {
+            CatchClause(node) {
+                const body = node.body;
+                if (!body || body.type !== 'BlockStatement')
+                    return;
+                if (body.body.length === 0)
+                    return;
+                if (hasConsoleError(body) && !hasAllowedAction(body)) {
+                    context.report({
+                        node,
+                        message: 'Catch block only logs with console.error — error is swallowed. Re-throw, return an error value, or use toast.error()/setError()/reportError().',
+                    });
+                }
+            },
+        };
+    },
+};
+const plugin = {
+    meta: { name: 'webpresso-safety' },
+    rules: {
+        'as-any-audit': asAnyAudit,
+        'no-swallowed-errors': noSwallowedErrors,
+    },
+};
+export default plugin;
+//# sourceMappingURL=code-safety.js.map

package/dist/esm/config/oxlint/foundation-purity.d.ts

@@ -0,0 +1,22 @@
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        'no-framework-imports': {
+            create(context: any): {
+                ImportDeclaration?: undefined;
+                ExportNamedDeclaration?: undefined;
+                ExportAllDeclaration?: undefined;
+                ImportExpression?: undefined;
+            } | {
+                ImportDeclaration(node: any): void;
+                ExportNamedDeclaration(node: any): void;
+                ExportAllDeclaration(node: any): void;
+                ImportExpression(node: any): void;
+            };
+        };
+    };
+};
+export default plugin;
+//# sourceMappingURL=foundation-purity.d.ts.map

package/dist/esm/config/oxlint/foundation-purity.js

@@ -0,0 +1,53 @@
+// @ts-nocheck
+// Foundation purity — prevents framework coupling in the foundation tier.
+// Flags imports from hono, express, fastify, koa in packages/foundation/ files.
+const FORBIDDEN_FRAMEWORKS = new Set(['hono', 'express', 'fastify', 'koa']);
+function isForbiddenImport(source) {
+    return typeof source === 'string' && FORBIDDEN_FRAMEWORKS.has(source.split('/')[0]);
+}
+function isFoundationFile(context) {
+    const filename = typeof context.getFilename === 'function' ? context.getFilename() : context.filename;
+    return filename.replaceAll('\\', '/').includes('/packages/foundation/');
+}
+const noFrameworkImports = {
+    create(context) {
+        if (!isFoundationFile(context))
+            return {};
+        function checkImport(source, node) {
+            if (isForbiddenImport(source)) {
+                context.report({
+                    node,
+                    message: `Foundation packages must not depend on HTTP frameworks. Remove import from "${source}" — framework adapters belong in apps or feature packages.`,
+                });
+            }
+        }
+        return {
+            ImportDeclaration(node) {
+                checkImport(node.source.value, node.source);
+            },
+            ExportNamedDeclaration(node) {
+                if (!node.source)
+                    return;
+                checkImport(node.source.value, node.source);
+            },
+            ExportAllDeclaration(node) {
+                if (!node.source)
+                    return;
+                checkImport(node.source.value, node.source);
+            },
+            ImportExpression(node) {
+                if (node.source.type !== 'Literal')
+                    return;
+                checkImport(node.source.value, node.source);
+            },
+        };
+    },
+};
+const plugin = {
+    meta: { name: 'webpresso-foundation-purity' },
+    rules: {
+        'no-framework-imports': noFrameworkImports,
+    },
+};
+export default plugin;
+//# sourceMappingURL=foundation-purity.js.map

package/dist/esm/config/oxlint/graphql-conventions.d.ts

@@ -0,0 +1,24 @@
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        'no-singular-graphql-fields': {
+            create(context: any): {
+                TemplateLiteral(node: any): void;
+                Literal(node: any): void;
+            };
+        };
+        'no-inline-graphql-in-app': {
+            create(context: any): {
+                TaggedTemplateExpression?: undefined;
+                TemplateLiteral?: undefined;
+            } | {
+                TaggedTemplateExpression(node: any): void;
+                TemplateLiteral(node: any): void;
+            };
+        };
+    };
+};
+export default plugin;
+//# sourceMappingURL=graphql-conventions.d.ts.map