@entifix/testing-e2e 0.1.0-0

package/dist/fixtures/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fixtures/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC"}

package/dist/fixtures/index.js

@@ -0,0 +1,6 @@
+export * from './entity-backend.js';
+export * from './entity-handlers.js';
+export * from './fake-infrastructure.js';
+export * from './signing-key.js';
+
+//# sourceMappingURL=index.js.map

package/dist/fixtures/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/fixtures/index.ts"],"sourcesContent":["export * from './entity-backend.js';\nexport * from './entity-handlers.js';\nexport * from './fake-infrastructure.js';\nexport * from './signing-key.js';\n"],"names":[],"mappings":"AAAA,cAAc,sBAAsB;AACpC,cAAc,uBAAuB;AACrC,cAAc,2BAA2B;AACzC,cAAc,mBAAmB"}

package/dist/fixtures/signing-key.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A throwaway RSA pair the e2e suites sign and verify test tokens with.
+ *
+ * It lives here, in one place, because two sides need *the same* pair: the
+ * `mock` composition root is configured to verify with the public half, and the
+ * spec helpers sign with the private half. Generating one per file would make
+ * every token the other side cannot verify.
+ *
+ * Deliberately **not** the development pair config-service seeds. A suite that
+ * happened to verify a real dev token would be passing for the wrong reason,
+ * and a fixture that doubles as a live credential is one copy-paste away from
+ * becoming one.
+ */
+export declare const E2E_KEY_ID = "e2e-key";
+export declare const E2E_PRIVATE_KEY_PEM = "-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCOQ+cUUN5cVpHo\nwv8SRQYNzGLS6jrEXxzCRggsKvwZS6aa13lJpneB4M5m1K+SXK5aedOeSOl/FyQM\ncLzK/xSMF/CIscZWt5mRFQO75bKyNysUWk2WFUT0e4IZkaAypJdN1pK75XF6OaCI\nvjrP8OuBfDQ61STTzlekLyMA+ZNzwUBR29LhB1Zuh1COocLyyXYry8Tg97njZHSp\nWnmtfKg3WVgHpHLcYiQDUnD0nmjhuJXor/1samgb87k+yxXMuJWTu++sxESQMmpV\ni1iJ4zPQn7IzS799pEn/zFJgRGyIowka3f2DOY8u7O/5JDn5XCI/Qcq4rq9ky1Qa\nH901dkXPAgMBAAECggEAA26GHOp0srLbAxLRGMgrPakUfoZsXkL1+qKd1hLqe6jW\nLVbpuvgyWrEFkLEBmzXJIK9ev3JFelEgle4ECoNPXOjf0IGniWDcaiIvMcNb0Cbz\npGmZPYYE7um4PM2otWVcyeGqvOkkbPQieBu+oFSX4NkSJ7BEjHzCox9BvcryF59d\nc9oFzS97YryD8g94qH6SqgF90qxnxD5oSqz3yRuON6o6SiBwSdsT5yCTiiBIsBSb\nyZP7KN/4LPZnFaPcHJ6UtlMOPae47Z7UBdiuP8/isSyIbnU7j1+TrpXUBqqG6JFI\nEJx3rRW4yYy/syt8BkkLnKa9idbZfCgii+C/X6FNgQKBgQDAd00/+ZIp5HwRkJ7M\ne4SSPxEW9kdCdNwCG9D6GvWZO9d/eeidnM+eoTRPx9NdvfiP5ztsZEtDDfXzMQFp\nJd7Loq5Nc3ZQBchPOIoFGIruUVWlUVawgneRKggfRzDEJLlKBjbVNsPPJFEPkMyO\nXShRKR0cnY4pNen6ug6YRQn7kQKBgQC9OkqCeqVftgi5gE0VkBRf1i1bRIIClw9z\nK08XYej54JcMdYqlTdpsRK0QQYye+wVH3V0Oe2p40leDeVbQMx4W4C1/Rl+Hk05r\nQF9yvgIBPccE/D63ufcKdagj1QLHDXIHUhoMVqtaZIodBSenAV0uOtPKS+6vlVH6\nOlM+Zo+7XwKBgQCOAbiCwn7g4A/W2fEBCQXY7iWK3q3XT+fgumtnjiq2JBwtl2JV\noJTkAydY0iSXHwreCouivyF02UEmbXsP/Pw1HdQjm1SpWIriQOI9Pk2L54Ec2DXx\nSGI2Pl/9zAYkQsBf6NPeX2j8Vlxk8r6rL/sGXyJ2sZ1ptLjt4QfRu+bQsQKBgQCy\niHHOQ3sOH4iBxIx2ALdIaKHoj21+lhnMlpsLu6P9RiodZjUGm7quFemXAdF0GfA0\niqWGyWh+UC6ja/M9gk0sVhx3DeWJ27DMPjMP5jesBiZlDLz7yWhMpQ+bpxj0xznD\nsHHFHGyVX3Bzyu5LglzxBi3Wmue7H831odvybv/DTwKBgETuVvv5b2EhMbKahtnf\ndNrT9ZivoiRD4OaZBXffTG0I2HMu20a7nthKbv2o4pxztDcpW8s6UMU87N8YAK4W\nGX3DjBMHIELxRE96tjifpW9MGQijLCI+jteq4lX0Pxf6HiUB+T1jZ1KDQQfvWJpH\ncAvNvxF+Tev5A4GaIKwmahLI\n-----END PRIVATE KEY-----\n";
+export declare const E2E_PUBLIC_KEY_PEM = "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAjkPnFFDeXFaR6ML/EkUG\nDcxi0uo6xF8cwkYILCr8GUummtd5SaZ3geDOZtSvklyuWnnTnkjpfxckDHC8yv8U\njBfwiLHGVreZkRUDu+WysjcrFFpNlhVE9HuCGZGgMqSXTdaSu+VxejmgiL46z/Dr\ngXw0OtUk085XpC8jAPmTc8FAUdvS4QdWbodQjqHC8sl2K8vE4Pe542R0qVp5rXyo\nN1lYB6Ry3GIkA1Jw9J5o4biV6K/9bGpoG/O5PssVzLiVk7vvrMREkDJqVYtYieMz\n0J+yM0u/faRJ/8xSYERsiKMJGt39gzmPLuzv+SQ5+VwiP0HKuK6vZMtUGh/dNXZF\nzwIDAQAB\n-----END PUBLIC KEY-----\n";
+/**
+ * A key nothing in the fleet trusts, for the suites that assert a forged token
+ * is refused.
+ *
+ * A separate pair rather than a mangled signature, because they fail for
+ * different reasons: a corrupt signature could plausibly be caught by a
+ * structural check, while a *validly signed token from the wrong issuer's key*
+ * is the actual attack, and only a real verification catches it.
+ */
+export declare const E2E_FOREIGN_PRIVATE_KEY_PEM = "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCgkVvRRzabj1gS\nZylt4+H7vMIL/nlCC/WoCLegBia3b9RaOkfCdXi+N99oFkcwwjywRsXmotNyPhEi\nrqFEvvxUCZQmk9Cdo2+DYzFZq/6k2/5+e3Tr3NDlvYHVaqp6CRC+DqMIorQ6TT3D\nSV/pu/Gz1U1MgE9TeB/Zw5yUjenknyjWzxeRwJjKvn10Jg2/YJzcvcsKeiED6+LU\nFVkiJsvnxUvuJWnjGmtXocb85PbN4oD54eERLGL/cxZB4p8K6P/KTQrQV207qL+m\nRqYjTj2Wu/ct4FSdGPKm5mhMP87sqioXU14t2R/nltIgiom0FajqyrR15krLkXSy\n0PrGIqbHAgMBAAECggEAT1aTrkxIRMQm6ez0cRqFOoyRuzhxtPtQ1kb8aIMxlTka\nDb03YPQHhcH4zycW5RZMw3Ms7SGuZggaEm+EOwI9js6u2AL4tTOg8aRNKbhNGiuj\ny953ruWMiMBDS28priQVlDuKPkWa1SX+aySx0j2uF8RBLhhGWgGEh2ba0yJuHCrq\nN+l7wU26loDjlwS7dTQYc8z2WvGnKBbJVUJzJaLeUyMftVCd86sgjiYX9nnVuqxo\nT9kE7/GhLOeP1vSjYj3Tk6CrQQlEanIUrSrogMt0LXVtek5sDyFPqTKnhd+bjNtl\nsTfibYU7Yq4xlV/Bu3ntJYXh0hiL4VS1bOWc1rh6oQKBgQDLtiMbPuREXwJwgYKP\nSB72RhGiT1fvklWyq43CGMsVgE43ncJAtrGb6A0fBVspYnS7YKIaUAVTyboNrycD\nJzgFaVF/m75GeQDKOoRoPRfke/ytA3NIEeAy2Vo+1ZD60SLVdvFgusuJbwrg0Vn7\noxbigMi39Bif5ADz/+nupDgoJwKBgQDJyEFLq0CSiltScR7GzkCM9rSNs2ntSNOL\nGVM7iZ32AP+UukFa02CC/s+6p660JUtFuZ6ax8npb+TAwWc2BydcRuqMQVmDMZ0j\nl1A/PNZS9myvgy+RpwCtWPJc0k2AIrMIJM6pcj/ZByxV1tJcKj19CyM03phlg9Py\nTtmkSX8QYQKBgQCnyDoeBKzJy18c/u5jyMkHmiqH/sW0olhHMpktVnJeITFLCXqn\nBlI+0N+Nv0GYUmlGs46QEXxxyGKfRrXhGPpBKr9fVQ1gyeTmq0/G8xqsq5ovffoD\nUAXSm8aCnjAtBPelzbN9MhzV80mIZaWxZmBA6kVnjXqCpq5KSWuJjGRcXQKBgBLe\n4IRkGqDZwZqfK6KqDU1hkRcjbUecpPQARVFvGE+2XjCZjp0g4Yi+rcyl++erCTQX\nHOcawh5LsZf5Pl7GIn81vp+pSObFEA4RC5cuaFjP5PAxE5TKinyrsdbOcCMIm7eq\nQY2FOsVgL1xDv96QsLlt/jfmjVgJERw7FY2QtgphAoGAcbrPfjRrDMqthf3LJsFu\nZH3hkadfbsCLld6UvAva0Vkugv5kOx0wB6+Bbk3rEGUPUxpaq1+iFhr7gUlghAA3\nlRKwXGJZJc5PIUuHoxCYg/W4rKbYlrlYAwYQaNIucTT/bUgXw6Ra5rxEqnpgKiqJ\nMUzrkxXjBuapqxOF4QzIySg=\n-----END PRIVATE KEY-----\n";
+//# sourceMappingURL=signing-key.d.ts.map

