@malloydata/malloy 0.0.415 → 0.0.417

package/dist/lang/lib/Malloy/MalloyParserListener.d.ts

@@ -216,6 +216,8 @@ import { GroupedByStatementContext } from "./MalloyParser";
 import { OrderByStatementContext } from "./MalloyParser";
 import { OrderingContext } from "./MalloyParser";
 import { OrderBySpecContext } from "./MalloyParser";
+import { PossibleBadPathContext } from "./MalloyParser";
+import { BadWordContext } from "./MalloyParser";
 import { LimitStatementContext } from "./MalloyParser";
 import { BySpecContext } from "./MalloyParser";
 import { TopStatementContext } from "./MalloyParser";
@@ -2632,6 +2634,26 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitOrderBySpec?: (ctx: OrderBySpecContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.possibleBadPath`.
+     * @param ctx the parse tree
+     */
+    enterPossibleBadPath?: (ctx: PossibleBadPathContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.possibleBadPath`.
+     * @param ctx the parse tree
+     */
+    exitPossibleBadPath?: (ctx: PossibleBadPathContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.badWord`.
+     * @param ctx the parse tree
+     */
+    enterBadWord?: (ctx: BadWordContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.badWord`.
+     * @param ctx the parse tree
+     */
+    exitBadWord?: (ctx: BadWordContext) => void;
     /**
      * Enter a parse tree produced by `MalloyParser.limitStatement`.
      * @param ctx the parse tree

package/dist/lang/lib/Malloy/MalloyParserVisitor.d.ts

@@ -216,6 +216,8 @@ import { GroupedByStatementContext } from "./MalloyParser";
 import { OrderByStatementContext } from "./MalloyParser";
 import { OrderingContext } from "./MalloyParser";
 import { OrderBySpecContext } from "./MalloyParser";
+import { PossibleBadPathContext } from "./MalloyParser";
+import { BadWordContext } from "./MalloyParser";
 import { LimitStatementContext } from "./MalloyParser";
 import { BySpecContext } from "./MalloyParser";
 import { TopStatementContext } from "./MalloyParser";
@@ -1676,6 +1678,18 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitOrderBySpec?: (ctx: OrderBySpecContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.possibleBadPath`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitPossibleBadPath?: (ctx: PossibleBadPathContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.badWord`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitBadWord?: (ctx: BadWordContext) => Result;
     /**
      * Visit a parse tree produced by `MalloyParser.limitStatement`.
      * @param ctx the parse tree

package/dist/lang/lib/Malloy/keyword-display-names.d.ts

@@ -0,0 +1 @@
+export declare const KEYWORD_DISPLAY_NAMES: Record<string, string>;

package/dist/lang/lib/Malloy/keyword-display-names.js

@@ -0,0 +1,121 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEYWORD_DISPLAY_NAMES = void 0;
+// GENERATED by src/lang/grammar/build_token_names.js from the
+// KEYWORDS-BEGIN..KEYWORDS-END section of MalloyLexer.g4. Do not edit by hand.
+// Maps a keyword token's symbolic name to the spelling a user types (including
+// the trailing colon for statement keywords), for parser error messages.
+// Run `npm run codegen` to regenerate.
+exports.KEYWORD_DISPLAY_NAMES = {
+    ACCEPT: "accept:",
+    AGGREGATE: "aggregate:",
+    ALL: "all",
+    AND: "and",
+    AS: "as",
+    ASC: "asc",
+    AVG: "avg",
+    BOOLEAN: "boolean",
+    BY: "by",
+    CALCULATE: "calculate:",
+    CALCULATION: "calculation:",
+    CASE: "case",
+    CAST: "cast",
+    COMPOSE: "compose",
+    CONNECTION: "connection:",
+    COUNT: "count",
+    DATE: "date",
+    DAY: "day",
+    DECLARE: "declare:",
+    DESC: "desc",
+    DIMENSION: "dimension:",
+    DISTINCT: "distinct",
+    DRILL: "drill:",
+    ELSE: "else",
+    END: "end",
+    EXCEPT: "except:",
+    EXCLUDE: "exclude",
+    EXPORT: "export",
+    EXTEND: "extend",
+    EXTENDQ: "extend:",
+    FALSE: "false",
+    FILTER: "filter",
+    FOR: "for",
+    FROM: "from",
+    FULL: "full",
+    GIVEN: "given:",
+    GROUPED_BY: "grouped_by:",
+    GROUP_BY: "group_by:",
+    HAS: "has",
+    HAVING: "having:",
+    HOUR: "hour",
+    IMPORT: "import",
+    IN: "in",
+    INCLUDE: "include",
+    INDEX: "index:",
+    INNER: "inner",
+    INTERNAL: "internal:",
+    INTERNAL_KW: "internal",
+    IS: "is",
+    JOIN_CROSS: "join_cross:",
+    JOIN_MANY: "join_many:",
+    JOIN_ONE: "join_one:",
+    JSON: "json",
+    LEFT: "left",
+    LIKE: "like",
+    LIMIT: "limit:",
+    MAX: "max",
+    MEASURE: "measure:",
+    MIN: "min",
+    MINUTE: "minute",
+    MONTH: "month",
+    NEST: "nest:",
+    NOT: "not",
+    NOW: "now",
+    NULL: "null",
+    NUMBER: "number",
+    ON: "on",
+    OR: "or",
+    ORDER_BY: "order_by:",
+    PARTITION_BY: "partition_by:",
+    PICK: "pick",
+    PRIMARY_KEY: "primary_key:",
+    PRIVATE: "private:",
+    PRIVATE_KW: "private",
+    PUBLIC: "public:",
+    PUBLIC_KW: "public",
+    QUARTER: "quarter",
+    QUERY: "query:",
+    RENAME: "rename:",
+    RIGHT: "right",
+    RUN: "run:",
+    SAMPLE: "sample:",
+    SECOND: "second",
+    SELECT: "select:",
+    SOURCE: "source:",
+    SOURCE_KW: "source",
+    SQL: "sql",
+    STRING: "string",
+    SUM: "sum",
+    TABLE: "table",
+    THEN: "then",
+    THIS: "this",
+    TIMESTAMP: "timestamp",
+    TIMESTAMPTZ: "timestamptz",
+    TIMEZONE: "timezone:",
+    TO: "to",
+    TOP: "top:",
+    TRUE: "true",
+    TYPE: "type:",
+    VIEW: "view:",
+    VIRTUAL: "virtual",
+    WEEK: "week",
+    WHEN: "when",
+    WHERE: "where:",
+    WITH: "with",
+    YEAR: "year",
+};
+//# sourceMappingURL=keyword-display-names.js.map

package/dist/lang/malloy-to-ast.d.ts

@@ -207,7 +207,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitExprString(pcx: parse.ExprStringContext): ast.ExprString;
     visitRawString(pcx: parse.RawStringContext): ast.ExprString;
     visitExprRegex(pcx: parse.ExprRegexContext): ast.ExprRegEx;
-    visitExprNow(_pcx: parse.ExprNowContext): ast.ExprNow;
+    visitExprNow(pcx: parse.ExprNowContext): ast.ExprNow;
     visitExprNumber(pcx: parse.ExprNumberContext): ast.ExprNumber;
     visitExprFieldPath(pcx: parse.ExprFieldPathContext): ast.ExprIdReference;
     visitExprGivenRef(pcx: parse.ExprGivenRefContext): ast.GivenReference;

package/dist/lang/malloy-to-ast.js

@@ -979,11 +979,33 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         if (ncx) {
             return new ast.OrderBy(this.getNumber(ncx), dir);
         }
-        const fieldCx = pcx.fieldName();
-        if (fieldCx) {
-            return new ast.OrderBy(this.getFieldName(fieldCx), dir);
-        }
-        throw this.internalError(pcx, "can't parse order_by specification");
+        const pathCx = pcx.possibleBadPath();
+        if (!pathCx) {
+            throw this.internalError(pcx, "can't parse order_by specification");
+        }
+        const words = pathCx.badWord();
+        const firstField = words[0].fieldName();
+        if (words.length === 1 && firstField) {
+            // A lone ordinary identifier -- the normal, valid order_by target.
+            return new ast.OrderBy(this.getFieldName(firstField), dir);
+        }
+        // Otherwise illegal: a dotted path, and/or a reserved-word segment that
+        // would have to be quoted. Logging an error here prevents translation, so
+        // the throwaway OrderBy below is never evaluated -- it only satisfies the
+        // visitor's contract.
+        const last = words[words.length - 1];
+        const lastFieldCx = last.fieldName();
+        const lastName = lastFieldCx ? lastFieldCx.text : '`' + last.text + '`';
+        const message = words.length > 1
+            ? `order_by takes the name of a field in the query output, not a path ('${pathCx.text}'). ` +
+                `To order by '${last.text}', make it an output field and order by its name` +
+                (lastFieldCx === undefined
+                    ? `, quoting it because '${last.text}' is a reserved word: ${lastName}`
+                    : `: ${lastName}`) +
+                '.'
+            : `'${last.text}' is a reserved word, so to order by it you must quote it: ${lastName}`;
+        this.contextError(pathCx, 'order-by-bad-reference', message);
+        return new ast.OrderBy(new ast.FieldName('internal_error'), dir);
     }
     visitOrdering(pcx) {
         const orderList = pcx.orderBySpec().map(o => this.visitOrderBySpec(o));
@@ -1135,7 +1157,11 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const malloyRegex = pcx.HACKY_REGEX().text;
         return new ast.ExprRegEx(malloyRegex.slice(2, -1));
     }
-    visitExprNow(_pcx) {
+    visitExprNow(pcx) {
+        if (pcx.OPAREN()) {
+            // `now` is a value, not a function; accept `now()`, warn, compile as `now`.
+            this.contextError(pcx, 'now-is-not-a-function', "'now' is a value, not a function; the parentheses are unnecessary. Write 'now'.", { severity: 'warn' });
+        }
         return new ast.ExprNow();
     }
     visitExprNumber(pcx) {

package/dist/lang/malloy-to-stable-query.js

@@ -368,24 +368,28 @@ class MalloyToQuery extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor
         });
     }
     getOrderByStatement(obcx) {
+        var _a, _b;
         const specs = obcx.ordering().orderBySpec();
         const orders = [];
         for (const spec of specs) {
             if (spec.INTEGER_LITERAL()) {
                 this.notAllowed(spec, 'Indexed order by statements');
+                continue;
             }
-            else if (spec.fieldName()) {
-                const fieldName = (0, parse_utils_1.getId)(spec.fieldName());
-                const direction = spec.ASC() ? 'asc' : spec.DESC() ? 'desc' : undefined;
-                orders.push({
-                    kind: 'order_by',
-                    direction,
-                    field_reference: { name: fieldName },
-                });
-            }
-            else {
+            // A valid order_by target is a single ordinary name; a dotted path or a
+            // bare reserved word is not representable as a stable query.
+            const words = (_b = (_a = spec.possibleBadPath()) === null || _a === void 0 ? void 0 : _a.badWord()) !== null && _b !== void 0 ? _b : [];
+            const firstField = words.length === 1 ? words[0].fieldName() : undefined;
+            if (!firstField) {
                 return null;
             }
+            const fieldName = (0, parse_utils_1.getId)(firstField);
+            const direction = spec.ASC() ? 'asc' : spec.DESC() ? 'desc' : undefined;
+            orders.push({
+                kind: 'order_by',
+                direction,
+                field_reference: { name: fieldName },
+            });
         }
         return orders;
     }

package/dist/lang/parse-log.d.ts

@@ -222,6 +222,8 @@ type MessageParameterTypes = {
     'aggregate-in-where': string;
     'order-by-not-found-in-output': string;
     'order-by-analytic': string;
+    'order-by-bad-reference': string;
+    'now-is-not-a-function': string;
     'illegal-index-operation': string;
     'illegal-project-operation': string;
     'illegal-grouping-operation': string;

package/dist/lang/syntax-errors/malloy-error-strategy.d.ts

@@ -1,12 +1,19 @@
+import type { InputMismatchException, NoViableAltException, Parser } from 'antlr4ts';
 import { DefaultErrorStrategy } from 'antlr4ts';
 /**
- * Custom error strategy for the Malloy Parser.
+ * Overrides the DefaultErrorStrategy methods that paste the parser's
+ * expected-token set into the message: tokens are named the way the user types
+ * them (via describeExpected) and the set is dropped once too large to be a hint.
  *
- * This class does not currently override default ANTLR error handling.
+ * Each path also checks reservedNameMessage first, so a reserved word used where
+ * a name was expected (`group_by: year`) says "quote it".
  *
- * For more details, read the documentation in DefaultErrorStrategy.d.ts
- * or reference the superclass at:
- * https://github.com/tunnelvisionlabs/antlr4ts/blob/master/src/DefaultErrorStrategy.ts
+ * Fallback only — MalloyParserErrorListener's custom-error cases run first and
+ * override these when they match.
  */
 export declare class MalloyErrorStrategy extends DefaultErrorStrategy {
+    protected reportInputMismatch(recognizer: Parser, e: InputMismatchException): void;
+    protected reportUnwantedToken(recognizer: Parser): void;
+    protected reportMissingToken(recognizer: Parser): void;
+    protected reportNoViableAlternative(recognizer: Parser, e: NoViableAltException): void;
 }

package/dist/lang/syntax-errors/malloy-error-strategy.js

@@ -6,16 +6,85 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MalloyErrorStrategy = void 0;
 const antlr4ts_1 = require("antlr4ts");
+const token_names_1 = require("./token-names");
+function unexpected(offending, clause) {
+    return clause
+        ? `unexpected ${offending}, expected ${clause}`
+        : `unexpected ${offending}`;
+}
 /**
- * Custom error strategy for the Malloy Parser.
+ * Overrides the DefaultErrorStrategy methods that paste the parser's
+ * expected-token set into the message: tokens are named the way the user types
+ * them (via describeExpected) and the set is dropped once too large to be a hint.
  *
- * This class does not currently override default ANTLR error handling.
+ * Each path also checks reservedNameMessage first, so a reserved word used where
+ * a name was expected (`group_by: year`) says "quote it".
  *
- * For more details, read the documentation in DefaultErrorStrategy.d.ts
- * or reference the superclass at:
- * https://github.com/tunnelvisionlabs/antlr4ts/blob/master/src/DefaultErrorStrategy.ts
+ * Fallback only — MalloyParserErrorListener's custom-error cases run first and
+ * override these when they match.
  */
 class MalloyErrorStrategy extends antlr4ts_1.DefaultErrorStrategy {
+    reportInputMismatch(recognizer, e) {
+        var _a, _b;
+        const offendingToken = e.getOffendingToken(recognizer);
+        const expected = (_b = (_a = e.expectedTokens) === null || _a === void 0 ? void 0 : _a.toArray()) !== null && _b !== void 0 ? _b : [];
+        const reserved = (0, token_names_1.reservedNameMessage)(offendingToken, expected, recognizer);
+        if (reserved) {
+            this.notifyErrorListeners(recognizer, reserved, e);
+            return;
+        }
+        const offending = this.getTokenErrorDisplay(offendingToken);
+        const clause = (0, token_names_1.describeExpected)(expected, recognizer.vocabulary);
+        this.notifyErrorListeners(recognizer, unexpected(offending, clause), e);
+    }
+    reportUnwantedToken(recognizer) {
+        if (this.inErrorRecoveryMode(recognizer)) {
+            return;
+        }
+        this.beginErrorCondition(recognizer);
+        const t = recognizer.currentToken;
+        const expected = this.getExpectedTokens(recognizer).toArray();
+        const reserved = (0, token_names_1.reservedNameMessage)(t, expected, recognizer);
+        if (reserved) {
+            recognizer.notifyErrorListeners(reserved, t, undefined);
+            return;
+        }
+        const offending = this.getTokenErrorDisplay(t);
+        const clause = (0, token_names_1.describeExpected)(expected, recognizer.vocabulary);
+        recognizer.notifyErrorListeners(unexpected(offending, clause), t, undefined);
+    }
+    reportMissingToken(recognizer) {
+        if (this.inErrorRecoveryMode(recognizer)) {
+            return;
+        }
+        this.beginErrorCondition(recognizer);
+        const t = recognizer.currentToken;
+        const expected = this.getExpectedTokens(recognizer).toArray();
+        const reserved = (0, token_names_1.reservedNameMessage)(t, expected, recognizer);
+        if (reserved) {
+            recognizer.notifyErrorListeners(reserved, t, undefined);
+            return;
+        }
+        const offending = this.getTokenErrorDisplay(t);
+        const clause = (0, token_names_1.describeExpected)(expected, recognizer.vocabulary);
+        const msg = clause
+            ? `missing ${clause} before ${offending}`
+            : `something is missing before ${offending}`;
+        recognizer.notifyErrorListeners(msg, t, undefined);
+    }
+    // Dispatched from reportError (already in error condition), unlike the inline-
+    // recovery methods above — an inErrorRecoveryMode guard here would swallow the
+    // error. Short-circuit to the reserved-word hint, else defer to super.
+    reportNoViableAlternative(recognizer, e) {
+        const t = recognizer.currentToken;
+        const expected = this.getExpectedTokens(recognizer).toArray();
+        const reserved = (0, token_names_1.reservedNameMessage)(t, expected, recognizer);
+        if (reserved) {
+            this.notifyErrorListeners(recognizer, reserved, e);
+            return;
+        }
+        super.reportNoViableAlternative(recognizer, e);
+    }
 }
 exports.MalloyErrorStrategy = MalloyErrorStrategy;
 //# sourceMappingURL=malloy-error-strategy.js.map

package/dist/lang/syntax-errors/token-names.d.ts

@@ -0,0 +1,5 @@
+import type { Parser, Vocabulary } from 'antlr4ts';
+import { Token } from 'antlr4ts';
+export declare function describeToken(type: number, vocabulary: Vocabulary): string;
+export declare function describeExpected(types: number[], vocabulary: Vocabulary): string | undefined;
+export declare function reservedNameMessage(offending: Token | undefined, expected: number[], recognizer: Parser): string | undefined;

package/dist/lang/syntax-errors/token-names.js

@@ -0,0 +1,89 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeToken = describeToken;
+exports.describeExpected = describeExpected;
+exports.reservedNameMessage = reservedNameMessage;
+const antlr4ts_1 = require("antlr4ts");
+const MalloyParser_1 = require("../lib/Malloy/MalloyParser");
+const keyword_display_names_1 = require("../lib/Malloy/keyword-display-names");
+// Pattern tokens have neither a literal nor a keyword spelling to show, so they
+// get hand-written prose instead of their SHOUTING symbolic name.
+const CLASS_TOKEN_DISPLAY_NAMES = {
+    IDENTIFIER: 'a name',
+    BQ_STRING: 'a `quoted` name',
+    SQ_STRING: 'a quoted string',
+    DQ_STRING: 'a quoted string',
+    NUMERIC_LITERAL: 'a number',
+    INTEGER_LITERAL: 'a number',
+    PERCENT_LITERAL: 'a percentage',
+    GIVEN_REF: 'a $given reference',
+};
+// Past this many alternatives the expected-set is the parser's follow-set, not
+// a hint, so describeExpected drops it.
+const MAX_EXPECTED_NAMED = 3;
+function describeToken(type, vocabulary) {
+    if (type === antlr4ts_1.Token.EOF)
+        return 'end of input';
+    const symbolic = vocabulary.getSymbolicName(type);
+    if (symbolic !== undefined) {
+        const prose = CLASS_TOKEN_DISPLAY_NAMES[symbolic];
+        if (prose !== undefined)
+            return prose;
+        const keyword = keyword_display_names_1.KEYWORD_DISPLAY_NAMES[symbolic];
+        if (keyword !== undefined)
+            return `'${keyword}'`;
+    }
+    // Punctuation already carries a quoted literal name, e.g. "'{'".
+    const literal = vocabulary.getLiteralName(type);
+    if (literal !== undefined)
+        return literal;
+    return symbolic !== null && symbolic !== void 0 ? symbolic : `<token ${type}>`;
+}
+function joinOr(items) {
+    if (items.length === 1)
+        return items[0];
+    return `${items.slice(0, -1).join(', ')} or ${items[items.length - 1]}`;
+}
+function describeExpected(types, vocabulary) {
+    const displays = [];
+    const seen = new Set();
+    for (const type of types) {
+        if (type < antlr4ts_1.Token.MIN_USER_TOKEN_TYPE && type !== antlr4ts_1.Token.EOF)
+            continue;
+        const display = describeToken(type, vocabulary);
+        if (!seen.has(display)) {
+            seen.add(display);
+            displays.push(display);
+        }
+    }
+    if (displays.length === 0 || displays.length > MAX_EXPECTED_NAMED) {
+        return undefined;
+    }
+    return joinOr(displays);
+}
+// When a bare-word reserved token appears where a name (IDENTIFIER) was legal,
+// the user meant it as a field name; return a "quote it" message. undefined
+// otherwise, so the caller keeps its normal message.
+function reservedNameMessage(offending, expected, recognizer) {
+    const text = offending === null || offending === void 0 ? void 0 : offending.text;
+    if (!text || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(text))
+        return undefined;
+    const symbolic = recognizer.vocabulary.getSymbolicName(offending.type);
+    if (symbolic === undefined || keyword_display_names_1.KEYWORD_DISPLAY_NAMES[symbolic] === undefined) {
+        return undefined;
+    }
+    if (!expected.includes(MalloyParser_1.MalloyParser.IDENTIFIER))
+        return undefined;
+    // A reserved word followed by '(' is a function call (count()), not a name.
+    // offending is the current token here, so LA(2) is the next on-channel token;
+    // LA fetches it lazily rather than pre-filling the stream.
+    if (recognizer.inputStream.LA(2) === MalloyParser_1.MalloyParser.OPAREN) {
+        return undefined;
+    }
+    return `'${text}' is a reserved word, so to use it as a name you must quote it: \`${text}\``;
+}
+//# sourceMappingURL=token-names.js.map

package/dist/model/utils.js

@@ -23,8 +23,8 @@ exports.caseGroup = caseGroup;
 exports.mkModelID = mkModelID;
 exports.mkModelDef = mkModelDef;
 const uuid_1 = require("uuid");
-const sha256_1 = require("@noble/hashes/sha256");
-const utils_1 = require("@noble/hashes/utils");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const utils_js_1 = require("@noble/hashes/utils.js");
 const malloy_types_1 = require("./malloy_types");
 /**
  * Format a typeDef as user-readable Malloy type syntax. Used in error
@@ -155,7 +155,9 @@ function makeDigest(...parts) {
     const combined = parts
         .map(p => (p === undefined ? '{undefined}' : `${p.length}:${p}`))
         .join('/');
-    return (0, utils_1.bytesToHex)((0, sha256_1.sha256)(combined));
+    // @noble/hashes v2 dropped implicit string hashing; v1 accepted a string and
+    // UTF-8 encoded it internally, so utf8ToBytes here yields the identical digest.
+    return (0, utils_js_1.bytesToHex)((0, sha2_js_1.sha256)((0, utils_js_1.utf8ToBytes)(combined)));
 }
 function joinWith(els, sep) {
     const result = [];

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.415";
+export declare const MALLOY_VERSION = "0.0.417";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.415';
+exports.MALLOY_VERSION = '0.0.417';
 //# sourceMappingURL=version.js.map

package/femto-config.motly

@@ -16,6 +16,16 @@ parser: {
   ]
 }
 
+tokenNames: {
+  deps = [lexer]
+  inputs = [
+    "src/lang/grammar/MalloyLexer.g4",
+    "src/lang/grammar/build_token_names.js"
+  ]
+  outputs = ["src/lang/lib/Malloy/keyword-display-names.ts"]
+  commands = ["node src/lang/grammar/build_token_names.js"]
+}
+
 codegen: {
-  deps = [parser]
+  deps = [parser, tokenNames]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.415",
+  "version": "0.0.417",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -51,22 +51,22 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.415",
-    "@malloydata/malloy-interfaces": "0.0.415",
-    "@malloydata/malloy-tag": "0.0.415",
-    "@noble/hashes": "^1.8.0",
+    "@malloydata/malloy-filter": "0.0.417",
+    "@malloydata/malloy-interfaces": "0.0.417",
+    "@malloydata/malloy-tag": "0.0.417",
+    "@noble/hashes": "^2.2.0",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",
-    "jest-diff": "^29.6.2",
     "lodash": "^4.18.1",
-    "luxon": "^3.5.0",
-    "uuid": "^8.3.2"
+    "luxon": "^3.7.2",
+    "uuid": "^14.0.0"
   },
   "devDependencies": {
     "@types/jaro-winkler": "^0.2.3",
-    "@types/lodash": "^4.14.165",
-    "@types/luxon": "^3.5.0",
-    "antlr4ts-cli": "^0.5.0-alpha.4"
+    "@types/lodash": "^4.17.24",
+    "@types/luxon": "^3.7.2",
+    "antlr4ts-cli": "^0.5.0-alpha.4",
+    "jest-diff": "^30.4.1"
   }
 }