@webpresso/agent-kit 0.21.0

package/dist/esm/config/oxlint/graphql-conventions.js

@@ -0,0 +1,204 @@
+// @ts-nocheck
+// Webpresso GraphQL convention rules:
+// - no-singular-graphql-fields: Prevents use of singular table names in GraphQL queries/mutations
+//
+// Hasura auto-generates GraphQL root fields from table names. All Webpresso tables use plural names
+// (e.g., `users`, `organizations`, `projects`). Using singular names (e.g., `user(limit: 1)`)
+// causes runtime errors: "field 'user' not found in type: 'query_root'"
+//
+// This rule scans template literals and string literals for known singular patterns and reports them.
+// Mapping of singular table patterns to their correct plural/actual GraphQL field names.
+// Format: [singular, correct, description]
+const SINGULAR_TABLE_RULES = [
+    ['user', 'users', 'users'],
+    ['organization', 'organizations', 'organizations'],
+    ['member', 'members', 'members'],
+    ['project', 'projects', 'projects'],
+    ['entity', 'meta_entities', 'meta_entities'],
+];
+// Build regex patterns for each singular table name.
+// These detect GraphQL root field usage patterns:
+//   - Query fields:        `user(`, `user {`, `user_by_pk`, `user_aggregate`
+//   - Insert mutations:    `insert_user_one`, `insert_user(`
+//   - Update mutations:    `update_user_by_pk`, `update_user(`
+//   - Delete mutations:    `delete_user_by_pk`, `delete_user(`
+function buildPatterns() {
+    const patterns = [];
+    for (const [singular, correct, label] of SINGULAR_TABLE_RULES) {
+        // Query root fields: `user {`, `user_by_pk`, `user_aggregate`, `user(where:`, `user(limit:`
+        // Must NOT match plural forms (e.g., `users(`) or compound words (e.g., `user_id`)
+        // For `singular(`, requires GraphQL-like arg after `(` to avoid false positives
+        // on English text like "organization (RLS Block)"
+        patterns.push({
+            regex: new RegExp(`(?<![a-zA-Z_])${singular}(?:` +
+                `\\s*\\{` + // `user {` (field selection)
+                `|_by_pk` + // `user_by_pk`
+                `|_aggregate` + // `user_aggregate`
+                `|\\s*\\(\\s*(?:where|limit|offset|order_by|distinct_on|\\$)` + // `user(where:`, `user(limit:`, `user($var`
+                `)(?!s)`),
+            singular,
+            correct,
+            label,
+            type: 'query',
+        });
+        // Insert mutations: `insert_user_one`, `insert_user(`
+        patterns.push({
+            regex: new RegExp(`insert_${singular}(?:_one|\\s*\\()`),
+            singular,
+            correct,
+            label,
+            type: 'insert',
+        });
+        // Update mutations: `update_user_by_pk`, `update_user(`
+        patterns.push({
+            regex: new RegExp(`update_${singular}(?:_by_pk|\\s*\\()`),
+            singular,
+            correct,
+            label,
+            type: 'update',
+        });
+        // Delete mutations: `delete_user_by_pk`, `delete_user(`
+        patterns.push({
+            regex: new RegExp(`delete_${singular}(?:_by_pk|\\s*\\()`),
+            singular,
+            correct,
+            label,
+            type: 'delete',
+        });
+    }
+    return patterns;
+}
+const PATTERNS = buildPatterns();
+const INLINE_GRAPHQL_EXEMPT_PATH_SEGMENTS = [
+    '/.webpresso/generated/',
+    '/packages/sdk/schema-engine/src/emitters/',
+    '/packages/feature/app-core/src/daemon/',
+];
+function normalizeFilename(filename) {
+    return typeof filename === 'string' ? filename.replaceAll('\\', '/') : '';
+}
+function getFilename(context) {
+    if (typeof context.getFilename === 'function') {
+        return normalizeFilename(context.getFilename());
+    }
+    return normalizeFilename(context.filename);
+}
+function isClientQuerySurface(filename) {
+    const normalized = normalizeFilename(filename);
+    if (!/\.tsx?$/.test(normalized))
+        return false;
+    if (INLINE_GRAPHQL_EXEMPT_PATH_SEGMENTS.some((segment) => normalized.includes(segment))) {
+        return false;
+    }
+    const isWebAppSurface = normalized.includes('/apps/web/') && normalized.includes('/app/');
+    const isFeatureSurface = normalized.includes('/packages/feature/') && normalized.includes('/src/');
+    return isWebAppSurface || isFeatureSurface;
+}
+function getNodeStart(node) {
+    if (Array.isArray(node?.range) && typeof node.range[0] === 'number') {
+        return node.range[0];
+    }
+    return typeof node?.start === 'number' ? node.start : null;
+}
+function isGraphqlCommentTagged(context, node) {
+    const sourceText = context.sourceCode?.getText?.();
+    const start = getNodeStart(node);
+    if (typeof sourceText !== 'string' || typeof start !== 'number') {
+        return false;
+    }
+    return /\/\*\s*GraphQL\s*\*\/\s*$/.test(sourceText.slice(Math.max(0, start - 40), start));
+}
+function isGqlTag(tag) {
+    if (!tag)
+        return false;
+    if (tag.type === 'Identifier')
+        return tag.name === 'gql';
+    return (tag.type === 'MemberExpression' &&
+        !tag.computed &&
+        tag.property?.type === 'Identifier' &&
+        tag.property.name === 'gql');
+}
+function checkStringForSingularFields(context, node, text) {
+    // Quick pre-check: skip strings that don't look like GraphQL
+    // GraphQL queries contain `{` or `query` or `mutation` or `subscription`
+    if (!text.includes('{') &&
+        !text.includes('query') &&
+        !text.includes('mutation') &&
+        !text.includes('subscription')) {
+        return;
+    }
+    for (const pattern of PATTERNS) {
+        if (!pattern.regex.test(text))
+            continue;
+        const correctedField = pattern.type === 'query'
+            ? pattern.correct
+            : pattern.type === 'insert'
+                ? `insert_${pattern.correct}_one`
+                : pattern.type === 'update'
+                    ? `update_${pattern.correct}_by_pk`
+                    : `delete_${pattern.correct}_by_pk`;
+        const matched = text.match(pattern.regex)?.[0] ?? `${pattern.singular}`;
+        context.report({
+            node,
+            message: `Singular GraphQL field name '${matched}' — Hasura uses plural table names. ` +
+                `Use '${correctedField}' instead. ` +
+                `All tables use plural names (e.g., users, organizations, projects, members, meta_entities).`,
+        });
+        // Report only the first match per string to avoid noise
+        return;
+    }
+}
+const noSingularGraphqlFields = {
+    create(context) {
+        return {
+            // Check template literals (most GraphQL queries use backticks)
+            TemplateLiteral(node) {
+                // Combine all quasis (static parts) of the template literal
+                const text = node.quasis.map((q) => q.value?.raw ?? q.value?.cooked ?? '').join('');
+                checkStringForSingularFields(context, node, text);
+            },
+            // Check regular string literals (some queries use single/double quotes)
+            Literal(node) {
+                if (typeof node.value !== 'string')
+                    return;
+                checkStringForSingularFields(context, node, node.value);
+            },
+        };
+    },
+};
+const noInlineGraphqlInApp = {
+    create(context) {
+        if (!isClientQuerySurface(getFilename(context))) {
+            return {};
+        }
+        function report(node) {
+            context.report({
+                node,
+                message: 'Inline GraphQL is banned in client query surfaces. Use generated SDK operations or shared query option factories instead.',
+            });
+        }
+        return {
+            TaggedTemplateExpression(node) {
+                if (!isGqlTag(node.tag))
+                    return;
+                report(node);
+            },
+            TemplateLiteral(node) {
+                if (node.parent?.type === 'TaggedTemplateExpression')
+                    return;
+                if (!isGraphqlCommentTagged(context, node))
+                    return;
+                report(node);
+            },
+        };
+    },
+};
+const plugin = {
+    meta: { name: 'webpresso-graphql' },
+    rules: {
+        'no-singular-graphql-fields': noSingularGraphqlFields,
+        'no-inline-graphql-in-app': noInlineGraphqlInApp,
+    },
+};
+export default plugin;
+//# sourceMappingURL=graphql-conventions.js.map