package/dist/fixtures/signing-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signing-key.d.ts","sourceRoot":"","sources":["../../src/fixtures/signing-key.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,YAAY,CAAC;AAEpC,eAAO,MAAM,mBAAmB,ysDA4B/B,CAAC;AAEF,eAAO,MAAM,kBAAkB,idAS9B,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,ysDA4BvC,CAAC"}

package/dist/fixtures/signing-key.js

@@ -0,0 +1,91 @@
+/**
+ * A throwaway RSA pair the e2e suites sign and verify test tokens with.
+ *
+ * It lives here, in one place, because two sides need *the same* pair: the
+ * `mock` composition root is configured to verify with the public half, and the
+ * spec helpers sign with the private half. Generating one per file would make
+ * every token the other side cannot verify.
+ *
+ * Deliberately **not** the development pair config-service seeds. A suite that
+ * happened to verify a real dev token would be passing for the wrong reason,
+ * and a fixture that doubles as a live credential is one copy-paste away from
+ * becoming one.
+ */ export const E2E_KEY_ID = 'e2e-key';
+export const E2E_PRIVATE_KEY_PEM = `-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCOQ+cUUN5cVpHo
+wv8SRQYNzGLS6jrEXxzCRggsKvwZS6aa13lJpneB4M5m1K+SXK5aedOeSOl/FyQM
+cLzK/xSMF/CIscZWt5mRFQO75bKyNysUWk2WFUT0e4IZkaAypJdN1pK75XF6OaCI
+vjrP8OuBfDQ61STTzlekLyMA+ZNzwUBR29LhB1Zuh1COocLyyXYry8Tg97njZHSp
+WnmtfKg3WVgHpHLcYiQDUnD0nmjhuJXor/1samgb87k+yxXMuJWTu++sxESQMmpV
+i1iJ4zPQn7IzS799pEn/zFJgRGyIowka3f2DOY8u7O/5JDn5XCI/Qcq4rq9ky1Qa
+H901dkXPAgMBAAECggEAA26GHOp0srLbAxLRGMgrPakUfoZsXkL1+qKd1hLqe6jW
+LVbpuvgyWrEFkLEBmzXJIK9ev3JFelEgle4ECoNPXOjf0IGniWDcaiIvMcNb0Cbz
+pGmZPYYE7um4PM2otWVcyeGqvOkkbPQieBu+oFSX4NkSJ7BEjHzCox9BvcryF59d
+c9oFzS97YryD8g94qH6SqgF90qxnxD5oSqz3yRuON6o6SiBwSdsT5yCTiiBIsBSb
+yZP7KN/4LPZnFaPcHJ6UtlMOPae47Z7UBdiuP8/isSyIbnU7j1+TrpXUBqqG6JFI
+EJx3rRW4yYy/syt8BkkLnKa9idbZfCgii+C/X6FNgQKBgQDAd00/+ZIp5HwRkJ7M
+e4SSPxEW9kdCdNwCG9D6GvWZO9d/eeidnM+eoTRPx9NdvfiP5ztsZEtDDfXzMQFp
+Jd7Loq5Nc3ZQBchPOIoFGIruUVWlUVawgneRKggfRzDEJLlKBjbVNsPPJFEPkMyO
+XShRKR0cnY4pNen6ug6YRQn7kQKBgQC9OkqCeqVftgi5gE0VkBRf1i1bRIIClw9z
+K08XYej54JcMdYqlTdpsRK0QQYye+wVH3V0Oe2p40leDeVbQMx4W4C1/Rl+Hk05r
+QF9yvgIBPccE/D63ufcKdagj1QLHDXIHUhoMVqtaZIodBSenAV0uOtPKS+6vlVH6
+OlM+Zo+7XwKBgQCOAbiCwn7g4A/W2fEBCQXY7iWK3q3XT+fgumtnjiq2JBwtl2JV
+oJTkAydY0iSXHwreCouivyF02UEmbXsP/Pw1HdQjm1SpWIriQOI9Pk2L54Ec2DXx
+SGI2Pl/9zAYkQsBf6NPeX2j8Vlxk8r6rL/sGXyJ2sZ1ptLjt4QfRu+bQsQKBgQCy
+iHHOQ3sOH4iBxIx2ALdIaKHoj21+lhnMlpsLu6P9RiodZjUGm7quFemXAdF0GfA0
+iqWGyWh+UC6ja/M9gk0sVhx3DeWJ27DMPjMP5jesBiZlDLz7yWhMpQ+bpxj0xznD
+sHHFHGyVX3Bzyu5LglzxBi3Wmue7H831odvybv/DTwKBgETuVvv5b2EhMbKahtnf
+dNrT9ZivoiRD4OaZBXffTG0I2HMu20a7nthKbv2o4pxztDcpW8s6UMU87N8YAK4W
+GX3DjBMHIELxRE96tjifpW9MGQijLCI+jteq4lX0Pxf6HiUB+T1jZ1KDQQfvWJpH
+cAvNvxF+Tev5A4GaIKwmahLI
+-----END PRIVATE KEY-----
+`;
+export const E2E_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAjkPnFFDeXFaR6ML/EkUG
+Dcxi0uo6xF8cwkYILCr8GUummtd5SaZ3geDOZtSvklyuWnnTnkjpfxckDHC8yv8U
+jBfwiLHGVreZkRUDu+WysjcrFFpNlhVE9HuCGZGgMqSXTdaSu+VxejmgiL46z/Dr
+gXw0OtUk085XpC8jAPmTc8FAUdvS4QdWbodQjqHC8sl2K8vE4Pe542R0qVp5rXyo
+N1lYB6Ry3GIkA1Jw9J5o4biV6K/9bGpoG/O5PssVzLiVk7vvrMREkDJqVYtYieMz
+0J+yM0u/faRJ/8xSYERsiKMJGt39gzmPLuzv+SQ5+VwiP0HKuK6vZMtUGh/dNXZF
+zwIDAQAB
+-----END PUBLIC KEY-----
+`;
+/**
+ * A key nothing in the fleet trusts, for the suites that assert a forged token
+ * is refused.
+ *
+ * A separate pair rather than a mangled signature, because they fail for
+ * different reasons: a corrupt signature could plausibly be caught by a
+ * structural check, while a *validly signed token from the wrong issuer's key*
+ * is the actual attack, and only a real verification catches it.
+ */ export const E2E_FOREIGN_PRIVATE_KEY_PEM = `-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCgkVvRRzabj1gS
+Zylt4+H7vMIL/nlCC/WoCLegBia3b9RaOkfCdXi+N99oFkcwwjywRsXmotNyPhEi
+rqFEvvxUCZQmk9Cdo2+DYzFZq/6k2/5+e3Tr3NDlvYHVaqp6CRC+DqMIorQ6TT3D
+SV/pu/Gz1U1MgE9TeB/Zw5yUjenknyjWzxeRwJjKvn10Jg2/YJzcvcsKeiED6+LU
+FVkiJsvnxUvuJWnjGmtXocb85PbN4oD54eERLGL/cxZB4p8K6P/KTQrQV207qL+m
+RqYjTj2Wu/ct4FSdGPKm5mhMP87sqioXU14t2R/nltIgiom0FajqyrR15krLkXSy
+0PrGIqbHAgMBAAECggEAT1aTrkxIRMQm6ez0cRqFOoyRuzhxtPtQ1kb8aIMxlTka
+Db03YPQHhcH4zycW5RZMw3Ms7SGuZggaEm+EOwI9js6u2AL4tTOg8aRNKbhNGiuj
+y953ruWMiMBDS28priQVlDuKPkWa1SX+aySx0j2uF8RBLhhGWgGEh2ba0yJuHCrq
+N+l7wU26loDjlwS7dTQYc8z2WvGnKBbJVUJzJaLeUyMftVCd86sgjiYX9nnVuqxo
+T9kE7/GhLOeP1vSjYj3Tk6CrQQlEanIUrSrogMt0LXVtek5sDyFPqTKnhd+bjNtl
+sTfibYU7Yq4xlV/Bu3ntJYXh0hiL4VS1bOWc1rh6oQKBgQDLtiMbPuREXwJwgYKP
+SB72RhGiT1fvklWyq43CGMsVgE43ncJAtrGb6A0fBVspYnS7YKIaUAVTyboNrycD
+JzgFaVF/m75GeQDKOoRoPRfke/ytA3NIEeAy2Vo+1ZD60SLVdvFgusuJbwrg0Vn7
+oxbigMi39Bif5ADz/+nupDgoJwKBgQDJyEFLq0CSiltScR7GzkCM9rSNs2ntSNOL
+GVM7iZ32AP+UukFa02CC/s+6p660JUtFuZ6ax8npb+TAwWc2BydcRuqMQVmDMZ0j
+l1A/PNZS9myvgy+RpwCtWPJc0k2AIrMIJM6pcj/ZByxV1tJcKj19CyM03phlg9Py
+TtmkSX8QYQKBgQCnyDoeBKzJy18c/u5jyMkHmiqH/sW0olhHMpktVnJeITFLCXqn
+BlI+0N+Nv0GYUmlGs46QEXxxyGKfRrXhGPpBKr9fVQ1gyeTmq0/G8xqsq5ovffoD
+UAXSm8aCnjAtBPelzbN9MhzV80mIZaWxZmBA6kVnjXqCpq5KSWuJjGRcXQKBgBLe
+4IRkGqDZwZqfK6KqDU1hkRcjbUecpPQARVFvGE+2XjCZjp0g4Yi+rcyl++erCTQX
+HOcawh5LsZf5Pl7GIn81vp+pSObFEA4RC5cuaFjP5PAxE5TKinyrsdbOcCMIm7eq
+QY2FOsVgL1xDv96QsLlt/jfmjVgJERw7FY2QtgphAoGAcbrPfjRrDMqthf3LJsFu
+ZH3hkadfbsCLld6UvAva0Vkugv5kOx0wB6+Bbk3rEGUPUxpaq1+iFhr7gUlghAA3
+lRKwXGJZJc5PIUuHoxCYg/W4rKbYlrlYAwYQaNIucTT/bUgXw6Ra5rxEqnpgKiqJ
+MUzrkxXjBuapqxOF4QzIySg=
+-----END PRIVATE KEY-----
+`;
+
+//# sourceMappingURL=signing-key.js.map

package/dist/fixtures/signing-key.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/fixtures/signing-key.ts"],"sourcesContent":["/**\n * A throwaway RSA pair the e2e suites sign and verify test tokens with.\n *\n * It lives here, in one place, because two sides need *the same* pair: the\n * `mock` composition root is configured to verify with the public half, and the\n * spec helpers sign with the private half. Generating one per file would make\n * every token the other side cannot verify.\n *\n * Deliberately **not** the development pair config-service seeds. A suite that\n * happened to verify a real dev token would be passing for the wrong reason,\n * and a fixture that doubles as a live credential is one copy-paste away from\n * becoming one.\n */\nexport const E2E_KEY_ID = 'e2e-key';\n\nexport const E2E_PRIVATE_KEY_PEM = `-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCOQ+cUUN5cVpHo\nwv8SRQYNzGLS6jrEXxzCRggsKvwZS6aa13lJpneB4M5m1K+SXK5aedOeSOl/FyQM\ncLzK/xSMF/CIscZWt5mRFQO75bKyNysUWk2WFUT0e4IZkaAypJdN1pK75XF6OaCI\nvjrP8OuBfDQ61STTzlekLyMA+ZNzwUBR29LhB1Zuh1COocLyyXYry8Tg97njZHSp\nWnmtfKg3WVgHpHLcYiQDUnD0nmjhuJXor/1samgb87k+yxXMuJWTu++sxESQMmpV\ni1iJ4zPQn7IzS799pEn/zFJgRGyIowka3f2DOY8u7O/5JDn5XCI/Qcq4rq9ky1Qa\nH901dkXPAgMBAAECggEAA26GHOp0srLbAxLRGMgrPakUfoZsXkL1+qKd1hLqe6jW\nLVbpuvgyWrEFkLEBmzXJIK9ev3JFelEgle4ECoNPXOjf0IGniWDcaiIvMcNb0Cbz\npGmZPYYE7um4PM2otWVcyeGqvOkkbPQieBu+oFSX4NkSJ7BEjHzCox9BvcryF59d\nc9oFzS97YryD8g94qH6SqgF90qxnxD5oSqz3yRuON6o6SiBwSdsT5yCTiiBIsBSb\nyZP7KN/4LPZnFaPcHJ6UtlMOPae47Z7UBdiuP8/isSyIbnU7j1+TrpXUBqqG6JFI\nEJx3rRW4yYy/syt8BkkLnKa9idbZfCgii+C/X6FNgQKBgQDAd00/+ZIp5HwRkJ7M\ne4SSPxEW9kdCdNwCG9D6GvWZO9d/eeidnM+eoTRPx9NdvfiP5ztsZEtDDfXzMQFp\nJd7Loq5Nc3ZQBchPOIoFGIruUVWlUVawgneRKggfRzDEJLlKBjbVNsPPJFEPkMyO\nXShRKR0cnY4pNen6ug6YRQn7kQKBgQC9OkqCeqVftgi5gE0VkBRf1i1bRIIClw9z\nK08XYej54JcMdYqlTdpsRK0QQYye+wVH3V0Oe2p40leDeVbQMx4W4C1/Rl+Hk05r\nQF9yvgIBPccE/D63ufcKdagj1QLHDXIHUhoMVqtaZIodBSenAV0uOtPKS+6vlVH6\nOlM+Zo+7XwKBgQCOAbiCwn7g4A/W2fEBCQXY7iWK3q3XT+fgumtnjiq2JBwtl2JV\noJTkAydY0iSXHwreCouivyF02UEmbXsP/Pw1HdQjm1SpWIriQOI9Pk2L54Ec2DXx\nSGI2Pl/9zAYkQsBf6NPeX2j8Vlxk8r6rL/sGXyJ2sZ1ptLjt4QfRu+bQsQKBgQCy\niHHOQ3sOH4iBxIx2ALdIaKHoj21+lhnMlpsLu6P9RiodZjUGm7quFemXAdF0GfA0\niqWGyWh+UC6ja/M9gk0sVhx3DeWJ27DMPjMP5jesBiZlDLz7yWhMpQ+bpxj0xznD\nsHHFHGyVX3Bzyu5LglzxBi3Wmue7H831odvybv/DTwKBgETuVvv5b2EhMbKahtnf\ndNrT9ZivoiRD4OaZBXffTG0I2HMu20a7nthKbv2o4pxztDcpW8s6UMU87N8YAK4W\nGX3DjBMHIELxRE96tjifpW9MGQijLCI+jteq4lX0Pxf6HiUB+T1jZ1KDQQfvWJpH\ncAvNvxF+Tev5A4GaIKwmahLI\n-----END PRIVATE KEY-----\n`;\n\nexport const E2E_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAjkPnFFDeXFaR6ML/EkUG\nDcxi0uo6xF8cwkYILCr8GUummtd5SaZ3geDOZtSvklyuWnnTnkjpfxckDHC8yv8U\njBfwiLHGVreZkRUDu+WysjcrFFpNlhVE9HuCGZGgMqSXTdaSu+VxejmgiL46z/Dr\ngXw0OtUk085XpC8jAPmTc8FAUdvS4QdWbodQjqHC8sl2K8vE4Pe542R0qVp5rXyo\nN1lYB6Ry3GIkA1Jw9J5o4biV6K/9bGpoG/O5PssVzLiVk7vvrMREkDJqVYtYieMz\n0J+yM0u/faRJ/8xSYERsiKMJGt39gzmPLuzv+SQ5+VwiP0HKuK6vZMtUGh/dNXZF\nzwIDAQAB\n-----END PUBLIC KEY-----\n`;\n\n/**\n * A key nothing in the fleet trusts, for the suites that assert a forged token\n * is refused.\n *\n * A separate pair rather than a mangled signature, because they fail for\n * different reasons: a corrupt signature could plausibly be caught by a\n * structural check, while a *validly signed token from the wrong issuer's key*\n * is the actual attack, and only a real verification catches it.\n */\nexport const E2E_FOREIGN_PRIVATE_KEY_PEM = `-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCgkVvRRzabj1gS\nZylt4+H7vMIL/nlCC/WoCLegBia3b9RaOkfCdXi+N99oFkcwwjywRsXmotNyPhEi\nrqFEvvxUCZQmk9Cdo2+DYzFZq/6k2/5+e3Tr3NDlvYHVaqp6CRC+DqMIorQ6TT3D\nSV/pu/Gz1U1MgE9TeB/Zw5yUjenknyjWzxeRwJjKvn10Jg2/YJzcvcsKeiED6+LU\nFVkiJsvnxUvuJWnjGmtXocb85PbN4oD54eERLGL/cxZB4p8K6P/KTQrQV207qL+m\nRqYjTj2Wu/ct4FSdGPKm5mhMP87sqioXU14t2R/nltIgiom0FajqyrR15krLkXSy\n0PrGIqbHAgMBAAECggEAT1aTrkxIRMQm6ez0cRqFOoyRuzhxtPtQ1kb8aIMxlTka\nDb03YPQHhcH4zycW5RZMw3Ms7SGuZggaEm+EOwI9js6u2AL4tTOg8aRNKbhNGiuj\ny953ruWMiMBDS28priQVlDuKPkWa1SX+aySx0j2uF8RBLhhGWgGEh2ba0yJuHCrq\nN+l7wU26loDjlwS7dTQYc8z2WvGnKBbJVUJzJaLeUyMftVCd86sgjiYX9nnVuqxo\nT9kE7/GhLOeP1vSjYj3Tk6CrQQlEanIUrSrogMt0LXVtek5sDyFPqTKnhd+bjNtl\nsTfibYU7Yq4xlV/Bu3ntJYXh0hiL4VS1bOWc1rh6oQKBgQDLtiMbPuREXwJwgYKP\nSB72RhGiT1fvklWyq43CGMsVgE43ncJAtrGb6A0fBVspYnS7YKIaUAVTyboNrycD\nJzgFaVF/m75GeQDKOoRoPRfke/ytA3NIEeAy2Vo+1ZD60SLVdvFgusuJbwrg0Vn7\noxbigMi39Bif5ADz/+nupDgoJwKBgQDJyEFLq0CSiltScR7GzkCM9rSNs2ntSNOL\nGVM7iZ32AP+UukFa02CC/s+6p660JUtFuZ6ax8npb+TAwWc2BydcRuqMQVmDMZ0j\nl1A/PNZS9myvgy+RpwCtWPJc0k2AIrMIJM6pcj/ZByxV1tJcKj19CyM03phlg9Py\nTtmkSX8QYQKBgQCnyDoeBKzJy18c/u5jyMkHmiqH/sW0olhHMpktVnJeITFLCXqn\nBlI+0N+Nv0GYUmlGs46QEXxxyGKfRrXhGPpBKr9fVQ1gyeTmq0/G8xqsq5ovffoD\nUAXSm8aCnjAtBPelzbN9MhzV80mIZaWxZmBA6kVnjXqCpq5KSWuJjGRcXQKBgBLe\n4IRkGqDZwZqfK6KqDU1hkRcjbUecpPQARVFvGE+2XjCZjp0g4Yi+rcyl++erCTQX\nHOcawh5LsZf5Pl7GIn81vp+pSObFEA4RC5cuaFjP5PAxE5TKinyrsdbOcCMIm7eq\nQY2FOsVgL1xDv96QsLlt/jfmjVgJERw7FY2QtgphAoGAcbrPfjRrDMqthf3LJsFu\nZH3hkadfbsCLld6UvAva0Vkugv5kOx0wB6+Bbk3rEGUPUxpaq1+iFhr7gUlghAA3\nlRKwXGJZJc5PIUuHoxCYg/W4rKbYlrlYAwYQaNIucTT/bUgXw6Ra5rxEqnpgKiqJ\nMUzrkxXjBuapqxOF4QzIySg=\n-----END PRIVATE KEY-----\n`;\n"],"names":["E2E_KEY_ID","E2E_PRIVATE_KEY_PEM","E2E_PUBLIC_KEY_PEM","E2E_FOREIGN_PRIVATE_KEY_PEM"],"mappings":"AAAA;;;;;;;;;;;;CAYC,GACD,OAAO,MAAMA,aAAa,UAAU;AAEpC,OAAO,MAAMC,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BpC,CAAC,CAAC;AAEF,OAAO,MAAMC,qBAAqB,CAAC;;;;;;;;;AASnC,CAAC,CAAC;AAEF;;;;;;;;CAQC,GACD,OAAO,MAAMC,8BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4B5C,CAAC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './profile/profile.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './profile/profile.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './profile/profile.js';\n"],"names":[],"mappings":"AAAA,cAAc,uBAAuB"}

