@malloy-publisher/server 0.5.1 → 0.7.0

package/dist/package_load_worker.mjs

@@ -939,7 +939,7 @@ import os from "os";
 function normalizeModelPath(p) {
   return p.replace(/\\/g, "/").replace(/^\.\//, "");
 }
-var API_PREFIX = "/api/v0", README_NAME = "README.md", PUBLISHER_CONFIG_NAME = "publisher.config.json", PACKAGE_MANIFEST_NAME = "publisher.json", MODEL_FILE_SUFFIX = ".malloy", NOTEBOOK_FILE_SUFFIX = ".malloynb", DEFAULT_QUERY_ROW_LIMIT = 1000, DEFAULT_MAX_QUERY_ROWS = 1e5, DEFAULT_MAX_RESPONSE_BYTES = 50000000, DEFAULT_QUERY_TIMEOUT_MS = 300000, DEFAULT_MAX_CONCURRENT_QUERIES = 32, TEMP_DIR_PATH, PUBLISHER_DATA_DIR = "publisher_data";
+var API_PREFIX = "/api/v0", README_NAME = "README.md", PUBLISHER_CONFIG_NAME = "publisher.config.json", PACKAGE_MANIFEST_NAME = "publisher.json", MODEL_FILE_SUFFIX = ".malloy", NOTEBOOK_FILE_SUFFIX = ".malloynb", INDEX_MODEL_NAME = "index.malloy", DEFAULT_QUERY_ROW_LIMIT = 1000, DEFAULT_MAX_QUERY_ROWS = 1e5, DEFAULT_MAX_RESPONSE_BYTES = 50000000, DEFAULT_QUERY_TIMEOUT_MS = 300000, DEFAULT_MAX_CONCURRENT_QUERIES = 32, TEMP_DIR_PATH, PUBLISHER_DATA_DIR = "publisher_data";
 var init_constants = __esm(() => {
   TEMP_DIR_PATH = os.tmpdir();
 });
@@ -13103,6 +13103,29 @@ var init_errors = __esm(() => {
   };
 });
 
