@platformos/platformos-check-common 0.0.16 → 0.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformos/platformos-check-common",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -26,7 +26,7 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
-    "@platformos/liquid-html-parser": "0.0.15",
+    "@platformos/liquid-html-parser": "0.0.16",
     "graphql": "^16.12.0",
     "js-yaml": "^4.1.1",
     "jsonc-parser": "^3.3.1",

package/src/checks/index.ts

@@ -30,7 +30,7 @@ import { ValidJSON } from './valid-json';
 import { ValidDocParamTypes } from './valid-doc-param-types';
 import { ValidRenderPartialArgumentTypes } from './valid-render-partial-argument-types';
 import { VariableName } from './variable-name';
-import { MetadataParamsCheck } from './metadata-params';
+import { PartialCallArguments } from './partial-call-arguments';
 import { GraphQLVariablesCheck } from './graphql-variables';
 import { GraphQLCheck } from './graphql';
 import { UnknownProperty } from './unknown-property';
@@ -39,6 +39,8 @@ import { DuplicateFunctionArguments } from './duplicate-function-arguments';
 import { MissingRenderPartialArguments } from './missing-render-partial-arguments';
 import { NestedGraphQLQuery } from './nested-graphql-query';
 import { MissingPage } from './missing-page';
+import { ValidFrontmatter } from './valid-frontmatter';
+import { JsonLiteralQuoteStyle } from './json-literal-quote-style';
 
 export const allChecks: (
   | LiquidCheckDefinition
@@ -71,7 +73,7 @@ export const allChecks: (
   ValidDocParamTypes,
   ValidRenderPartialArgumentTypes,
   VariableName,
-  MetadataParamsCheck,
+  PartialCallArguments,
   GraphQLVariablesCheck,
   GraphQLCheck,
   UnknownProperty,
@@ -79,6 +81,8 @@ export const allChecks: (
   MissingRenderPartialArguments,
   NestedGraphQLQuery,
   MissingPage,
+  ValidFrontmatter,
+  JsonLiteralQuoteStyle,
 ];
 
 /**

package/src/checks/json-literal-quote-style/index.spec.ts

@@ -0,0 +1,129 @@
+import { expect, describe, it } from 'vitest';
+import { JsonLiteralQuoteStyle } from './index';
+import { applyFix, runLiquidCheck } from '../../test';
+
+describe('Module: JsonLiteralQuoteStyle', () => {
+  it('should report single-quoted keys in an inline hash literal', async () => {
+    const sourceCode = `{% assign a = {'a': 5} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal(
+      'Use double quotes for string literals inside object/array literals (e.g. \'{"key": "value"}\', not "{\'key\': \'value\'}").',
+    );
+  });
+
+  it('should report single-quoted string values in an inline hash literal', async () => {
+    const sourceCode = `{% assign a = {"key": 'value'} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.have.length(1);
+  });
+
+  it('should report both single-quoted keys and values', async () => {
+    const sourceCode = `{% assign a = {'a': 'b', 'c': 'd'} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.have.length(4);
+  });
+
+  it('should report single-quoted strings in nested hash literals', async () => {
+    const sourceCode = `{% assign a = {"outer": {'inner': 1}} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.have.length(1);
+  });
+
+  it('should report single-quoted strings inside array literals', async () => {
+    const sourceCode = `{% assign a = ['x', 'y'] %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.have.length(2);
+  });
+
+  it('should not report double-quoted strings in object literals', async () => {
+    const sourceCode = `{% assign a = {"a": "b", "c": [1, "d"]} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.be.empty;
+  });
+
+  it('should not report bare keys in object literals', async () => {
+    const sourceCode = `{% assign a = {a: 2} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.be.empty;
+  });
+
+  it('should not report single-quoted strings outside of inline JSON literals', async () => {
+    const sourceCode = `
+      {% assign a = 'plain string' %}
+      {% assign b = 'pass' | upcase %}
+      {{ 'hello' }}
+    `;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.be.empty;
+  });
+
+  it('should not report parse_json style JSON-in-a-string', async () => {
+    const sourceCode = `{% assign a = '{"a": 5}' | parse_json %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.be.empty;
+  });
+
+  it('should fix single-quoted keys to double-quoted keys', async () => {
+    const sourceCode = `{% assign a = {'a': 5} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+    const fixed = applyFix(sourceCode, offenses[0]);
+
+    expect(fixed).to.equal(`{% assign a = {"a": 5} %}`);
+  });
+
+  it('should fix single-quoted string values to double-quoted values', async () => {
+    const sourceCode = `{% assign a = {"key": 'value'} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+    const fixed = applyFix(sourceCode, offenses[0]);
+
+    expect(fixed).to.equal(`{% assign a = {"key": "value"} %}`);
+  });
+
+  it('should properly escape embedded double quotes when fixing', async () => {
+    const sourceCode = `{% assign a = {'msg': 'she said "hi"'} %}`;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+    expect(offenses).to.have.length(2);
+
+    const valueOffense = offenses.find((o) =>
+      sourceCode.slice(o.start.index, o.end.index).includes('she said'),
+    );
+    expect(valueOffense).to.not.be.undefined;
+
+    const fixedValue = applyFix(sourceCode, valueOffense!);
+    expect(fixedValue).to.equal(`{% assign a = {'msg': "she said \\"hi\\""} %}`);
+  });
+
+  it('should report single-quoted strings in function return literals', async () => {
+    const sourceCode = `
+      {% function result = my_func %}
+        {% return {'a': 5} %}
+      {% endfunction %}
+    `;
+
+    const offenses = await runLiquidCheck(JsonLiteralQuoteStyle, sourceCode);
+
+    expect(offenses).to.have.length(1);
+  });
+});

package/src/checks/json-literal-quote-style/index.ts

@@ -0,0 +1,45 @@
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
+
+export const JsonLiteralQuoteStyle: LiquidCheckDefinition = {
+  meta: {
+    code: 'JsonLiteralQuoteStyle',
+    name: 'Use double quotes in JSON literals',
+    docs: {
+      description:
+        'Enforces double-quoted string literals inside inline object/array literals (e.g. {% assign a = {"a": 5} %}). Single-quoted strings inside these literals are not valid JSON.',
+      recommended: true,
+      url: undefined,
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.ERROR,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    return {
+      async String(node, ancestors) {
+        if (!node.single) return;
+
+        // Only flag strings that are inside an inline object/array literal.
+        const insideJsonLiteral = ancestors.some(
+          (ancestor) =>
+            ancestor.type === NodeTypes.JsonHashLiteral ||
+            ancestor.type === NodeTypes.JsonArrayLiteral,
+        );
+        if (!insideJsonLiteral) return;
+
+        context.report({
+          message:
+            'Use double quotes for string literals inside object/array literals (e.g. \'{"key": "value"}\', not "{\'key\': \'value\'}").',
+          startIndex: node.position.start,
+          endIndex: node.position.end,
+          fix: (corrector) => {
+            corrector.replace(node.position.start, node.position.end, JSON.stringify(node.value));
+          },
+        });
+      },
+    };
+  },
+};

package/src/checks/liquid-html-syntax-error/checks/InvalidAssignSyntax.spec.ts

@@ -0,0 +1,422 @@
+import { describe, it, expect } from 'vitest';
+import { runLiquidCheck } from '../../../test';
+import { LiquidHTMLSyntaxError } from '../index';
+
+describe('detectInvalidAssignSyntax', () => {
+  describe('structurally-broken assign tags', () => {
+    const brokenCases: Array<[string, string]> = [
+      ['missing `=` with quoted value', `{% assign x "var" %}`],
+      ['missing `=` with bare identifier', `{% assign x abc %}`],
+      ['missing target', `{% assign = 'val' %}`],
+      ['completely empty', `{% assign %}`],
+      ['target only, no operator', `{% assign x %}`],
+      ['empty RHS after `=`', `{% assign x = %}`],
+    ];
+
+    for (const [label, sourceCode] of brokenCases) {
+      it(`should report: ${label} — ${sourceCode}`, async () => {
+        const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+        const syntaxOffenses = offenses.filter((o) => o.message.includes('Invalid syntax for tag'));
+        expect(syntaxOffenses).toHaveLength(1);
+        expect(syntaxOffenses[0].message).toContain("Invalid syntax for tag 'assign'");
+      });
+    }
+  });
+
+  describe('invalid targets', () => {
+    // Literal delimiters at the start of the target are never a valid assign target.
+    // Digit-starting names (e.g. `23_hours_ago`) are accepted by the platformOS runtime
+    // even though our parser's `variableSegment` grammar rule falls back on them —
+    // to avoid false positives, we do not flag digit-starting targets here.
+    const invalidTargetCases: Array<[string, string]> = [
+      ['target is a single-quoted string', `{% assign 'str' = 'v' %}`],
+      ['target is a double-quoted string', `{% assign "str" = 'v' %}`],
+      ['target is an array literal', `{% assign [] = 'v' %}`],
+      ['target is a hash literal', `{% assign {} = 'v' %}`],
+    ];
+
+    for (const [label, sourceCode] of invalidTargetCases) {
+      it(`should report: ${label} — ${sourceCode}`, async () => {
+        const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+        const syntaxOffenses = offenses.filter((o) =>
+          o.message.includes("Invalid syntax for tag 'assign'"),
+        );
+        expect(syntaxOffenses).toHaveLength(1);
+      });
+    }
+
+    it('should NOT flag a valid dotted target (parser accepts it)', async () => {
+      const sourceCode = `{% assign foo.bar = 'v' %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should NOT flag a valid indexed target', async () => {
+      const sourceCode = `{% assign foo[0] = 'v' %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should NOT flag a digit-starting target (valid per platformOS runtime)', async () => {
+      // Liquify accepts `23_hours_ago` as a valid name; our parser falls back to base
+      // case but this check must not over-report vs. runtime.
+      const sourceCode = `{% assign 23_hours_ago = 'some value' %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      const syntaxOffenses = offenses.filter((o) =>
+        o.message.includes("Invalid syntax for tag 'assign'"),
+      );
+      expect(syntaxOffenses).toHaveLength(0);
+    });
+  });
+
+  describe('operator variants', () => {
+    it('should report `:=` (not a recognized operator) as an assign syntax error', async () => {
+      const sourceCode = `{% assign x := 'v' %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      const syntaxOffenses = offenses.filter((o) =>
+        o.message.includes("Invalid syntax for tag 'assign'"),
+      );
+      expect(syntaxOffenses).toHaveLength(1);
+    });
+
+    it('should have some offense for `==` (MultipleAssignValues handles it)', async () => {
+      const sourceCode = `{% assign x == 'v' %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses.length).toBeGreaterThan(0);
+    });
+
+    it('should have some offense for `=+`', async () => {
+      const sourceCode = `{% assign x =+ 'v' %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('valid syntax — should NOT report', () => {
+    const validCases: Array<[string, string]> = [
+      // primitives
+      ['single-quoted string', `{% assign x = 'str' %}`],
+      ['double-quoted string', `{% assign x = "str" %}`],
+      ['integer', `{% assign x = 42 %}`],
+      ['negative float', `{% assign x = -1.5 %}`],
+      ['true', `{% assign x = true %}`],
+      ['false', `{% assign x = false %}`],
+      ['nil', `{% assign x = nil %}`],
+      ['null', `{% assign x = null %}`],
+      ['blank', `{% assign x = blank %}`],
+      ['empty', `{% assign x = empty %}`],
+      ['range', `{% assign x = (1..10) %}`],
+
+      // lookups
+      ['variable', `{% assign x = other %}`],
+      ['dot lookup', `{% assign x = other.prop %}`],
+      ['string index lookup', `{% assign x = other["prop"] %}`],
+      ['variable index lookup', `{% assign x = other[key] %}`],
+      ['deep dot chain', `{% assign x = a.b.c.d %}`],
+
+      // filters
+      ['single filter', `{% assign x = y | upcase %}`],
+      ['filter with arg', `{% assign x = y | default: 'z' %}`],
+      ['chained filters', `{% assign x = y | default: 'z' | upcase %}`],
+      ['filter with positional args', `{% assign x = y | append: "a" %}`],
+      ['filter with JSON array arg', `{% assign x = y | concat: [1,2] %}`],
+      ['filter with JSON hash arg', `{% assign x = y | merge: {a:1} %}`],
+      ['chained filter after JSON arg', `{% assign x = y | default: [] | join: "," %}`],
+
+      // JSON hash
+      ['empty hash', `{% assign x = {} %}`],
+      ['hash with string key', `{% assign x = { "a": 1 } %}`],
+      ['hash with bare key', `{% assign x = { a: 1 } %}`],
+      ['hash with multiple string keys', `{% assign x = { "a": 1, "b": 2 } %}`],
+      ['hash with mixed keys', `{% assign x = { "a": 1, b: 2 } %}`],
+      ['hash with nested hash', `{% assign x = { "a": { "nested": true } } %}`],
+      ['hash with nested array', `{% assign x = { "a": [1,2,3] } %}`],
+      [
+        'hash with string-interpolated value',
+        `{% assign x = { "email": "{{ email | downcase }}" } %}`,
+      ],
+
+      // JSON array
+      ['empty array', `{% assign x = [] %}`],
+      ['array of numbers', `{% assign x = [1, 2, 3] %}`],
+      ['array of strings', `{% assign x = ["a", "b"] %}`],
+      ['array of literals', `{% assign x = [true, false, nil] %}`],
+      ['array of variables', `{% assign x = [a, b, c] %}`],
+      ['nested arrays', `{% assign x = [[1,2],[3,4]] %}`],
+      ['array of hashes', `{% assign x = [{"a":1}, {"b":2}] %}`],
+
+      // push syntax — only the bare form `a << value` is valid; `a = b << c`
+      // is a compound operator and is NOT accepted by the platformOS runtime.
+      ['bare push with string value', `{% assign my_val << "item" %}`],
+      ['bare push with variable value', `{% assign my_val << val %}`],
+      ['bare push with filter', `{% assign my_val << val | upcase %}`],
+
+      // whitespace-strip
+      ['both trim', `{%- assign x = 'v' -%}`],
+      ['both trim with hash', `{%- assign x = {} -%}`],
+      ['left trim with array', `{%- assign x = [] %}`],
+      ['right trim only', `{% assign x = 'v' -%}`],
+
+      // identifiers
+      ['underscore prefix', `{% assign _private = 1 %}`],
+      ['snake_case', `{% assign snake_case = 1 %}`],
+      ['hyphen in identifier', `{% assign my-var = "hello" %}`],
+      ['multiple hyphens', `{% assign my-complex-var-name = "test" %}`],
+      ['digit in middle', `{% assign x1 = 1 %}`],
+    ];
+
+    for (const [label, sourceCode] of validCases) {
+      it(`should not report: ${label} — ${sourceCode}`, async () => {
+        const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+        expect(offenses).toHaveLength(0);
+      });
+    }
+  });
+
+  describe('interaction with other sub-checks', () => {
+    it('should not fire when MultipleAssignValues already reports trailing garbage', async () => {
+      const sourceCode = `{% assign foo = '123' 555 text %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      const syntaxOffenses = offenses.filter((o) => o.message.includes('Invalid syntax for tag'));
+      expect(syntaxOffenses).toHaveLength(0);
+      const supportOffenses = offenses.filter((o) => o.message === 'Syntax is not supported');
+      expect(supportOffenses).toHaveLength(1);
+    });
+
+    it('should not fire on assign with invalid filter name', async () => {
+      const sourceCode = `{% assign x = "v" | upcase@ %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      const syntaxOffenses = offenses.filter((o) =>
+        o.message.includes("Invalid syntax for tag 'assign'"),
+      );
+      expect(syntaxOffenses).toHaveLength(0);
+    });
+
+    it('should not fire on assign with pipe syntax issue', async () => {
+      const sourceCode = `{% assign x = "v" || upcase %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      const syntaxOffenses = offenses.filter((o) =>
+        o.message.includes("Invalid syntax for tag 'assign'"),
+      );
+      expect(syntaxOffenses).toHaveLength(0);
+    });
+
+    it('should not fire for non-assign tags', async () => {
+      const sourceCode = `{% echo x %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      const syntaxOffenses = offenses.filter((o) =>
+        o.message.includes("Invalid syntax for tag 'assign'"),
+      );
+      expect(syntaxOffenses).toHaveLength(0);
+    });
+  });
+
+  describe('inside {% liquid %} blocks', () => {
+    it('should accept a simple assign statement', async () => {
+      const sourceCode = `{% liquid
+  assign x = 1
+%}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should accept a multi-line hash literal', async () => {
+      const sourceCode = `{% liquid
+  assign h = {
+    "a": 1,
+    "b": 2
+  }
+%}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should accept a multi-line array literal', async () => {
+      const sourceCode = `{% liquid
+  assign a = [
+    "a",
+    "b"
+  ]
+%}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should accept nested multi-line hash', async () => {
+      const sourceCode = `{% liquid
+  assign h = {
+    outer: {
+      inner: "v"
+    }
+  }
+%}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should not let an empty hash swallow the next statement', async () => {
+      const sourceCode = `{% liquid
+  assign h = {}
+  assign a = 'x'
+%}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should parse subsequent tag cleanly after array', async () => {
+      const sourceCode = `{% liquid
+  assign a = [1]
+  render 'p'
+%}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should report target-only assign', async () => {
+      const sourceCode = `{% liquid
+  assign x
+%}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      const syntaxOffenses = offenses.filter((o) =>
+        o.message.includes("Invalid syntax for tag 'assign'"),
+      );
+      expect(syntaxOffenses).toHaveLength(1);
+    });
+
+    it('should report assign with empty RHS', async () => {
+      const sourceCode = `{% liquid
+  assign x =
+%}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      const syntaxOffenses = offenses.filter((o) =>
+        o.message.includes("Invalid syntax for tag 'assign'"),
+      );
+      expect(syntaxOffenses).toHaveLength(1);
+    });
+
+    it('should report assign without `=`', async () => {
+      const sourceCode = `{% liquid
+  assign x "v"
+%}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      const syntaxOffenses = offenses.filter((o) =>
+        o.message.includes("Invalid syntax for tag 'assign'"),
+      );
+      expect(syntaxOffenses).toHaveLength(1);
+    });
+
+    it('should report garbage between hash entries as a parse error', async () => {
+      const sourceCode = `{% liquid
+  assign x = {
+    "a": 1
+  extra garbage
+  }
+%}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses.length).toBeGreaterThan(0);
+    });
+
+    it('should report an unclosed hash before `%}` in tolerant mode', async () => {
+      const sourceCode = `{% liquid
+  assign x = { "a": 1
+%}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('whitespace-trimming delimiters', () => {
+    it('should report with trim delimiters', async () => {
+      const sourceCode = `{%- assign x "var" -%}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      const syntaxOffenses = offenses.filter((o) =>
+        o.message.includes("Invalid syntax for tag 'assign'"),
+      );
+      expect(syntaxOffenses).toHaveLength(1);
+    });
+  });
+
+  // These assertions mirror scenarios from the platformOS runtime test suite
+  // (desksnearme/test/lib/liquify/tags/assign_tag_test.rb) to make sure our
+  // lint-level acceptance aligns with runtime acceptance for common patterns.
+  describe('runtime-alignment scenarios', () => {
+    it('accepts JSON literal as default filter argument (matches Liquify behavior)', async () => {
+      const sourceCode = `{% assign my_val = null | default: [] %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('accepts empty hash as default filter argument', async () => {
+      const sourceCode = `{% assign my_hash = null | default: {} %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('accepts hash_merge with two hash arguments', async () => {
+      const sourceCode = `{% assign merged = { "a": 1 } | hash_merge: h2 | hash_merge: h3 %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('accepts JSON array with mixed primitive types', async () => {
+      const sourceCode = `{% assign arr = ["string", 42, true, null, { "nested": "object" }] %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('accepts JSON hash with escaped double-quote in string value', async () => {
+      const sourceCode = `{% assign data = { "quote": "He said \\"hello\\"" } %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('accepts escaped backslash in double-quoted string', async () => {
+      const sourceCode = `{% assign x = "path\\\\to\\\\file" %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('accepts escaped single-quote in single-quoted string', async () => {
+      const sourceCode = `{% assign x = 'can\\'t' %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('accepts deeply nested JSON structures', async () => {
+      const sourceCode = `{% assign data = {
+        "level1": {
+          "level2": {
+            "level3": {
+              "level4": {
+                "value": "deep",
+                "array": [1, 2, 3]
+              }
+            }
+          }
+        }
+      } %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('accepts JSON array of hashes then map/join filters', async () => {
+      const sourceCode = `{% assign names = users | map: "name" | join: ", " %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('accepts push syntax — `{% assign v << "x" %}`', async () => {
+      const sourceCode = `{% assign my_val << "item" %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('rejects compound operator — `{% assign a = b << c %}` is invalid', async () => {
+      // Per platformOS runtime: an assign uses exactly one of `=` or `<<`, never both.
+      // Our parser falls back to base case; check should flag via MAV or IAS.
+      const sourceCode = `{% assign a = b << c %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses.length).toBeGreaterThan(0);
+    });
+  });
+});