package/dist/playwright/assert-expected-server.d.ts

@@ -0,0 +1,43 @@
+import { type E2eEnv } from '../profile/profile.js';
+/** Opts out of the guard, for a developer who knows what they are attaching to. */
+export declare const ALLOW_DEV_SERVER_VAR = "R10C_E2E_ALLOW_DEV_SERVER";
+export interface AssertExpectedServerOptions {
+    /** Where the suite is pointed, e.g. `http://localhost:3001`. */
+    readonly baseURL: string;
+    readonly env?: E2eEnv;
+    readonly fetchImpl?: typeof fetch;
+    readonly warn?: (message: string) => void;
+}
+/**
+ * Refuses to run the hermetic suite against a development server.
+ *
+ * `reuseExistingServer` is what makes a local run fast, and turning it off costs
+ * a production build every time. So the reuse stays and the *assumption* is
+ * checked instead: the `mock` profile's whole claim is that it is hermetic, and
+ * attached to a dev server it is not. Turning a silent wrong answer into a loud
+ * failure is the trade — see issue #69.
+ *
+ * `live` is exempt on purpose: it expects an already-running app and makes no
+ * hermeticity claim, so which build answers is the operator's business.
+ *
+ * Only when **both** signals are unreadable does the run continue, with a
+ * warning: an app that exposes neither is not a reason to refuse to test it.
+ */
+export declare const assertExpectedServer: ({ baseURL, env, fetchImpl, warn, }: AssertExpectedServerOptions) => Promise<void>;
+/**
+ * The form `defineEntifixE2eTest` calls, from an auto fixture.
+ *
+ * A fixture rather than `globalSetup`, which is where this naturally belongs:
+ * Playwright loads a `globalSetup` file through a different module path than
+ * the config and the specs, and this package is `"type": "module"` while an
+ * app's `playwright.config.ts` is CJS — the same file transpiles for one and
+ * throws `exports is not defined in ES module scope` for the other. The
+ * fixture rides the path that already works, at the cost of reporting the
+ * refusal once per test rather than once per run.
+ *
+ * The promise is cached, so the probe happens once and every subsequent test
+ * rejects with the same error instead of re-asking a server that will not have
+ * changed mid-run.
+ */
+export declare const assertExpectedServerOnce: (baseURL: string | undefined) => Promise<void>;
+//# sourceMappingURL=assert-expected-server.d.ts.map