+// src/service/authorize_routes.ts
+function canonicalAuthorizeRoute(route) {
+  switch (route) {
+    case ACCESS_FILTER_ROUTE:
+      return ACCESS_FILTER_ROUTE;
+    case AUTHORIZE_ROUTE:
+      return AUTHORIZE_ROUTE;
+    default:
+      return;
+  }
+}
+var AUTHORIZE_ROUTE = "authorize", ACCESS_FILTER_ROUTE = "access_filter", RECOGNIZED_AUTHORIZE_SPELLINGS, CANONICAL_AUTHORIZE_ROUTES;
+var init_authorize_routes = __esm(() => {
+  RECOGNIZED_AUTHORIZE_SPELLINGS = [
+    ACCESS_FILTER_ROUTE,
+    AUTHORIZE_ROUTE
+  ];
+  CANONICAL_AUTHORIZE_ROUTES = [
+    ACCESS_FILTER_ROUTE,
+    AUTHORIZE_ROUTE
+  ];
+});
+
 // src/service/authorize.ts
 import { payloadOf, routeOf } from "@malloydata/malloy";
 function noteRoute(text) {
@@ -13111,8 +13134,61 @@ function noteRoute(text) {
 function notePayload(text) {
   return payloadOf({ value: text.trimStart() }) ?? "";
 }
+function nearMissRouteNames(route) {
+  switch (route) {
+    case AUTHORIZE_ROUTE:
+      return [
+        "authorize",
+        "source_authorize",
+        "source-authorize",
+        "sourceauthorize",
+        "authorize_source",
+        "authorize-source",
+        "authorizesource"
+      ];
+    case ACCESS_FILTER_ROUTE:
+      return [
+        "access_filter",
+        "access-filter",
+        "accessfilter",
+        "filter_access",
+        "filter-access",
+        "filteraccess",
+        "row_authorize",
+        "row-authorize",
+        "rowauthorize",
+        "authorize_row",
+        "authorize-row",
+        "authorizerow"
+      ];
+    default:
+      return [route];
+  }
+}
+function nearMissWordAlternation(route) {
+  const names = nearMissRouteNames(route);
+  if (names.length === 0) {
+    throw new Error(`No near-miss spellings for authorize route \`${route}\` — an empty ` + "alternation matches every malformed-prefix note, which would " + "fail package loads over annotations nobody wrote.");
+  }
+  return names.map((name) => name.replace(REGEXP_SPECIAL, "\\$&")).join("|");
+}
+function motlyAuthorizePayloadPattern(route) {
+  return new RegExp(`^[ \\t]*[([{<][ \\t]*(?:${nearMissWordAlternation(route)})[ \\t]*[)\\]}>]`, "iu");
+}
+function malformedAuthorizeAttemptPattern(route) {
+  return new RegExp(`^##?\\|?[ \\t]*[([{<]?[ \\t]*(?:${nearMissWordAlternation(route)})`, "iu");
+}
 function authorizeNoteContent(text) {
-  return noteRoute(text) === AUTHORIZE_ROUTE ? notePayload(text) : undefined;
+  const route = canonicalAuthorizeRoute(noteRoute(text));
+  if (route === undefined)
+    return;
+  return { route, content: notePayload(text) };
+}
+function authorizeAnnotationRoute(text) {
+  return authorizeNoteContent(text)?.route;
+}
+function hasCallerAuthorizeAnnotation(callerText) {
+  return AUTHORIZE_ANNOTATION_ANYWHERE.test(callerText);
 }
 function assertNoCallerAuthorizeAnnotation(callerText) {
   if (!AUTHORIZE_ANNOTATION_ANYWHERE.test(callerText))
@@ -13122,37 +13198,59 @@ function assertNoCallerAuthorizeAnnotation(callerText) {
 function containsAuthorizeAnnotationTag(texts) {
   return texts.some((text) => authorizeNoteContent(text) !== undefined);
 }
-function collectAuthorizeNearMisses(texts) {
+function collectAuthorizeNearMisses(texts, route) {
+  const motlyPattern = motlyAuthorizePayloadPattern(route);
+  const malformedPattern = malformedAuthorizeAttemptPattern(route);
+  const nearMissNames = new Set(nearMissRouteNames(route).map((name) => name.toLowerCase()));
   const found = [];
   for (const text of texts) {
     const trimmed = text.trimStart();
-    const route = noteRoute(trimmed);
-    if (route === AUTHORIZE_ROUTE)
+    const noted = noteRoute(trimmed);
+    if (noted === route)
       continue;
-    const nearMiss = route === undefined ? MALFORMED_AUTHORIZE_ATTEMPT.test(trimmed) : route === "" ? MOTLY_AUTHORIZE_PAYLOAD.test(notePayload(trimmed)) : route.toLowerCase() === AUTHORIZE_ROUTE;
+    const nearMiss = noted === undefined ? malformedPattern.test(trimmed) : noted === "" ? motlyPattern.test(notePayload(trimmed)) : nearMissNames.has(noted.toLowerCase());
     if (!nearMiss)
       continue;
     found.push(trimmed.split(/[\r\n]/, 1)[0]);
   }
   return found;
 }
+function collectAuthorizeNearMissesAllRoutes(texts) {
+  const materialized = [...texts];
+  return RECOGNIZED_AUTHORIZE_SPELLINGS.flatMap((route) => collectAuthorizeNearMisses(materialized, route));
+}
+function guessedNearMissRoute(text) {
+  const lower = text.toLowerCase();
+  let best = ACCESS_FILTER_ROUTE;
+  let bestLength = 0;
+  for (const route of RECOGNIZED_AUTHORIZE_SPELLINGS) {
+    for (const name of nearMissRouteNames(route)) {
+      if (lower.includes(name) && name.length > bestLength) {
+        best = route;
+        bestLength = name.length;
+      }
+    }
+  }
+  return best;
+}
 function assertNoAuthorizeNearMisses(found) {
   if (found.length === 0)
     return;
   const unique = [...new Set(found)];
   throw new ModelCompilationError({
-    message: `These annotations are not \`authorize\` gates and nothing enforces ` + `them:
-${unique.map((t) => `  - \`${t}\``).join(`
+    message: `These annotations are never enforced:
+${unique.map((t) => `  - \`${t}\` (meant \`#(${guessedNearMissRoute(t)})\`?)`).join(`
 `)}
-` + `Malloy routes an annotation by its prefix, and only ` + `\`#(authorize)\` (or \`##(authorize)\`, or the block form ` + `\`#|(authorize)\`) reaches the authorize route — a space after the ` + `\`#\`, spaces inside the brackets, or anything trailing the closing ` + `bracket makes it a plain tag Malloy hands to something else. Write ` + `\`#(authorize) <expression>\` on its own line directly above the ` + `\`source:\` statement you mean to protect (unquoted — the quoted ` + `string form is retired). This is refused rather than interpreted: ` + `guessing at the ` + `intent would let publisher start enforcing a filter on a package that ` + `has been serving every row.`
+` + `Malloy routes an annotation by its prefix, and only ` + `\`#(authorize)\` and \`#(access_filter)\` reach an access-control ` + `route (in their \`##\` and ` + `block-form \`#|(...)\` spellings too). A space after the \`#\`, spaces ` + `inside the brackets, a mis-hyphenated or transposed word, or anything ` + `trailing the closing bracket makes it a plain tag Malloy hands to ` + `something else. Write the tag named above, unquoted, on its own line ` + `directly above the \`source:\` statement you mean to protect (the ` + `quoted string form is retired). This is refused rather than ` + `interpreted: guessing at the intent would let publisher start ` + `enforcing a filter on a package that has been serving every row.`
   });
 }
 function describeMisplacedAuthorizeAnnotation(f) {
-  if (f.kind === "query")
-    return `on query "${f.name}"`;
   if (f.kind === "file")
-    return "at the file level (`##(authorize)`)";
-  return `on field "${f.fieldName}" of source "${f.name}"`;
+    return `at the file level (\`##(${f.route})\`)`;
+  const tag = `\`#(${f.route})\``;
+  if (f.kind === "query")
+    return `on query "${f.name}" (${tag})`;
+  return `on field "${f.fieldName}" of source "${f.name}" (${tag})`;
 }
 function assertNoMisplacedAuthorizeAnnotations(found) {
   if (found.length === 0)
@@ -13160,9 +13258,9 @@ function assertNoMisplacedAuthorizeAnnotations(found) {
   const positions = found.map((f) => `  - ${describeMisplacedAuthorizeAnnotation(f)}`).join(`
 `);
   throw new ModelCompilationError({
-    message: `An \`#(authorize)\` annotation is never enforced at:
+    message: `An authorize annotation is never enforced at:
 ${positions}
-` + `A gate only applies where model load looks for one — a \`source:\`'s ` + `own annotation, or one it inherits from an \`extend\`/query-source ` + `base. File-level \`##(authorize)\` is deprecated and no longer ` + `enforced anywhere, so it always lands here: declare \`#(authorize)\` ` + `on each \`source:\` it was meant to protect instead. Every other ` + `position above should move to the \`source:\` statement it is meant ` + `to protect.`
+` + `A gate only applies where model load looks for one — a \`source:\`'s ` + `own annotation, or one it inherits from an \`extend\`/query-source ` + `base. A file-level annotation (\`##(authorize)\` / ` + `\`##(access_filter)\`) is deprecated and no longer enforced ` + `anywhere, so it always lands here: declare the same tag on each ` + `\`source:\` it was meant to protect instead. Every other ` + `position above should move — with the same tag named beside it — ` + `to the \`source:\` statement it is meant ` + `to protect.`
   });
 }
 function referencedGivenNames(expr) {
@@ -13199,7 +13297,7 @@ function liftProbeFilterCondition(prepared, label, filterText) {
   return lifted;
 }
 function gateFilterText(exprs) {
-  return exprs.map((e) => `(${e})`).join(" or ");
+  return exprs.map((e) => `(${e})`).join(" and ");
 }
 async function liftRowLevelCondition(compiler, sourceName, exprs) {
   const filterText = gateFilterText(exprs);
@@ -13209,7 +13307,7 @@ async function liftRowLevelCondition(compiler, sourceName, exprs) {
 async function validateAuthorizeProbes(compiler, options) {
   const ownNotesOf = options.authorizeOwnNotes ?? new Map;
   for (const [sourceName, groups] of options.authorizeMap ?? []) {
-    for (const exprs of groups) {
+    for (const { route, exprs } of groups) {
       if (exprs.length === 0)
         continue;
       let condition;
@@ -13217,17 +13315,17 @@ async function validateAuthorizeProbes(compiler, options) {
         condition = await liftRowLevelCondition(compiler, sourceName, exprs);
       } catch (err) {
         const detail = err instanceof Error ? err.message : String(err);
-        const ownNotes = ownNotesOf.get(sourceName) ?? [];
+        const ownNotes = ownNotesOf.get(sourceName)?.get(route) ?? [];
         if (ownNotes.length === 0) {
           options.onRowLevelGateRejected?.("entry_point_unexpressible");
           options.onRowLevelGateUnexpressible?.(sourceName, detail);
           continue;
         }
         throw new ModelCompilationError({
-          message: `Invalid #(authorize) annotation on source "${sourceName}" ` + `[${exprs.join(" | ")}]: ${detail}`
+          message: `Invalid #(${route}) annotation on source "${sourceName}" ` + `[${exprs.join(" and ")}]: ${detail}`
         });
       }
-      options.onOwnRowLevelConditionCompiled?.(sourceName, condition);
+      options.onOwnRowLevelConditionCompiled?.(sourceName, condition, route);
     }
   }
 }
@@ -13241,59 +13339,41 @@ function unquoteLegacyGatePayload(payload) {
   return trimmed[0] === "'" ? inner.replace(SINGLE_QUOTE_ESCAPE, "$1") : inner.replace(DOUBLE_QUOTE_ESCAPE, "$1");
 }
 function parseAuthorizeAnnotation(annotation) {
-  const content = authorizeNoteContent(annotation);
-  if (content === undefined)
+  const parsed = authorizeNoteContent(annotation);
+  if (parsed === undefined)
     return null;
-  const trimmed = content.trim();
+  const trimmed = parsed.content.trim();
   if (trimmed.length === 0) {
     throw new Error("authorize annotation has an empty expression body");
   }
-  return trimmed;
+  return { route: parsed.route, expr: trimmed };
 }
 function collectAuthorizeExprs(annotations) {
   const exprs = [];
   for (const annotation of annotations) {
-    const expr = parseAuthorizeAnnotation(annotation);
-    if (expr !== null) {
-      exprs.push(expr);
+    const parsed = parseAuthorizeAnnotation(annotation);
+    if (parsed !== null) {
+      exprs.push(parsed);
     }
   }
   return exprs;
 }
-function findMultipleAuthorizeGates(authorizeOwnNotes) {
-  const found = [];
-  for (const [sourceName, notes] of authorizeOwnNotes) {
-    if (notes.length > 1) {
-      found.push({ sourceName, texts: notes.map((note) => note.text) });
-    }
-  }
-  return found;
-}
-function assertAtMostOneAuthorizeGate(found) {
-  if (found.length === 0)
-    return;
-  const positions = found.map(({ sourceName, texts }) => `  - source "${sourceName}" declares ${texts.length}:
-` + texts.map((t) => `      \`${t.trim().split(/[\r\n]/, 1)[0]}\``).join(`
-`)).join(`
-`);
-  throw new ModelCompilationError({
-    message: `A source may declare at most one \`#(authorize)\` annotation:
-${positions}
-` + `Combine multiple conditions into one expression with \`or\` instead of ` + `repeating the annotation, e.g. ` + "`#(authorize) $ROLE = 'admin' or org_id in $GROUPS`."
-  });
+function collectAuthorizeExprsForRoute(annotations, route) {
+  return collectAuthorizeExprs(annotations).filter((e) => e.route === route).map((e) => e.expr);
 }
 function findLegacyStringGates(authorizeOwnNotes) {
   const found = [];
-  for (const [sourceName, notes] of authorizeOwnNotes) {
+  for (const [sourceName, notesByRoute] of authorizeOwnNotes) {
+    const notes = [...notesByRoute.values()].flat();
     const legacyNotes = notes.filter((note) => {
       const content = authorizeNoteContent(note.text);
-      return content !== undefined && isLegacyQuotedPayload(content);
+      return content !== undefined && isLegacyQuotedPayload(content.content);
     });
     if (legacyNotes.length === 0)
       continue;
-    const exprs = collectAuthorizeExprs(legacyNotes.map((note) => note.text));
-    if (exprs.length > 0) {
-      found.push({ sourceName, exprs });
+    const gates = legacyNotes.flatMap((note) => collectAuthorizeExprs([note.text]));
+    if (gates.length > 0) {
+      found.push({ sourceName, gates });
     }
   }
   return found;
@@ -13301,22 +13381,22 @@ function findLegacyStringGates(authorizeOwnNotes) {
 function assertNoLegacyStringGate(found) {
   if (found.length === 0)
     return;
-  const rewrites = found.flatMap(({ sourceName, exprs }) => exprs.map((expr) => `  - source "${sourceName}": replace \`#(authorize) ${expr}\`` + ` with
-      #(authorize) ${unquoteLegacyGatePayload(expr)}`)).join(`
+  const rewrites = found.flatMap(({ sourceName, gates }) => gates.map(({ route, expr }) => `  - source "${sourceName}": replace \`#(${route}) ${expr}\`` + ` with
+      #(${route}) ${unquoteLegacyGatePayload(expr)}`)).join(`
 `);
   throw new ModelCompilationError({
-    message: `The string form of \`#(authorize)\` (a Malloy-quoted expression on ` + `the \`source:\` line) is no longer accepted. Replace it with the ` + `unquoted expression, carried by an \`#(authorize)\` annotation on ` + `its own line directly above the \`source:\` line:
+    message: `The string form of an authorize gate (a Malloy-quoted expression on ` + `the \`source:\` line) is no longer accepted. Replace it with the ` + `unquoted expression, carried by the same annotation on its own line ` + `directly above the \`source:\` line:
 ${rewrites}
 ` + `Test that the rewrite gates the same rows and check the row count ` + `matches what the string form served.`
   });
 }
-var AUTHORIZE_ROUTE = "authorize", AUTHORIZE_TAG_LIKE, AUTHORIZE_ANNOTATION_ANYWHERE, MOTLY_AUTHORIZE_PAYLOAD, MALFORMED_AUTHORIZE_ATTEMPT, GIVEN_REF_PATTERN, SINGLE_QUOTE_ESCAPE, DOUBLE_QUOTE_ESCAPE, STRING_LITERAL_PATTERN, everyMemberOf = () => (...members) => members, ROW_LEVEL_GATE_REJECTION_CAUSES, WHOLE_BODY_QUOTED_STRING, WHOLE_BODY_SINGLE_QUOTED_STRING;
+var AUTHORIZE_TAG_LIKE, AUTHORIZE_ANNOTATION_ANYWHERE, REGEXP_SPECIAL, GIVEN_REF_PATTERN, SINGLE_QUOTE_ESCAPE, DOUBLE_QUOTE_ESCAPE, STRING_LITERAL_PATTERN, everyMemberOf = () => (...members) => members, ROW_LEVEL_GATE_REJECTION_CAUSES, WHOLE_BODY_QUOTED_STRING, WHOLE_BODY_SINGLE_QUOTED_STRING;
 var init_authorize = __esm(() => {
   init_errors();
-  AUTHORIZE_TAG_LIKE = String.raw`##?\|?[ \t]*[([{<]?[ \t]*authorize(?=[)\]}>]|[ \t]|$)`;
+  init_authorize_routes();
+  AUTHORIZE_TAG_LIKE = String.raw`##?\|?[ \t]*[([{<]?[ \t]*(?:(?:(?:row|source)[-_]?)?authorize|access[-_]?filter)(?=[)\]}>]|[ \t]|$)`;
   AUTHORIZE_ANNOTATION_ANYWHERE = new RegExp(AUTHORIZE_TAG_LIKE, "iu");
-  MOTLY_AUTHORIZE_PAYLOAD = /^[ \t]*[([{<][ \t]*authorize[ \t]*[)\]}>]/iu;
-  MALFORMED_AUTHORIZE_ATTEMPT = /^##?\|?[ \t]*[([{<]?[ \t]*authorize/iu;
+  REGEXP_SPECIAL = /[.*+?^${}()|[\]\\]/g;
   GIVEN_REF_PATTERN = /\$([A-Za-z_][A-Za-z0-9_]*)/g;
   SINGLE_QUOTE_ESCAPE = /\\(['\\])/g;
   DOUBLE_QUOTE_ESCAPE = /\\(["\\])/g;
@@ -13341,20 +13421,33 @@ function recordAuthorizeBypass(entryPoint) {
 }
 function recordRowLevelGateDecision(decision) {
   rowLevelDecisionCounter ??= publisherMeter().createCounter("publisher_authorize_row_level_total", {
-    description: "How a row-level `#(authorize)` gate resolved a request. Label: decision ('denied_by_gate'|'empty_after_filter'). 'denied_by_gate' is the fail-closed refusal when the gate could not be applied; 'empty_after_filter' is a successful response with zero rows after the filter matched none, which is NOT an error."
+    description: "How a row-level `#(access_filter)` gate resolved a request. Label: decision ('denied_by_gate'|'empty_after_filter'). 'denied_by_gate' is the fail-closed refusal when the gate could not be applied; 'empty_after_filter' is a successful response with zero rows after the filter matched none, which is NOT an error."
   });
   rowLevelDecisionCounter.add(1, { decision });
 }
 function recordRowLevelGateRejected(cause) {
   rowLevelRejectionCounter ??= publisherMeter().createCounter("publisher_authorize_row_level_rejected_total", {
-    description: "Row-level `#(authorize)` gates that were refused, warned about, or could not be resolved. Label: cause (" + ROW_LEVEL_GATE_REJECTION_CAUSES.map((c) => `'${c}'`).join("|") + "). Only 'legacy_string_gate' fails the whole model load. 'entry_point_unexpressible', 'source_line_gate_no_given_reference' and 'source_line_gate_negated_membership' warn at load and leave the model servable. 'unreachable_given', 'given_usage_unresolvable' and 'unclassifiable_condition' are request-time only — that entry point denies every request. Alert on any nonzero value since the last publish; the request-time causes also make this a rate signal, so see the doc above before writing an alert."
+    description: "Row-level `#(access_filter)` gates that were refused, warned about, or could not be resolved. Label: cause (" + ROW_LEVEL_GATE_REJECTION_CAUSES.map((c) => `'${c}'`).join("|") + "). Only 'legacy_string_gate' fails the whole model load. 'entry_point_unexpressible', 'source_line_gate_no_given_reference' and 'source_line_gate_negated_membership' warn at load and leave the model servable. 'unreachable_given', 'given_usage_unresolvable' and 'unclassifiable_condition' are request-time only — that entry point denies every request. Alert on any nonzero value since the last publish; the request-time causes also make this a rate signal, so see the doc above before writing an alert."
   });
   rowLevelRejectionCounter.add(1, { cause });
 }
-var guardRejectionCounter = null, bypassCounter = null, rowLevelDecisionCounter = null, rowLevelRejectionCounter = null;
+function recordAuthorizeAdmitAllGate(route) {
+  admitAllCounter ??= publisherMeter().createCounter("publisher_authorize_admit_all_total", {
+    description: "Sources declaring their OWN unconditional admit-all gate (`#(authorize) true`), counted once each at package load. Label: route (" + CANONICAL_AUTHORIZE_ROUTES.map((r) => `'${r}'`).join("|") + "). Not an error — `true` is the only spelling for an extension that deliberately re-opens a gated base — but it is the one declaration that turns a gate off, so a jump since the last publish is worth a look."
+  });
+  admitAllCounter.add(1, { route });
+}
+function recordLockDecision(decision) {
+  lockDecisionCounter ??= publisherMeter().createCounter("publisher_authorize_lock_total", {
+    description: "How a `#(authorize)` lock resolved a request. Label: decision ('admitted'|'denied_by_lock'|'denied_unresolvable'). Both denials are a 403; 'denied_by_lock' is the gate refusing a caller it does not admit (routine), 'denied_unresolvable' is the fail-closed refusal when the gate could not be decided at all."
+  });
+  lockDecisionCounter.add(1, { decision });
+}
+var guardRejectionCounter = null, bypassCounter = null, rowLevelDecisionCounter = null, rowLevelRejectionCounter = null, admitAllCounter = null, lockDecisionCounter = null;
 var init_authorize_metrics = __esm(() => {
   init_telemetry();
   init_authorize();
+  init_authorize_routes();
 });
 
 // src/data_styles.ts
@@ -13480,6 +13573,317 @@ function ownLevelNotes(annote) {
 }
 var init_annotations = () => {};
 
+// src/service/authorize_grammar.ts
+import { routeOf as routeOf2 } from "@malloydata/malloy";
+function noteRoute2(text) {
+  return routeOf2({ value: text.trimStart() });
+}
+function splitFieldPathSegments(fieldPath) {
+  const segments = [];
+  let i = 0;
+  while (i < fieldPath.length) {
+    if (fieldPath[i] === "`") {
+      const end = fieldPath.indexOf("`", i + 1);
+      segments.push(fieldPath.slice(i + 1, end));
+      i = end + 1;
+    } else {
+      const dot = fieldPath.indexOf(".", i);
+      const end = dot === -1 ? fieldPath.length : dot;
+      segments.push(fieldPath.slice(i, end));
+      i = end;
+    }
+    if (fieldPath[i] === ".")
+      i++;
+  }
+  return segments;
+}
+function rejectionMessage(sourceName, body, detail) {
+  return `Source "${sourceName}" declares an authorize gate \`${body}\`: ${detail} ` + GRAMMAR_SUMMARY;
+}
+function reject(sourceName, body, cause, detail) {
+  throw new AuthorizeGrammarError(cause, rejectionMessage(sourceName, body, detail));
+}
+function rejectCoherence(sourceName, cause, detail) {
+  throw new AuthorizeGrammarError(cause, `Source "${sourceName}" declares authorize notes whose terms ` + `conflict: ${detail} ${GRAMMAR_SUMMARY}`);
+}
+function splitTerms(body) {
+  const terms = [];
+  const compoundTokens = [];
+  let depth = 0;
+  let quote;
+  let start = 0;
+  let i = 0;
+  while (i < body.length) {
+    const ch = body[i];
+    if (quote) {
+      if (ch === "\\" && quote !== "`") {
+        i += 2;
+        continue;
+      }
+      if (ch === quote)
+        quote = undefined;
+      i++;
+      continue;
+    }
+    if (isQuote(ch)) {
+      quote = ch;
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      depth = Math.max(0, depth - 1);
+      i++;
+      continue;
+    }
+    if (depth === 0) {
+      const wordMatch = /^(and|or|not)\b/i.exec(body.slice(i));
+      if (wordMatch && (i === 0 || !/[A-Za-z0-9_]/.test(body[i - 1]))) {
+        const word = wordMatch[1].toLowerCase();
+        if (word === "and") {
+          terms.push(body.slice(start, i));
+          i += wordMatch[0].length;
+          start = i;
+          continue;
+        }
+        compoundTokens.push(word);
+      }
+    }
+    i++;
+  }
+  terms.push(body.slice(start));
+  return { terms, compoundTokens };
+}
+function isQuote(ch) {
+  return ch === "'" || ch === '"' || ch === "`";
+}
+function findOperatorOutsideQuotes(s, re) {
+  let quote;
+  for (let i = 0;i < s.length; i++) {
+    const ch = s[i];
+    if (quote) {
+      if (ch === "\\" && quote !== "`") {
+        i++;
+        continue;
+      }
+      if (ch === quote)
+        quote = undefined;
+      continue;
+    }
+    if (isQuote(ch)) {
+      quote = ch;
+      continue;
+    }
+    re.lastIndex = i;
+    const m = re.exec(s);
+    if (m && m.index === i)
+      return i;
+  }
+  return -1;
+}
+function parseTerm(sourceName, body, term, givenDeclaredTypes) {
+  const trimmed = term.trim();
+  if (findOperatorOutsideQuotes(trimmed, NEGATED_OPERATOR_RE) !== -1) {
+    reject(sourceName, body, "negated_operator", "`!=` is not allowed.");
+  }
+  if (findOperatorOutsideQuotes(trimmed, COMPARISON_OPERATOR_RE) !== -1) {
+    reject(sourceName, body, "comparison_operator", "only `=` and `in` are allowed, not `<`/`>`/`<=`/`>=`.");
+  }
+  const inIdx = findOperatorOutsideQuotes(trimmed, IN_OPERATOR_RE);
+  const eqIdx = findOperatorOutsideQuotes(trimmed, EQ_OPERATOR_RE);
+  let operator;
+  let opIdx;
+  let opLen;
+  if (inIdx !== -1 && (eqIdx === -1 || inIdx < eqIdx)) {
+    operator = "in";
+    opIdx = inIdx;
+    opLen = 2;
+  } else if (eqIdx !== -1) {
+    operator = "=";
+    opIdx = eqIdx;
+    opLen = 1;
+  } else {
+    reject(sourceName, body, "malformed_body", "no `=` or `in` operator was found.");
+  }
+  let left = trimmed.slice(0, opIdx).trim();
+  let right = trimmed.slice(opIdx + opLen).trim();
+  if (GIVEN_REF_RE.test(left) && STRING_LITERAL_RE.test(right)) {
+    if (operator === "in") {
+      reject(sourceName, body, "reversed_in_operands", `\`${left} in ${right}\` reads $GIVEN in 'literal', which Malloy ` + `rejects as array-in-string membership. Write the literal ` + `first: \`${right} in ${left}\`.`);
+    }
+    [left, right] = [right, left];
+  }
+  const leftIsFieldPath = FIELD_PATH_RE.test(left);
+  const leftIsLiteral = STRING_LITERAL_RE.test(left);
+  if (!leftIsFieldPath && !leftIsLiteral) {
+    reject(sourceName, body, "left_not_field_path", `\`${left}\` is neither a field path nor a string literal — one ` + "side must be a single column, a dotted join path, or a quoted " + "literal, and the other a `$GIVEN`.");
+  }
+  const givenMatch = GIVEN_REF_RE.exec(right);
+  if (!givenMatch) {
+    reject(sourceName, body, "missing_given_reference", `\`${right}\` is not a given reference — a term compares against ` + "`$NAME`.");
+  }
+  const given = givenMatch[1];
+  const declaredType = givenDeclaredTypes.get(given);
+  if (declaredType !== undefined) {
+    const isListType = declaredType === "array" || declaredType.endsWith("[]");
+    if (operator === "=" && isListType) {
+      reject(sourceName, body, "operator_arity_mismatch", `\`$${given}\` is a list-typed given — use \`in\`, not \`=\`.`);
+    }
+    if (operator === "in" && !isListType) {
+      reject(sourceName, body, "operator_arity_mismatch", `\`$${given}\` is a scalar given — use \`=\`, not \`in\`.`);
+    }
+  }
+  if (leftIsLiteral) {
+    return { scope: "source_level", literal: left, given };
+  }
+  return {
+    scope: "row_level",
+    fieldPath: left,
+    fieldPathSegments: splitFieldPathSegments(left),
+    given,
+    operator
+  };
+}
+function assertAuthorizeGrammarTermsCoherent(sourceName, terms) {
+  if (terms.length > 1 && terms.some(({ term }) => term.scope === "deny_all")) {
+    rejectCoherence(sourceName, "deny_all_with_sibling", "an unconditional `false` deny-all cannot be combined with any " + "other authorize note — a deny-all admits nothing, so a " + "sibling note can never change what is served and its " + "presence is very likely a mistake.");
+  }
+  const byRoute = new Map;
+  for (const { term, route } of terms) {
+    if (term.scope === "deny_all")
+      continue;
+    const list = byRoute.get(route);
+    if (list)
+      list.push(term);
+    else
+      byRoute.set(route, [term]);
+  }
+  for (const allRouteTerms of byRoute.values()) {
+    if (allRouteTerms.length > 1 && allRouteTerms.some((t) => t.scope === "admit_all")) {
+      rejectCoherence(sourceName, "admit_all_with_sibling", "an unconditional `true` admit-all cannot be combined with " + "another `#(authorize)` note — the lock's notes AND " + "together, so `true and x` reduces to `x` and the admit-all " + "is dead text. To unlock a base while its rows stay " + "filtered, pair the `true` with `#(access_filter)` instead.");
+    }
+    const routeTerms = allRouteTerms.filter((t) => t.scope !== "admit_all" && t.scope !== "deny_all");
+    const seenGivens = new Set;
+    const seenFieldPaths = new Set;
+    for (const t of routeTerms) {
+      if (seenGivens.has(t.given)) {
+        rejectCoherence(sourceName, "duplicate_given", `\`$${t.given}\` is used by more than one term — a given ` + "can back at most one term per route.");
+      }
+      seenGivens.add(t.given);
+      if (t.scope === "row_level") {
+        const canonicalPath = JSON.stringify(t.fieldPathSegments);
+        if (seenFieldPaths.has(canonicalPath)) {
+          rejectCoherence(sourceName, "duplicate_field_path", `\`${t.fieldPath}\` is used by more than one term.`);
+        }
+        seenFieldPaths.add(canonicalPath);
+      }
+    }
+  }
+}
+function parseAuthorizeGrammarBody(sourceName, body, givenDeclaredTypes, route) {
+  const trimmedBody = body.trim();
+  if (trimmedBody.length === 0) {
+    reject(sourceName, trimmedBody, "empty_body", "the expression body is empty.");
+  }
+  const sentinel = trimmedBody.toLowerCase();
+  if (sentinel === "false" || sentinel === "true") {
+    if (route !== AUTHORIZE_ROUTE) {
+      reject(sourceName, trimmedBody, "sentinel_in_access_filter", `a bare \`${sentinel}\` is not allowed in \`#(access_filter)\` — ` + (sentinel === "false" ? "write `#(authorize) false`, which refuses the caller " + "rather than serving them zero rows." : "it filters nothing; delete the annotation, or write " + "`#(authorize) true` to re-open a locked base."));
+    }
+    return [{ scope: sentinel === "false" ? "deny_all" : "admit_all" }];
+  }
+  const { terms: rawTerms, compoundTokens } = splitTerms(trimmedBody);
+  if (compoundTokens.length > 0) {
+    reject(sourceName, trimmedBody, "compound_boolean", `a compound boolean (\`${compoundTokens[0]}\`) is not allowed — ` + "join terms with `and` only.");
+  }
+  const parsed = rawTerms.map((term) => parseTerm(sourceName, trimmedBody, term, givenDeclaredTypes));
+  const ADMITTED_SCOPE = {
+    [AUTHORIZE_ROUTE]: "source_level",
+    [ACCESS_FILTER_ROUTE]: "row_level"
+  };
+  const admitted = ADMITTED_SCOPE[route];
+  const offending = parsed.find((t) => t.scope !== admitted);
+  if (offending) {
+    const inLock = route === AUTHORIZE_ROUTE;
+    reject(sourceName, trimmedBody, inLock ? "row_level_term_in_authorize" : "source_level_term_in_access_filter", inLock ? "a row-level term (field on the left) is not allowed in " + "`#(authorize)`, which decides whether the caller may reach " + "the source at all — move the term to `#(access_filter)`." : "a source-level term (literal on the left) is not allowed in " + "`#(access_filter)`, which decides which rows a caller may " + "see — move the term to `#(authorize)`, which refuses a " + "caller it does not admit rather than serving them zero rows.");
+  }
+  assertAuthorizeGrammarTermsCoherent(sourceName, parsed.map((term) => ({ term, route })));
+  return parsed;
+}
+function containsRetiredRouteTag(texts) {
+  for (const text of texts) {
+    const route = noteRoute2(text);
+    if (route !== undefined && RETIRED_ROUTES.includes(route)) {
+      return route;
+    }
+  }
+  return;
+}
+function reachesRetiredRouteTagBelow(node, seen = new WeakSet, depth = 0) {
+  if (depth > MAX_RETIRED_ROUTE_WALK_DEPTH) {
+    throw new Error("retired-route IR walk exceeded max depth");
+  }
+  if (node === null || typeof node !== "object")
+    return;
+  if (seen.has(node))
+    return;
+  seen.add(node);
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      const found = reachesRetiredRouteTagBelow(item, seen, depth + 1);
+      if (found)
+        return found;
+    }
+    return;
+  }
+  const record = node;
+  if (depth > 0) {
+    for (const key of ["blockNotes", "notes"]) {
+      const arr = record[key];
+      if (!Array.isArray(arr))
+        continue;
+      const texts = arr.map((n) => typeof n === "string" ? n : n && typeof n === "object" && typeof n.text === "string" ? n.text : undefined).filter((text) => text !== undefined);
+      const found = containsRetiredRouteTag(texts);
+      if (found)
+        return found;
+    }
+  }
+  for (const [key, value] of Object.entries(record)) {
+    if (depth === 0 && key === "annotations")
+      continue;
+    const found = reachesRetiredRouteTagBelow(value, seen, depth + 1);
+    if (found)
+      return found;
+  }
+  return;
+}
+var AuthorizeGrammarError, IDENT = "[A-Za-z_][A-Za-z0-9_]*", QUOTED_IDENT = "`[^`]+`", SEGMENT, FIELD_PATH_RE, GIVEN_REF_RE, STRING_LITERAL_RE, NEGATED_OPERATOR_RE, COMPARISON_OPERATOR_RE, GRAMMAR_SUMMARY, IN_OPERATOR_RE, EQ_OPERATOR_RE, RETIRED_ROUTES, MAX_RETIRED_ROUTE_WALK_DEPTH = 200;
+var init_authorize_grammar = __esm(() => {
+  init_errors();
+  init_authorize_routes();
+  AuthorizeGrammarError = class AuthorizeGrammarError extends ModelCompilationError {
+    rejectionCause;
+    constructor(rejectionCause, message) {
+      super({ message });
+      this.rejectionCause = rejectionCause;
+    }
+  };
+  SEGMENT = `(?:${IDENT}|${QUOTED_IDENT})`;
+  FIELD_PATH_RE = new RegExp(`^${SEGMENT}(?:\\.${SEGMENT})*$`);
+  GIVEN_REF_RE = new RegExp(`^\\$(${IDENT})$`);
+  STRING_LITERAL_RE = /^(?:'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*")$/;
+  NEGATED_OPERATOR_RE = /!=/gu;
+  COMPARISON_OPERATOR_RE = /(?:>=|<=|>|<)/gu;
+  GRAMMAR_SUMMARY = "An authorize gate only accepts one or more `and`-joined terms, each " + "either `<column> <op> $GIVEN` (a single field or a dotted join " + "path on the left) or `'<literal>' in $GIVEN` (a literal on the " + "left), where <op> is fixed by the given's own arity: `in` for a " + "list-typed given, `=` for a scalar one.";
+  IN_OPERATOR_RE = /\bin\b/giu;
+  EQ_OPERATOR_RE = /=/gu;
+  RETIRED_ROUTES = ["partition"];
+});
+
 // src/service/gate_dimension.ts
 import {
   isJoined,
@@ -13544,11 +13948,12 @@ function containsNegatedMembership(node, depth = 0) {
     return containsNegatedMembership(n.e, depth + 1);
   return false;
 }
-function validateSourceLineGateGivenUsage(sourceName, struct, refSummary, conditionExpr, modelDef, onWarning) {
+function validateSourceLineGateGivenUsage(sourceName, route, struct, refSummary, conditionExpr, modelDef, onWarning) {
+  const gate = `#(${route}) gate`;
   const expansion = expandRefSummaryGivenIds(struct, refSummary);
   if (!expansion.ok) {
     throw new ModelCompilationError({
-      message: `#(authorize) on source "${sourceName}" references ` + `"${expansion.unresolvedPath}", which could not be resolved to a ` + `field this model can reach. An unresolvable reference is refused, ` + `not treated as referencing no given`
+      message: `The ${gate} on source "${sourceName}" references ` + `"${expansion.unresolvedPath}", which could not be resolved to a ` + `field this model can reach. An unresolvable reference is refused, ` + `not treated as referencing no given`
     });
   }
   const givenIds = expansion.givenIds;
@@ -13556,15 +13961,15 @@ function validateSourceLineGateGivenUsage(sourceName, struct, refSummary, condit
     const given = modelDef.givens?.[id];
     if (given && (given.default !== undefined || given.defaultText !== undefined)) {
       throw new ModelCompilationError({
-        message: `#(authorize) on source "${sourceName}" references ` + `\`$${given.name}\`, which is declared with a default. A ` + `caller who supplies no value for \`$${given.name}\` gets ` + `that default, which can admit rows the gate was meant to ` + `exclude. Declare \`$${given.name}\` with no default`
+        message: `The ${gate} on source "${sourceName}" references ` + `\`$${given.name}\`, which is declared with a default. A ` + `caller who supplies no value for \`$${given.name}\` gets ` + `that default, which can admit what the gate was meant to ` + `exclude. Declare \`$${given.name}\` with no default`
       });
     }
   }
   if (givenIds.size === 0) {
-    onWarning?.("source_line_gate_no_given_reference", `#(authorize) on source "${sourceName}" references no given; it is ` + `a fixed predicate, not an access rule keyed on the caller`);
+    onWarning?.("source_line_gate_no_given_reference", `The ${gate} on source "${sourceName}" references no given; it is ` + `a fixed predicate, not an access rule keyed on the caller`);
   }
   if (containsNegatedMembership(conditionExpr)) {
-    onWarning?.("source_line_gate_negated_membership", `#(authorize) on source "${sourceName}" negates a membership test; ` + `an empty given then matches every row instead of none`);
+    onWarning?.("source_line_gate_negated_membership", `The ${gate} on source "${sourceName}" negates a membership test; ` + `an empty given then matches everything instead of nothing`);
   }
 }
 var init_gate_dimension = __esm(() => {
@@ -13592,10 +13997,10 @@ function resolveDeclaredSource(struct, modelDef) {
   }
   return sawBrokenEntry ? { kind: "unresolvable" } : { kind: "none" };
 }
-function ancestorGateExprs(struct, modelDef, seen = new Set) {
+function ancestorGateExprs(struct, modelDef, route, seen = new Set) {
   let inherited = struct.annotations?.inherits;
   for (let depth = 0;inherited && depth < ANCESTOR_WALK_MAX_DEPTH; depth++) {
-    const exprs2 = collectAuthorizeExprs(ownLevelNoteTexts(inherited));
+    const exprs2 = collectAuthorizeExprsForRoute(ownLevelNoteTexts(inherited), route);
     if (exprs2.length > 0)
       return exprs2;
     inherited = inherited.inherits;
@@ -13603,15 +14008,17 @@ function ancestorGateExprs(struct, modelDef, seen = new Set) {
   if (inherited)
     return ["false"];
   seen.add(struct);
-  if (seen.size > ANCESTOR_WALK_MAX_DEPTH)
+  if (seen.size > ANCESTOR_WALK_MAX_DEPTH) {
     return ["false"];
+  }
   const declared = resolveDeclaredSource(struct, modelDef);
-  if (declared.kind === "unresolvable")
+  if (declared.kind === "unresolvable") {
     return ["false"];
+  }
   if (declared.kind === "none" || seen.has(declared.source))
     return [];
-  const exprs = collectAuthorizeExprs(ownLevelNoteTexts(declared.source.annotations));
-  return exprs.length > 0 ? exprs : ancestorGateExprs(declared.source, modelDef, seen);
+  const exprs = collectAuthorizeExprsForRoute(ownLevelNoteTexts(declared.source.annotations), route);
+  return exprs.length > 0 ? exprs : ancestorGateExprs(declared.source, modelDef, route, seen);
 }
 function resolveQuerySourceBase(struct, modelDef) {
   const duck = struct;
@@ -13625,8 +14032,8 @@ function resolveCompositeResolvedBase(struct) {
   const duck = struct;
   return duck.type === "query_source" ? duck.query?.compositeResolvedSourceDef : undefined;
 }
-function effectiveAncestorGateExprs(struct, modelDef, seen = new Set) {
-  const direct = ancestorGateExprs(struct, modelDef, new Set(seen));
+function effectiveAncestorGateExprs(struct, modelDef, route, seen = new Set) {
+  const direct = ancestorGateExprs(struct, modelDef, route, new Set(seen));
   if (direct.length > 0)
     return [direct];
   if (seen.has(struct))
@@ -13636,18 +14043,19 @@ function effectiveAncestorGateExprs(struct, modelDef, seen = new Set) {
   const base = resolveQuerySourceBase(struct, modelDef);
   if (!base) {
     const duck = struct;
-    if (duck.type === "query_source")
+    if (duck.type === "query_source") {
       groups.push(["false"]);
+    }
   } else if (!seen.has(base)) {
-    const ownExprs = collectAuthorizeExprs(ownLevelNoteTexts(base.annotations));
-    groups.push(...ownExprs.length > 0 ? [ownExprs] : effectiveAncestorGateExprs(base, modelDef, seen));
+    const ownExprs = collectAuthorizeExprsForRoute(ownLevelNoteTexts(base.annotations), route);
+    groups.push(...ownExprs.length > 0 ? [ownExprs] : effectiveAncestorGateExprs(base, modelDef, route, seen));
   }
   const composite = resolveCompositeResolvedBase(struct);
   if (composite && !seen.has(composite)) {
     const parentOwnNotes = base ? ownLevelNotes(base.annotations) : [];
     const compositeOwnNotes = ownLevelNotes(composite.annotations).filter((note) => !parentOwnNotes.includes(note));
-    const compositeOwn = collectAuthorizeExprs(compositeOwnNotes.map((note) => note.text));
-    groups.push(...compositeOwn.length > 0 ? [compositeOwn] : effectiveAncestorGateExprs(composite, modelDef, seen));
+    const compositeOwn = collectAuthorizeExprsForRoute(compositeOwnNotes.map((note) => note.text), route);
+    groups.push(...compositeOwn.length > 0 ? [compositeOwn] : effectiveAncestorGateExprs(composite, modelDef, route, seen));
   }
   return groups;
 }
@@ -13676,120 +14084,9 @@ var init_gate_registry_walk = __esm(() => {
   init_authorize();
 });
 
-// src/service/partition_annotation.ts
-import { payloadOf as payloadOf2, routeOf as routeOf2 } from "@malloydata/malloy";
-function noteRoute2(text) {
-  return routeOf2({ value: text.trimStart() });
-}
-function containsPartitionAnnotationTag(texts) {
-  return texts.some((text) => noteRoute2(text) === PARTITION_ROUTE);
-}
-function reachesPartitionTagBelow(node, seen = new WeakSet, depth = 0) {
-  if (depth > MAX_PARTITION_IR_WALK_DEPTH) {
-    throw new Error("partition-marker IR walk exceeded max depth");
-  }
-  if (node === null || typeof node !== "object")
-    return false;
-  if (seen.has(node))
-    return false;
-  seen.add(node);
-  if (Array.isArray(node)) {
-    return node.some((item) => reachesPartitionTagBelow(item, seen, depth + 1));
-  }
-  const record = node;
-  if (depth > 0 && record.join !== undefined)
-    return false;
-  if (depth > 0) {
-    for (const key of ["blockNotes", "notes"]) {
-      const arr = record[key];
-      if (!Array.isArray(arr))
-        continue;
-      const texts = arr.map((n) => typeof n === "string" ? n : n && typeof n === "object" && typeof n.text === "string" ? n.text : undefined).filter((text) => text !== undefined);
-      if (containsPartitionAnnotationTag(texts))
-        return true;
-    }
-  }
-  return Object.entries(record).some(([key, value]) => depth === 0 && key === "annotations" ? false : reachesPartitionTagBelow(value, seen, depth + 1));
-}
-function notePayload2(text) {
-  return payloadOf2({ value: text.trimStart() }) ?? "";
-}
-function rejectionMessage(sourceName, body, detail) {
-  return `Source "${sourceName}" declares \`#(partition) ${body}\`: ${detail} ` + `#(partition) only accepts \`<column> = $GIVEN\`, where <column> is a ` + `single field or a dotted join path.`;
-}
-function reject(sourceName, body, cause, detail) {
-  throw new PartitionAnnotationError(cause, rejectionMessage(sourceName, body, detail));
-}
-function parsePartitionAnnotation(sourceName, annotationText) {
-  if (noteRoute2(annotationText) !== PARTITION_ROUTE)
-    return null;
-  const body = notePayload2(annotationText).trim();
-  if (body.length === 0) {
-    reject(sourceName, body, "empty_body", "the expression body is empty.");
-  }
-  if (COMPOUND_BOOLEAN_RE.test(body)) {
-    reject(sourceName, body, "compound_boolean", "a compound boolean (`and`/`or`/`not`) is not allowed — declare one " + "`#(partition)` marker per column.");
-  }
-  if (IN_OPERATOR_RE.test(body)) {
-    reject(sourceName, body, "in_operator", "the `in` operator is not allowed.");
-  }
-  if (NEGATED_OPERATOR_RE.test(body)) {
-    reject(sourceName, body, "negated_operator", "`!=` is not allowed.");
-  }
-  if (COMPARISON_OPERATOR_RE.test(body)) {
-    reject(sourceName, body, "comparison_operator", "only `=` is allowed, not `<`/`>`/`<=`/`>=`.");
-  }
-  const eq = body.indexOf("=");
-  if (eq === -1) {
-    reject(sourceName, body, "malformed_body", "no `=` was found.");
-  }
-  const left = body.slice(0, eq).trim();
-  const right = body.slice(eq + 1).trim();
-  if (!FIELD_PATH_RE.test(left)) {
-    reject(sourceName, body, "left_not_field_path", `\`${left}\` is not a field path — the left side must be a single ` + "column or a dotted join path, not an expression.");
-  }
-  const givenMatch = GIVEN_REF_RE.exec(right);
-  if (!givenMatch) {
-    reject(sourceName, body, "missing_given_reference", `\`${right}\` is not a given reference — the right side must be ` + "`$NAME`.");
-  }
-  return { column: left, given: givenMatch[1] };
-}
-function collectPartitionPairs(sourceName, annotationTexts2) {
-  const pairs = [];
-  const seenGivens = new Map;
-  for (const text of annotationTexts2) {
-    const pair = parsePartitionAnnotation(sourceName, text);
-    if (pair === null)
-      continue;
-    const priorColumn = seenGivens.get(pair.given);
-    if (priorColumn !== undefined) {
-      throw new PartitionAnnotationError("duplicate_given", `Source "${sourceName}" declares \`#(partition)\` on both ` + `\`${priorColumn}\` and \`${pair.column}\` for the same given ` + `\`$${pair.given}\` — a given can back at most one partition ` + `column per source.`);
-    }
-    seenGivens.set(pair.given, pair.column);
-    pairs.push(pair);
-  }
-  return pairs;
-}
-var PARTITION_ROUTE = "partition", MAX_PARTITION_IR_WALK_DEPTH = 200, PartitionAnnotationError, IDENT = "[A-Za-z_][A-Za-z0-9_]*", FIELD_PATH_RE, GIVEN_REF_RE, COMPOUND_BOOLEAN_RE, IN_OPERATOR_RE, NEGATED_OPERATOR_RE, COMPARISON_OPERATOR_RE;
-var init_partition_annotation = __esm(() => {
-  init_errors();
-  PartitionAnnotationError = class PartitionAnnotationError extends ModelCompilationError {
-    rejectionCause;
-    constructor(rejectionCause, message) {
-      super({ message });
-      this.rejectionCause = rejectionCause;
-    }
-  };
-  FIELD_PATH_RE = new RegExp(`^${IDENT}(?:\\.${IDENT})*$`);
-  GIVEN_REF_RE = new RegExp(`^\\$(${IDENT})$`);
-  COMPOUND_BOOLEAN_RE = /\b(and|or|not)\b/i;
-  IN_OPERATOR_RE = /\bin\b/i;
-  NEGATED_OPERATOR_RE = /!=/;
-  COMPARISON_OPERATOR_RE = /(>=|<=|>|<)/;
-});
-
 // src/service/gate_classification.ts
 import {
+  isJoined as isJoined2,
   isSourceDef as isSourceDef3
 } from "@malloydata/malloy";
 function createGateClassificationDeps(givens, modelPath) {
@@ -13799,30 +14096,41 @@ function createGateClassificationDeps(givens, modelPath) {
     modelPath
   };
 }
-function gateExprsForOwnAnnotations(struct, modelDef, excludeNotes = []) {
+function gateExprsForOwnAnnotations(struct, route, modelDef, excludeNotes = []) {
   const ownNotes = ownLevelNotes(struct.annotations).filter((note) => !excludeNotes.includes(note));
   try {
-    const own = collectAuthorizeExprs(ownNotes.map((note) => note.text));
+    const own = collectAuthorizeExprsForRoute(ownNotes.map((note) => note.text), route);
     if (own.length > 0) {
       return { exprs: own, fromAncestor: false };
     }
-    const ancestor = ancestorGateExprs(struct, modelDef);
+    const ancestor = ancestorGateExprs(struct, modelDef, route);
     return { exprs: ancestor, fromAncestor: ancestor.length > 0 };
   } catch {
-    return { exprs: ["false"], fromAncestor: false };
+    return {
+      exprs: ["false"],
+      fromAncestor: false
+    };
   }
 }
 function collectEntryPointGates(struct, modelDef, seen = new Set, treatAsOwnGate = false, entryPointStruct = struct, excludeNotes = []) {
+  const results = [];
+  for (const route of CANONICAL_AUTHORIZE_ROUTES) {
+    results.push(...collectEntryPointGatesForRoute(struct, modelDef, route, new Set(seen), treatAsOwnGate, entryPointStruct, excludeNotes));
+  }
+  return results;
+}
+function collectEntryPointGatesForRoute(struct, modelDef, route, seen, treatAsOwnGate, entryPointStruct, excludeNotes) {
   if (!struct || !modelDef || seen.has(struct))
     return [];
   seen.add(struct);
   const results = [];
   const label = struct.as ?? struct.name;
-  const { exprs: ownExprs, fromAncestor } = gateExprsForOwnAnnotations(struct, modelDef, excludeNotes);
+  const { exprs: ownExprs, fromAncestor } = gateExprsForOwnAnnotations(struct, route, modelDef, excludeNotes);
   if (ownExprs.length > 0) {
     results.push({
       label,
       exprs: ownExprs,
+      route,
       selfContained: fromAncestor || !treatAsOwnGate,
       struct: entryPointStruct
     });
@@ -13831,17 +14139,18 @@ function collectEntryPointGates(struct, modelDef, seen = new Set, treatAsOwnGate
   if (duck.type === "query_source") {
     const base = resolveQuerySourceBase(struct, modelDef);
     if (base) {
-      results.push(...collectEntryPointGates(base, modelDef, seen, false, entryPointStruct));
+      results.push(...collectEntryPointGatesForRoute(base, modelDef, route, seen, false, entryPointStruct, []));
     } else {
       results.push({
         label,
         exprs: ["false"],
+        route,
         selfContained: true
       });
     }
     const resolved = duck.query?.compositeResolvedSourceDef;
     if (resolved) {
-      results.push(...collectEntryPointGates(resolved, modelDef, seen, false, entryPointStruct, base ? ownLevelNotes(base.annotations) : []));
+      results.push(...collectEntryPointGatesForRoute(resolved, modelDef, route, seen, false, entryPointStruct, base ? ownLevelNotes(base.annotations) : []));
     }
   }
   return results;
@@ -13858,7 +14167,7 @@ async function resolveGateShape(entry, originModelDef, graftScope, deps) {
     return { shape: "rejected" };
   }
   const filterText = gateFilterText(entry.exprs);
-  const cacheKey = `${graftScope.cacheScope}\x00${graftTarget}\x00${filterText}`;
+  const cacheKey = `${graftScope.cacheScope}\x00${entry.route}\x00${graftTarget}\x00${filterText}`;
   let cached = deps.gateShapeCache.get(cacheKey);
   if (!cached) {
     let condition;
@@ -13881,7 +14190,11 @@ async function resolveGateShape(entry, originModelDef, graftScope, deps) {
         detail: "this entry's lifted condition carries no usable expression"
       };
     } else if (isBareFalseLiteral(condition.e)) {
-      classification = { shape: "row_level", givenNames: [] };
+      classification = {
+        shape: "row_level",
+        givenNames: [],
+        givenNamesById: new Map
+      };
     } else {
       const targetStruct = graftScope.modelDef.contents[graftTarget];
       if (!isSourceDef3(targetStruct)) {
@@ -13899,7 +14212,13 @@ async function resolveGateShape(entry, originModelDef, graftScope, deps) {
             detail: `this gate references \`${expansion.unresolvedPath}\`, which could not be resolved on the graft target`
           };
         } else {
-          const givenNames = Array.from(expansion.givenIds).map((id) => graftScope.modelDef.givens?.[id]?.name).filter((name) => !!name);
+          const givenNamesById = new Map;
+          for (const id of expansion.givenIds) {
+            const name = graftScope.modelDef.givens?.[id]?.name;
+            if (name)
+              givenNamesById.set(id, name);
+          }
+          const givenNames = Array.from(givenNamesById.values());
           const literalNames = referencedGivenNames(filterText);
           const accountedFor = new Set(givenNames);
           const unaccounted = literalNames.filter((name) => !accountedFor.has(name));
@@ -13910,7 +14229,11 @@ async function resolveGateShape(entry, originModelDef, graftScope, deps) {
               detail: "this gate references a given id that does not resolve to a name on this model"
             };
           } else {
-            classification = { shape: "row_level", givenNames };
+            classification = {
+              shape: "row_level",
+              givenNames,
+              givenNamesById
+            };
           }
         }
       }
@@ -13936,6 +14259,14 @@ async function resolveGateShape(entry, originModelDef, graftScope, deps) {
   if (cached.classification.shape === "rejected") {
     return { shape: "rejected", cause: cached.classification.cause };
   }
+  if (entry.route === AUTHORIZE_ROUTE) {
+    return {
+      shape: "lock",
+      condition: cached.condition,
+      givenNames: cached.classification.givenNames,
+      givenNamesById: cached.classification.givenNamesById
+    };
+  }
   return {
     shape: "row_level",
     graftTarget,
@@ -14018,142 +14349,120 @@ function isBareFalseLiteral(expr) {
 function computeGivenDeclaredTypes(givens) {
   return new Map((givens ?? []).filter((g) => g.name != null && g.type != null).map((g) => [g.name, g.type]));
 }
-function resolveEntryPointPartitions(struct, modelDef, seen = new Set) {
-  if (!struct || !modelDef || seen.has(struct))
-    return [];
-  seen.add(struct);
-  const label = struct.as ?? struct.name;
-  const own = collectPartitionPairs(label, ownLevelNotes(struct.annotations).map((note) => note.text));
-  if (own.length > 0)
-    return own;
-  let inherited = struct.annotations?.inherits;
-  for (let depth = 0;inherited && depth < ANCESTOR_WALK_MAX_DEPTH; depth++) {
-    const pairs = collectPartitionPairs(label, ownLevelNoteTexts(inherited));
-    if (pairs.length > 0)
-      return pairs;
-    inherited = inherited.inherits;
-  }
-  if (inherited)
-    throw unresolvableAncestry(label);
-  const declared = resolveDeclaredSource(struct, modelDef);
-  if (declared.kind === "unresolvable")
-    throw unresolvableAncestry(label);
-  if (declared.kind === "resolved") {
-    const pairs = resolveEntryPointPartitions(declared.source, modelDef, seen);
-    if (pairs.length > 0)
-      return pairs;
-  }
-  const queryBase = resolveQuerySourceBase(struct, modelDef);
-  if (queryBase)
-    return resolveEntryPointPartitions(queryBase, modelDef, seen);
-  return [];
-}
-function unresolvableAncestry(label) {
-  return new PartitionAnnotationError("ancestry_unresolvable", `Could not resolve whether source "${label}" carries a ` + `\`#(partition)\` marker: the derivation chain it inherits from ` + `could not be read. Denying rather than serving unfiltered.`);
-}
-function assertPartitionAnnotationsValid(modelDef) {
+function assertAuthorizeGrammarValid(modelDef, authorizeMap, authorizeOwnNotes, givenDeclaredTypes, onAdmitAllGate, attributedAuthorizeOwnNotes) {
   if (!modelDef)
     return;
-  for (const [key, obj] of Object.entries(modelDef.contents)) {
-    if (!isSourceDef3(obj))
-      continue;
-    const label = obj.as ?? obj.name ?? key;
-    if (obj.type !== "composite") {
-      let resolved = [];
-      try {
-        resolved = resolveEntryPointPartitions(obj, modelDef);
-      } catch (err) {
-        if (!(err instanceof PartitionAnnotationError) || err.rejectionCause !== "ancestry_unresolvable") {
-          throw err;
+  for (const [sourceName, groups] of authorizeMap) {
+    const struct = modelDef.contents[sourceName];
+    const ownGroupTerms = [];
+    const declaredAdmitAllRoutes = [];
+    for (const { route, exprs } of groups) {
+      const isOwn = (authorizeOwnNotes.get(sourceName)?.get(route)?.length ?? 0) > 0;
+      const filteredExprs = exprs.filter((expr) => (isOwn || expr !== "false") && !isLegacyQuotedPayload(expr));
+      const groupTerms = [];
+      for (const expr of filteredExprs) {
+        const terms = parseAuthorizeGrammarBody(sourceName, expr, givenDeclaredTypes, route);
+        for (const term of terms) {
+          groupTerms.push({ term, route });
+          if (term.scope === "admit_all" && (attributedAuthorizeOwnNotes?.get(sourceName)?.get(route)?.length ?? 0) > 0) {
+            declaredAdmitAllRoutes.push(route);
+          }
+          if (term.scope === "row_level" && isSourceDef3(struct)) {
+            assertNoFanoutFieldPath(sourceName, struct, term.fieldPath, term.fieldPathSegments);
+          }
         }
-        continue;
       }
-      assertNoUnreachableMarker(obj, label, resolved);
-      continue;
+      if (isOwn) {
+        ownGroupTerms.push(...groupTerms);
+      } else {
+        assertAuthorizeGrammarTermsCoherent(sourceName, groupTerms);
+      }
     }
-    if (resolveEntryPointPartitions(obj, modelDef).length > 0) {
-      throw new PartitionAnnotationError("partitioned_composite", `Source "${label}" is a composite source (\`compose(...)\`) and ` + `also declares \`#(partition)\` (on itself or an ancestor it ` + `derives from). A composite run target compiles each query ` + `against one resolved member branch, which a partition filter ` + `cannot attach to — declare \`#(partition)\` on a non-composite ` + `source instead.`);
+    if (ownGroupTerms.length > 0) {
+      assertAuthorizeGrammarTermsCoherent(sourceName, ownGroupTerms);
     }
-    const marked = partitionedMemberLabel(obj, modelDef);
-    if (marked !== undefined) {
-      throw new PartitionAnnotationError("partitioned_composite", `Source "${label}" is a composite source (\`compose(...)\`) with ` + `member "${marked}", which declares \`#(partition)\`. MEASURED: ` + `querying the composite reads EVERY partition of that member — ` + `the graft lands on the composite's own struct, not the ` + `resolved member branch, so no filter reaches the executed ` + `query. Remove the composite, or drop \`#(partition)\` from ` + `"${marked}" and expose it as its own source.`);
+    for (const route of declaredAdmitAllRoutes) {
+      onAdmitAllGate?.(sourceName, route);
     }
   }
 }
-function assertNoUnreachableMarker(struct, label, resolved) {
-  if (resolved.length > 0)
-    return;
-  let reachesBelow;
-  try {
-    reachesBelow = reachesPartitionTagBelow(struct);
-  } catch {
-    reachesBelow = true;
-  }
-  if (!reachesBelow)
-    return;
-  throw new PartitionAnnotationError("marker_unreachable", `Source "${label}" carries a \`#(partition)\` marker that is not ` + `declared on the source itself — it sits on a field, a view, or an ` + `inline \`compose(...)\` inside it. Nothing would filter this ` + `source: every caller would read every partition. Move the marker ` + `onto the \`source:\` declaration.`);
-}
-function partitionedMemberLabel(composite, modelDef, seen = new Set) {
-  if (seen.has(composite))
-    return;
-  seen.add(composite);
-  for (const member of composite.sources ?? []) {
-    const label = member.as ?? member.name;
-    if (resolveEntryPointPartitions(member, modelDef).length > 0) {
-      return label;
+function fanoutSegment(struct, path) {
+  let current = struct;
+  for (let i = 0;i < path.length - 1; i++) {
+    const seg = path[i];
+    const field = (current.fields ?? []).find((f) => (f.as ?? f.name) === seg);
+    if (!field)
+      return { segment: seg, reason: "unresolved" };
+    if (isJoined2(field) && field.join !== "one") {
+      return { segment: seg, reason: "fanout" };
     }
-    if (member.type === "composite") {
-      const nested = partitionedMemberLabel(member, modelDef, seen);
-      if (nested !== undefined)
-        return nested;
+    if (!isSourceDef3(field) && field.type !== "record" && field.type !== "array") {
+      return { segment: seg, reason: "unresolved" };
     }
+    current = field;
   }
   return;
 }
-async function resolvePartitionGraftEntries(struct, originModelDef, graftScope, deps) {
-  if (!struct || !originModelDef)
-    return [];
-  const pairs = resolveEntryPointPartitions(struct, originModelDef);
-  if (pairs.length === 0)
-    return [];
-  const label = struct.as ?? struct.name;
-  if (!graftScope) {
-    logger.debug("Partition filter has no graft scope to attach to; denying", { modelPath: deps.modelPath, label });
-    throw new Error(`partition on "${label}" has no graft scope`);
-  }
-  const graftTarget = resolveGraftTarget(struct, originModelDef, graftScope.modelDef);
-  if (!graftTarget) {
-    logger.debug("Partition filter resolved to no graft target; denying", {
-      modelPath: deps.modelPath,
-      label
-    });
-    throw new Error(`partition on "${label}" resolved to no graft target`);
+function assertNoFanoutFieldPath(sourceName, struct, fieldPath, fieldPathSegments) {
+  const finding = fanoutSegment(struct, fieldPathSegments);
+  if (finding === undefined)
+    return;
+  const detail = finding.reason === "fanout" ? `which reaches through \`${finding.segment}\`, a fan-out join ` + `(\`join_many\`/\`join_cross\`, or a repeated record) — the ` + `entry row has many values for what follows, so there is no ` + `single key to compare against a given. Gate on a field reached ` + `only through \`join_one\` joins.` : `whose segment \`${finding.segment}\` does not resolve against ` + `this source — refused rather than assumed safe.`;
+  throw new AuthorizeGrammarError("fanout_path", `Source "${sourceName}" declares an authorize gate on \`${fieldPath}\`, ${detail}`);
+}
+function collectRetiredRouteMarkers(modelDef) {
+  const found = [];
+  if (!modelDef)
+    return found;
+  const fileMatch = containsRetiredRouteTag(ownLevelNoteTexts(modelAnnotations(modelDef)));
+  if (fileMatch) {
+    found.push(`the model itself declares a retired \`##(${fileMatch})\` annotation`);
   }
-  const entries = [];
-  for (const pair of pairs) {
-    if (!deps.givenDeclaredTypes.has(pair.given)) {
-      logger.warn("Partition references a given off the model surface; denying", { modelPath: deps.modelPath, graftTarget, givenName: pair.given });
-      throw new Error(`partition on "${label}" references \`$${pair.given}\`, which is not on this model's given surface`);
+  for (const [key, obj] of Object.entries(modelDef.contents)) {
+    const isQuery = obj.type === "query";
+    if (!isSourceDef3(obj) && !isQuery)
+      continue;
+    const label = obj.as ?? obj.name ?? key;
+    const noun = isQuery ? "query" : "source";
+    const ownMatch = containsRetiredRouteTag(annotationTexts(obj.annotations) ?? []);
+    if (ownMatch) {
+      found.push(`${noun} "${label}" declares a retired \`#(${ownMatch})\` annotation`);
+      continue;
+    }
+    if (isQuery) {
+      continue;
+    }
+    let belowMatch;
+    try {
+      belowMatch = reachesRetiredRouteTagBelow(obj);
+    } catch {
+      belowMatch = RETIRED_ROUTES[0];
+    }
+    if (belowMatch) {
+      found.push(`source "${label}" carries a retired \`#(${belowMatch})\` ` + `annotation somewhere in its IR (not on the source line itself)`);
     }
-    const filterText = `${pair.column} = $${pair.given}`;
-    const condition = await liftGateCondition(graftTarget, filterText, graftScope.materializer);
-    entries.push({
-      label,
-      graftTarget,
-      filterText,
-      condition,
-      givenNames: [pair.given]
-    });
   }
-  return entries;
+  return found;
+}
+function assertNoRetiredRouteMarkers(found) {
+  if (found.length === 0)
+    return;
+  throw new ModelCompilationError({
+    message: `These sources carry a marker from a retired annotation route:
+` + `${found.map((f) => `  - ${f}`).join(`
+`)}
+` + `The route is no longer enforced by anything, so Malloy would ` + `otherwise parse it, load the model clean, and serve every row as ` + `if the marker were never written. Remove the annotation.`
+  });
 }
 var init_gate_classification = __esm(() => {
+  init_errors();
   init_logger();
   init_annotations();
   init_authorize();
+  init_authorize_grammar();
+  init_authorize_routes();
   init_gate_dimension();
   init_gate_registry_walk();
-  init_partition_annotation();
 });
 
 // src/service/filter.ts
@@ -14350,7 +14659,7 @@ var init_filter = __esm(() => {
 
 // src/service/source_extraction.ts
 import {
-  isJoined as isJoined2,
+  isJoined as isJoined3,
   isSourceDef as isSourceDef4,
   modelDefToModelInfo
 } from "@malloydata/malloy";
@@ -14404,7 +14713,7 @@ function extractSourcesFromModelDef(modelDef, givens, onParseError) {
         considerNoteOwner(authorizeNoteDeclaredBy, note, struct);
       }
     }
-    nearMissAuthorize.push(...collectAuthorizeNearMisses([
+    nearMissAuthorize.push(...collectAuthorizeNearMissesAllRoutes([
       ...ownLevelNotes(struct.annotations),
       ...struct.fields.flatMap((field) => ownLevelNotes(field.annotations))
     ].map((note) => note.text)));
@@ -14422,23 +14731,29 @@ function extractSourcesFromModelDef(modelDef, givens, onParseError) {
         considerNoteOwner(authorizeNoteDeclaredBy, note, entry);
       }
     }
-    nearMissAuthorize.push(...collectAuthorizeNearMisses(ownLevelNotes(entry.annotations).map((note) => note.text)));
+    nearMissAuthorize.push(...collectAuthorizeNearMissesAllRoutes(ownLevelNotes(entry.annotations).map((note) => note.text)));
   }
   for (const struct of derivedStructsReachable(sweptStructs, modelDef)) {
-    nearMissAuthorize.push(...collectAuthorizeNearMisses([
+    nearMissAuthorize.push(...collectAuthorizeNearMissesAllRoutes([
       ...ownLevelNotes(struct.annotations),
       ...struct.fields.flatMap((field) => ownLevelNotes(field.annotations))
     ].map((note) => note.text)));
   }
   {
     const folded = modelAnnotations(modelDef);
-    nearMissAuthorize.push(...collectAuthorizeNearMisses([...folded.notes ?? [], ...folded.blockNotes ?? []].map((note) => note.text)));
+    nearMissAuthorize.push(...collectAuthorizeNearMissesAllRoutes([...folded.notes ?? [], ...folded.blockNotes ?? []].map((note) => note.text)));
   }
   assertNoAuthorizeNearMisses(nearMissAuthorize);
   const authorizeOwnNotes = new Map;
   const attributedAuthorizeOwnNotes = new Map;
-  if (containsAuthorizeAnnotationTag((modelAnnotations(modelDef).notes ?? []).map((note) => note.text))) {
-    misplacedAuthorize.push({ kind: "file" });
+  {
+    const fileNoteTexts = ownLevelNoteTexts(modelAnnotations(modelDef));
+    if (containsAuthorizeAnnotationTag(fileNoteTexts)) {
+      misplacedAuthorize.push({
+        kind: "file",
+        route: fileNoteTexts.map((text) => authorizeAnnotationRoute(text)).find((r) => r !== undefined) ?? ACCESS_FILTER_ROUTE
+      });
+    }
   }
   const sources = Object.values(modelDef.contents).filter((obj) => isSourceDef4(obj)).map((sourceObj) => {
     const struct = sourceObj;
@@ -14477,17 +14792,32 @@ function extractSourcesFromModelDef(modelDef, givens, onParseError) {
       }
     }
     const ownNotes = ownLevelNoteTexts(struct.annotations);
-    const ownGates = collectAuthorizeExprs(ownNotes);
     const ownAuthorizeNotes = ownLevelNotes(struct.annotations).filter((note) => containsAuthorizeAnnotationTag([note.text]));
-    authorizeOwnNotes.set(sourceName, ownAuthorizeNotes);
-    attributedAuthorizeOwnNotes.set(sourceName, ownAuthorizeNotes.filter((note) => authorizeNoteDeclaredBy.get(note) === struct));
-    const inheritedGroups = ownGates.length === 0 ? effectiveAncestorGateExprs(struct, modelDef) : [];
-    const effectiveGroups = ownGates.length > 0 ? [ownGates] : inheritedGroups;
-    let authorize;
-    if (effectiveGroups.length > 0) {
-      authorizeMap.set(sourceName, effectiveGroups);
-      authorize = effectiveGroups.flat();
-    }
+    const ownNotesByRoute = new Map;
+    const attributedOwnNotesByRoute = new Map;
+    for (const route of CANONICAL_AUTHORIZE_ROUTES) {
+      const notesForRoute = ownAuthorizeNotes.filter((note) => authorizeAnnotationRoute(note.text) === route);
+      ownNotesByRoute.set(route, notesForRoute);
+      attributedOwnNotesByRoute.set(route, notesForRoute.filter((note) => authorizeNoteDeclaredBy.get(note) === struct));
+    }
+    authorizeOwnNotes.set(sourceName, ownNotesByRoute);
+    attributedAuthorizeOwnNotes.set(sourceName, attributedOwnNotesByRoute);
+    const groupsForSource = [];
+    const routeGroupsByRoute = new Map;
+    for (const route of CANONICAL_AUTHORIZE_ROUTES) {
+      const ownExprsForRoute = collectAuthorizeExprsForRoute(ownNotes, route);
+      const groupsForRoute = ownExprsForRoute.length > 0 ? [ownExprsForRoute] : effectiveAncestorGateExprs(struct, modelDef, route);
+      for (const exprs of groupsForRoute) {
+        groupsForSource.push({ route, exprs });
+      }
+      routeGroupsByRoute.set(route, groupsForRoute);
+    }
+    if (groupsForSource.length > 0) {
+      authorizeMap.set(sourceName, groupsForSource);
+    }
+    const routeGroupsToFlatWire = (groups) => groups && groups.length > 0 ? groups.flat() : undefined;
+    const authorize = routeGroupsToFlatWire(routeGroupsByRoute.get(AUTHORIZE_ROUTE));
+    const accessFilter = routeGroupsToFlatWire(routeGroupsByRoute.get(ACCESS_FILTER_ROUTE));
     const views = struct.fields.filter((field) => field.type === "turtle").filter((turtle) => turtle.pipeline.map((stage) => stage.type).every((type) => type === "reduce")).map((turtle) => ({
       name: turtle.as || turtle.name,
       annotations: annotationTexts(turtle.annotations)
@@ -14500,7 +14830,7 @@ function extractSourcesFromModelDef(modelDef, givens, onParseError) {
         continue;
       }
       const fieldName = field.as || field.name;
-      if (isJoined2(field) && isSourceDef4(field)) {
+      if (isJoined3(field) && isSourceDef4(field)) {
         const joinedStruct = field;
         if (joinFieldNamesUnresolvableDeclaration(joinedStruct, modelDef)) {
           continue;
@@ -14508,14 +14838,16 @@ function extractSourcesFromModelDef(modelDef, givens, onParseError) {
         misplacedAuthorize.push({
           kind: "field",
           name: sourceName,
-          fieldName
+          fieldName,
+          route: fieldAuthorizeNotes.map((note) => authorizeAnnotationRoute(note.text)).find((r) => r !== undefined) ?? ACCESS_FILTER_ROUTE
         });
         continue;
       }
       misplacedAuthorize.push({
         kind: "field",
         name: sourceName,
-        fieldName
+        fieldName,
+        route: fieldAuthorizeNotes.map((note) => authorizeAnnotationRoute(note.text)).find((r) => r !== undefined) ?? ACCESS_FILTER_ROUTE
       });
     }
     return {
@@ -14524,7 +14856,8 @@ function extractSourcesFromModelDef(modelDef, givens, onParseError) {
       views,
       filters,
       givens,
-      authorize
+      authorize,
+      accessFilter
     };
   });
   return {
@@ -14541,7 +14874,8 @@ function extractQueriesFromModelDef(modelDef) {
   const namedQueries = Object.values(modelDef.contents).filter(isNamedQuery);
   const misplacedAuthorize = namedQueries.filter((queryObj) => containsAuthorizeAnnotationTag(ownLevelNoteTexts(queryObj.annotations))).map((queryObj) => ({
     kind: "query",
-    name: queryObj.as || queryObj.name
+    name: queryObj.as || queryObj.name,
+    route: ownLevelNoteTexts(queryObj.annotations).map((text) => authorizeAnnotationRoute(text)).find((r) => r !== undefined) ?? ACCESS_FILTER_ROUTE
   }));
   const queries = namedQueries.map((queryObj) => ({
     name: queryObj.as || queryObj.name,
@@ -14553,6 +14887,7 @@ function extractQueriesFromModelDef(modelDef) {
 var init_source_extraction = __esm(() => {
   init_annotations();
   init_authorize();
+  init_authorize_routes();
   init_filter();
   init_gate_registry_walk();
 });
@@ -14918,7 +15253,13 @@ function collectGivenRefs(value, into) {
   for (const child of Object.values(node))
     collectGivenRefs(child, into);
 }
-function suggestGivenLookup(modelDef, authorizeBySource, surfaced) {
+function gateGivenSource(sources, name) {
+  const source = sources.find((candidate) => candidate.name === name);
+  if (!source)
+    return;
+  return [...source.authorize ?? [], ...source.accessFilter ?? []];
+}
+function suggestGivenLookup(modelDef, gatesBySource, surfaced) {
   const registry = modelDef.givens ?? {};
   const bySource = new Map;
   const byQuery = new Map;
@@ -14927,7 +15268,7 @@ function suggestGivenLookup(modelDef, authorizeBySource, surfaced) {
       const name = obj.as || obj.name;
       const refs = new Set;
       collectGivenRefs(obj.filterList, refs);
-      for (const expr of authorizeBySource(name) ?? []) {
+      for (const expr of gatesBySource(name) ?? []) {
         for (const given of referencedGivenNames(expr))
           refs.add(given);
       }
@@ -15028,6 +15369,7 @@ import { parentPort, threadId } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
 
 // src/service/package_manifest.ts
+init_constants();
 var FRESHNESS_FALLBACKS = ["live", "stale_ok", "fail"];
 var PACKAGE_SCOPES = ["version", "package"];
 function parsePackageScope(raw) {
@@ -15155,6 +15497,48 @@ function materializationWithQueryMetadata(parsed, queryMetadataRaw) {
 function queryMetadataParseWarnings(raw, home = "root") {
   return parseQueryMetadata(raw, QUERY_METADATA_HOME_LABELS[home]).warnings;
 }
+function resolveExplores(input) {
+  const { declaredExplores, declaredQueryableSources, modelPaths } = input;
+  const hasIndexModel = modelPaths.includes(INDEX_MODEL_NAME);
+  const warnings = [];
+  if (declaredExplores !== undefined && !(Array.isArray(declaredExplores) && declaredExplores.every((entry) => typeof entry === "string"))) {
+    throw new Error(`Invalid "explores" in publisher.json: expected an array of model ` + `paths, got ${JSON.stringify(declaredExplores)}. The package is ` + `not served, because ignoring the key would publish every source ` + `it was meant to withhold. Fix: "explores": ` + `["${INDEX_MODEL_NAME}"], or delete the key to use a root ` + `"${INDEX_MODEL_NAME}" instead.`);
+  }
+  const declared = Array.isArray(declaredExplores) ? declaredExplores.map((entry) => normalizeModelPath(entry)) : undefined;
+  if (declaredQueryableSources !== undefined && declaredQueryableSources !== "all") {
+    warnings.push(QUERYABLE_SOURCES_DEPRECATION);
+  }
+  if (declared !== undefined) {
+    if (declared.length === 0 && !hasIndexModel) {
+      warnings.push(EXPLORES_EMPTY_IS_UNCURATED);
+    } else if (declared.length === 0) {
+      warnings.push(EXPLORES_EMPTY_SUPPRESSES_CONVENTION);
+    } else if (declared.length === 1) {
+      warnings.push(EXPLORES_DEPRECATION);
+    }
+    if (hasIndexModel && declared.length > 0) {
+      if (!declared.includes(INDEX_MODEL_NAME)) {
+        warnings.push(exploresOmitsIndexModel(declared));
+      }
+    }
+    return { explores: declared, warnings };
+  }
+  if (!hasIndexModel) {
+    return { explores: undefined, warnings };
+  }
+  if (modelPaths.some((modelPath) => modelPath.endsWith(MODEL_FILE_SUFFIX) && modelPath !== INDEX_MODEL_NAME)) {
+    warnings.push(INDEX_MODEL_IS_THE_SURFACE);
+  }
+  return { explores: [INDEX_MODEL_NAME], warnings };
+}
+var INDEX_MODEL_IS_THE_SURFACE = `This package has a root "${INDEX_MODEL_NAME}" and no "explores" in ` + `publisher.json, so that file is its published surface: only it is listed, ` + `and sources it does not "export { ... }" are refused by name with a 404. ` + `Other models still compile and are still importable and joinable. If that ` + `is intended, nothing to do. If this package is not meant to be curated, ` + `add "explores": [] to publisher.json, which keeps every model listed and ` + `queryable. Do NOT rename or delete the file to opt out: that widens the ` + `surface silently and breaks every import that names it.`;
+function exploresOmitsIndexModel(declared) {
+  return `This package has an "${INDEX_MODEL_NAME}" but its publisher.json ` + `"explores" does not list it (${JSON.stringify(declared)}). The ` + `explicit key wins, so "${INDEX_MODEL_NAME}" is neither listed nor ` + `queryable. If that is intended, rename the file to silence this. If you ` + `meant it to be the package's entry point, delete "explores" and let the ` + `convention use it, or add it to the list.`;
+}
+var EXPLORES_DEPRECATION = `"explores" in publisher.json is deprecated: put an "${INDEX_MODEL_NAME}" ` + `at the package root that imports your models and "export { ... }"s what ` + `you publish, then delete the key. The file is the surface, it is checked ` + `by the compiler rather than by a path list, and it curates and enforces ` + `exactly as the key does. The key still works and is not going away in this ` + `release.`;
+var EXPLORES_EMPTY_SUPPRESSES_CONVENTION = `"explores": [] in publisher.json is keeping this package uncurated. It has ` + `an "${INDEX_MODEL_NAME}", which would otherwise be its published surface: ` + `only that file would be listed, and sources it does not export would stop ` + `answering by name. The empty array suppresses that, so every model stays ` + `listed and queryable. This is supported and is the intended way to opt out ` + `-- do NOT delete the key unless you want the convention to take effect.`;
+var EXPLORES_EMPTY_IS_UNCURATED = `"explores": [] in publisher.json is keeping this package uncurated: every ` + `model is listed and queryable by name. This is supported and is the ` + `intended way to say "do not curate". Nothing to do unless you meant to ` + `publish a surface, in which case list the models, or add a root ` + `"${INDEX_MODEL_NAME}" and delete the key.`;
+var QUERYABLE_SOURCES_DEPRECATION = `"queryableSources" in publisher.json is deprecated. "declared" is already ` + `the default, so the key changes nothing, and an "${INDEX_MODEL_NAME}" ` + `gives the same curated-and-enforced surface with no manifest field at all. ` + `Delete it. The key still works and is not going away in this release.`;
 
 // src/package_load/package_load_worker.ts
 init_source_extraction();
@@ -15389,21 +15773,27 @@ function buildWorkerMalloyConfig(job) {
   }));
   return config;
 }
-async function readPackageMetadata(packagePath) {
+async function readPackageMetadata(packagePath, modelPaths) {
   const manifestPath = path2.join(packagePath, PACKAGE_MANIFEST_NAME);
   const contents = await fs2.promises.readFile(manifestPath, "utf8");
   const parsed = JSON.parse(contents);
   const scope = resolvePackageScope(parsed.scope, parsed.materialization);
   const queryMetadata = resolvePackageQueryMetadata(parsed.queryMetadata, parsed.materialization);
+  const explores = resolveExplores({
+    declaredExplores: parsed.explores,
+    declaredQueryableSources: parsed.queryableSources,
+    modelPaths
+  });
   const manifestWarnings = [
     ...scope.warnings,
     ...queryMetadata.warnings,
+    ...explores.warnings,
     ...queryMetadataParseWarnings(queryMetadata.queryMetadata, queryMetadata.home)
   ];
   return {
     name: parsed.name,
     description: parsed.description,
-    explores: Array.isArray(parsed.explores) ? parsed.explores.map(normalizeModelPath) : undefined,
+    explores: explores.explores,
     queryableSources: parsed.queryableSources === "all" ? "all" : "declared",
     manifestLocation: typeof parsed.manifestLocation === "string" ? parsed.manifestLocation : null,
     materialization: materializationWithQueryMetadata(parsePackageMaterialization(parsed.materialization), queryMetadata.queryMetadata),
@@ -15441,7 +15831,7 @@ function authorizeWarningCollector() {
   return {
     warnings,
     onRowLevelGateUnexpressible: (sourceName, detail) => {
-      warnings.push(`Row-level #(authorize) gate not expressible at entry point "${sourceName}"; every query against it will be denied: ${detail}`);
+      warnings.push(`Row-level #(access_filter) gate not expressible at entry point "${sourceName}"; every query against it will be denied: ${detail}`);
     }
   };
 }
@@ -15500,10 +15890,10 @@ async function compileMalloyModel(job, malloyConfig, modelPath) {
     authorizeOwnNotes,
     attributedAuthorizeOwnNotes
   } = extractSources(modelDef, givens);
-  attachSuggestGivenNames(givens, suggestGivenLookup(modelDef, (name) => sources.find((source) => source.name === name)?.authorize, new Set((givens ?? []).map((given) => given.name))));
+  attachSuggestGivenNames(givens, suggestGivenLookup(modelDef, (name) => gateGivenSource(sources, name), new Set((givens ?? []).map((given) => given.name))));
   const queryResult = extractQueries(modelDef);
   const queries = queryResult.queries;
-  assertPartitionAnnotationsValid(modelDef);
+  assertNoRetiredRouteMarkers(collectRetiredRouteMarkers(modelDef));
   assertNoMisplacedAuthorizeAnnotations([
     ...misplacedAuthorize,
     ...queryResult.misplacedAuthorize
@@ -15511,20 +15901,20 @@ async function compileMalloyModel(job, malloyConfig, modelPath) {
   const legacyStringGates = findLegacyStringGates(authorizeOwnNotes);
   legacyStringGates.forEach(() => recordRowLevelGateRejected("legacy_string_gate"));
   assertNoLegacyStringGate(legacyStringGates);
-  assertAtMostOneAuthorizeGate(findMultipleAuthorizeGates(authorizeOwnNotes));
+  assertAuthorizeGrammarValid(modelDef, authorizeMap, authorizeOwnNotes, computeGivenDeclaredTypes(givens), (_sourceName, route) => recordAuthorizeAdmitAllGate(route), attributedAuthorizeOwnNotes);
   const authorizeWarningCollection = authorizeWarningCollector();
   await validateAuthorizeProbes(mm, {
     authorizeMap,
     authorizeOwnNotes: attributedAuthorizeOwnNotes,
     onRowLevelGateRejected: recordRowLevelGateRejected,
     onRowLevelGateUnexpressible: authorizeWarningCollection.onRowLevelGateUnexpressible,
-    onOwnRowLevelConditionCompiled: (sourceName, condition) => {
+    onOwnRowLevelConditionCompiled: (sourceName, condition, route) => {
       const struct = modelDef.contents[sourceName];
       if (!struct || !isSourceDef6(struct))
         return;
-      validateSourceLineGateGivenUsage(sourceName, struct, condition.refSummary, condition.e, modelDef, (cause, detail) => {
+      validateSourceLineGateGivenUsage(sourceName, route, struct, condition.refSummary, condition.e, modelDef, (cause, detail) => {
         recordRowLevelGateRejected(cause);
-        authorizeWarningCollection.warnings.push(`Row-level #(authorize) gate warning on "${sourceName}" (${cause}): ${detail}`);
+        authorizeWarningCollection.warnings.push(`#(${route}) gate warning on "${sourceName}" (${cause}): ${detail}`);
       });
     }
   });
@@ -15624,11 +16014,11 @@ async function compileNotebookModel(job, malloyConfig, modelPath) {
     finalSourceInfos = collectSourceInfos(finalModelDef);
     const extracted = extractSources(finalModelDef, finalGivens);
     finalSources = extracted.sources;
-    attachSuggestGivenNames(finalGivens, suggestGivenLookup(finalModelDef, (name) => extracted.sources.find((source) => source.name === name)?.authorize, new Set((finalGivens ?? []).map((given) => given.name))));
+    attachSuggestGivenNames(finalGivens, suggestGivenLookup(finalModelDef, (name) => gateGivenSource(extracted.sources, name), new Set((finalGivens ?? []).map((given) => given.name))));
     finalFilterMap = extracted.filterMap;
     const finalQueryResult = extractQueries(finalModelDef);
     finalQueries = finalQueryResult.queries;
-    assertPartitionAnnotationsValid(finalModelDef);
+    assertNoRetiredRouteMarkers(collectRetiredRouteMarkers(finalModelDef));
     assertNoMisplacedAuthorizeAnnotations([
       ...extracted.misplacedAuthorize,
       ...finalQueryResult.misplacedAuthorize
@@ -15636,20 +16026,20 @@ async function compileNotebookModel(job, malloyConfig, modelPath) {
     const finalLegacyStringGates = findLegacyStringGates(extracted.authorizeOwnNotes);
     finalLegacyStringGates.forEach(() => recordRowLevelGateRejected("legacy_string_gate"));
     assertNoLegacyStringGate(finalLegacyStringGates);
-    assertAtMostOneAuthorizeGate(findMultipleAuthorizeGates(extracted.authorizeOwnNotes));
+    assertAuthorizeGrammarValid(finalModelDef, extracted.authorizeMap, extracted.authorizeOwnNotes, computeGivenDeclaredTypes(finalGivens), (_sourceName, route) => recordAuthorizeAdmitAllGate(route), extracted.attributedAuthorizeOwnNotes);
     const finalCompiledModelDef = finalModelDef;
     await validateAuthorizeProbes(mm, {
       authorizeMap: extracted.authorizeMap,
       authorizeOwnNotes: extracted.attributedAuthorizeOwnNotes,
       onRowLevelGateRejected: recordRowLevelGateRejected,
       onRowLevelGateUnexpressible: authorizeWarningCollection.onRowLevelGateUnexpressible,
-      onOwnRowLevelConditionCompiled: (sourceName, condition) => {
+      onOwnRowLevelConditionCompiled: (sourceName, condition, route) => {
         const struct = finalCompiledModelDef.contents[sourceName];
         if (!struct || !isSourceDef6(struct))
           return;
-        validateSourceLineGateGivenUsage(sourceName, struct, condition.refSummary, condition.e, finalCompiledModelDef, (cause, detail) => {
+        validateSourceLineGateGivenUsage(sourceName, route, struct, condition.refSummary, condition.e, finalCompiledModelDef, (cause, detail) => {
           recordRowLevelGateRejected(cause);
-          authorizeWarningCollection.warnings.push(`Row-level #(authorize) gate warning on "${sourceName}" (${cause}): ${detail}`);
+          authorizeWarningCollection.warnings.push(`#(${route}) gate warning on "${sourceName}" (${cause}): ${detail}`);
         });
       }
     });
@@ -15698,10 +16088,10 @@ async function compileOneModel(job, malloyConfig, modelPath) {
 }
 async function loadPackage(job) {
   const loadStart = performance.now();
-  const packageMetadata = await readPackageMetadata(job.packagePath);
-  const malloyConfig = buildWorkerMalloyConfig(job);
   const allFiles = await listPackageFiles(job.packagePath);
   const modelPaths = filterModelPaths(allFiles);
+  const packageMetadata = await readPackageMetadata(job.packagePath, modelPaths);
+  const malloyConfig = buildWorkerMalloyConfig(job);
   const replacementMatchedExisting = job.replacement ? modelPaths.includes(job.replacement.modelPath) : undefined;
   if (job.replacement && !replacementMatchedExisting) {
     modelPaths.push(job.replacement.modelPath);