@hypequery/serve 0.16.2 → 0.17.1

package/dist/cloud-compatibility.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Deploy-time diagnostics for managed (Cloud) execution.
+ *
+ * A deployment contract carries policy, not mechanism: an `AuthStrategy` is
+ * reduced to `{ kind, roles, scopes }`, a `TenantConfig.extract` to a column
+ * name, and middlewares, hooks, and context factories are not carried at all.
+ * That is deliberate — Cloud re-implements those concerns itself — but it means
+ * a Serve app can behave differently once deployed, and silently.
+ *
+ * The dangerous case is tenancy. `resolveTenantFilterColumn` returns the
+ * dataset's `tenantKey`, and the planner applies the tenant predicate only when
+ * a column resolves. A dataset with no `tenantKey` exposed under a config that
+ * requires a tenant will demand a tenant and filter nothing, so every tenant
+ * reads every row. Locally a middleware or resolver may cover that gap; in
+ * Cloud there is no customer code left to do it.
+ *
+ * These checks run when the deployment contract is built, so they apply to
+ * every consumer rather than only the CLI.
+ */
+import type { ServeConfig } from './types.js';
+export type CloudCompatibilitySeverity = 'error' | 'warning';
+export type CloudCompatibilityCode = 'HQ_CLOUD_TENANT_NOT_ENFORCEABLE' | 'HQ_CLOUD_MIDDLEWARE_DROPPED' | 'HQ_CLOUD_HOOKS_DROPPED' | 'HQ_CLOUD_CONTEXT_DROPPED' | 'HQ_CLOUD_AUTH_WITHOUT_ROLES';
+export interface CloudCompatibilityDiagnostic {
+    readonly severity: CloudCompatibilitySeverity;
+    readonly code: CloudCompatibilityCode;
+    /** The endpoint, dataset, or config key the finding applies to. */
+    readonly subject: string;
+    readonly message: string;
+    /** What the author should do instead. */
+    readonly remedy: string;
+}
+/**
+ * Reports how a Serve config will differ once executed by Cloud.
+ *
+ * Pure and side-effect free so it can be run for reporting without building a
+ * contract.
+ */
+export declare function analyzeCloudCompatibility(config: ServeConfig<any, any, any, any, any>): readonly CloudCompatibilityDiagnostic[];
+/**
+ * Formats diagnostics for a thrown error. Errors are listed first because they
+ * are what blocks the deployment.
+ */
+export declare function formatCloudCompatibilityDiagnostics(diagnostics: readonly CloudCompatibilityDiagnostic[]): string;
+//# sourceMappingURL=cloud-compatibility.d.ts.map

package/dist/cloud-compatibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud-compatibility.d.ts","sourceRoot":"","sources":["../src/cloud-compatibility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAA0C,WAAW,EAAE,MAAM,YAAY,CAAC;AAKtF,MAAM,MAAM,0BAA0B,GAAG,OAAO,GAAG,SAAS,CAAC;AAE7D,MAAM,MAAM,sBAAsB,GAC9B,iCAAiC,GACjC,6BAA6B,GAC7B,wBAAwB,GACxB,0BAA0B,GAC1B,6BAA6B,CAAC;AAElC,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,QAAQ,EAAE,0BAA0B,CAAC;IAC9C,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IACtC,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,yCAAyC;IACzC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAoDD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,GAC3C,SAAS,4BAA4B,EAAE,CAiJzC;AAQD;;;GAGG;AACH,wBAAgB,mCAAmC,CACjD,WAAW,EAAE,SAAS,4BAA4B,EAAE,GACnD,MAAM,CAIR"}

package/dist/cloud-compatibility.js