package/dist/playwright/assert-expected-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-expected-server.d.ts","sourceRoot":"","sources":["../../src/playwright/assert-expected-server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAiB,MAAM,uBAAuB,CAAC;AAEnE,mFAAmF;AACnF,eAAO,MAAM,oBAAoB,8BAA8B,CAAC;AA0BhE,MAAM,WAAW,2BAA2B;IAC1C,gEAAgE;IAChE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IAClC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAC3C;AAiBD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,GAAU,oCAKxC,2BAA2B,KAAG,OAAO,CAAC,IAAI,CAiC5C,CAAC;AAKF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB,GACnC,SAAS,MAAM,GAAG,SAAS,KAC1B,OAAO,CAAC,IAAI,CAKd,CAAC"}

package/dist/playwright/assert-expected-server.js

@@ -0,0 +1,98 @@
+import { isMockProfile } from '../profile/profile.js';
+/** Opts out of the guard, for a developer who knows what they are attaching to. */ export const ALLOW_DEV_SERVER_VAR = 'R10C_E2E_ALLOW_DEV_SERVER';
+/**
+ * Liveness, not the config's `readyPath`: every app answers it, it answers from
+ * the process alone, and it carries the one field this check needs. `readyPath`
+ * differs per app and defaults to `/`, which returns HTML.
+ */ const LIVENESS_PATH = '/api/health/live';
+/**
+ * The second signal, which needs no cooperation from the app at all.
+ *
+ * `next dev` serves its static assets under the literal segment `development`;
+ * a production build uses a hashed build id, so this 404s under `next start`.
+ * It is a Next internal and therefore the *fallback*, but it is the one that
+ * survives the case that motivates it: an `nx e2e` run builds into the same
+ * `.next` the running dev server owns, which corrupts that server's Turbopack
+ * cache and makes every app route — liveness included — answer `500`. A guard
+ * that only asked the app would degrade to "cannot tell" at exactly the moment
+ * it is needed.
+ */ const DEV_ASSET_PATH = '/_next/static/development/_buildManifest.js';
+/** A probe that hangs must not hold the whole run hostage. */ const PROBE_TIMEOUT_MS = 5000;
+const describeMismatch = (baseURL)=>[
+        `The hermetic e2e profile attached to a DEVELOPMENT server at ${baseURL}.`,
+        '',
+        'Playwright reuses whatever already listens on the app port, so this run would',
+        'test `next dev` — a different bundle, no prerender, and with the dev fleet',
+        "behind it the real services instead of this profile's fakes. It can fail, or",
+        'pass, for reasons that have nothing to do with the code under test. The build',
+        'this run just made also writes the same `.next` the dev server owns, which',
+        'corrupts its Turbopack cache on the way past.',
+        '',
+        'Stop the dev server on that port and run again, or set',
+        `${ALLOW_DEV_SERVER_VAR}=1 to accept the risk.`
+    ].join('\n');
+/**
+ * Refuses to run the hermetic suite against a development server.
+ *
+ * `reuseExistingServer` is what makes a local run fast, and turning it off costs
+ * a production build every time. So the reuse stays and the *assumption* is
+ * checked instead: the `mock` profile's whole claim is that it is hermetic, and
+ * attached to a dev server it is not. Turning a silent wrong answer into a loud
+ * failure is the trade — see issue #69.
+ *
+ * `live` is exempt on purpose: it expects an already-running app and makes no
+ * hermeticity claim, so which build answers is the operator's business.
+ *
+ * Only when **both** signals are unreadable does the run continue, with a
+ * warning: an app that exposes neither is not a reason to refuse to test it.
+ */ export const assertExpectedServer = async ({ baseURL, env = process.env, fetchImpl = fetch, warn = (message)=>console.warn(message) })=>{
+    if (!isMockProfile(env)) return;
+    const override = env[ALLOW_DEV_SERVER_VAR];
+    if (override !== undefined && override !== '') return;
+    const get = async (path)=>{
+        try {
+            return await fetchImpl(`${baseURL}${path}`, {
+                signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+            });
+        } catch (unused) {
+            return undefined;
+        }
+    };
+    const liveness = await get(LIVENESS_PATH);
+    if ((liveness == null ? void 0 : liveness.ok) === true) {
+        const mode = (await liveness.json()).mode;
+        if (mode === 'production') return;
+        if (mode === 'development') throw new Error(describeMismatch(baseURL));
+    }
+    // The app could not answer for itself. Ask Next directly.
+    const devAsset = await get(DEV_ASSET_PATH);
+    if (devAsset === undefined) {
+        warn(`e2e: could not reach ${baseURL}; cannot tell which build is serving.`);
+        return;
+    }
+    if (devAsset.ok) throw new Error(describeMismatch(baseURL));
+};
+/** One probe per worker process, whatever the outcome. */ let verdict;
+/**
+ * The form `defineEntifixE2eTest` calls, from an auto fixture.
+ *
+ * A fixture rather than `globalSetup`, which is where this naturally belongs:
+ * Playwright loads a `globalSetup` file through a different module path than
+ * the config and the specs, and this package is `"type": "module"` while an
+ * app's `playwright.config.ts` is CJS — the same file transpiles for one and
+ * throws `exports is not defined in ES module scope` for the other. The
+ * fixture rides the path that already works, at the cost of reporting the
+ * refusal once per test rather than once per run.
+ *
+ * The promise is cached, so the probe happens once and every subsequent test
+ * rejects with the same error instead of re-asking a server that will not have
+ * changed mid-run.
+ */ export const assertExpectedServerOnce = (baseURL)=>{
+    if (baseURL === undefined || baseURL === '') return Promise.resolve();
+    verdict != null ? verdict : verdict = assertExpectedServer({
+        baseURL
+    });
+    return verdict;
+};
+
+//# sourceMappingURL=assert-expected-server.js.map