package/dist/esm/config/oxlint/import-hygiene.d.ts

@@ -0,0 +1,35 @@
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        'no-relative-parent-imports': {
+            create(context: any): {
+                ImportDeclaration(node: any): void;
+                ExportNamedDeclaration(node: any): void;
+                ExportAllDeclaration(node: any): void;
+                ImportExpression(node: any): void;
+            };
+        };
+        'no-src-path-imports': {
+            create(context: any): {
+                ImportDeclaration(node: any): void;
+            };
+        };
+        'no-relative-mock-paths': {
+            create(context: any): {
+                CallExpression(node: any): void;
+            };
+        };
+        'no-forbidden-package-imports': {
+            create(context: any): {
+                ImportDeclaration(node: any): void;
+                ExportNamedDeclaration(node: any): void;
+                ExportAllDeclaration(node: any): void;
+                ImportExpression(node: any): void;
+            };
+        };
+    };
+};
+export default plugin;
+//# sourceMappingURL=import-hygiene.d.ts.map

package/dist/esm/config/oxlint/import-hygiene.js

@@ -0,0 +1,208 @@
+// @ts-nocheck
+// Webpresso import hygiene rules — replaces GritQL patterns:
+// - no-relative-parent-imports
+// - no-src-path-imports
+// - no-relative-mock-paths
+// - no-forbidden-package-imports
+const CROSS_PACKAGE_SEGMENT = /(?:^|\/)(packages|apps|tooling|infra|webpresso)\//;
+function isRelativeParentPath(source) {
+    return typeof source === 'string' && source.includes('../');
+}
+function isRelativeGeneratedImport(source) {
+    return (typeof source === 'string' && source.startsWith('.') && source.includes('.webpresso/generated/'));
+}
+function isGeneratedPathsSourceImport(source) {
+    return (typeof source === 'string' && source.includes('/packages/cli/cli-utils/src/generated-paths'));
+}
+function isAllowedRelativeParentImport(source) {
+    return isGeneratedPathsSourceImport(source);
+}
+function isCrossPackageRelativePath(source) {
+    return isRelativeParentPath(source) && CROSS_PACKAGE_SEGMENT.test(source);
+}
+function reportRelativeParentImport(context, node) {
+    context.report({
+        node,
+        message: 'Use `#` or package imports instead of relative parent imports. For cross-package access, add a proper package export and import via the package name.',
+    });
+}
+function reportCrossPackageImport(context, node) {
+    context.report({
+        node,
+        message: 'Do not reach into another package/app with a relative filesystem import. Add a proper package export and import it via the package name.',
+    });
+}
+function normalizeFilename(filename) {
+    return typeof filename === 'string' ? filename.replaceAll('\\', '/') : '';
+}
+function getFilename(context) {
+    if (typeof context.getFilename === 'function') {
+        return normalizeFilename(context.getFilename());
+    }
+    return normalizeFilename(context.filename);
+}
+function checkStaticModuleSource(node, callback) {
+    if (!node.source)
+        return;
+    callback(node.source.value, node.source);
+}
+function isPlatformAppFile(filename) {
+    return filename.includes('/apps/workers/') || filename.includes('/apps/web/');
+}
+function isSdkPackageFile(filename) {
+    return filename.includes('/packages/sdk/');
+}
+function isSchemaEngineImport(source) {
+    return typeof source === 'string' && source.startsWith('@webpresso/schema-engine/');
+}
+function isSchemaRuntimeImport(source) {
+    return typeof source === 'string' && source.startsWith('@webpresso/schema-runtime');
+}
+function isGeneratedImport(source) {
+    return typeof source === 'string' && source.startsWith('@webpresso/generated/');
+}
+const FORBIDDEN_SDK_TOOLING_IMPORTS = new Set([
+    '@webpresso/schema-loaders',
+    '@webpresso/cli-utils',
+    '@webpresso/blueprint',
+]);
+const noRelativeParentImports = {
+    create(context) {
+        function checkSource(source, node) {
+            if (isRelativeGeneratedImport(source)) {
+                context.report({
+                    node,
+                    message: 'Do not import generated artifacts via relative filesystem paths. Use the real workspace package `@webpresso/generated/*` instead.',
+                });
+                return;
+            }
+            if (isRelativeParentPath(source) && !isAllowedRelativeParentImport(source)) {
+                reportRelativeParentImport(context, node);
+            }
+        }
+        return {
+            ImportDeclaration(node) {
+                checkSource(node.source.value, node.source);
+            },
+            // Also catch export ... from '../...'
+            ExportNamedDeclaration(node) {
+                checkStaticModuleSource(node, checkSource);
+            },
+            ExportAllDeclaration(node) {
+                checkStaticModuleSource(node, checkSource);
+            },
+            ImportExpression(node) {
+                if (node.source.type !== 'Literal')
+                    return;
+                const source = node.source.value;
+                if (isCrossPackageRelativePath(source)) {
+                    reportCrossPackageImport(context, node.source);
+                }
+            },
+        };
+    },
+};
+const noSrcPathImports = {
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                const source = node.source.value;
+                if (typeof source === 'string' && source.includes('../src/')) {
+                    context.report({
+                        node: node.source,
+                        message: "Use `#` alias instead of `../src/` paths (e.g. '#database' not '../src/database').",
+                    });
+                }
+            },
+        };
+    },
+};
+const noRelativeMockPaths = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== 'MemberExpression' ||
+                    node.callee.object.type !== 'Identifier' ||
+                    node.callee.object.name !== 'vi' ||
+                    node.callee.property.type !== 'Identifier' ||
+                    node.callee.property.name !== 'mock') {
+                    return;
+                }
+                const arg = node.arguments[0];
+                if (!arg || arg.type !== 'Literal' || typeof arg.value !== 'string')
+                    return;
+                if (arg.value.includes('../')) {
+                    context.report({
+                        node: arg,
+                        message: "Ban vi.mock() with relative parent paths. Use the module's package name or `#` alias instead.",
+                    });
+                }
+            },
+        };
+    },
+};
+const noForbiddenPackageImports = {
+    create(context) {
+        const filename = getFilename(context);
+        function checkImport(source, node) {
+            if (typeof source !== 'string')
+                return;
+            if (isPlatformAppFile(filename) &&
+                isSchemaEngineImport(source) &&
+                source !== '@webpresso/schema-engine/api') {
+                context.report({
+                    node,
+                    message: 'Platform apps may only import `@webpresso/schema-engine/api`, `@webpresso/generated/*`, or `@webpresso/schema-runtime/*`. Move schema-engine internals behind a public surface.',
+                });
+                return;
+            }
+            if (isPlatformAppFile(filename) && isGeneratedImport(source)) {
+                return;
+            }
+            if (isSdkPackageFile(filename) && FORBIDDEN_SDK_TOOLING_IMPORTS.has(source)) {
+                context.report({
+                    node,
+                    message: 'SDK packages must not import CLI/tooling packages such as `@webpresso/schema-loaders`, `@webpresso/cli-utils`, or `@webpresso/blueprint`.',
+                });
+                return;
+            }
+            // Runtime helpers are allowed for platform apps, so keep the explicit allowlist
+            // visible here rather than indirectly relying on a broader schema-engine prefix.
+            if (isPlatformAppFile(filename) &&
+                isSchemaRuntimeImport(source) &&
+                !source.startsWith('@webpresso/schema-runtime/')) {
+                context.report({
+                    node,
+                    message: 'Platform apps must import `@webpresso/schema-runtime/*` subpaths, not the package root.',
+                });
+            }
+        }
+        return {
+            ImportDeclaration(node) {
+                checkImport(node.source.value, node.source);
+            },
+            ExportNamedDeclaration(node) {
+                checkStaticModuleSource(node, checkImport);
+            },
+            ExportAllDeclaration(node) {
+                checkStaticModuleSource(node, checkImport);
+            },
+            ImportExpression(node) {
+                if (node.source.type !== 'Literal')
+                    return;
+                checkImport(node.source.value, node.source);
+            },
+        };
+    },
+};
+const plugin = {
+    meta: { name: 'webpresso-imports' },
+    rules: {
+        'no-relative-parent-imports': noRelativeParentImports,
+        'no-src-path-imports': noSrcPathImports,
+        'no-relative-mock-paths': noRelativeMockPaths,
+        'no-forbidden-package-imports': noForbiddenPackageImports,
+    },
+};
+export default plugin;
+//# sourceMappingURL=import-hygiene.js.map

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