@@ -0,0 +1,188 @@
+/**
+ * Deploy-time diagnostics for managed (Cloud) execution.
+ *
+ * A deployment contract carries policy, not mechanism: an `AuthStrategy` is
+ * reduced to `{ kind, roles, scopes }`, a `TenantConfig.extract` to a column
+ * name, and middlewares, hooks, and context factories are not carried at all.
+ * That is deliberate — Cloud re-implements those concerns itself — but it means
+ * a Serve app can behave differently once deployed, and silently.
+ *
+ * The dangerous case is tenancy. `resolveTenantFilterColumn` returns the
+ * dataset's `tenantKey`, and the planner applies the tenant predicate only when
+ * a column resolves. A dataset with no `tenantKey` exposed under a config that
+ * requires a tenant will demand a tenant and filter nothing, so every tenant
+ * reads every row. Locally a middleware or resolver may cover that gap; in
+ * Cloud there is no customer code left to do it.
+ *
+ * These checks run when the deployment contract is built, so they apply to
+ * every consumer rather than only the CLI.
+ */
+import { resolveDatasetEntry } from './semantic/datasets/utils/dataset-entry.js';
+import { resolveLocalAuthRequirement } from './auth-requirement.js';
+import { resolveMetricEntry } from './semantic/datasets/metric-endpoint.js';
+function tenantIsExpected(local, global) {
+    if (local === undefined && global === undefined)
+        return false;
+    const effective = { ...(global ?? {}), ...(local ?? {}) };
+    return effective.required !== false;
+}
+function hasAuth(auth) {
+    return Array.isArray(auth) ? auth.length > 0 : auth !== undefined && auth !== null;
+}
+function declaresRolesOrScopes(entry) {
+    return (entry.requiredRoles?.length ?? 0) > 0 || (entry.requiredScopes?.length ?? 0) > 0;
+}
+/**
+ * True when an endpoint ends up authenticated but declares nothing Cloud can
+ * enforce. Mirrors `accessPolicy` in the protocol adapter, including the local
+ * opt-out: an endpoint with `auth: null` or `requiresAuth: false` resolves to
+ * public and is not a downgrade.
+ */
+function isAuthenticatedWithoutRoles(local, globalAuth) {
+    if (declaresRolesOrScopes(local))
+        return false;
+    return (resolveLocalAuthRequirement(local) ?? hasAuth(globalAuth)) === true;
+}
+/**
+ * Reports how a Serve config will differ once executed by Cloud.
+ *
+ * Pure and side-effect free so it can be run for reporting without building a
+ * contract.
+ */
+export function analyzeCloudCompatibility(config) {
+    const serveConfig = config;
+    const diagnostics = [];
+    // Semantic endpoints have no customer code in Cloud, so an unenforceable
+    // tenant requirement silently becomes no isolation at all.
+    const semanticTargets = [
+        ...Object.entries(serveConfig.datasets ?? {}).map(([name, entry]) => ({
+            label: `datasets.${name}`,
+            entry,
+        })),
+        ...Object.entries(serveConfig.metrics ?? {}).map(([name, entry]) => ({
+            label: `metrics.${name}`,
+            entry,
+        })),
+    ];
+    for (const { label, entry } of semanticTargets) {
+        const resolved = label.startsWith('datasets.')
+            ? resolveDatasetEntry(entry)
+            : resolveMetricEntry(entry);
+        const dataset = label.startsWith('datasets.')
+            ? resolved.dataset
+            : datasetOfMetric(resolved);
+        const local = resolved.tenant;
+        if (!tenantIsExpected(local, serveConfig.tenant))
+            continue;
+        if (dataset?.tenantKey)
+            continue;
+        diagnostics.push({
+            severity: 'error',
+            code: 'HQ_CLOUD_TENANT_NOT_ENFORCEABLE',
+            subject: label,
+            message: `Tenant isolation is required for "${label}" but dataset `
+                + `"${dataset?.name ?? 'unknown'}" declares no tenantKey. Cloud resolves the `
+                + 'tenant filter column from the dataset, so it would accept a tenant and '
+                + 'return every tenant\'s rows.',
+            remedy: `Add tenantKey to the "${dataset?.name ?? ''}" dataset, or set `
+                + 'tenant.required to false if this data is genuinely shared.',
+        });
+    }
+    // Everything below is dropped by the protocol adapter.
+    const globalMiddlewares = serveConfig.middlewares ?? [];
+    if (globalMiddlewares.length > 0) {
+        diagnostics.push({
+            severity: 'error',
+            code: 'HQ_CLOUD_MIDDLEWARE_DROPPED',
+            subject: 'middlewares',
+            message: `${globalMiddlewares.length} global middleware(s) are not carried in the `
+                + 'deployment contract and will not run in Cloud. Middleware that performs '
+                + 'authentication or filtering would leave endpoints less protected than '
+                + 'they are locally.',
+            remedy: 'Express the requirement declaratively with requiresAuth, requiredRoles, '
+                + 'requiredScopes, or tenant config, or keep this app self-hosted.',
+        });
+    }
+    const queryEntries = Object.entries(serveConfig.queries ?? {});
+    for (const [name, query] of queryEntries) {
+        if ((query?.middlewares?.length ?? 0) === 0)
+            continue;
+        diagnostics.push({
+            severity: 'error',
+            code: 'HQ_CLOUD_MIDDLEWARE_DROPPED',
+            subject: `queries.${name}`,
+            message: `Middleware on query "${name}" is not carried in the deployment contract `
+                + 'and will not run in Cloud.',
+            remedy: 'Express the requirement declaratively on the query, or move the logic into '
+                + 'the query resolver itself.',
+        });
+    }
+    if (serveConfig.hooks !== undefined) {
+        diagnostics.push({
+            severity: 'warning',
+            code: 'HQ_CLOUD_HOOKS_DROPPED',
+            subject: 'hooks',
+            message: 'Lifecycle hooks do not run in Cloud.',
+            remedy: 'Cloud records its own request log for deployed endpoints; remove the hooks '
+                + 'or keep them for local runs only.',
+        });
+    }
+    if (serveConfig.context !== undefined) {
+        diagnostics.push({
+            severity: 'warning',
+            code: 'HQ_CLOUD_CONTEXT_DROPPED',
+            subject: 'context',
+            message: 'The context factory does not run in Cloud, so values it provides will be '
+                + 'absent from query resolvers.',
+            remedy: 'Derive those values inside the resolver, or pass them as query input.',
+        });
+    }
+    {
+        // Custom queries undergo the same reduction as semantic endpoints: the
+        // adapter calls endpointPolicy for all three, so a query with a strategy
+        // but no declared roles is downgraded exactly the same way.
+        const endpoints = [
+            ...Object.entries(serveConfig.datasets ?? {}).map(([name, entry]) => [
+                `datasets.${name}`,
+                resolveDatasetEntry(entry),
+            ]),
+            ...Object.entries(serveConfig.metrics ?? {}).map(([name, entry]) => [
+                `metrics.${name}`,
+                resolveMetricEntry(entry),
+            ]),
+            ...Object.entries(serveConfig.queries ?? {}).map(([name, entry]) => [
+                `queries.${name}`,
+                (entry ?? {}),
+            ]),
+        ];
+        const undeclared = endpoints.filter(([, resolved]) => isAuthenticatedWithoutRoles(resolved, serveConfig.auth));
+        for (const [label] of undeclared) {
+            diagnostics.push({
+                severity: 'warning',
+                code: 'HQ_CLOUD_AUTH_WITHOUT_ROLES',
+                subject: label,
+                message: `"${label}" is authenticated but declares no roles or scopes. The auth `
+                    + 'strategy itself is not carried, so Cloud accepts any valid credential '
+                    + 'for this endpoint even if the local strategy is stricter.',
+                remedy: 'Declare requiredRoles or requiredScopes so Cloud can enforce the same '
+                    + 'restriction.',
+            });
+        }
+    }
+    return diagnostics;
+}
+function datasetOfMetric(resolved) {
+    const metric = resolved.metric;
+    if (!metric)
+        return undefined;
+    return metric.__type === 'grained_metric_ref' ? metric.metric?.dataset : metric.dataset;
+}
+/**
+ * Formats diagnostics for a thrown error. Errors are listed first because they
+ * are what blocks the deployment.
+ */
+export function formatCloudCompatibilityDiagnostics(diagnostics) {
+    return diagnostics
+        .map(d => `  [${d.severity}] ${d.code} (${d.subject})\n    ${d.message}\n    → ${d.remedy}`)
+        .join('\n\n');
+}

package/dist/index.d.ts

@@ -20,9 +20,13 @@ export { createCacheObservability, detectBuilderCache } from "./cache-observabil
 export type { CacheObservability, CacheLayerStats, BuilderCacheLike } from "./cache-observability.js";
 export { buildProtocolDeploymentContract } from './protocol-adapter.js';
 export type { BuildProtocolDeploymentOptions } from './protocol-adapter.js';
+export { analyzeCloudCompatibility, formatCloudCompatibilityDiagnostics, } from './cloud-compatibility.js';
+export type { CloudCompatibilityCode, CloudCompatibilityDiagnostic, CloudCompatibilitySeverity, } from './cloud-compatibility.js';
 export { ProtocolSchemaAdapterError, zodToProtocolSchema } from './protocol-schema-adapter.js';
 /** @deprecated Import from `@hypequery/serve/dev` instead. */
 export { serveDev } from "./dev.js";
 export * from "./serve.js";
 export * from "./semantic/index.js";
+export { readServeMcpSource } from './server/mcp-source.js';
+export type { ServeMcpSource } from './server/mcp-source.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AACtF,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AACnE,OAAO,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACxF,YAAY,EAAE,kBAAkB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACtG,OAAO,EAAE,+BAA+B,EAAE,MAAM,uBAAuB,CAAC;AACxE,YAAY,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,EAAE,0BAA0B,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAC/F,8DAA8D;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AACtF,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AACnE,OAAO,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACxF,YAAY,EAAE,kBAAkB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACtG,OAAO,EAAE,+BAA+B,EAAE,MAAM,uBAAuB,CAAC;AACxE,YAAY,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,EACL,yBAAyB,EACzB,mCAAmC,GACpC,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,sBAAsB,EACtB,4BAA4B,EAC5B,0BAA0B,GAC3B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,0BAA0B,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAC/F,8DAA8D;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AAGpC,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/index.js

@@ -17,8 +17,11 @@ export * from "./adapters/vercel.js";
 export { startServer, toNodeHandler, toFetchHandler } from "./adapters/standalone.js";
 export { createCacheObservability, detectBuilderCache } from "./cache-observability.js";
 export { buildProtocolDeploymentContract } from './protocol-adapter.js';