package/dist/playwright/assert-expected-server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/playwright/assert-expected-server.ts"],"sourcesContent":["import { type E2eEnv, isMockProfile } from '../profile/profile.js';\n\n/** Opts out of the guard, for a developer who knows what they are attaching to. */\nexport const ALLOW_DEV_SERVER_VAR = 'R10C_E2E_ALLOW_DEV_SERVER';\n\n/**\n * Liveness, not the config's `readyPath`: every app answers it, it answers from\n * the process alone, and it carries the one field this check needs. `readyPath`\n * differs per app and defaults to `/`, which returns HTML.\n */\nconst LIVENESS_PATH = '/api/health/live';\n\n/**\n * The second signal, which needs no cooperation from the app at all.\n *\n * `next dev` serves its static assets under the literal segment `development`;\n * a production build uses a hashed build id, so this 404s under `next start`.\n * It is a Next internal and therefore the *fallback*, but it is the one that\n * survives the case that motivates it: an `nx e2e` run builds into the same\n * `.next` the running dev server owns, which corrupts that server's Turbopack\n * cache and makes every app route — liveness included — answer `500`. A guard\n * that only asked the app would degrade to \"cannot tell\" at exactly the moment\n * it is needed.\n */\nconst DEV_ASSET_PATH = '/_next/static/development/_buildManifest.js';\n\n/** A probe that hangs must not hold the whole run hostage. */\nconst PROBE_TIMEOUT_MS = 5_000;\n\nexport interface AssertExpectedServerOptions {\n  /** Where the suite is pointed, e.g. `http://localhost:3001`. */\n  readonly baseURL: string;\n  readonly env?: E2eEnv;\n  readonly fetchImpl?: typeof fetch;\n  readonly warn?: (message: string) => void;\n}\n\nconst describeMismatch = (baseURL: string): string =>\n  [\n    `The hermetic e2e profile attached to a DEVELOPMENT server at ${baseURL}.`,\n    '',\n    'Playwright reuses whatever already listens on the app port, so this run would',\n    'test `next dev` — a different bundle, no prerender, and with the dev fleet',\n    \"behind it the real services instead of this profile's fakes. It can fail, or\",\n    'pass, for reasons that have nothing to do with the code under test. The build',\n    'this run just made also writes the same `.next` the dev server owns, which',\n    'corrupts its Turbopack cache on the way past.',\n    '',\n    'Stop the dev server on that port and run again, or set',\n    `${ALLOW_DEV_SERVER_VAR}=1 to accept the risk.`,\n  ].join('\\n');\n\n/**\n * Refuses to run the hermetic suite against a development server.\n *\n * `reuseExistingServer` is what makes a local run fast, and turning it off costs\n * a production build every time. So the reuse stays and the *assumption* is\n * checked instead: the `mock` profile's whole claim is that it is hermetic, and\n * attached to a dev server it is not. Turning a silent wrong answer into a loud\n * failure is the trade — see issue #69.\n *\n * `live` is exempt on purpose: it expects an already-running app and makes no\n * hermeticity claim, so which build answers is the operator's business.\n *\n * Only when **both** signals are unreadable does the run continue, with a\n * warning: an app that exposes neither is not a reason to refuse to test it.\n */\nexport const assertExpectedServer = async ({\n  baseURL,\n  env = process.env,\n  fetchImpl = fetch,\n  warn = message => console.warn(message),\n}: AssertExpectedServerOptions): Promise<void> => {\n  if (!isMockProfile(env)) return;\n\n  const override = env[ALLOW_DEV_SERVER_VAR];\n  if (override !== undefined && override !== '') return;\n\n  const get = async (path: string): Promise<Response | undefined> => {\n    try {\n      return await fetchImpl(`${baseURL}${path}`, {\n        signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),\n      });\n    } catch {\n      return undefined;\n    }\n  };\n\n  const liveness = await get(LIVENESS_PATH);\n  if (liveness?.ok === true) {\n    const mode = ((await liveness.json()) as { mode?: unknown }).mode;\n    if (mode === 'production') return;\n    if (mode === 'development') throw new Error(describeMismatch(baseURL));\n  }\n\n  // The app could not answer for itself. Ask Next directly.\n  const devAsset = await get(DEV_ASSET_PATH);\n  if (devAsset === undefined) {\n    warn(\n      `e2e: could not reach ${baseURL}; cannot tell which build is serving.`,\n    );\n    return;\n  }\n\n  if (devAsset.ok) throw new Error(describeMismatch(baseURL));\n};\n\n/** One probe per worker process, whatever the outcome. */\nlet verdict: Promise<void> | undefined;\n\n/**\n * The form `defineEntifixE2eTest` calls, from an auto fixture.\n *\n * A fixture rather than `globalSetup`, which is where this naturally belongs:\n * Playwright loads a `globalSetup` file through a different module path than\n * the config and the specs, and this package is `\"type\": \"module\"` while an\n * app's `playwright.config.ts` is CJS — the same file transpiles for one and\n * throws `exports is not defined in ES module scope` for the other. The\n * fixture rides the path that already works, at the cost of reporting the\n * refusal once per test rather than once per run.\n *\n * The promise is cached, so the probe happens once and every subsequent test\n * rejects with the same error instead of re-asking a server that will not have\n * changed mid-run.\n */\nexport const assertExpectedServerOnce = (\n  baseURL: string | undefined,\n): Promise<void> => {\n  if (baseURL === undefined || baseURL === '') return Promise.resolve();\n\n  verdict ??= assertExpectedServer({ baseURL });\n  return verdict;\n};\n"],"names":["isMockProfile","ALLOW_DEV_SERVER_VAR","LIVENESS_PATH","DEV_ASSET_PATH","PROBE_TIMEOUT_MS","describeMismatch","baseURL","join","assertExpectedServer","env","process","fetchImpl","fetch","warn","message","console","override","undefined","get","path","signal","AbortSignal","timeout","liveness","ok","mode","json","Error","devAsset","verdict","assertExpectedServerOnce","Promise","resolve"],"mappings":"AAAA,SAAsBA,aAAa,QAAQ,wBAAwB;AAEnE,iFAAiF,GACjF,OAAO,MAAMC,uBAAuB,4BAA4B;AAEhE;;;;CAIC,GACD,MAAMC,gBAAgB;AAEtB;;;;;;;;;;;CAWC,GACD,MAAMC,iBAAiB;AAEvB,4DAA4D,GAC5D,MAAMC,mBAAmB;AAUzB,MAAMC,mBAAmB,CAACC,UACxB;QACE,CAAC,6DAA6D,EAAEA,QAAQ,CAAC,CAAC;QAC1E;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA,GAAGL,qBAAqB,sBAAsB,CAAC;KAChD,CAACM,IAAI,CAAC;AAET;;;;;;;;;;;;;;CAcC,GACD,OAAO,MAAMC,uBAAuB,OAAO,EACzCF,OAAO,EACPG,MAAMC,QAAQD,GAAG,EACjBE,YAAYC,KAAK,EACjBC,OAAOC,CAAAA,UAAWC,QAAQF,IAAI,CAACC,QAAQ,EACX;IAC5B,IAAI,CAACd,cAAcS,MAAM;IAEzB,MAAMO,WAAWP,GAAG,CAACR,qBAAqB;IAC1C,IAAIe,aAAaC,aAAaD,aAAa,IAAI;IAE/C,MAAME,MAAM,OAAOC;QACjB,IAAI;YACF,OAAO,MAAMR,UAAU,GAAGL,UAAUa,MAAM,EAAE;gBAC1CC,QAAQC,YAAYC,OAAO,CAAClB;YAC9B;QACF,EAAE,eAAM;YACN,OAAOa;QACT;IACF;IAEA,MAAMM,WAAW,MAAML,IAAIhB;IAC3B,IAAIqB,CAAAA,4BAAAA,SAAUC,EAAE,MAAK,MAAM;QACzB,MAAMC,OAAO,AAAE,CAAA,MAAMF,SAASG,IAAI,EAAC,EAA0BD,IAAI;QACjE,IAAIA,SAAS,cAAc;QAC3B,IAAIA,SAAS,eAAe,MAAM,IAAIE,MAAMtB,iBAAiBC;IAC/D;IAEA,0DAA0D;IAC1D,MAAMsB,WAAW,MAAMV,IAAIf;IAC3B,IAAIyB,aAAaX,WAAW;QAC1BJ,KACE,CAAC,qBAAqB,EAAEP,QAAQ,qCAAqC,CAAC;QAExE;IACF;IAEA,IAAIsB,SAASJ,EAAE,EAAE,MAAM,IAAIG,MAAMtB,iBAAiBC;AACpD,EAAE;AAEF,wDAAwD,GACxD,IAAIuB;AAEJ;;;;;;;;;;;;;;CAcC,GACD,OAAO,MAAMC,2BAA2B,CACtCxB;IAEA,IAAIA,YAAYW,aAAaX,YAAY,IAAI,OAAOyB,QAAQC,OAAO;IAEnEH,kBAAAA,UAAAA,UAAYrB,qBAAqB;QAAEF;IAAQ;IAC3C,OAAOuB;AACT,EAAE"}