@@ -0,0 +1,23 @@
+import codeSafety from './code-safety.js';
+import foundationPurity from './foundation-purity.js';
+import graphqlConventions from './graphql-conventions.js';
+import importHygiene from './import-hygiene.js';
+import monorepoNpaths from './monorepo-paths.js';
+import queryPatterns from './query-patterns.js';
+import testingQuality from './testing-quality.js';
+import tierBoundaries from './tier-boundaries.js';
+type OxlintRuleSeverity = 'error';
+interface OxlintPlugin {
+    meta: {
+        name: string;
+    };
+    rules: Record<string, unknown>;
+}
+export { codeSafety, foundationPurity, graphqlConventions, importHygiene, monorepoNpaths, queryPatterns, testingQuality, tierBoundaries, };
+export declare const plugins: Record<string, OxlintPlugin>;
+export declare const rules: Record<string, OxlintRuleSeverity>;
+export declare const config: {
+    plugins: Record<string, OxlintPlugin>;
+    rules: Record<string, "error">;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,29 @@
+import codeSafety from './code-safety.js';
+import foundationPurity from './foundation-purity.js';
+import graphqlConventions from './graphql-conventions.js';
+import importHygiene from './import-hygiene.js';
+import monorepoNpaths from './monorepo-paths.js';
+import queryPatterns from './query-patterns.js';
+import testingQuality from './testing-quality.js';
+import tierBoundaries from './tier-boundaries.js';
+export { codeSafety, foundationPurity, graphqlConventions, importHygiene, monorepoNpaths, queryPatterns, testingQuality, tierBoundaries, };
+const pluginEntries = [
+    codeSafety,
+    foundationPurity,
+    graphqlConventions,
+    importHygiene,
+    monorepoNpaths,
+    queryPatterns,
+    testingQuality,
+    tierBoundaries,
+].map((plugin) => [plugin.meta.name, plugin]);
+export const plugins = Object.fromEntries(pluginEntries);
+export const rules = Object.fromEntries(pluginEntries.flatMap(([pluginName, plugin]) => Object.keys(plugin.rules).map((ruleName) => [
+    `${pluginName}/${ruleName}`,
+    'error',
+])));
+export const config = {
+    plugins,
+    rules,
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/config/oxlint/monorepo-paths.d.ts

@@ -0,0 +1,19 @@
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        'no-hardcoded-repo-root': {
+            create(context: any): {
+                CallExpression(node: any): void;
+            };
+        };
+        'no-cross-package-paths': {
+            create(context: any): {
+                CallExpression(node: any): void;
+            };
+        };
+    };
+};
+export default plugin;
+//# sourceMappingURL=monorepo-paths.d.ts.map