+export { analyzeCloudCompatibility, formatCloudCompatibilityDiagnostics, } from './cloud-compatibility.js';
 export { ProtocolSchemaAdapterError, zodToProtocolSchema } from './protocol-schema-adapter.js';
 /** @deprecated Import from `@hypequery/serve/dev` instead. */
 export { serveDev } from "./dev.js";
 export * from "./serve.js";
 export * from "./semantic/index.js";
+// MCP tooling seam: lets `hypequery mcp` reuse this entrypoint's datasets.
+export { readServeMcpSource } from './server/mcp-source.js';

package/dist/protocol-adapter.d.ts

@@ -1,4 +1,5 @@
 import { type ProtocolDeploymentContract, type ProtocolQueryImplementation, type ProtocolRuntimeArtifact, type ProtocolSchema } from '@hypequery/protocol';
+import { type CloudCompatibilityDiagnostic } from './cloud-compatibility.js';
 import type { ServeConfig } from './types.js';
 export interface BuildProtocolDeploymentOptions {
     /** Runtime artifact used for Serve callbacks without an explicit implementation override. */
@@ -12,6 +13,16 @@ export interface BuildProtocolDeploymentOptions {
         readonly input?: ProtocolSchema;
         readonly output?: ProtocolSchema;
     }>>;
+    /**
+     * Receives every managed-execution diagnostic, including ones that do not
+     * block the build. Without it, warnings are discarded and only errors surface.
+     */
+    readonly onCloudDiagnostic?: (diagnostic: CloudCompatibilityDiagnostic) => void;
+    /**
+     * Downgrades managed-execution errors to warnings. The author is asserting
+     * they know the deployed behaviour differs from local.
+     */
+    readonly allowUnsupportedConfig?: boolean;
 }
 /**
  * Converts an existing Serve configuration and its Dataset/metric definitions

package/dist/protocol-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"protocol-adapter.d.ts","sourceRoot":"","sources":["../src/protocol-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,0BAA0B,EAG/B,KAAK,2BAA2B,EAChC,KAAK,uBAAuB,EAC5B,KAAK,cAAc,EACpB,MAAM,qBAAqB,CAAC;AAM7B,OAAO,KAAK,EAOV,WAAW,EAGZ,MAAM,YAAY,CAAC;AAMpB,MAAM,WAAW,8BAA8B;IAC7C,6FAA6F;IAC7F,QAAQ,CAAC,eAAe,CAAC,EAAE,uBAAuB,GAAG;QACnD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;KACpC,CAAC;IACF,mFAAmF;IACnF,QAAQ,CAAC,oBAAoB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,2BAA2B,CAAC,CAAC,CAAC;IACtF,gFAAgF;IAChF,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE;QAC9C,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;QAChC,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;KAClC,CAAC,CAAC,CAAC;CACL;AA2JD;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAC5C,OAAO,GAAE,8BAAmC,GAC3C,0BAA0B,CAkF5B"}
+{"version":3,"file":"protocol-adapter.d.ts","sourceRoot":"","sources":["../src/protocol-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,0BAA0B,EAG/B,KAAK,2BAA2B,EAChC,KAAK,uBAAuB,EAC5B,KAAK,cAAc,EACpB,MAAM,qBAAqB,CAAC;AAM7B,OAAO,EAGL,KAAK,4BAA4B,EAClC,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAOV,WAAW,EAGZ,MAAM,YAAY,CAAC;AAMpB,MAAM,WAAW,8BAA8B;IAC7C,6FAA6F;IAC7F,QAAQ,CAAC,eAAe,CAAC,EAAE,uBAAuB,GAAG;QACnD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;KACpC,CAAC;IACF,mFAAmF;IACnF,QAAQ,CAAC,oBAAoB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,2BAA2B,CAAC,CAAC,CAAC;IACtF,gFAAgF;IAChF,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE;QAC9C,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;QAChC,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;KAClC,CAAC,CAAC,CAAC;IACJ;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,UAAU,EAAE,4BAA4B,KAAK,IAAI,CAAC;IAChF;;;OAGG;IACH,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAC3C;AA6KD;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAC5C,OAAO,GAAE,8BAAmC,GAC3C,0BAA0B,CAmF5B"}

package/dist/protocol-adapter.js

@@ -1,9 +1,25 @@
 import { validateProtocolDeploymentContract, } from '@hypequery/protocol';
 import { buildProtocolDatasetContract, } from '@hypequery/datasets';
+import { analyzeCloudCompatibility, formatCloudCompatibilityDiagnostics, } from './cloud-compatibility.js';
 import { resolveDatasetEntry } from './semantic/datasets/utils/dataset-entry.js';
 import { resolveMetricEntry } from './semantic/datasets/metric-endpoint.js';
 import { zodToProtocolSchema } from './protocol-schema-adapter.js';
 import { resolveLocalAuthRequirement } from './auth-requirement.js';
+function reportCloudCompatibility(config, options) {
+    const diagnostics = analyzeCloudCompatibility(config);
+    if (diagnostics.length === 0)
+        return;
+    for (const diagnostic of diagnostics)
+        options.onCloudDiagnostic?.(diagnostic);
+    if (options.allowUnsupportedConfig)
+        return;
+    const blocking = diagnostics.filter(diagnostic => diagnostic.severity === 'error');
+    if (blocking.length === 0)
+        return;
+    throw new Error('This Serve configuration would behave differently under managed execution:\n\n'
+        + `${formatCloudCompatibilityDiagnostics(blocking)}\n\n`
+        + 'Resolve these, or pass allowUnsupportedConfig to deploy anyway.');
+}
 function normalizePath(...parts) {
     const joined = parts
         .filter(Boolean)
@@ -110,6 +126,7 @@ function runtimeArtifacts(implementations, configured) {
  * into the strict, immutable protocol deployment contract.
  */
 export function buildProtocolDeploymentContract(config, options = {}) {
+    reportCloudCompatibility(config, options);
     const serveConfig = config;
     const basePath = serveConfig.basePath ?? '/api/analytics';
     const datasetsPath = serveConfig.semanticPaths?.datasets ?? '/datasets';

package/dist/semantic/datasets/dataset-endpoint.d.ts

@@ -48,11 +48,6 @@ declare const datasetResultSchema: z.ZodObject<{
         }>>;
     }, "strip", z.ZodTypeAny, {
         tenant?: string | undefined;
-        cache?: {
-            hit: boolean;
-            ageMs?: number | undefined;
-            stale?: boolean | undefined;
-        } | undefined;
         timingMs?: number | undefined;
         sql?: string | undefined;
         rowCount?: number | undefined;
@@ -61,13 +56,13 @@ declare const datasetResultSchema: z.ZodObject<{
             offset: number;
             hasMore: boolean;
         } | undefined;
-    }, {
-        tenant?: string | undefined;
         cache?: {
             hit: boolean;
             ageMs?: number | undefined;
             stale?: boolean | undefined;
         } | undefined;
+    }, {
+        tenant?: string | undefined;
         timingMs?: number | undefined;
         sql?: string | undefined;
         rowCount?: number | undefined;
@@ -76,16 +71,16 @@ declare const datasetResultSchema: z.ZodObject<{
             offset: number;
             hasMore: boolean;
         } | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    data: Record<string, unknown>[];
-    meta?: {
-        tenant?: string | undefined;
         cache?: {
             hit: boolean;
             ageMs?: number | undefined;
             stale?: boolean | undefined;
         } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    data: Record<string, unknown>[];
+    meta?: {
+        tenant?: string | undefined;
         timingMs?: number | undefined;
         sql?: string | undefined;
         rowCount?: number | undefined;
@@ -94,16 +89,16 @@ declare const datasetResultSchema: z.ZodObject<{
             offset: number;
             hasMore: boolean;
         } | undefined;
-    } | undefined;
-}, {
-    data: Record<string, unknown>[];
-    meta?: {
-        tenant?: string | undefined;
         cache?: {
             hit: boolean;
             ageMs?: number | undefined;
             stale?: boolean | undefined;
         } | undefined;
+    } | undefined;
+}, {
+    data: Record<string, unknown>[];
+    meta?: {
+        tenant?: string | undefined;
         timingMs?: number | undefined;
         sql?: string | undefined;
         rowCount?: number | undefined;
@@ -112,6 +107,11 @@ declare const datasetResultSchema: z.ZodObject<{
             offset: number;
             hasMore: boolean;
         } | undefined;
+        cache?: {
+            hit: boolean;
+            ageMs?: number | undefined;
+            stale?: boolean | undefined;
+        } | undefined;
     } | undefined;
 }>;
 export declare function createDatasetEndpoint<TAuth extends AuthContext>(name: string, entry: DatasetEntry<TAuth>, analytics: DatasetClient, builderFactory: QueryBuilderFactoryLike): ServeEndpoint<z.ZodTypeAny, typeof datasetResultSchema, any, TAuth, any>;

package/dist/semantic/datasets/dataset-endpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataset-endpoint.d.ts","sourceRoot":"","sources":["../../../src/semantic/datasets/dataset-endpoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,WAAW,EAGX,aAAa,EAEd,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EACxB,MAAM,qBAAqB,CAAC;AAQ7B,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAIlF,YAAY,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAuB7D,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvB,CAAC;AAMH,wBAAgB,qBAAqB,CAAC,KAAK,SAAS,WAAW,EAC7D,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,YAAY,CAAC,KAAK,CAAC,EAC1B,SAAS,EAAE,aAAa,EACxB,cAAc,EAAE,uBAAuB,GACtC,aAAa,CAAC,CAAC,CAAC,UAAU,EAAE,OAAO,mBAAmB,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,CA0G1E"}
+{"version":3,"file":"dataset-endpoint.d.ts","sourceRoot":"","sources":["../../../src/semantic/datasets/dataset-endpoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,WAAW,EAGX,aAAa,EAEd,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EACxB,MAAM,qBAAqB,CAAC;AAS7B,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAGlF,YAAY,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAuB7D,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGvB,CAAC;AAMH,wBAAgB,qBAAqB,CAAC,KAAK,SAAS,WAAW,EAC7D,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,YAAY,CAAC,KAAK,CAAC,EAC1B,SAAS,EAAE,aAAa,EACxB,cAAc,EAAE,uBAAuB,GACtC,aAAa,CAAC,CAAC,CAAC,UAAU,EAAE,OAAO,mBAAmB,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,CAmH1E"}

package/dist/semantic/datasets/dataset-endpoint.js

@@ -9,11 +9,11 @@
  * - Returns { data } or { data, meta } based on headers
  */
 import { z } from 'zod';
+import { buildDatasetInputSchema } from '@hypequery/datasets';
 import { ServeHttpError } from '../../errors.js';
 import { resolveSemanticExecutionRuntime, resolveSemanticQueryBuilder, } from '../query-builder-context.js';
 import { buildDatasetQueryDescription } from './utils/dataset-query-metadata.js';
 import { resolveDatasetEntry } from './utils/dataset-entry.js';
-import { buildDatasetInputSchema } from './utils/semantic-input-schema.js';
 import { resolveLocalAuthRequirement } from '../../auth-requirement.js';
 // ---------------------------------------------------------------------------
 // Zod schemas for dataset query input / output
@@ -47,7 +47,16 @@ export function createDatasetEndpoint(name, entry, analytics, builderFactory) {
     const effectiveMaxLimit = resolved.maxLimit ?? ds.limits?.maxResultSize ?? 1000;
     // Build a schema whose dimension/measure/filter fields are enumerated from
     // this dataset's contract, so OpenAPI/docs and clients see the valid fields.
-    const datasetQueryInputSchema = buildDatasetInputSchema(ds);
+    const datasetQueryInputSchema = buildDatasetInputSchema(ds, {
+        includeMeta: true,
+        requireSelection: false,
+        enforceResultLimit: false,
+        maxOffset: undefined,
+        maxDimensions: undefined,
+        maxMeasures: undefined,
+        maxFilters: undefined,
+        maxOrderBy: undefined,
+    });
     const metadata = {
         path: '', // filled by router.register
         method: 'POST',

package/dist/semantic/datasets/index.d.ts

@@ -1,5 +1,5 @@
-export { dataset, dimension, measure, belongsTo, hasMany, hasOne, sum, count, countDistinct, avg, min, max, divide, multiply, subtract, add, nullIfZero, coalesce, round, floor, ceil, eq, neq, gt, gte, lt, lte, inList, notInList, between, like, asc, desc, filter, order, createDatasetRegistry, } from '@hypequery/datasets';
-export type { FieldType, DimensionType, DimensionOptions, DimensionDefinition, MeasureOptions, MeasureDefinition, InferDimensionType, RelationshipKind, RelationshipDefinition, AggregationType, MeasureAggregation, AggregationSpec, FormulaExpr, DerivedMetricSpec, TimeGrain, MetricRef, BaseMetricRef, DerivedMetricRef, GrainedMetricRef, MetricContract, MetricFilter, MetricOrderBy, MetricQuery, DatasetQuery, MetricResultMeta, MetricResult, DatasetQueryResult, MetricHandle, ExecutionContext, SemanticExecutionRuntime, SemanticTenantRuntime, SemanticFilterDefinition, SemanticFiltersDefinition, DatasetConfig, DatasetLimits, DatasetInstance, BaseMetricConfig, DerivedMetricConfig, DatasetRegistryInstance, DatasetFieldNames, } from '@hypequery/datasets';
+export { dataset, dimension, measure, belongsTo, hasMany, hasOne, sum, count, countDistinct, avg, min, max, divide, multiply, subtract, add, nullIfZero, coalesce, round, floor, ceil, eq, neq, gt, gte, lt, lte, inList, notInList, between, like, asc, desc, filter, order, createDatasetRegistry, publishDatasets, } from '@hypequery/datasets';
+export type { FieldType, DimensionType, DimensionOptions, DimensionDefinition, MeasureOptions, MeasureDefinition, InferDimensionType, RelationshipKind, RelationshipDefinition, AggregationType, MeasureAggregation, AggregationSpec, FormulaExpr, DerivedMetricSpec, TimeGrain, MetricRef, BaseMetricRef, DerivedMetricRef, GrainedMetricRef, MetricContract, MetricFilter, MetricOrderBy, MetricQuery, DatasetQuery, MetricResultMeta, MetricResult, DatasetQueryResult, MetricHandle, ExecutionContext, SemanticExecutionRuntime, SemanticTenantRuntime, SemanticFilterDefinition, SemanticFiltersDefinition, DatasetConfig, DatasetLimits, DatasetInstance, BaseMetricConfig, DerivedMetricConfig, DatasetRegistryInstance, DatasetFieldNames, DatasetPublisher, PublishableMetric, PublishedMetricHandle, PublishedMetricMap, PublishedMetrics, PublishedDataset, PublishedDatasetRegistry, PublishDatasetOptions, } from '@hypequery/datasets';
 export { createMetricEndpoint } from './metric-endpoint.js';
 export { createDatasetEndpoint } from './dataset-endpoint.js';
 export { createSemanticContractEndpoint, buildSemanticContractSource, } from './contract-endpoint.js';

package/dist/semantic/datasets/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/semantic/datasets/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,OAAO,EACP,SAAS,EACT,OAAO,EACP,SAAS,EACT,OAAO,EACP,MAAM,EACN,GAAG,EACH,KAAK,EACL,aAAa,EACb,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,GAAG,EACH,UAAU,EACV,QAAQ,EACR,KAAK,EACL,KAAK,EACL,IAAI,EACJ,EAAE,EACF,GAAG,EACH,EAAE,EACF,GAAG,EACH,EAAE,EACF,GAAG,EACH,MAAM,EACN,SAAS,EACT,OAAO,EACP,IAAI,EACJ,GAAG,EACH,IAAI,EACJ,MAAM,EACN,KAAK,EACL,qBAAqB,GACtB,MAAM,qBAAqB,CAAC;AAE7B,YAAY,EACV,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACtB,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,SAAS,EACT,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,aAAa,EACb,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,wBAAwB,EACxB,qBAAqB,EACrB,wBAAwB,EACxB,yBAAyB,EACzB,aAAa,EACb,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,mBAAmB,EACnB,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EACL,8BAA8B,EAC9B,2BAA2B,GAC5B,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/semantic/datasets/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,OAAO,EACP,SAAS,EACT,OAAO,EACP,SAAS,EACT,OAAO,EACP,MAAM,EACN,GAAG,EACH,KAAK,EACL,aAAa,EACb,GAAG,EACH,GAAG,EACH,GAAG,EACH,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,GAAG,EACH,UAAU,EACV,QAAQ,EACR,KAAK,EACL,KAAK,EACL,IAAI,EACJ,EAAE,EACF,GAAG,EACH,EAAE,EACF,GAAG,EACH,EAAE,EACF,GAAG,EACH,MAAM,EACN,SAAS,EACT,OAAO,EACP,IAAI,EACJ,GAAG,EACH,IAAI,EACJ,MAAM,EACN,KAAK,EACL,qBAAqB,EACrB,eAAe,GAChB,MAAM,qBAAqB,CAAC;AAE7B,YAAY,EACV,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACtB,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,SAAS,EACT,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,aAAa,EACb,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,wBAAwB,EACxB,qBAAqB,EACrB,wBAAwB,EACxB,yBAAyB,EACzB,aAAa,EACb,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,mBAAmB,EACnB,uBAAuB,EACvB,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EAChB,wBAAwB,EACxB,qBAAqB,GACtB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EACL,8BAA8B,EAC9B,2BAA2B,GAC5B,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/semantic/datasets/index.js

@@ -1,5 +1,5 @@
 // Re-export public datasets APIs for convenience
-export { dataset, dimension, measure, belongsTo, hasMany, hasOne, sum, count, countDistinct, avg, min, max, divide, multiply, subtract, add, nullIfZero, coalesce, round, floor, ceil, eq, neq, gt, gte, lt, lte, inList, notInList, between, like, asc, desc, filter, order, createDatasetRegistry, } from '@hypequery/datasets';
+export { dataset, dimension, measure, belongsTo, hasMany, hasOne, sum, count, countDistinct, avg, min, max, divide, multiply, subtract, add, nullIfZero, coalesce, round, floor, ceil, eq, neq, gt, gte, lt, lte, inList, notInList, between, like, asc, desc, filter, order, createDatasetRegistry, publishDatasets, } from '@hypequery/datasets';
 // Serve-specific endpoint integration
 export { createMetricEndpoint } from './metric-endpoint.js';
 export { createDatasetEndpoint } from './dataset-endpoint.js';

package/dist/semantic/datasets/metric-endpoint.d.ts

@@ -8,7 +8,7 @@
  */
 import { z } from 'zod';
 import type { AuthContext, AuthStrategy, MetricEntry, ServeEndpoint, ServeMiddleware, TenantConfigOverride } from '../../types.js';
-import type { DatasetClient, MetricHandle, QueryBuilderFactoryLike } from '@hypequery/datasets';
+import { type DatasetClient, type MetricHandle, type QueryBuilderFactoryLike } from '@hypequery/datasets';
 declare const metricResultSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
     meta: z.ZodOptional<z.ZodObject<{
@@ -44,11 +44,6 @@ declare const metricResultSchema: z.ZodObject<{
         }>>;
     }, "strip", z.ZodTypeAny, {
         tenant?: string | undefined;
-        cache?: {
-            hit: boolean;
-            ageMs?: number | undefined;
-            stale?: boolean | undefined;
-        } | undefined;
         timingMs?: number | undefined;
         sql?: string | undefined;
         rowCount?: number | undefined;
@@ -57,13 +52,13 @@ declare const metricResultSchema: z.ZodObject<{
             offset: number;
             hasMore: boolean;
         } | undefined;
-    }, {
-        tenant?: string | undefined;
         cache?: {
             hit: boolean;
             ageMs?: number | undefined;
             stale?: boolean | undefined;
         } | undefined;
+    }, {
+        tenant?: string | undefined;
         timingMs?: number | undefined;
         sql?: string | undefined;
         rowCount?: number | undefined;
@@ -72,16 +67,16 @@ declare const metricResultSchema: z.ZodObject<{
             offset: number;
             hasMore: boolean;
         } | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    data: Record<string, unknown>[];
-    meta?: {
-        tenant?: string | undefined;
         cache?: {
             hit: boolean;
             ageMs?: number | undefined;
             stale?: boolean | undefined;
         } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    data: Record<string, unknown>[];
+    meta?: {
+        tenant?: string | undefined;
         timingMs?: number | undefined;
         sql?: string | undefined;
         rowCount?: number | undefined;
@@ -90,16 +85,16 @@ declare const metricResultSchema: z.ZodObject<{
             offset: number;
             hasMore: boolean;
         } | undefined;
-    } | undefined;
-}, {
-    data: Record<string, unknown>[];
-    meta?: {
-        tenant?: string | undefined;
         cache?: {
             hit: boolean;
             ageMs?: number | undefined;
             stale?: boolean | undefined;
         } | undefined;
+    } | undefined;
+}, {
+    data: Record<string, unknown>[];
+    meta?: {
+        tenant?: string | undefined;
         timingMs?: number | undefined;
         sql?: string | undefined;
         rowCount?: number | undefined;
@@ -108,6 +103,11 @@ declare const metricResultSchema: z.ZodObject<{
             offset: number;
             hasMore: boolean;
         } | undefined;
+        cache?: {
+            hit: boolean;
+            ageMs?: number | undefined;
+            stale?: boolean | undefined;
+        } | undefined;
     } | undefined;
 }>;
 export declare function resolveMetricEntry<TAuth extends AuthContext>(entry: MetricEntry<TAuth>): {

package/dist/semantic/datasets/metric-endpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metric-endpoint.d.ts","sourceRoot":"","sources":["../../../src/semantic/datasets/metric-endpoint.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EAGZ,WAAW,EACX,aAAa,EACb,eAAe,EACf,oBAAoB,EACrB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAsB,aAAa,EAAkB,YAAY,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AA8BpI,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtB,CAAC;AAyBH,wBAAgB,kBAAkB,CAAC,KAAK,SAAS,WAAW,EAC1D,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,GACxB;IACD,MAAM,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAC/B,IAAI,CAAC,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAClC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,oBAAoB,CAAC,KAAK,CAAC,CAAC;IACrC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,WAAW,CAAC,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,CAAC;IACtD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAUA;AAMD,wBAAgB,oBAAoB,CAAC,KAAK,SAAS,WAAW,EAC5D,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,EACzB,SAAS,EAAE,aAAa,EACxB,qBAAqB,EAAE,uBAAuB,GAC7C,aAAa,CAAC,CAAC,CAAC,UAAU,EAAE,OAAO,kBAAkB,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,CA+GzE"}
+{"version":3,"file":"metric-endpoint.d.ts","sourceRoot":"","sources":["../../../src/semantic/datasets/metric-endpoint.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EAGZ,WAAW,EACX,aAAa,EACb,eAAe,EACf,oBAAoB,EACrB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAGL,KAAK,aAAa,EAElB,KAAK,YAAY,EACjB,KAAK,uBAAuB,EAC7B,MAAM,qBAAqB,CAAC;AA6B7B,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtB,CAAC;AAyBH,wBAAgB,kBAAkB,CAAC,KAAK,SAAS,WAAW,EAC1D,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,GACxB;IACD,MAAM,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAC/B,IAAI,CAAC,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAClC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,oBAAoB,CAAC,KAAK,CAAC,CAAC;IACrC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,WAAW,CAAC,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,CAAC;IACtD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAUA;AAMD,wBAAgB,oBAAoB,CAAC,KAAK,SAAS,WAAW,EAC5D,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,EACzB,SAAS,EAAE,aAAa,EACxB,qBAAqB,EAAE,uBAAuB,GAC7C,aAAa,CAAC,CAAC,CAAC,UAAU,EAAE,OAAO,kBAAkB,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,CAuHzE"}

package/dist/semantic/datasets/metric-endpoint.js

@@ -7,9 +7,9 @@
  * - Returns { data } or { data, meta } based on headers
  */
 import { z } from 'zod';
+import { buildMetricInputSchema, } from '@hypequery/datasets';
 import { ServeHttpError } from '../../errors.js';
 import { resolveSemanticExecutionRuntime, resolveSemanticQueryBuilder, } from '../query-builder-context.js';
-import { buildMetricInputSchema } from './utils/semantic-input-schema.js';
 import { resolveLocalAuthRequirement } from '../../auth-requirement.js';
 // ---------------------------------------------------------------------------
 // Zod schemas for metric query input / output
@@ -62,10 +62,18 @@ export function createMetricEndpoint(name, entry, analytics, defaultBuilderFacto
     // The metric's underlying dataset, used to enumerate valid query fields and
     // page-size defaults.
     const ds = (metricRef.__type === 'metric_ref' ? metricRef.dataset : metricRef.metric.dataset);
-    const metricQueryInputSchema = buildMetricInputSchema(ds, contract.name);
     // Page-size cap, mirroring datasets: clamp (don't reject) and apply a default
     // so a metric query is never unbounded.
     const effectiveMaxLimit = resolved.maxLimit ?? ds.limits?.maxResultSize ?? 1000;
+    const metricQueryInputSchema = buildMetricInputSchema(ds, contract.name, {
+        includeMeta: true,
+        enforceResultLimit: false,
+        maxOffset: undefined,
+        maxDimensions: undefined,
+        maxMeasures: undefined,
+        maxFilters: undefined,
+        maxOrderBy: undefined,
+    }, contract);
     const metadata = {
         path: '', // filled by router.register
         method: 'POST',

package/dist/semantic/datasets/utils/semantic-input-schema.d.ts

@@ -1,107 +1,6 @@
 /**
- * Builds per-dataset / per-metric Zod input schemas whose dimension, measure,
- * filter, and orderBy fields are constrained to the names the semantic
- * validators accept. This upgrades the generated OpenAPI/docs from "array of
- * arbitrary strings" to enumerated fields and enables typed client codegen.
- *
- * The enums are deliberately a *superset-safe* mirror of the runtime validators
- * (`validateDatasetQueryInput` / the metric `validateQuery`): they never reject
- * a field the validator would accept. Where a list would be empty (e.g. a
- * dataset with no declared filters) we fall back to `z.string()` and let the
- * validator produce the precise error, rather than emitting an empty enum.
+ * @deprecated Import these canonical schema builders from
+ * `@hypequery/datasets`. This compatibility module contains no schema logic.
  */
-import { z } from 'zod';
-import { type AnyDatasetInstance } from '@hypequery/datasets';
-/**
- * Input schema for a dataset query endpoint, mirroring
- * `validateDatasetQueryInput`.
- */
-export declare function buildDatasetInputSchema(ds: AnyDatasetInstance): z.ZodObject<{
-    dimensions: z.ZodOptional<z.ZodArray<z.ZodTypeAny, "many">>;
-    measures: z.ZodOptional<z.ZodArray<z.ZodTypeAny, "many">>;
-    filters: z.ZodOptional<z.ZodArray<z.ZodTypeAny, "many">>;
-    orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        field: z.ZodTypeAny;
-        direction: z.ZodEnum<["asc", "desc"]>;
-    }, "strip", z.ZodTypeAny, {
-        direction: "asc" | "desc";
-        field?: any;
-    }, {
-        direction: "asc" | "desc";
-        field?: any;
-    }>, "many">>;
-    limit: z.ZodOptional<z.ZodNumber>;
-    offset: z.ZodOptional<z.ZodNumber>;
-    by: z.ZodOptional<z.ZodTypeAny>;
-    includeMeta: z.ZodOptional<z.ZodBoolean>;
-}, "strict", z.ZodTypeAny, {
-    dimensions?: any[] | undefined;
-    measures?: any[] | undefined;
-    filters?: any[] | undefined;
-    orderBy?: {
-        direction: "asc" | "desc";
-        field?: any;
-    }[] | undefined;
-    limit?: number | undefined;
-    offset?: number | undefined;
-    by?: any;
-    includeMeta?: boolean | undefined;
-}, {
-    dimensions?: any[] | undefined;
-    measures?: any[] | undefined;
-    filters?: any[] | undefined;
-    orderBy?: {
-        direction: "asc" | "desc";
-        field?: any;
-    }[] | undefined;
-    limit?: number | undefined;
-    offset?: number | undefined;
-    by?: any;
-    includeMeta?: boolean | undefined;
-}>;
-/**
- * Input schema for a metric query endpoint, mirroring the metric `validateQuery`.
- * Metrics select a single value, so there is no `measures` field; `orderBy` may
- * reference the metric's own output column (`metricName`).
- */
-export declare function buildMetricInputSchema(ds: AnyDatasetInstance, metricName: string): z.ZodObject<{
-    dimensions: z.ZodOptional<z.ZodArray<z.ZodTypeAny, "many">>;
-    filters: z.ZodOptional<z.ZodArray<z.ZodTypeAny, "many">>;
-    orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        field: z.ZodTypeAny;
-        direction: z.ZodEnum<["asc", "desc"]>;
-    }, "strip", z.ZodTypeAny, {
-        direction: "asc" | "desc";
-        field?: any;
-    }, {
-        direction: "asc" | "desc";
-        field?: any;
-    }>, "many">>;
-    limit: z.ZodOptional<z.ZodNumber>;
-    offset: z.ZodOptional<z.ZodNumber>;
-    by: z.ZodOptional<z.ZodTypeAny>;
-    includeMeta: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    dimensions?: any[] | undefined;
-    filters?: any[] | undefined;
-    orderBy?: {
-        direction: "asc" | "desc";
-        field?: any;
-    }[] | undefined;
-    limit?: number | undefined;
-    offset?: number | undefined;
-    by?: any;
-    includeMeta?: boolean | undefined;
-}, {
-    dimensions?: any[] | undefined;
-    filters?: any[] | undefined;
-    orderBy?: {
-        direction: "asc" | "desc";
-        field?: any;
-    }[] | undefined;
-    limit?: number | undefined;
-    offset?: number | undefined;
-    by?: any;
-    includeMeta?: boolean | undefined;
-}>;
+export { buildDatasetInputSchema, buildMetricInputSchema, } from '@hypequery/datasets';
 //# sourceMappingURL=semantic-input-schema.d.ts.map

package/dist/semantic/datasets/utils/semantic-input-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"semantic-input-schema.d.ts","sourceRoot":"","sources":["../../../../src/semantic/datasets/utils/semantic-input-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAIL,KAAK,kBAAkB,EAExB,MAAM,qBAAqB,CAAC;AAmC7B;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwB7D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BhF"}
+{"version":3,"file":"semantic-input-schema.d.ts","sourceRoot":"","sources":["../../../../src/semantic/datasets/utils/semantic-input-schema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACL,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,qBAAqB,CAAC"}

package/dist/semantic/datasets/utils/semantic-input-schema.js

@@ -1,104 +1,5 @@
 /**
- * Builds per-dataset / per-metric Zod input schemas whose dimension, measure,
- * filter, and orderBy fields are constrained to the names the semantic
- * validators accept. This upgrades the generated OpenAPI/docs from "array of
- * arbitrary strings" to enumerated fields and enables typed client codegen.
- *
- * The enums are deliberately a *superset-safe* mirror of the runtime validators
- * (`validateDatasetQueryInput` / the metric `validateQuery`): they never reject
- * a field the validator would accept. Where a list would be empty (e.g. a
- * dataset with no declared filters) we fall back to `z.string()` and let the
- * validator produce the precise error, rather than emitting an empty enum.
+ * @deprecated Import these canonical schema builders from
+ * `@hypequery/datasets`. This compatibility module contains no schema logic.
  */
-import { z } from 'zod';
-import { getDatasetCatalog, getQueryableRelationshipFields, SEMANTIC_FILTER_OPERATORS, } from '@hypequery/datasets';
-/** An enum over the given field names, or a plain string when none are known. */
-function fieldEnum(values) {
-    const unique = Array.from(new Set(values));
-    return unique.length > 0
-        ? z.enum(unique)
-        : z.string();
-}
-function grainEnum(catalog) {
-    return fieldEnum(catalog.supportedGrains);
-}
-function filterSchema(fieldNames) {
-    return z.object({
-        field: fieldEnum(fieldNames),
-        operator: z.enum(SEMANTIC_FILTER_OPERATORS),
-        value: z.unknown(),
-    });
-}
-function orderBySchema(fieldNames) {
-    return z.object({
-        field: fieldEnum(fieldNames),
-        direction: z.enum(['asc', 'desc']),
-    });
-}
-/** Apply a `.max()` bound only when the dataset declares one. */
-function boundedArray(item, max) {
-    const arr = z.array(item);
-    return (max != null ? arr.max(max) : arr).optional();
-}
-/**
- * Input schema for a dataset query endpoint, mirroring
- * `validateDatasetQueryInput`.
- */
-export function buildDatasetInputSchema(ds) {
-    const catalog = getDatasetCatalog(ds);
-    const dimensionNames = [
-        ...Object.keys(catalog.dimensions),
-        ...getQueryableRelationshipFields(catalog),
-    ];
-    const measureNames = Object.keys(catalog.measures);
-    // Dataset runtime (`validateDatasetQueryInput`) rejects any non-relationship
-    // field not in `catalog.filters`, so mirror that exactly (no dimension fallback).
-    const filterFieldNames = [
-        ...Object.keys(catalog.filters),
-        ...getQueryableRelationshipFields(catalog),
-    ];
-    return z.object({
-        dimensions: boundedArray(fieldEnum(dimensionNames), ds.limits?.maxDimensions),
-        measures: boundedArray(fieldEnum(measureNames), ds.limits?.maxMeasures),
-        filters: boundedArray(filterSchema(filterFieldNames), ds.limits?.maxFilters),
-        orderBy: z.array(orderBySchema(catalog.orderableFields)).optional(),
-        limit: z.number().int().positive().optional(),
-        offset: z.number().int().nonnegative().optional(),
-        by: grainEnum(catalog).optional(),
-        includeMeta: z.boolean().optional(),
-    }).strict();
-}
-/**
- * Input schema for a metric query endpoint, mirroring the metric `validateQuery`.
- * Metrics select a single value, so there is no `measures` field; `orderBy` may
- * reference the metric's own output column (`metricName`).
- */
-export function buildMetricInputSchema(ds, metricName) {
-    const catalog = getDatasetCatalog(ds);
-    const dimensionNames = [
-        ...Object.keys(catalog.dimensions),
-        ...getQueryableRelationshipFields(catalog),
-    ];
-    const orderableNames = [
-        ...dimensionNames,
-        metricName,
-        ...(catalog.timeKey ? ['period'] : []),
-    ];
-    // Metric runtime (`validateQuery`) falls back to all dimensions as valid
-    // filter fields when the dataset declares no filters — mirror that fallback so
-    // the schema never rejects a local-dimension filter the runtime would accept.
-    const declaredFilters = Object.keys(catalog.filters);
-    const filterFieldNames = [
-        ...(declaredFilters.length > 0 ? declaredFilters : Object.keys(catalog.dimensions)),
-        ...getQueryableRelationshipFields(catalog),
-    ];
-    return z.object({
-        dimensions: boundedArray(fieldEnum(dimensionNames), ds.limits?.maxDimensions),
-        filters: boundedArray(filterSchema(filterFieldNames), ds.limits?.maxFilters),
-        orderBy: z.array(orderBySchema(orderableNames)).optional(),
-        limit: z.number().int().positive().optional(),
-        offset: z.number().int().nonnegative().optional(),
-        by: grainEnum(catalog).optional(),
-        includeMeta: z.boolean().optional(),
-    });
-}
+export { buildDatasetInputSchema, buildMetricInputSchema, } from '@hypequery/datasets';

package/dist/server/create-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-api.d.ts","sourceRoot":"","sources":["../../src/server/create-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EAEX,YAAY,EAEZ,gBAAgB,EAIhB,eAAe,EACf,WAAW,EACX,aAAa,EACb,cAAc,EACd,wBAAwB,EACzB,MAAM,aAAa,CAAC;AAkCrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,SAAS,GACpB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,KAAK,SAAS,WAAW,GAAG,WAAW,EACvC,QAAQ,SAAS,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EACxE,QAAQ,SAAS,aAAa,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAC5D,SAAS,SAAS,cAAc,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAE9D,QAAQ,WAAW,CAAC,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,KAClE,YAAY,CACb,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,GACvC,wBAAwB,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,CAAC,EAClE,QAAQ,EACR,KAAK,CAqRN,CAAC"}
+{"version":3,"file":"create-api.d.ts","sourceRoot":"","sources":["../../src/server/create-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EAEX,YAAY,EAEZ,gBAAgB,EAIhB,eAAe,EACf,WAAW,EACX,aAAa,EACb,cAAc,EACd,wBAAwB,EACzB,MAAM,aAAa,CAAC;AAmCrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,SAAS,GACpB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,KAAK,SAAS,WAAW,GAAG,WAAW,EACvC,QAAQ,SAAS,eAAe,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EACxE,QAAQ,SAAS,aAAa,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAC5D,SAAS,SAAS,cAAc,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAE9D,QAAQ,WAAW,CAAC,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,KAClE,YAAY,CACb,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,GACvC,wBAAwB,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,CAAC,EAClE,QAAQ,EACR,KAAK,CAuSN,CAAC"}

package/dist/server/create-api.js

@@ -10,6 +10,7 @@ import { createAPImethods } from "./api-builder.js";
 import { createCacheObservability, detectBuilderCache } from "../cache-observability.js";
 import { createDatasetClient, serializeSemanticContract, toQueryBuilderFactory } from "@hypequery/datasets";
 import { createMetricEndpoint, createDatasetEndpoint, createSemanticContractEndpoint, buildSemanticContractSource, } from "../semantic/datasets/index.js";
+import { attachServeMcpSource } from "./mcp-source.js";
 import { attachSemanticQueryBuilder, extractQueryBuilderFromContext } from "../semantic/query-builder-context.js";
 import { buildProtocolDeploymentContract } from "../protocol-adapter.js";
 const assertSemanticKeyAvailable = (queryEntries, key, kind) => {
@@ -231,6 +232,21 @@ export const createAPI = (config) => {
         getBuilderCache: () => detectBuilderCache(resolvedQueryBuilder),
     });
     const api = createAPImethods(queryEntries, queryLogger, router, authStrategies, globalMiddlewares, executeQuery, handler, basePath, cacheObservability, options => buildProtocolDeploymentContract(config, options), Object.keys(configuredQueries));
+    // Expose the registered datasets to `hypequery mcp`, so the CLI serves the
+    // same semantic model as this entrypoint rather than a second MCP config.
+    if (config.datasets) {
+        const mcpDatasets = buildSemanticContractSource(config.datasets, config.metrics);
+        attachServeMcpSource(api, {
+            datasets: mcpDatasets,
+            resolveAnalytics: () => {
+                if (!resolvedQueryBuilder) {
+                    throw new Error('A query builder is required to execute datasets over MCP. Pass `queryBuilder` '
+                        + 'to defineServe, or expose it as `context.db`.');
+                }
+                return getAnalytics(resolvedQueryBuilder);
+            },
+        });
+    }
     if (openapiConfig.enabled) {
         const openapiEndpoint = createOpenApiEndpoint(openapiConfig.path, () => router.list(), config.openapi);
         router.register(openapiEndpoint);

package/dist/server/mcp-source.d.ts

@@ -0,0 +1,16 @@
+import type { DatasetCatalogSource, DatasetClient } from '@hypequery/datasets';
+export interface ServeMcpSource {
+    readonly version: 1;
+    /** Datasets keyed as registered, with named metrics grouped onto each. */
+    readonly datasets: Readonly<Record<string, DatasetCatalogSource>>;
+    /**
+     * Resolves the shared semantic client. Deferred because the client is only
+     * constructed once a semantic endpoint needs it, and an application with no
+     * configured query builder should fail when MCP starts rather than at import.
+     */
+    readonly resolveAnalytics: () => DatasetClient;
+}
+export declare function attachServeMcpSource(target: object, source: Omit<ServeMcpSource, 'version'>): void;
+/** Read the MCP source off a loaded Serve entrypoint, if it registered datasets. */
+export declare function readServeMcpSource(value: unknown): ServeMcpSource | undefined;
+//# sourceMappingURL=mcp-source.d.ts.map

package/dist/server/mcp-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-source.d.ts","sourceRoot":"","sources":["../../src/server/mcp-source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAa/E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IACpB,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC;IAClE;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,MAAM,aAAa,CAAC;CAChD;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC,GACtC,IAAI,CAWN;AAED,oFAAoF;AACpF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS,CAM7E"}

package/dist/server/mcp-source.js

@@ -0,0 +1,36 @@
+/**
+ * Lets `hypequery mcp` serve an application's datasets from the same
+ * entrypoint local development already uses, instead of asking the author to
+ * maintain a second MCP config that can drift from it.
+ *
+ * Attached under a registered symbol rather than a public property: it is a
+ * build/tooling seam, not part of the API surface an application calls. The
+ * same approach as `attachDeploymentBuildSource`.
+ */
+const mcpSourceSymbol = Symbol.for('hypequery.mcp-source.v1');
+export function attachServeMcpSource(target, source) {
+    Object.defineProperty(target, mcpSourceSymbol, {
+        value: Object.freeze({
+            version: 1,
+            datasets: Object.freeze({ ...source.datasets }),
+            resolveAnalytics: source.resolveAnalytics,
+        }),
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+}
+/** Read the MCP source off a loaded Serve entrypoint, if it registered datasets. */
+export function readServeMcpSource(value) {
+    if (value === null || (typeof value !== 'object' && typeof value !== 'function')) {
+        return undefined;
+    }
+    const source = value[mcpSourceSymbol];
+    return isMcpSource(source) ? source : undefined;
+}
+function isMcpSource(value) {
+    return (typeof value === 'object'
+        && value !== null
+        && value.version === 1
+        && typeof value.resolveAnalytics === 'function');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypequery/serve",
-  "version": "0.16.2",
+  "version": "0.17.1",
   "description": "Code-first TypeScript runtime for validated ClickHouse analytics APIs, OpenAPI, auth, and tenancy",
   "keywords": [
     "clickhouse",
@@ -34,12 +34,12 @@
     "dist"
   ],
   "dependencies": {
-    "@hypequery/protocol": "^0.11.0",
+    "@hypequery/protocol": "^0.13.0",
     "jose": "^5.9.6",
     "openapi-typescript": "^7.13.0",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.5",
-    "@hypequery/datasets": "^0.13.6"
+    "@hypequery/datasets": "^0.15.0"
   },
   "peerDependencies": {
     "tsx": "^4.0.0",