package/dist/playwright/config.d.ts

@@ -0,0 +1,78 @@
+import { type PlaywrightTestConfig } from '@playwright/test';
+import { requireLiveUrl, resolveE2eProfile } from '../profile/profile.js';
+export interface EntifixE2eConfigOptions {
+    /** The playwright config file — pass `__filename`, as the Nx preset wants. */
+    configFile: string;
+    /**
+     * The app's directory, relative to the workspace root, e.g.
+     * `apps/back-office-app`. The server is started from there.
+     */
+    appDir: string;
+    /** The port that app serves on (the `300N` convention). */
+    port: number;
+    /** Spec directory, relative to the config file. */
+    testDir?: string;
+    /**
+     * Path Playwright polls to decide the server is up, relative to the base URL.
+     *
+     * A gated app needs one, and it must be **exempt from the auth middleware and
+     * free of backend dependencies**: a cold probe against `/` gets a redirect to
+     * a sign-in origin that is not running, and one against `/api/config` gets a
+     * 500 until config-service is up. Either way the run dies on `Timed out
+     * waiting for config.webServer` before a single spec starts. Defaults to the
+     * base URL, which is right for an app with no gate.
+     */
+    readyPath?: string;
+    /**
+     * What Playwright runs to serve the app, when `next start` alone is not
+     * enough.
+     *
+     * The one caller so far is the storefront, whose reads happen in **server
+     * components**: `page.route()` cannot see a fetch the Next process makes, so
+     * its `mock` profile launches the server under a `--import` preload that
+     * installs msw inside that process instead. Expressed here rather than
+     * through `overrides` so the cwd, the readiness URL and the reuse rule stay
+     * in one place — an override would have to restate all three to change one.
+     *
+     * Ignored outside `mock`: a `live` run talks to real services and must not
+     * start a faked one.
+     */
+    mockServerCommand?: string;
+    /** Anything else to merge in, for a project with a genuine special case. */
+    overrides?: PlaywrightTestConfig;
+}
+/**
+ * The shared Playwright configuration for an entifix app e2e project.
+ *
+ * The profile decides three things, and specs decide none of them:
+ *
+ * - **which specs run** — by filename (`*.mock.spec.ts` / `*.live.spec.ts`).
+ *   Selection by `testIgnore` rather than by an in-spec `test.skip` means a
+ *   run with the wrong environment fails instead of quietly reporting green.
+ * - **the base URL** — the local app in `mock`; in `live` the app is expected
+ *   to already be running (started with its real backend), so Playwright
+ *   reuses it rather than racing a second one.
+ * - **whether a reused server is acceptable** — `mock` refuses a development
+ *   one, `live` accepts whatever is there. Enforced by an auto fixture in
+ *   `defineEntifixE2eTest`, not from here: Playwright loads `globalSetup`
+ *   through a different module path than the one it uses for the config and the
+ *   specs, and this package is `"type": "module"` while an app's
+ *   `playwright.config.ts` is CJS — a file reached both ways transpiles for one
+ *   and fails for the other. See `assertExpectedServer`.
+ *
+ * Browsers are chromium in both profiles unless `E2E_BROWSERS=all`.
+ */
+export declare const defineEntifixE2eConfig: ({ configFile, appDir, port, testDir, readyPath, mockServerCommand, overrides, }: EntifixE2eConfigOptions) => PlaywrightTestConfig;
+/**
+ * Re-exported so a Playwright suite reaches both from this entry point.
+ *
+ * ⚠️ Not only for convenience. `@nx/enforce-module-boundaries` treats a package
+ * that any file in the consuming project loads with a dynamic `import()` as
+ * lazy-loaded, and then refuses every *static* import of it — and
+ * `marketplace-app-e2e` has one: its msw preload must call `register()` for the
+ * resolver hook before it resolves anything, so its imports cannot be hoisted.
+ * The rule keys on the specifier, so a `live` spec there can reach
+ * `requireLiveUrl` through `/playwright` and not through the root entry.
+ */
+export { requireLiveUrl, resolveE2eProfile };
+//# sourceMappingURL=config.d.ts.map

package/dist/playwright/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/playwright/config.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAEL,cAAc,EACd,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAE/B,MAAM,WAAW,uBAAuB;IACtC,8EAA8E;IAC9E,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;;;;;;;OAaG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,4EAA4E;IAC5E,SAAS,CAAC,EAAE,oBAAoB,CAAC;CAClC;AAuBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,sBAAsB,GAAI,iFAQpC,uBAAuB,KAAG,oBAuC5B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/playwright/config.js