package/dist/esm/config/oxlint/monorepo-paths.js

@@ -0,0 +1,129 @@
+// @ts-nocheck
+// Webpresso monorepo path rules — replaces GritQL patterns:
+// - no-hardcoded-repo-root (import.meta.dirname + '../..')
+// - no-hardcoded-repo-root-dirname (__dirname + '../..')
+// - no-cross-package-paths (single-arg)
+// - no-cross-package-paths-multiarg
+const RESOLVE_FUNCTIONS = new Set(['resolve', 'join']);
+const QUALIFIED_RESOLVE = new Set(['path.resolve', 'path.join']);
+function getCalleeName(callee) {
+    if (callee.type === 'Identifier')
+        return callee.name;
+    if (callee.type === 'MemberExpression' &&
+        callee.object.type === 'Identifier' &&
+        callee.property.type === 'Identifier') {
+        return `${callee.object.name}.${callee.property.name}`;
+    }
+    return null;
+}
+function isMetaDirname(node) {
+    return (node.type === 'MemberExpression' &&
+        node.object.type === 'MetaProperty' &&
+        node.property.type === 'Identifier' &&
+        node.property.name === 'dirname');
+}
+function isDunderDirname(node) {
+    return node.type === 'Identifier' && node.name === '__dirname';
+}
+function hasDoubleParentTraversal(value) {
+    return typeof value === 'string' && /\.\.\/\.\./.test(value);
+}
+const noHardcodedRepoRoot = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const name = getCalleeName(node.callee);
+                if (!name)
+                    return;
+                if (!RESOLVE_FUNCTIONS.has(name) && !QUALIFIED_RESOLVE.has(name))
+                    return;
+                const args = node.arguments;
+                if (args.length < 2)
+                    return;
+                const first = args[0];
+                const isMetaDir = isMetaDirname(first);
+                const isDunder = isDunderDirname(first);
+                // Check any-arg variant: resolve(ANY_VAR, '../../..') or join(X, '../../../..')
+                // This catches patterns like resolve(PACKAGE_ROOT, '..', '..', '..') and join(SCRIPT_DIR, '../../../..')
+                for (let i = 1; i < args.length; i++) {
+                    const arg = args[i];
+                    if (arg.type === 'Literal' && hasDoubleParentTraversal(arg.value)) {
+                        const source = isMetaDir ? 'import.meta.dirname' : isDunder ? '__dirname' : 'variable';
+                        context.report({
+                            node: arg,
+                            message: `Hardcoded repo root via ${source} + relative path. Use findRepoRoot() from @webpresso/cli-utils/find-repo-root instead.`,
+                        });
+                        return;
+                    }
+                }
+                // Multi-arg variant: join(X, '..', '..', '..') — 3+ parent segments from any starting point
+                if (args.length >= 4) {
+                    let parentCount = 0;
+                    for (let i = 1; i < args.length; i++) {
+                        if (args[i].type === 'Literal' && args[i].value === '..') {
+                            parentCount++;
+                        }
+                    }
+                    if (parentCount >= 2) {
+                        const source = isMetaDir ? 'import.meta.dirname' : isDunder ? '__dirname' : 'variable';
+                        context.report({
+                            node: args[1],
+                            message: `Hardcoded repo root via ${source} + multiple '../' segments. Use findRepoRoot() from @webpresso/cli-utils/find-repo-root instead.`,
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+const MONOREPO_DIRS = /(?:packages|apps|tooling|infra)/;
+const noCrossPackagePaths = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const name = getCalleeName(node.callee);
+                if (!name)
+                    return;
+                if (!RESOLVE_FUNCTIONS.has(name) && !QUALIFIED_RESOLVE.has(name))
+                    return;
+                const args = node.arguments;
+                if (args.length < 2)
+                    return;
+                const first = args[0];
+                if (!isDunderDirname(first) && !isMetaDirname(first))
+                    return;
+                // Single-arg: resolve(__dirname, '../../../packages/foo')
+                for (let i = 1; i < args.length; i++) {
+                    const arg = args[i];
+                    if (arg.type !== 'Literal' || typeof arg.value !== 'string')
+                        continue;
+                    if (/\.\./.test(arg.value) && MONOREPO_DIRS.test(arg.value)) {
+                        context.report({
+                            node: arg,
+                            message: 'Cross-package path traversal via __dirname. Use proper package imports or findRepoRoot() instead.',
+                        });
+                        return;
+                    }
+                }
+                // Multi-arg: resolve(__dirname, '..', '..', 'packages', 'cli2')
+                const hasParent = args.some((a) => a.type === 'Literal' && a.value === '..');
+                const hasMonoDir = args.some((a) => a.type === 'Literal' && typeof a.value === 'string' && MONOREPO_DIRS.test(a.value));
+                if (hasParent && hasMonoDir) {
+                    context.report({
+                        node: args[1],
+                        message: 'Cross-package path traversal via __dirname. Use proper package imports or findRepoRoot() instead.',
+                    });
+                }
+            },
+        };
+    },
+};
+const plugin = {
+    meta: { name: 'webpresso-monorepo' },
+    rules: {
+        'no-hardcoded-repo-root': noHardcodedRepoRoot,
+        'no-cross-package-paths': noCrossPackagePaths,
+    },
+};
+export default plugin;
+//# sourceMappingURL=monorepo-paths.js.map

package/dist/esm/config/oxlint/oxlint-config.fixture.d.ts

@@ -0,0 +1,3 @@
+import { config } from './index.js';
+export default config;
+//# sourceMappingURL=oxlint-config.fixture.d.ts.map

package/dist/esm/config/oxlint/oxlint-config.fixture.js

@@ -0,0 +1,5 @@
+import { config } from './index.js';
+// Consumer repos can use the same shape from the public subpath:
+// import { config } from 'webpresso/oxlint'
+export default config;
+//# sourceMappingURL=oxlint-config.fixture.js.map