@sequenceholdings/orm 2.11.0 → 2.11.1

package/dist/compiler.d.cts

@@ -5,7 +5,7 @@ export { DynamicInputIssue, DynamicInputResult, NormalizedBoolExp, NormalizedOnC
 export { CompilePolicyInput, CompilePredicateInput, POLICY_COMPARE_OPS, POLICY_MAX_LINK_DEPTH, ParsedPolicy, PolicyAccess, PolicyColumnInfo, PolicyCompareOp, PolicyCompileError, PolicyCompileErrorCode, PolicyLinkInfo, PolicyNode, PolicyOperand, PolicyParseError, PolicyResolver, PolicyTableInfo, assertClaimsOnlyWhen, compilePolicy, compilePredicateV2, parsePolicy, walkPolicy } from './predicate-v2.cjs';
 import { z } from 'zod';
 export { P as PLATFORM_USER_TYPENAME, c as camelCase, g as enumTypeName, p as pascalCase } from './naming-BMZKFO0W.cjs';
-export { S as SqlOperationDefinition, d as defineOperation, s as sqlOperationDefinitionSchema } from './definition-CevES7lM.cjs';
+export { S as SqlOperationDefinition, d as defineOperation, s as sqlOperationDefinitionSchema } from './definition-B99BsOAO.cjs';
 import './constants-D2o0vK6U.cjs';
 import './policy-1iZbGnZZ.cjs';
 
@@ -238,16 +238,13 @@ declare function parseDocuments({ schema, documents, }: {
 
 /** Content hash of the canonical definition — the schema identity ops compile against. */
 declare function computeSchemaHash(canonical: CanonicalDefinition): string;
-interface ClientManifestOperation {
-    opHash: string;
-    kind: 'query' | 'mutation';
-    requires: CompiledOperation['requires'];
-}
-/** What codegen/the client transport needs: name → hash mapping + set identity. */
+/** Registration tripwire: exact compiled contracts, never selector digests.
+ * Public generated client manifests project only kind and capability gates. */
+type ClientManifestOperation = CompiledOperation;
+/** What codegen/the client transport needs: namespace-scoped name, kind and capability contract. */
 interface ClientManifest {
     namespace: string;
     schemaHash: string;
-    opsHash: string;
     operations: Record<string, ClientManifestOperation>;
 }
 interface CompileNamespaceInput {
@@ -287,16 +284,8 @@ declare function flattenOperation({ operation, fragments, }: {
     fragments: ReadonlyMap<string, FragmentDefinitionNode>;
 }): OperationDefinitionNode;
 
-/** Bump on any change to lowering semantics — invalidates every op hash. */
-declare const COMPILER_MAJOR = 1;
 /** Canonical print of one flattened operation (fragments already inlined). */
 declare function canonicalOperationText(definition: OperationDefinitionNode): string;
-declare function computeOpHash({ definition, schemaHash, }: {
-    definition: OperationDefinitionNode;
-    schemaHash: string;
-}): string;
-/** Order-independent set hash over the sorted op hashes. */
-declare function computeOpsHash(opHashes: readonly string[]): string;
 
 /**
  * Restrict pass — the grammar gate that keeps operations inside the v2.0
@@ -721,4 +710,4 @@ declare function projectOperationMetadata({ artifact, operation }: {
     operation: CompiledOperation;
 }): CompiledArtifact;
 
-export { type BuildContextResult, COMPILER_MAJOR, CONST_TRUE, type ClientManifest, type ClientManifestOperation, type CompileContext, type CompileNamespaceInput, type CompileNamespaceResult, type CompilerDiagnostic, DATASET_PREVIEW_LIMIT, DEFAULT_LIMIT, type DiagnosticSeverity, DocumentCompileError, MAX_LIMIT, type MutationOp, type MutationRootInfo, NamespaceCompileError, OBJECT_METADATA_FORMAT, OPERATION_METADATA_FORMAT, type ObjectMetadataProjection, type ObjectSqlBundle, OperationLowerer, PLATFORM_USER_TABLE, type ParseDocumentsResult, type ParsedDocument, type PinnedColumn, type QueryRootInfo, type RestrictedOperation, type SourceDocument, type SqlQueryInput, andPred, bindNamedParameters, buildCompileContext, canonicalOperationText, classifyInputType, collectPinnedColumns, compileBuiltinSqlArtifact, compileDatasetPreviews, compileDefaultOperations, compileNamespace, compileNamespaceOrThrow, compileObjectMetadata, compileOperationDocuments, compileRuntimeSql, composeObjectSqlArtifact, computeOpHash, computeOpsHash, computePinnedColumnsByTable, computeSchemaHash, flattenOperation, generateDefaultOperations, injectPolicies, inputTypeName, isSqlOperationDocument, lowerOperation, mutationRootNames, objectSqlBundleSchema, parseDocuments, parseSdl, platformUserMeta, predContains, predContainsExists, projectOperationMetadata, queryRootNames, referencedSqlObjects, restrictOperation, sqlQueryInputSchema, typeNameForTable, validateManagedViewQueries, walkPred };
+export { type BuildContextResult, CONST_TRUE, type ClientManifest, type ClientManifestOperation, type CompileContext, type CompileNamespaceInput, type CompileNamespaceResult, type CompilerDiagnostic, DATASET_PREVIEW_LIMIT, DEFAULT_LIMIT, type DiagnosticSeverity, DocumentCompileError, MAX_LIMIT, type MutationOp, type MutationRootInfo, NamespaceCompileError, OBJECT_METADATA_FORMAT, OPERATION_METADATA_FORMAT, type ObjectMetadataProjection, type ObjectSqlBundle, OperationLowerer, PLATFORM_USER_TABLE, type ParseDocumentsResult, type ParsedDocument, type PinnedColumn, type QueryRootInfo, type RestrictedOperation, type SourceDocument, type SqlQueryInput, andPred, bindNamedParameters, buildCompileContext, canonicalOperationText, classifyInputType, collectPinnedColumns, compileBuiltinSqlArtifact, compileDatasetPreviews, compileDefaultOperations, compileNamespace, compileNamespaceOrThrow, compileObjectMetadata, compileOperationDocuments, compileRuntimeSql, composeObjectSqlArtifact, computePinnedColumnsByTable, computeSchemaHash, flattenOperation, generateDefaultOperations, injectPolicies, inputTypeName, isSqlOperationDocument, lowerOperation, mutationRootNames, objectSqlBundleSchema, parseDocuments, parseSdl, platformUserMeta, predContains, predContainsExists, projectOperationMetadata, queryRootNames, referencedSqlObjects, restrictOperation, sqlQueryInputSchema, typeNameForTable, validateManagedViewQueries, walkPred };

package/dist/compiler.d.ts

@@ -5,7 +5,7 @@ export { DynamicInputIssue, DynamicInputResult, NormalizedBoolExp, NormalizedOnC
 export { CompilePolicyInput, CompilePredicateInput, POLICY_COMPARE_OPS, POLICY_MAX_LINK_DEPTH, ParsedPolicy, PolicyAccess, PolicyColumnInfo, PolicyCompareOp, PolicyCompileError, PolicyCompileErrorCode, PolicyLinkInfo, PolicyNode, PolicyOperand, PolicyParseError, PolicyResolver, PolicyTableInfo, assertClaimsOnlyWhen, compilePolicy, compilePredicateV2, parsePolicy, walkPolicy } from './predicate-v2.js';
 import { z } from 'zod';
 export { P as PLATFORM_USER_TYPENAME, c as camelCase, g as enumTypeName, p as pascalCase } from './naming-DUk7AcXs.js';
-export { S as SqlOperationDefinition, d as defineOperation, s as sqlOperationDefinitionSchema } from './definition-CevES7lM.js';
+export { S as SqlOperationDefinition, d as defineOperation, s as sqlOperationDefinitionSchema } from './definition-B99BsOAO.js';
 import './constants-D2o0vK6U.js';
 import './policy-1iZbGnZZ.js';
 
@@ -238,16 +238,13 @@ declare function parseDocuments({ schema, documents, }: {
 
 /** Content hash of the canonical definition — the schema identity ops compile against. */
 declare function computeSchemaHash(canonical: CanonicalDefinition): string;
-interface ClientManifestOperation {
-    opHash: string;
-    kind: 'query' | 'mutation';
-    requires: CompiledOperation['requires'];
-}
-/** What codegen/the client transport needs: name → hash mapping + set identity. */
+/** Registration tripwire: exact compiled contracts, never selector digests.
+ * Public generated client manifests project only kind and capability gates. */
+type ClientManifestOperation = CompiledOperation;
+/** What codegen/the client transport needs: namespace-scoped name, kind and capability contract. */
 interface ClientManifest {
     namespace: string;
     schemaHash: string;
-    opsHash: string;
     operations: Record<string, ClientManifestOperation>;
 }
 interface CompileNamespaceInput {
@@ -287,16 +284,8 @@ declare function flattenOperation({ operation, fragments, }: {
     fragments: ReadonlyMap<string, FragmentDefinitionNode>;
 }): OperationDefinitionNode;
 
-/** Bump on any change to lowering semantics — invalidates every op hash. */
-declare const COMPILER_MAJOR = 1;
 /** Canonical print of one flattened operation (fragments already inlined). */
 declare function canonicalOperationText(definition: OperationDefinitionNode): string;
-declare function computeOpHash({ definition, schemaHash, }: {
-    definition: OperationDefinitionNode;
-    schemaHash: string;
-}): string;
-/** Order-independent set hash over the sorted op hashes. */
-declare function computeOpsHash(opHashes: readonly string[]): string;
 
 /**
  * Restrict pass — the grammar gate that keeps operations inside the v2.0
@@ -721,4 +710,4 @@ declare function projectOperationMetadata({ artifact, operation }: {
     operation: CompiledOperation;
 }): CompiledArtifact;
 
-export { type BuildContextResult, COMPILER_MAJOR, CONST_TRUE, type ClientManifest, type ClientManifestOperation, type CompileContext, type CompileNamespaceInput, type CompileNamespaceResult, type CompilerDiagnostic, DATASET_PREVIEW_LIMIT, DEFAULT_LIMIT, type DiagnosticSeverity, DocumentCompileError, MAX_LIMIT, type MutationOp, type MutationRootInfo, NamespaceCompileError, OBJECT_METADATA_FORMAT, OPERATION_METADATA_FORMAT, type ObjectMetadataProjection, type ObjectSqlBundle, OperationLowerer, PLATFORM_USER_TABLE, type ParseDocumentsResult, type ParsedDocument, type PinnedColumn, type QueryRootInfo, type RestrictedOperation, type SourceDocument, type SqlQueryInput, andPred, bindNamedParameters, buildCompileContext, canonicalOperationText, classifyInputType, collectPinnedColumns, compileBuiltinSqlArtifact, compileDatasetPreviews, compileDefaultOperations, compileNamespace, compileNamespaceOrThrow, compileObjectMetadata, compileOperationDocuments, compileRuntimeSql, composeObjectSqlArtifact, computeOpHash, computeOpsHash, computePinnedColumnsByTable, computeSchemaHash, flattenOperation, generateDefaultOperations, injectPolicies, inputTypeName, isSqlOperationDocument, lowerOperation, mutationRootNames, objectSqlBundleSchema, parseDocuments, parseSdl, platformUserMeta, predContains, predContainsExists, projectOperationMetadata, queryRootNames, referencedSqlObjects, restrictOperation, sqlQueryInputSchema, typeNameForTable, validateManagedViewQueries, walkPred };
+export { type BuildContextResult, CONST_TRUE, type ClientManifest, type ClientManifestOperation, type CompileContext, type CompileNamespaceInput, type CompileNamespaceResult, type CompilerDiagnostic, DATASET_PREVIEW_LIMIT, DEFAULT_LIMIT, type DiagnosticSeverity, DocumentCompileError, MAX_LIMIT, type MutationOp, type MutationRootInfo, NamespaceCompileError, OBJECT_METADATA_FORMAT, OPERATION_METADATA_FORMAT, type ObjectMetadataProjection, type ObjectSqlBundle, OperationLowerer, PLATFORM_USER_TABLE, type ParseDocumentsResult, type ParsedDocument, type PinnedColumn, type QueryRootInfo, type RestrictedOperation, type SourceDocument, type SqlQueryInput, andPred, bindNamedParameters, buildCompileContext, canonicalOperationText, classifyInputType, collectPinnedColumns, compileBuiltinSqlArtifact, compileDatasetPreviews, compileDefaultOperations, compileNamespace, compileNamespaceOrThrow, compileObjectMetadata, compileOperationDocuments, compileRuntimeSql, composeObjectSqlArtifact, computePinnedColumnsByTable, computeSchemaHash, flattenOperation, generateDefaultOperations, injectPolicies, inputTypeName, isSqlOperationDocument, lowerOperation, mutationRootNames, objectSqlBundleSchema, parseDocuments, parseSdl, platformUserMeta, predContains, predContainsExists, projectOperationMetadata, queryRootNames, referencedSqlObjects, restrictOperation, sqlQueryInputSchema, typeNameForTable, validateManagedViewQueries, walkPred };

package/dist/compiler.js

@@ -1,6 +1,6 @@
 import { createHash } from 'crypto';
 import { z } from 'zod';
-import { Kind, print, visit, buildSchema, parse, validate, GraphQLObjectType, valueFromASTUntyped, getNamedType, GraphQLScalarType, GraphQLEnumType, GraphQLInputObjectType, GraphQLNonNull, GraphQLList } from 'graphql';
+import { Kind, visit, buildSchema, parse, validate, print, GraphQLObjectType, valueFromASTUntyped, getNamedType, GraphQLScalarType, GraphQLEnumType, GraphQLInputObjectType, GraphQLNonNull, GraphQLList } from 'graphql';
 import { PgParser } from '@supabase/pg-parser';
 
 // src/compiler-gql/artifact.ts
@@ -2135,9 +2135,6 @@ function normalizeCanonical(definition) {
   return normalized;
 }
 
-// src/client/sql.ts
-var BUILTIN_SQL_READ_HASH = "sha256:a50c477c952a5e0fe68ed158a4530e4aab573c09bcbb1a8ac454dc88a39a6258";
-
 // src/ir/index.ts
 var IR_VERSION = 6;
 var LEGACY_IR_VERSION = 1;
@@ -2466,8 +2463,7 @@ var compiledOperationSchema = z.object({
     maxRows: z.number().int().min(1).max(1e4)
   }).strict().optional(),
   irVersion: irVersionSchema,
-  name: z.string(),
-  opHash: z.string().regex(/^sha256:[0-9a-f]{64}$/),
+  name: z.string().regex(/^[_A-Za-z][_0-9A-Za-z]{0,254}$/),
   kind: z.enum(["query", "mutation"]),
   requires: z.object({
     capability: z.string().optional(),
@@ -2483,7 +2479,7 @@ var compiledOperationSchema = z.object({
   }
   if (operation.language === "sql") {
     const validPlan = operation.sqlQuery ? !operation.sql && operation.irVersion === RUNTIME_SQL_IR_VERSION : !!operation.sql && operation.irVersion === SQL_IR_VERSION;
-    const builtin = operation.name === "BuiltinSqlRead" && operation.opHash === BUILTIN_SQL_READ_HASH && operation.requires === null;
+    const builtin = operation.name === "BuiltinSqlRead" && operation.requires === null;
     if (!validPlan || operation.kind !== "query" || operation.roots.length !== 0 || !builtin && !operation.requires?.capability) {
       ctx.addIssue({ code: "custom", message: "SQL operations require a query-only v4 plan or v5 runtime contract, capability, and no GraphQL roots" });
     }
@@ -2498,7 +2494,7 @@ var compiledOperationSchema = z.object({
   }
 });
 var resolvedSourceIrSchema = z.object({
-  name: z.string(),
+  name: z.string().regex(/^[_A-Za-z][_0-9A-Za-z]{0,254}$/),
   kind: z.enum(["manual", "etl", "prefetch"]),
   /** Logical table key of the backing relation. */
   table: z.string(),
@@ -2612,7 +2608,6 @@ var compiledArtifactSchema = z.object({
   ownSchemaHash: z.string().optional(),
   dependencies: z.record(z.string(), z.string()).optional(),
   readPolicies: z.record(z.string(), predIrSchema).optional(),
-  opsHash: z.string(),
   /** Apply-observed synced objects without a serving backing; not part of the authored schema hash. */
   unbackedTables: z.array(z.string()).optional(),
   tables: z.record(z.string(), tableMetaIrSchema),
@@ -4317,24 +4312,6 @@ function flattenOperation({
 }) {
   return { ...operation, selectionSet: flattenSelectionSet(operation.selectionSet, fragments, []) };
 }
-var COMPILER_MAJOR = 1;
-var OP_HASH_DOMAIN = "sequence-orm-op\0";
-var OPS_HASH_DOMAIN = "sequence-orm-opset\0";
-function canonicalOperationText(definition) {
-  const document2 = { kind: Kind.DOCUMENT, definitions: [definition] };
-  return print(document2);
-}
-function computeOpHash({
-  definition,
-  schemaHash
-}) {
-  const digest2 = createHash("sha256").update(OP_HASH_DOMAIN).update(`${COMPILER_MAJOR}\0${schemaHash}\0`).update(canonicalOperationText(definition)).digest("hex");
-  return `sha256:${digest2}`;
-}
-function computeOpsHash(opHashes) {
-  const digest2 = createHash("sha256").update(OPS_HASH_DOMAIN).update([...opHashes].sort().join("\n")).digest("hex");
-  return `sha256:${digest2}`;
-}
 var SOURCE_DIRECTIVES = /* @__PURE__ */ new Set(["prefetch", "writeback", "localOnly"]);
 var fail = (message, code) => {
   throw new DocumentCompileError(message, code);
@@ -5830,7 +5807,6 @@ function compileNamespace({ canonical, sdl, documents }) {
         operations[restricted.name] = {
           irVersion: usesServicePrincipal(roots) ? SERVICE_PRINCIPAL_IR_VERSION : canonical.imports?.length ? COMPOSED_IR_VERSION : roots.some((root) => root.kind === "mutation" && root.assertAffectedRows !== void 0) ? GUARDED_IR_VERSION : LEGACY_IR_VERSION,
           name: restricted.name,
-          opHash: computeOpHash({ definition: flattened, schemaHash }),
           kind: restricted.kind,
           requires: restricted.requires,
           variables: restricted.variables,
@@ -5863,7 +5839,6 @@ function compileNamespace({ canonical, sdl, documents }) {
       dependencies: Object.fromEntries(canonical.imports.map((owner) => [owner.namespace, computeSchemaHash(localContract(owner))]))
     } : {},
     readPolicies: Object.fromEntries(ctx.readPolicies),
-    opsHash: computeOpsHash(Object.values(operations).map((op) => op.opHash)),
     tables: ctx.tables,
     operations
   };
@@ -5871,11 +5846,10 @@ function compileNamespace({ canonical, sdl, documents }) {
   const manifest = {
     namespace: ctx.namespace,
     schemaHash,
-    opsHash: normalized.opsHash,
     operations: Object.fromEntries(
       Object.values(normalized.operations).map((op) => [
         op.name,
-        { opHash: op.opHash, kind: op.kind, requires: op.requires }
+        op
       ])
     )
   };
@@ -6271,6 +6245,10 @@ function validateOnConflictInput({
   }
   return finish(collector, { constraint, updateColumns });
 }
+function canonicalOperationText(definition) {
+  const document2 = { kind: Kind.DOCUMENT, definitions: [definition] };
+  return print(document2);
+}
 
 // src/sdl/generate.ts
 var SdlGenerationError = class extends Error {
@@ -7249,7 +7227,6 @@ function createSqlCatalog({ canonical, publishedObjects, executionTarget }) {
 }
 function createSqlCatalogFromContext({ canonical, publishedObjects, executionTarget, ctx, identity: suppliedIdentity }) {
   if (!publishedObjects.length || new Set(publishedObjects).size !== publishedObjects.length) throw new Error("SQL objects must be explicitly declared and unique");
-  const identity = suppliedIdentity ?? sqlHash(`ontology-sql-v1\0${computeSchemaHash(canonical)}\0${executionTarget}`);
   const logicalNames = new Map(Object.entries(ctx.tables).map(([key, meta]) => [meta, key]));
   const refOf = (meta) => `${meta.namespace ?? canonical.namespace}/${logicalNames.get(meta)}`;
   const definitions = [canonical, ...canonical.imports ?? []];
@@ -7274,7 +7251,7 @@ function createSqlCatalogFromContext({ canonical, publishedObjects, executionTar
     const scan = `SELECT ${projection} FROM ${quoteIdentifier(meta.schema)}.${quoteIdentifier(meta.table)} AS ${quoteIdentifier("p0")} WHERE ${compileStaticPolicySql({ table: meta, predicate: policy, tables: ctx.tables, namespace: canonical.namespace, alias: "p0", onRead: (target) => reads.add(refOf(target)) })}`;
     return { ref, table: meta.table, columns, scan, read: [...reads].sort() };
   });
-  return { identity, objects };
+  return { identity: suppliedIdentity ?? sqlHash(JSON.stringify(["ontology-sql-catalog-v2", executionTarget, objects])), objects };
 }
 
 // src/sql/ast.ts
@@ -7828,20 +7805,10 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
       const catalog = createSqlCatalog({ canonical: input.canonical, publishedObjects: read, executionTarget: "registered-operation" });
       if ("mode" in definition) {
         if (catalog.objects.some((object) => object.read.some((ref) => !read.includes(ref)))) throw new Error("SQL policy accesses an undeclared ontology object");
-        const opHash2 = sqlHash(JSON.stringify([
-          "sequence-runtime-sql-operation-v1",
-          definition.name,
-          definition.namespace,
-          definition.requires.capability,
-          read,
-          catalog.identity,
-          definition.maxRows
-        ]));
         result.artifact.operations[definition.name] = compiledOperationSchema.parse({
           irVersion: RUNTIME_SQL_IR_VERSION,
           language: "sql",
           name: definition.name,
-          opHash: opHash2,
           kind: "query",
           requires: definition.requires,
           variables: [
@@ -7852,7 +7819,7 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
           tableSet: read.map((ref) => ref.split("/")[1]).sort(),
           sqlQuery: { catalog, read, maxRows: definition.maxRows }
         });
-        result.manifest.operations[definition.name] = { opHash: opHash2, kind: "query", requires: definition.requires };
+        result.manifest.operations[definition.name] = result.artifact.operations[definition.name];
         continue;
       }
       const names = Object.keys(definition.parameters).sort();
@@ -7870,20 +7837,10 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
         nullable: !definition.parameters[name2].required,
         list: false
       }));
-      const opHash = sqlHash(JSON.stringify([
-        "sequence-sql-operation-v1",
-        definition.name,
-        definition.namespace,
-        definition.requires.capability,
-        read,
-        variables,
-        plan.queryHash
-      ]));
       const operation = compiledOperationSchema.parse({
         irVersion: SQL_IR_VERSION,
         language: "sql",
         name: definition.name,
-        opHash,
         kind: "query",
         requires: definition.requires,
         variables,
@@ -7892,7 +7849,7 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
         sql: { text: plan.text, columns: plan.columns, parameters: names, read, maxRows: plan.maxRows }
       });
       result.artifact.operations[definition.name] = operation;
-      result.manifest.operations[definition.name] = { opHash, kind: "query", requires: definition.requires };
+      result.manifest.operations[definition.name] = result.artifact.operations[definition.name];
     } catch (error) {
       return { ok: false, diagnostics: [...result.diagnostics, {
         severity: "error",
@@ -7904,8 +7861,6 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
   }
   const required = requiredArtifactIrVersion(Object.values(result.artifact.operations));
   if (required > result.artifact.irVersion) result.artifact.irVersion = required;
-  result.artifact.opsHash = computeOpsHash(Object.values(result.artifact.operations).map((op) => op.opHash));
-  result.manifest.opsHash = result.artifact.opsHash;
   return { ...result, artifact: normalizeIr(result.artifact) };
 }
 async function managedViewDiagnostics(canonical) {
@@ -8004,14 +7959,13 @@ function compileBuiltinSqlArtifact({ namespace, definitions, read, unbackedObjec
     namespace,
     executionTarget,
     read,
-    definitions.map((definition) => [definition.namespace, computeSchemaHash(definition)]).sort()
+    objects
   ])) };
   return normalizeIr({
     irVersion: usesServicePrincipal(policies) ? SERVICE_PRINCIPAL_IR_VERSION : RUNTIME_SQL_IR_VERSION,
     namespace,
     schemaHash: catalog.identity,
     ownSchemaHash: localHash(anchor),
-    opsHash: BUILTIN_SQL_READ_HASH,
     dependencies: Object.fromEntries(definitions.filter((definition) => definition.namespace !== namespace).map((definition) => [definition.namespace, localHash(definition)])),
     tables,
     readPolicies: policies,
@@ -8019,7 +7973,6 @@ function compileBuiltinSqlArtifact({ namespace, definitions, read, unbackedObjec
     operations: { BuiltinSqlRead: {
       irVersion: RUNTIME_SQL_IR_VERSION,
       name: "BuiltinSqlRead",
-      opHash: BUILTIN_SQL_READ_HASH,
       language: "sql",
       kind: "query",
       requires: null,
@@ -8184,13 +8137,11 @@ function composeObjectSqlArtifact({ namespace, bundles }) {
     irVersion: usesServicePrincipal(readPolicies) ? SERVICE_PRINCIPAL_IR_VERSION : RUNTIME_SQL_IR_VERSION,
     namespace,
     schemaHash: identity,
-    opsHash: BUILTIN_SQL_READ_HASH,
     tables,
     readPolicies,
     operations: { BuiltinSqlRead: {
       irVersion: RUNTIME_SQL_IR_VERSION,
       name: "BuiltinSqlRead",
-      opHash: BUILTIN_SQL_READ_HASH,
       language: "sql",
       kind: "query",
       requires: null,
@@ -8204,12 +8155,13 @@ function composeObjectSqlArtifact({ namespace, bundles }) {
     } }
   });
 }
+
+// src/compiler-gql/dataset-previews.ts
 var DATASET_PREVIEW_LIMIT = 100;
 function compileDatasetPreviews(input) {
   const canonical = normalizeCanonical(input);
   const { ctx, diagnostics } = buildCompileContext(canonical);
   if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) throw new NamespaceCompileError(diagnostics);
-  const schemaHash = computeSchemaHash(canonical);
   const operations = {};
   for (const relation of canonicalRelations(canonical)) {
     if (relation.internal || relation.source !== void 0) continue;
@@ -8234,11 +8186,9 @@ function compileDatasetPreviews(input) {
         throw new DocumentCompileError(`object '${meta.namespace}/${table}' is not exported for reads`, "unexported-object");
       }
     }
-    const hash = createHash("sha256").update("sequence-orm-dataset-preview-v1\0").update(stableJson({ schemaHash, roots, tableSet })).digest("hex");
     operations[relation.table] = compiledOperationSchema.parse({
       irVersion: usesServicePrincipal(roots) ? SERVICE_PRINCIPAL_IR_VERSION : canonical.imports?.length ? COMPOSED_IR_VERSION : LEGACY_IR_VERSION,
       name: `DatasetPreview_${relation.table}`,
-      opHash: `sha256:${hash}`,
       kind: "query",
       requires: null,
       variables: [],
@@ -8307,6 +8257,6 @@ function projectOperationMetadata({ artifact, operation }) {
   });
 }
 
-export { COMPILER_MAJOR, CONST_TRUE, DATASET_PREVIEW_LIMIT, DEFAULT_LIMIT, DocumentCompileError, MAX_LIMIT, NamespaceCompileError, OBJECT_METADATA_FORMAT, OPERATION_METADATA_FORMAT, ORDER_BY_DIRECTIONS, OperationLowerer, PLATFORM_USER_TABLE, PLATFORM_USER_TYPENAME, POLICY_COMPARE_OPS, POLICY_MAX_LINK_DEPTH, PolicyCompileError, PolicyParseError, allowedBoolExpOperators, allowedOps, andPred, assertClaimsOnlyWhen, bindNamedParameters, buildCompileContext, camelCase, canonicalOperationText, classifyInputType, collectPinnedColumns, compileBuiltinSqlArtifact, compileDatasetPreviews, compileDefaultOperations, compileNamespace, compileNamespaceOrThrow, compileObjectMetadata, compileOperationDocuments, compilePolicy, compilePredicateV2, compileRuntimeSql, composeObjectSqlArtifact, computeOpHash, computeOpsHash, computePinnedColumnsByTable, computeSchemaHash, defineOperation, enumTypeName, flattenOperation, generateDefaultOperations, injectPolicies, inputTypeName, isSqlOperationDocument, lowerOperation, mutationRootNames, objectSqlBundleSchema, parseDocuments, parsePolicy, parseSdl, pascalCase, platformUserMeta, predContains, predContainsExists, projectOperationMetadata, queryRootNames, referencedSqlObjects, restrictOperation, sqlOperationDefinitionSchema, sqlQueryInputSchema, typeNameForTable, validateAppendInput, validateBoolExpInput, validateInsertInput, validateManagedViewQueries, validateOnConflictInput, validateOrderByInput, validateSelectColumns, validateSetInput, walkPolicy, walkPred };
+export { CONST_TRUE, DATASET_PREVIEW_LIMIT, DEFAULT_LIMIT, DocumentCompileError, MAX_LIMIT, NamespaceCompileError, OBJECT_METADATA_FORMAT, OPERATION_METADATA_FORMAT, ORDER_BY_DIRECTIONS, OperationLowerer, PLATFORM_USER_TABLE, PLATFORM_USER_TYPENAME, POLICY_COMPARE_OPS, POLICY_MAX_LINK_DEPTH, PolicyCompileError, PolicyParseError, allowedBoolExpOperators, allowedOps, andPred, assertClaimsOnlyWhen, bindNamedParameters, buildCompileContext, camelCase, canonicalOperationText, classifyInputType, collectPinnedColumns, compileBuiltinSqlArtifact, compileDatasetPreviews, compileDefaultOperations, compileNamespace, compileNamespaceOrThrow, compileObjectMetadata, compileOperationDocuments, compilePolicy, compilePredicateV2, compileRuntimeSql, composeObjectSqlArtifact, computePinnedColumnsByTable, computeSchemaHash, defineOperation, enumTypeName, flattenOperation, generateDefaultOperations, injectPolicies, inputTypeName, isSqlOperationDocument, lowerOperation, mutationRootNames, objectSqlBundleSchema, parseDocuments, parsePolicy, parseSdl, pascalCase, platformUserMeta, predContains, predContainsExists, projectOperationMetadata, queryRootNames, referencedSqlObjects, restrictOperation, sqlOperationDefinitionSchema, sqlQueryInputSchema, typeNameForTable, validateAppendInput, validateBoolExpInput, validateInsertInput, validateManagedViewQueries, validateOnConflictInput, validateOrderByInput, validateSelectColumns, validateSetInput, walkPolicy, walkPred };
 //# sourceMappingURL=compiler.js.map
 //# sourceMappingURL=compiler.js.map