@@ -0,0 +1,96 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { join } from 'node:path';
+import { workspaceRoot } from '@nx/devkit';
+import { nxE2EPreset } from '@nx/playwright/preset';
+import { defineConfig, devices } from '@playwright/test';
+import { isMockProfile, requireLiveUrl, resolveE2eProfile } from '../profile/profile.js';
+/**
+ * Every browser Playwright can drive.
+ *
+ * Chromium is the default in **both** profiles. Interception happens through
+ * `page.route()`, which behaves the same everywhere, so `mock` would triple the
+ * pull-request time to re-assert identical wire traffic; and a normal dev
+ * machine has only chromium installed, so a `live` run that insisted on all
+ * three failed on a missing engine rather than on the code. Cross-browser
+ * rendering is worth checking deliberately, not on every run.
+ */ const ALL_BROWSERS = [
+    {
+        name: 'chromium',
+        use: _extends({}, devices['Desktop Chrome'])
+    },
+    {
+        name: 'firefox',
+        use: _extends({}, devices['Desktop Firefox'])
+    },
+    {
+        name: 'webkit',
+        use: _extends({}, devices['Desktop Safari'])
+    }
+];
+const CHROMIUM_ONLY = ALL_BROWSERS.slice(0, 1);
+/** Opts into firefox and webkit; needs `pnpm exec playwright install` first. */ const ALL_BROWSERS_VAR = 'E2E_BROWSERS';
+/**
+ * The shared Playwright configuration for an entifix app e2e project.
+ *
+ * The profile decides three things, and specs decide none of them:
+ *
+ * - **which specs run** — by filename (`*.mock.spec.ts` / `*.live.spec.ts`).
+ *   Selection by `testIgnore` rather than by an in-spec `test.skip` means a
+ *   run with the wrong environment fails instead of quietly reporting green.
+ * - **the base URL** — the local app in `mock`; in `live` the app is expected
+ *   to already be running (started with its real backend), so Playwright
+ *   reuses it rather than racing a second one.
+ * - **whether a reused server is acceptable** — `mock` refuses a development
+ *   one, `live` accepts whatever is there. Enforced by an auto fixture in
+ *   `defineEntifixE2eTest`, not from here: Playwright loads `globalSetup`
+ *   through a different module path than the one it uses for the config and the
+ *   specs, and this package is `"type": "module"` while an app's
+ *   `playwright.config.ts` is CJS — a file reached both ways transpiles for one
+ *   and fails for the other. See `assertExpectedServer`.
+ *
+ * Browsers are chromium in both profiles unless `E2E_BROWSERS=all`.
+ */ export const defineEntifixE2eConfig = ({ configFile, appDir, port, testDir = './src', readyPath = '', mockServerCommand, overrides = {} })=>{
+    var _process_env_BASE_URL;
+    const mock = isMockProfile();
+    const baseURL = (_process_env_BASE_URL = process.env['BASE_URL']) != null ? _process_env_BASE_URL : `http://localhost:${port}`;
+    return defineConfig(_extends({}, nxE2EPreset(configFile, {
+        testDir
+    }), {
+        // The other profile's specs are not skipped, they are not collected: a
+        // spec that cannot run here has nothing to say about this run.
+        testIgnore: mock ? '**/*.live.spec.ts' : '**/*.mock.spec.ts'
+    }, mock ? {} : {
+        timeout: 90000
+    }, {
+        use: {
+            baseURL,
+            trace: 'on-first-retry'
+        },
+        // Playwright starts the server itself, with `next start` rather than
+        // `nx run <app>:start`. An nx invocation here is inferred by
+        // `@nx/playwright/plugin` as a *continuous task dependency* of `e2e`, and
+        // the run then waits on a server that never signals completion — the e2e
+        // task never starts. The build the server needs is expressed instead as a
+        // plain `dependsOn` on the e2e target.
+        webServer: {
+            command: mock && mockServerCommand !== undefined ? mockServerCommand : `pnpm exec next start -p ${port}`,
+            cwd: join(workspaceRoot, appDir),
+            url: `${baseURL}${readyPath}`,
+            reuseExistingServer: true
+        },
+        projects: process.env[ALL_BROWSERS_VAR] === 'all' ? ALL_BROWSERS : CHROMIUM_ONLY
+    }, overrides));
+};
+/**
+ * Re-exported so a Playwright suite reaches both from this entry point.
+ *
+ * ⚠️ Not only for convenience. `@nx/enforce-module-boundaries` treats a package
+ * that any file in the consuming project loads with a dynamic `import()` as
+ * lazy-loaded, and then refuses every *static* import of it — and
+ * `marketplace-app-e2e` has one: its msw preload must call `register()` for the
+ * resolver hook before it resolves anything, so its imports cannot be hoisted.
+ * The rule keys on the specifier, so a `live` spec there can reach
+ * `requireLiveUrl` through `/playwright` and not through the root entry.
+ */ export { requireLiveUrl, resolveE2eProfile };
+
+//# sourceMappingURL=config.js.map

package/dist/playwright/config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/playwright/config.ts"],"sourcesContent":["import { join } from 'node:path';\n\nimport { workspaceRoot } from '@nx/devkit';\nimport { nxE2EPreset } from '@nx/playwright/preset';\nimport {\n  defineConfig,\n  devices,\n  type PlaywrightTestConfig,\n} from '@playwright/test';\n\nimport {\n  isMockProfile,\n  requireLiveUrl,\n  resolveE2eProfile,\n} from '../profile/profile.js';\n\nexport interface EntifixE2eConfigOptions {\n  /** The playwright config file — pass `__filename`, as the Nx preset wants. */\n  configFile: string;\n  /**\n   * The app's directory, relative to the workspace root, e.g.\n   * `apps/back-office-app`. The server is started from there.\n   */\n  appDir: string;\n  /** The port that app serves on (the `300N` convention). */\n  port: number;\n  /** Spec directory, relative to the config file. */\n  testDir?: string;\n  /**\n   * Path Playwright polls to decide the server is up, relative to the base URL.\n   *\n   * A gated app needs one, and it must be **exempt from the auth middleware and\n   * free of backend dependencies**: a cold probe against `/` gets a redirect to\n   * a sign-in origin that is not running, and one against `/api/config` gets a\n   * 500 until config-service is up. Either way the run dies on `Timed out\n   * waiting for config.webServer` before a single spec starts. Defaults to the\n   * base URL, which is right for an app with no gate.\n   */\n  readyPath?: string;\n  /**\n   * What Playwright runs to serve the app, when `next start` alone is not\n   * enough.\n   *\n   * The one caller so far is the storefront, whose reads happen in **server\n   * components**: `page.route()` cannot see a fetch the Next process makes, so\n   * its `mock` profile launches the server under a `--import` preload that\n   * installs msw inside that process instead. Expressed here rather than\n   * through `overrides` so the cwd, the readiness URL and the reuse rule stay\n   * in one place — an override would have to restate all three to change one.\n   *\n   * Ignored outside `mock`: a `live` run talks to real services and must not\n   * start a faked one.\n   */\n  mockServerCommand?: string;\n  /** Anything else to merge in, for a project with a genuine special case. */\n  overrides?: PlaywrightTestConfig;\n}\n\n/**\n * Every browser Playwright can drive.\n *\n * Chromium is the default in **both** profiles. Interception happens through\n * `page.route()`, which behaves the same everywhere, so `mock` would triple the\n * pull-request time to re-assert identical wire traffic; and a normal dev\n * machine has only chromium installed, so a `live` run that insisted on all\n * three failed on a missing engine rather than on the code. Cross-browser\n * rendering is worth checking deliberately, not on every run.\n */\nconst ALL_BROWSERS = [\n  { name: 'chromium', use: { ...devices['Desktop Chrome'] } },\n  { name: 'firefox', use: { ...devices['Desktop Firefox'] } },\n  { name: 'webkit', use: { ...devices['Desktop Safari'] } },\n];\n\nconst CHROMIUM_ONLY = ALL_BROWSERS.slice(0, 1);\n\n/** Opts into firefox and webkit; needs `pnpm exec playwright install` first. */\nconst ALL_BROWSERS_VAR = 'E2E_BROWSERS';\n\n/**\n * The shared Playwright configuration for an entifix app e2e project.\n *\n * The profile decides three things, and specs decide none of them:\n *\n * - **which specs run** — by filename (`*.mock.spec.ts` / `*.live.spec.ts`).\n *   Selection by `testIgnore` rather than by an in-spec `test.skip` means a\n *   run with the wrong environment fails instead of quietly reporting green.\n * - **the base URL** — the local app in `mock`; in `live` the app is expected\n *   to already be running (started with its real backend), so Playwright\n *   reuses it rather than racing a second one.\n * - **whether a reused server is acceptable** — `mock` refuses a development\n *   one, `live` accepts whatever is there. Enforced by an auto fixture in\n *   `defineEntifixE2eTest`, not from here: Playwright loads `globalSetup`\n *   through a different module path than the one it uses for the config and the\n *   specs, and this package is `\"type\": \"module\"` while an app's\n *   `playwright.config.ts` is CJS — a file reached both ways transpiles for one\n *   and fails for the other. See `assertExpectedServer`.\n *\n * Browsers are chromium in both profiles unless `E2E_BROWSERS=all`.\n */\nexport const defineEntifixE2eConfig = ({\n  configFile,\n  appDir,\n  port,\n  testDir = './src',\n  readyPath = '',\n  mockServerCommand,\n  overrides = {},\n}: EntifixE2eConfigOptions): PlaywrightTestConfig => {\n  const mock = isMockProfile();\n  const baseURL = process.env['BASE_URL'] ?? `http://localhost:${port}`;\n\n  return defineConfig({\n    ...nxE2EPreset(configFile, { testDir }),\n    // The other profile's specs are not skipped, they are not collected: a\n    // spec that cannot run here has nothing to say about this run.\n    testIgnore: mock ? '**/*.live.spec.ts' : '**/*.mock.spec.ts',\n    // `live` pays for a real sign-in before its first assertion: `seedSession`\n    // drives the provider's hosted login for real — three page loads across two\n    // origins, each a Next app that hydrates before it will accept a keystroke.\n    // Playwright's 30s default is spent on the fixture alone, and the failure it\n    // produces points at whatever action was in flight rather than at the clock.\n    // `mock` keeps the default: it fabricates the cookie and never leaves the app.\n    ...(mock ? {} : { timeout: 90_000 }),\n    use: {\n      baseURL,\n      trace: 'on-first-retry',\n    },\n    // Playwright starts the server itself, with `next start` rather than\n    // `nx run <app>:start`. An nx invocation here is inferred by\n    // `@nx/playwright/plugin` as a *continuous task dependency* of `e2e`, and\n    // the run then waits on a server that never signals completion — the e2e\n    // task never starts. The build the server needs is expressed instead as a\n    // plain `dependsOn` on the e2e target.\n    webServer: {\n      command:\n        mock && mockServerCommand !== undefined\n          ? mockServerCommand\n          : `pnpm exec next start -p ${port}`,\n      cwd: join(workspaceRoot, appDir),\n      url: `${baseURL}${readyPath}`,\n      reuseExistingServer: true,\n    },\n    projects:\n      process.env[ALL_BROWSERS_VAR] === 'all' ? ALL_BROWSERS : CHROMIUM_ONLY,\n    ...overrides,\n  });\n};\n\n/**\n * Re-exported so a Playwright suite reaches both from this entry point.\n *\n * ⚠️ Not only for convenience. `@nx/enforce-module-boundaries` treats a package\n * that any file in the consuming project loads with a dynamic `import()` as\n * lazy-loaded, and then refuses every *static* import of it — and\n * `marketplace-app-e2e` has one: its msw preload must call `register()` for the\n * resolver hook before it resolves anything, so its imports cannot be hoisted.\n * The rule keys on the specifier, so a `live` spec there can reach\n * `requireLiveUrl` through `/playwright` and not through the root entry.\n */\nexport { requireLiveUrl, resolveE2eProfile };\n"],"names":["join","workspaceRoot","nxE2EPreset","defineConfig","devices","isMockProfile","requireLiveUrl","resolveE2eProfile","ALL_BROWSERS","name","use","CHROMIUM_ONLY","slice","ALL_BROWSERS_VAR","defineEntifixE2eConfig","configFile","appDir","port","testDir","readyPath","mockServerCommand","overrides","process","mock","baseURL","env","testIgnore","timeout","trace","webServer","command","undefined","cwd","url","reuseExistingServer","projects"],"mappings":";AAAA,SAASA,IAAI,QAAQ,YAAY;AAEjC,SAASC,aAAa,QAAQ,aAAa;AAC3C,SAASC,WAAW,QAAQ,wBAAwB;AACpD,SACEC,YAAY,EACZC,OAAO,QAEF,mBAAmB;AAE1B,SACEC,aAAa,EACbC,cAAc,EACdC,iBAAiB,QACZ,wBAAwB;AA4C/B;;;;;;;;;CASC,GACD,MAAMC,eAAe;IACnB;QAAEC,MAAM;QAAYC,KAAK,aAAKN,OAAO,CAAC,iBAAiB;IAAG;IAC1D;QAAEK,MAAM;QAAWC,KAAK,aAAKN,OAAO,CAAC,kBAAkB;IAAG;IAC1D;QAAEK,MAAM;QAAUC,KAAK,aAAKN,OAAO,CAAC,iBAAiB;IAAG;CACzD;AAED,MAAMO,gBAAgBH,aAAaI,KAAK,CAAC,GAAG;AAE5C,8EAA8E,GAC9E,MAAMC,mBAAmB;AAEzB;;;;;;;;;;;;;;;;;;;;CAoBC,GACD,OAAO,MAAMC,yBAAyB,CAAC,EACrCC,UAAU,EACVC,MAAM,EACNC,IAAI,EACJC,UAAU,OAAO,EACjBC,YAAY,EAAE,EACdC,iBAAiB,EACjBC,YAAY,CAAC,CAAC,EACU;QAERC;IADhB,MAAMC,OAAOlB;IACb,MAAMmB,WAAUF,wBAAAA,QAAQG,GAAG,CAAC,WAAW,YAAvBH,wBAA2B,CAAC,iBAAiB,EAAEL,MAAM;IAErE,OAAOd,aAAa,aACfD,YAAYa,YAAY;QAAEG;IAAQ;QACrC,uEAAuE;QACvE,+DAA+D;QAC/DQ,YAAYH,OAAO,sBAAsB;OAOrCA,OAAO,CAAC,IAAI;QAAEI,SAAS;IAAO;QAClCjB,KAAK;YACHc;YACAI,OAAO;QACT;QACA,qEAAqE;QACrE,6DAA6D;QAC7D,0EAA0E;QAC1E,yEAAyE;QACzE,0EAA0E;QAC1E,uCAAuC;QACvCC,WAAW;YACTC,SACEP,QAAQH,sBAAsBW,YAC1BX,oBACA,CAAC,wBAAwB,EAAEH,MAAM;YACvCe,KAAKhC,KAAKC,eAAee;YACzBiB,KAAK,GAAGT,UAAUL,WAAW;YAC7Be,qBAAqB;QACvB;QACAC,UACEb,QAAQG,GAAG,CAACZ,iBAAiB,KAAK,QAAQL,eAAeG;OACxDU;AAEP,EAAE;AAEF;;;;;;;;;;CAUC,GACD,SAASf,cAAc,EAAEC,iBAAiB,GAAG"}

package/dist/playwright/entity-table.d.ts

@@ -0,0 +1,69 @@
+import { type Locator, type Page } from '@playwright/test';
+/** How a filter row is filled in. */
+export interface FilterClause {
+    member: string;
+    operator: string;
+    value: string;
+}
+export interface SortClause {
+    member: string;
+    direction?: 'asc' | 'desc';
+}
+/**
+ * A driver for the `EntityTable` organism: filters, sorting, paging and the
+ * rendered rows.
+ *
+ * Every entity listing in the workspace is the same component, so its selectors
+ * belong in one place rather than being re-declared as local helpers in each
+ * suite — which is what the two admin specs did, with two different sets of
+ * conventions for the same widget.
+ *
+ * The wide (grid) layout is what is asserted on. Both layouts always render —
+ * the pivot is CSS-only, so there is no SSR hydration mismatch — and the table
+ * is the one carrying column semantics.
+ */
+export declare class EntityTablePage {
+    private readonly page;
+    constructor(page: Page);
+    /** Rows of the wide layout. */
+    get rows(): Locator;
+    /** Waits until the listing has painted at least one row. */
+    waitForRows(): Promise<void>;
+    /** Column headers, in render order. */
+    headers(): Promise<string[]>;
+    /**
+     * The values of one column, addressed by its header label rather than by
+     * position: a column added to the entity — or reordered by the user's saved
+     * preferences — must not silently shift what a spec is asserting on.
+     */
+    columnValues(header: string): Promise<string[]>;
+    /** The distinct values of a column, sorted — the usual assertion subject. */
+    distinctColumnValues(header: string): Promise<string[]>;
+    openFilters(): Promise<void>;
+    /** `and` (default) or `or` across the rows of the panel. */
+    matchAny(match: 'and' | 'or'): Promise<void>;
+    /**
+     * Adds a filter row and fills it in.
+     *
+     * The member is always selected explicitly, never left at the default: a new
+     * row defaults to the entity's *first filterable* member, so a spec relying
+     * on it would break the moment a member is declared ahead of that one.
+     */
+    addFilter({ member, operator, value }: FilterClause): Promise<void>;
+    /** Filtering is emitted on Apply, not per keystroke — each emission is a request. */
+    applyFilters(): Promise<void>;
+    clearFilters(): Promise<void>;
+    /** Opens the panel, adds every clause, applies. */
+    filterBy(...clauses: FilterClause[]): Promise<void>;
+    openSorting(): Promise<void>;
+    addSort({ member, direction }: SortClause): Promise<void>;
+    applySorting(): Promise<void>;
+    /** Opens the panel, adds every term in precedence order, applies. */
+    sortBy(...clauses: SortClause[]): Promise<void>;
+    /**
+     * `exact` matters: Next.js' dev-tools button also matches a loose "Siguiente".
+     */
+    nextPage(): Promise<void>;
+    previousPage(): Promise<void>;
+}
+//# sourceMappingURL=entity-table.d.ts.map

package/dist/playwright/entity-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-table.d.ts","sourceRoot":"","sources":["../../src/playwright/entity-table.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAEnE,qCAAqC;AACrC,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,IAAI;IAEvC,+BAA+B;IAC/B,IAAI,IAAI,IAAI,OAAO,CAElB;IAED,4DAA4D;IACtD,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAIlC,uCAAuC;IACjC,OAAO,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAIlC;;;;OAIG;IACG,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAcrD,6EAA6E;IACvE,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAMvD,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAMlC,4DAA4D;IACtD,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAMlD;;;;;;OAMG;IACG,SAAS,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAczE,qFAAqF;IAC/E,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAI7B,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAInC,mDAAmD;IAC7C,QAAQ,CAAC,GAAG,OAAO,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAUnD,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,OAAO,CAAC,EAAE,MAAM,EAAE,SAAiB,EAAE,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAajE,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAInC,qEAAqE;IAC/D,MAAM,CAAC,GAAG,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAUrD;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAMzB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;CAKpC"}